fd8c9ed03e557bb17c6b77de3886c3aa4dbe7c32
[WebKit-https.git] / Source / WebCore / rendering / RenderFlexibleBox.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "RenderFlexibleBox.h"
33
34 #include "LayoutRepainter.h"
35 #include "RenderLayer.h"
36 #include "RenderView.h"
37 #include <limits>
38
39 namespace WebCore {
40
41 // Normally, -1 and 0 are not valid in a HashSet, but these are relatively likely flex-order values. Instead,
42 // we make the two smallest int values invalid flex-order values (in the css parser code we clamp them to
43 // int min + 2).
44 struct RenderFlexibleBox::FlexOrderHashTraits : WTF::GenericHashTraits<int> {
45     static const bool emptyValueIsZero = false;
46     static int emptyValue() { return std::numeric_limits<int>::min(); }
47     static void constructDeletedValue(int& slot) { slot = std::numeric_limits<int>::min() + 1; }
48     static bool isDeletedValue(int value) { return value == std::numeric_limits<int>::min() + 1; }
49 };
50
51 class RenderFlexibleBox::FlexOrderIterator {
52 public:
53     FlexOrderIterator(RenderFlexibleBox* flexibleBox, const FlexOrderHashSet& flexOrderValues)
54         : m_flexibleBox(flexibleBox)
55         , m_currentChild(0)
56         , m_orderValuesIterator(0)
57     {
58         copyToVector(flexOrderValues, m_orderValues);
59         std::sort(m_orderValues.begin(), m_orderValues.end());
60         first();
61     }
62
63     RenderBox* currentChild() { return m_currentChild; }
64
65     RenderBox* first()
66     {
67         reset();
68         return next();
69     }
70
71     RenderBox* next()
72     {
73         do {
74             if (!m_currentChild) {
75                 if (m_orderValuesIterator == m_orderValues.end())
76                     return 0;
77                 if (m_orderValuesIterator) {
78                     ++m_orderValuesIterator;
79                     if (m_orderValuesIterator == m_orderValues.end())
80                         return 0;
81                 } else
82                     m_orderValuesIterator = m_orderValues.begin();
83
84                 m_currentChild = m_flexibleBox->firstChildBox();
85             } else
86                 m_currentChild = m_currentChild->nextSiblingBox();
87         } while (!m_currentChild || m_currentChild->style()->flexOrder() != *m_orderValuesIterator);
88
89         return m_currentChild;
90     }
91
92     void reset()
93     {
94         m_currentChild = 0;
95         m_orderValuesIterator = 0;
96     }
97
98 private:
99     RenderFlexibleBox* m_flexibleBox;
100     RenderBox* m_currentChild;
101     Vector<int> m_orderValues;
102     Vector<int>::const_iterator m_orderValuesIterator;
103 };
104
105 struct RenderFlexibleBox::LineContext {
106     LineContext(LayoutUnit crossAxisOffset, LayoutUnit crossAxisExtent, size_t numberOfChildren, LayoutUnit maxAscent)
107         : crossAxisOffset(crossAxisOffset)
108         , crossAxisExtent(crossAxisExtent)
109         , numberOfChildren(numberOfChildren)
110         , maxAscent(maxAscent)
111     {
112     }
113
114     LayoutUnit crossAxisOffset;
115     LayoutUnit crossAxisExtent;
116     size_t numberOfChildren;
117     LayoutUnit maxAscent;
118 };
119
120 struct RenderFlexibleBox::Violation {
121     Violation(RenderBox* child, LayoutUnit childSize)
122         : child(child)
123         , childSize(childSize)
124     {
125     }
126
127     RenderBox* child;
128     LayoutUnit childSize;
129 };
130
131
132 RenderFlexibleBox::RenderFlexibleBox(Node* node)
133     : RenderBlock(node)
134 {
135     setChildrenInline(false); // All of our children must be block-level.
136 }
137
138 RenderFlexibleBox::~RenderFlexibleBox()
139 {
140 }
141
142 const char* RenderFlexibleBox::renderName() const
143 {
144     return "RenderFlexibleBox";
145 }
146
147 static LayoutUnit marginLogicalWidthForChild(RenderBox* child, RenderStyle* parentStyle)
148 {
149     // A margin has three types: fixed, percentage, and auto (variable).
150     // Auto and percentage margins become 0 when computing min/max width.
151     // Fixed margins can be added in as is.
152     Length marginLeft = child->style()->marginStartUsing(parentStyle);
153     Length marginRight = child->style()->marginEndUsing(parentStyle);
154     LayoutUnit margin = 0;
155     if (marginLeft.isFixed())
156         margin += marginLeft.value();
157     if (marginRight.isFixed())
158         margin += marginRight.value();
159     return margin;
160 }
161
162 void RenderFlexibleBox::computePreferredLogicalWidths()
163 {
164     ASSERT(preferredLogicalWidthsDirty());
165
166     RenderStyle* styleToUse = style();
167     if (styleToUse->logicalWidth().isFixed() && styleToUse->logicalWidth().value() > 0)
168         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = computeContentBoxLogicalWidth(styleToUse->logicalWidth().value());
169     else {
170         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = 0;
171
172         for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
173             if (child->isPositioned())
174                 continue;
175
176             LayoutUnit margin = marginLogicalWidthForChild(child, style());
177             bool hasOrthogonalWritingMode = child->isHorizontalWritingMode() != isHorizontalWritingMode();
178             LayoutUnit minPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->minPreferredLogicalWidth();
179             LayoutUnit maxPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->maxPreferredLogicalWidth();
180             minPreferredLogicalWidth += margin;
181             maxPreferredLogicalWidth += margin;
182             if (!isColumnFlow()) {
183                 m_maxPreferredLogicalWidth += maxPreferredLogicalWidth;
184                 if (isMultiline()) {
185                     // For multiline, the min preferred width is if you put a break between each item.
186                     m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, minPreferredLogicalWidth);
187                 } else
188                     m_minPreferredLogicalWidth += minPreferredLogicalWidth;
189             } else {
190                 m_minPreferredLogicalWidth = std::max(minPreferredLogicalWidth, m_minPreferredLogicalWidth);
191                 if (isMultiline()) {
192                     // For multiline, the max preferred width is if you put a break between each item.
193                     m_maxPreferredLogicalWidth += maxPreferredLogicalWidth;
194                 } else
195                     m_maxPreferredLogicalWidth = std::max(maxPreferredLogicalWidth, m_maxPreferredLogicalWidth);
196             }
197         }
198
199         m_maxPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
200     }
201
202     LayoutUnit scrollbarWidth = 0;
203     if (hasOverflowClip()) {
204         if (isHorizontalWritingMode() && styleToUse->overflowY() == OSCROLL) {
205             layer()->setHasVerticalScrollbar(true);
206             scrollbarWidth = verticalScrollbarWidth();
207         } else if (!isHorizontalWritingMode() && styleToUse->overflowX() == OSCROLL) {
208             layer()->setHasHorizontalScrollbar(true);
209             scrollbarWidth = horizontalScrollbarHeight();
210         }
211     }
212
213     m_maxPreferredLogicalWidth += scrollbarWidth;
214     m_minPreferredLogicalWidth += scrollbarWidth;
215
216     if (styleToUse->logicalMinWidth().isFixed() && styleToUse->logicalMinWidth().value() > 0) {
217         m_maxPreferredLogicalWidth = std::max(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
218         m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
219     }
220
221     if (styleToUse->logicalMaxWidth().isFixed()) {
222         m_maxPreferredLogicalWidth = std::min(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
223         m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
224     }
225
226     LayoutUnit borderAndPadding = borderAndPaddingLogicalWidth();
227     m_minPreferredLogicalWidth += borderAndPadding;
228     m_maxPreferredLogicalWidth += borderAndPadding;
229
230     setPreferredLogicalWidthsDirty(false);
231 }
232
233 void RenderFlexibleBox::layoutBlock(bool relayoutChildren, LayoutUnit)
234 {
235     ASSERT(needsLayout());
236
237     if (!relayoutChildren && simplifiedLayout())
238         return;
239
240     LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
241     LayoutStateMaintainer statePusher(view(), this, locationOffset(), hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode());
242
243     if (inRenderFlowThread()) {
244         // Regions changing widths can force us to relayout our children.
245         if (logicalWidthChangedInRegions())
246             relayoutChildren = true;
247     }
248     computeInitialRegionRangeForBlock();
249
250     LayoutSize previousSize = size();
251
252     setLogicalHeight(0);
253     computeLogicalWidth();
254
255     m_overflow.clear();
256
257     // For overflow:scroll blocks, ensure we have both scrollbars in place always.
258     if (scrollsOverflow()) {
259         if (style()->overflowX() == OSCROLL)
260             layer()->setHasHorizontalScrollbar(true);
261         if (style()->overflowY() == OSCROLL)
262             layer()->setHasVerticalScrollbar(true);
263     }
264
265     WTF::Vector<LineContext> lineContexts;
266     FlexOrderHashSet flexOrderValues;
267     computeMainAxisPreferredSizes(relayoutChildren, flexOrderValues);
268     FlexOrderIterator flexIterator(this, flexOrderValues);
269     layoutFlexItems(flexIterator, lineContexts);
270
271     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
272     computeLogicalHeight();
273     repositionLogicalHeightDependentFlexItems(flexIterator, lineContexts, oldClientAfterEdge);
274
275     if (size() != previousSize)
276         relayoutChildren = true;
277
278     layoutPositionedObjects(relayoutChildren || isRoot());
279
280     computeRegionRangeForBlock();
281
282     // FIXME: css3/flexbox/repaint-rtl-column.html seems to repaint more overflow than it needs to.
283     computeOverflow(oldClientAfterEdge);
284     statePusher.pop();
285
286     updateLayerTransform();
287
288     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
289     // we overflow or not.
290     if (hasOverflowClip())
291         layer()->updateScrollInfoAfterLayout();
292
293     repainter.repaintAfterLayout();
294
295     setNeedsLayout(false);
296 }
297
298 void RenderFlexibleBox::repositionLogicalHeightDependentFlexItems(FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts, LayoutUnit& oldClientAfterEdge)
299 {
300     LayoutUnit crossAxisStartEdge = lineContexts.isEmpty() ? ZERO_LAYOUT_UNIT : lineContexts[0].crossAxisOffset;
301     packFlexLines(iterator, lineContexts);
302
303     // If we have a single line flexbox, the line height is all the available space.
304     // For flex-direction: row, this means we need to use the height, so we do this after calling computeLogicalHeight.
305     if (!isMultiline() && lineContexts.size() == 1)
306         lineContexts[0].crossAxisExtent = crossAxisContentExtent();
307     alignChildren(iterator, lineContexts);
308
309     if (style()->flexWrap() == FlexWrapReverse) {
310         if (isHorizontalFlow())
311             oldClientAfterEdge = clientLogicalBottom();
312         flipForWrapReverse(iterator, lineContexts, crossAxisStartEdge);
313     }
314
315     // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
316     flipForRightToLeftColumn(iterator);
317 }
318
319 bool RenderFlexibleBox::hasOrthogonalFlow(RenderBox* child) const
320 {
321     // FIXME: If the child is a flexbox, then we need to check isHorizontalFlow.
322     return isHorizontalFlow() != child->isHorizontalWritingMode();
323 }
324
325 bool RenderFlexibleBox::isColumnFlow() const
326 {
327     return style()->isColumnFlexDirection();
328 }
329
330 bool RenderFlexibleBox::isHorizontalFlow() const
331 {
332     if (isHorizontalWritingMode())
333         return !isColumnFlow();
334     return isColumnFlow();
335 }
336
337 bool RenderFlexibleBox::isLeftToRightFlow() const
338 {
339     if (isColumnFlow())
340         return style()->writingMode() == TopToBottomWritingMode || style()->writingMode() == LeftToRightWritingMode;
341     return style()->isLeftToRightDirection() ^ (style()->flexDirection() == FlowRowReverse);
342 }
343
344 bool RenderFlexibleBox::isMultiline() const
345 {
346     return style()->flexWrap() != FlexWrapNone;
347 }
348
349 Length RenderFlexibleBox::preferredLengthForChild(RenderBox* child) const
350 {
351     Length flexLength = child->style()->flexPreferredSize();
352     if (flexLength.isAuto())
353         flexLength = isHorizontalFlow() ? child->style()->width() : child->style()->height();
354     return flexLength;
355 }
356
357 Length RenderFlexibleBox::crossAxisLength() const
358 {
359     return isHorizontalFlow() ? style()->height() : style()->width();
360 }
361
362 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
363 {
364     if (isHorizontalFlow())
365         setHeight(extent);
366     else
367         setWidth(extent);
368 }
369
370 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
371 {
372     return isHorizontalFlow() ? child->height() : child->width();
373 }
374
375 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
376 {
377     return isHorizontalFlow() ? child->width() : child->height();
378 }
379
380 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
381 {
382     return isHorizontalFlow() ? height() : width();
383 }
384
385 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
386 {
387     return isHorizontalFlow() ? width() : height();
388 }
389
390 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
391 {
392     return isHorizontalFlow() ? contentHeight() : contentWidth();
393 }
394
395 LayoutUnit RenderFlexibleBox::mainAxisContentExtent() const
396 {
397     return isHorizontalFlow() ? contentWidth() : contentHeight();
398 }
399
400 WritingMode RenderFlexibleBox::transformedWritingMode() const
401 {
402     WritingMode mode = style()->writingMode();
403     if (!isColumnFlow())
404         return mode;
405
406     switch (mode) {
407     case TopToBottomWritingMode:
408     case BottomToTopWritingMode:
409         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
410     case LeftToRightWritingMode:
411     case RightToLeftWritingMode:
412         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
413     }
414     ASSERT_NOT_REACHED();
415     return TopToBottomWritingMode;
416 }
417
418 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
419 {
420     if (isHorizontalFlow())
421         return isLeftToRightFlow() ? borderLeft() : borderRight();
422     return isLeftToRightFlow() ? borderTop() : borderBottom();
423 }
424
425 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
426 {
427     if (isHorizontalFlow())
428         return isLeftToRightFlow() ? borderRight() : borderLeft();
429     return isLeftToRightFlow() ? borderBottom() : borderTop();
430 }
431
432 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
433 {
434     switch (transformedWritingMode()) {
435     case TopToBottomWritingMode:
436         return borderTop();
437     case BottomToTopWritingMode:
438         return borderBottom();
439     case LeftToRightWritingMode:
440         return borderLeft();
441     case RightToLeftWritingMode:
442         return borderRight();
443     }
444     ASSERT_NOT_REACHED();
445     return borderTop();
446 }
447
448 LayoutUnit RenderFlexibleBox::flowAwareBorderAfter() const
449 {
450     switch (transformedWritingMode()) {
451     case TopToBottomWritingMode:
452         return borderBottom();
453     case BottomToTopWritingMode:
454         return borderTop();
455     case LeftToRightWritingMode:
456         return borderRight();
457     case RightToLeftWritingMode:
458         return borderLeft();
459     }
460     ASSERT_NOT_REACHED();
461     return borderTop();
462 }
463
464 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
465 {
466     if (isHorizontalFlow())
467         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
468     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
469 }
470
471 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
472 {
473     if (isHorizontalFlow())
474         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
475     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
476 }
477
478 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
479 {
480     switch (transformedWritingMode()) {
481     case TopToBottomWritingMode:
482         return paddingTop();
483     case BottomToTopWritingMode:
484         return paddingBottom();
485     case LeftToRightWritingMode:
486         return paddingLeft();
487     case RightToLeftWritingMode:
488         return paddingRight();
489     }
490     ASSERT_NOT_REACHED();
491     return paddingTop();
492 }
493
494 LayoutUnit RenderFlexibleBox::flowAwarePaddingAfter() const
495 {
496     switch (transformedWritingMode()) {
497     case TopToBottomWritingMode:
498         return paddingBottom();
499     case BottomToTopWritingMode:
500         return paddingTop();
501     case LeftToRightWritingMode:
502         return paddingRight();
503     case RightToLeftWritingMode:
504         return paddingLeft();
505     }
506     ASSERT_NOT_REACHED();
507     return paddingTop();
508 }
509
510 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
511 {
512     if (isHorizontalFlow())
513         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
514     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
515 }
516
517 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
518 {
519     if (isHorizontalFlow())
520         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
521     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
522 }
523
524 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
525 {
526     switch (transformedWritingMode()) {
527     case TopToBottomWritingMode:
528         return child->marginTop();
529     case BottomToTopWritingMode:
530         return child->marginBottom();
531     case LeftToRightWritingMode:
532         return child->marginLeft();
533     case RightToLeftWritingMode:
534         return child->marginRight();
535     }
536     ASSERT_NOT_REACHED();
537     return marginTop();
538 }
539
540 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
541 {
542     switch (transformedWritingMode()) {
543     case TopToBottomWritingMode:
544         return child->marginBottom();
545     case BottomToTopWritingMode:
546         return child->marginTop();
547     case LeftToRightWritingMode:
548         return child->marginRight();
549     case RightToLeftWritingMode:
550         return child->marginLeft();
551     }
552     ASSERT_NOT_REACHED();
553     return marginBottom();
554 }
555
556 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
557 {
558     return isHorizontalFlow() ? child->marginHeight() : child->marginWidth();
559 }
560
561 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
562 {
563     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
564 }
565
566 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
567 {
568     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
569 }
570
571 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
572 {
573     if (isHorizontalFlow())
574         child->setLocation(location);
575     else
576         child->setLocation(location.transposedPoint());
577 }
578
579 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
580 {
581     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
582 }
583
584 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
585 {
586     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
587 }
588
589 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child) const
590 {
591     Length mainAxisLength = preferredLengthForChild(child);
592     if (mainAxisLength.isAuto()) {
593         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
594         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
595     }
596     return minimumValueForLength(mainAxisLength, mainAxisContentExtent(), view());
597 }
598
599 LayoutUnit RenderFlexibleBox::computeAvailableFreeSpace(LayoutUnit preferredMainAxisExtent)
600 {
601     LayoutUnit contentExtent = 0;
602     if (!isColumnFlow())
603         contentExtent = mainAxisContentExtent();
604     else if (hasOverrideHeight())
605         contentExtent = overrideHeight() - (logicalHeight() - contentLogicalHeight());
606     else {
607         LayoutUnit heightResult = computeContentLogicalHeightUsing(style()->logicalHeight());
608         if (heightResult == -1)
609             heightResult = preferredMainAxisExtent;
610         LayoutUnit minHeight = computeContentLogicalHeightUsing(style()->logicalMinHeight()); // Leave as -1 if unset.
611         LayoutUnit maxHeight = style()->logicalMaxHeight().isUndefined() ? heightResult : computeContentLogicalHeightUsing(style()->logicalMaxHeight());
612         if (maxHeight == -1)
613             maxHeight = heightResult;
614         heightResult = std::min(maxHeight, heightResult);
615         heightResult = std::max(minHeight, heightResult);
616         contentExtent = heightResult;
617     }
618
619     return contentExtent - preferredMainAxisExtent;
620 }
621
622 void RenderFlexibleBox::layoutFlexItems(FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
623 {
624     OrderedFlexItemList orderedChildren;
625     LayoutUnit preferredMainAxisExtent;
626     float totalPositiveFlexibility;
627     float totalNegativeFlexibility;
628     LayoutUnit minMaxAppliedMainAxisExtent;
629
630     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
631     while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility, minMaxAppliedMainAxisExtent)) {
632         LayoutUnit availableFreeSpace = computeAvailableFreeSpace(preferredMainAxisExtent);
633         FlexSign flexSign = (minMaxAppliedMainAxisExtent < preferredMainAxisExtent + availableFreeSpace) ? PositiveFlexibility : NegativeFlexibility;
634         InflexibleFlexItemSize inflexibleItems;
635         WTF::Vector<LayoutUnit> childSizes;
636         while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
637             ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
638             ASSERT(inflexibleItems.size() > 0);
639         }
640
641         layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, availableFreeSpace, lineContexts);
642     }
643 }
644
645 LayoutUnit RenderFlexibleBox::autoMarginOffsetInMainAxis(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace)
646 {
647     if (availableFreeSpace <= 0)
648         return 0;
649
650     int numberOfAutoMargins = 0;
651     bool isHorizontal = isHorizontalFlow();
652     for (size_t i = 0; i < children.size(); ++i) {
653         RenderBox* child = children[i];
654         if (child->isPositioned())
655             continue;
656         if (isHorizontal) {
657             if (child->style()->marginLeft().isAuto())
658                 ++numberOfAutoMargins;
659             if (child->style()->marginRight().isAuto())
660                 ++numberOfAutoMargins;
661         } else {
662             if (child->style()->marginTop().isAuto())
663                 ++numberOfAutoMargins;
664             if (child->style()->marginBottom().isAuto())
665                 ++numberOfAutoMargins;
666         }
667     }
668     if (!numberOfAutoMargins)
669         return 0;
670
671     LayoutUnit sizeOfAutoMargin = availableFreeSpace / numberOfAutoMargins;
672     availableFreeSpace = 0;
673     return sizeOfAutoMargin;
674 }
675
676 void RenderFlexibleBox::updateAutoMarginsInMainAxis(RenderBox* child, LayoutUnit autoMarginOffset)
677 {
678     if (isHorizontalFlow()) {
679         if (child->style()->marginLeft().isAuto())
680             child->setMarginLeft(autoMarginOffset);
681         if (child->style()->marginRight().isAuto())
682             child->setMarginRight(autoMarginOffset);
683     } else {
684         if (child->style()->marginTop().isAuto())
685             child->setMarginTop(autoMarginOffset);
686         if (child->style()->marginBottom().isAuto())
687             child->setMarginBottom(autoMarginOffset);
688     }
689 }
690
691 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(LayoutUnit lineCrossAxisExtent, RenderBox* child)
692 {
693     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
694     return lineCrossAxisExtent - childCrossExtent;
695 }
696
697 LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(RenderBox* child)
698 {
699     LayoutUnit ascent = child->firstLineBoxBaseline();
700     if (ascent == -1)
701         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
702     return ascent + flowAwareMarginBeforeForChild(child);
703 }
704
705 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, FlexOrderHashSet& flexOrderValues)
706 {
707     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
708     RenderView* renderView = view();
709     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
710         flexOrderValues.add(child->style()->flexOrder());
711
712         if (child->isPositioned())
713             continue;
714
715         child->clearOverrideSize();
716         if (preferredLengthForChild(child).isAuto()) {
717             if (!relayoutChildren)
718                 child->setChildNeedsLayout(true);
719             child->layoutIfNeeded();
720         }
721
722         // Before running the flex algorithm, 'auto' has a margin of 0.
723         // Also, if we're not auto sizing, we don't do a layout that computes the start/end margins.
724         if (isHorizontalFlow()) {
725             child->setMarginLeft(minimumValueForLength(child->style()->marginLeft(), flexboxAvailableContentExtent, renderView));
726             child->setMarginRight(minimumValueForLength(child->style()->marginRight(), flexboxAvailableContentExtent, renderView));
727         } else {
728             child->setMarginTop(minimumValueForLength(child->style()->marginTop(), flexboxAvailableContentExtent, renderView));
729             child->setMarginBottom(minimumValueForLength(child->style()->marginBottom(), flexboxAvailableContentExtent, renderView));
730         }
731     }
732 }
733
734 LayoutUnit RenderFlexibleBox::lineBreakLength()
735 {
736     if (!isColumnFlow())
737         return mainAxisContentExtent();
738
739     LayoutUnit height = computeContentLogicalHeightUsing(style()->logicalHeight());
740     if (height == -1)
741         height = MAX_LAYOUT_UNIT;
742     LayoutUnit maxHeight = computeContentLogicalHeightUsing(style()->logicalMaxHeight());
743     if (maxHeight != -1)
744         height = std::min(height, maxHeight);
745     return height;
746 }
747
748 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize, LayoutUnit flexboxAvailableContentExtent)
749 {
750     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
751     Length min = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
752     RenderView* renderView = view();
753     // FIXME: valueForLength isn't quite right in quirks mode: percentage heights should check parents until a value is found.
754     // https://bugs.webkit.org/show_bug.cgi?id=81809
755     if (max.isSpecified() && childSize > valueForLength(max, flexboxAvailableContentExtent, renderView))
756         childSize = valueForLength(max, flexboxAvailableContentExtent, renderView);
757     if (min.isSpecified() && childSize < valueForLength(min, flexboxAvailableContentExtent, renderView))
758         childSize = valueForLength(min, flexboxAvailableContentExtent, renderView);
759     return childSize;
760 }
761
762 bool RenderFlexibleBox::computeNextFlexLine(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent)
763 {
764     orderedChildren.clear();
765     preferredMainAxisExtent = 0;
766     totalPositiveFlexibility = totalNegativeFlexibility = 0;
767     minMaxAppliedMainAxisExtent = 0;
768
769     if (!iterator.currentChild())
770         return false;
771
772     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
773     LayoutUnit lineBreak = lineBreakLength();
774
775     for (RenderBox* child = iterator.currentChild(); child; child = iterator.next()) {
776         if (child->isPositioned()) {
777             orderedChildren.append(child);
778             continue;
779         }
780
781         LayoutUnit childMainAxisExtent = preferredMainAxisContentExtentForChild(child);
782         LayoutUnit childMainAxisMarginBoxExtent = mainAxisBorderAndPaddingExtentForChild(child) + childMainAxisExtent;
783         childMainAxisMarginBoxExtent += isHorizontalFlow() ? child->marginWidth() : child->marginHeight();
784
785         if (isMultiline() && preferredMainAxisExtent + childMainAxisMarginBoxExtent > lineBreak && orderedChildren.size() > 0)
786             break;
787         orderedChildren.append(child);
788         preferredMainAxisExtent += childMainAxisMarginBoxExtent;
789         totalPositiveFlexibility += child->style()->positiveFlex();
790         totalNegativeFlexibility += child->style()->negativeFlex();
791
792         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent, flexboxAvailableContentExtent);
793         minMaxAppliedMainAxisExtent += childMinMaxAppliedMainAxisExtent - childMainAxisExtent + childMainAxisMarginBoxExtent;
794     }
795     return true;
796 }
797
798 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
799 {
800     for (size_t i = 0; i < violations.size(); ++i) {
801         RenderBox* child = violations[i].child;
802         LayoutUnit childSize = violations[i].childSize;
803         availableFreeSpace -= childSize - preferredMainAxisContentExtentForChild(child);
804         totalPositiveFlexibility -= child->style()->positiveFlex();
805         totalNegativeFlexibility -= child->style()->negativeFlex();
806         inflexibleItems.set(child, childSize);
807     }
808 }
809
810 // Returns true if we successfully ran the algorithm and sized the flex items.
811 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
812 {
813     childSizes.clear();
814     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
815     LayoutUnit totalViolation = 0;
816     LayoutUnit usedFreeSpace = 0;
817     WTF::Vector<Violation> minViolations;
818     WTF::Vector<Violation> maxViolations;
819     for (size_t i = 0; i < children.size(); ++i) {
820         RenderBox* child = children[i];
821         if (child->isPositioned()) {
822             childSizes.append(0);
823             continue;
824         }
825
826         if (inflexibleItems.contains(child))
827             childSizes.append(inflexibleItems.get(child));
828         else {
829             LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
830             LayoutUnit childSize = preferredChildSize;
831             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0 && flexSign == PositiveFlexibility)
832                 childSize += lroundf(availableFreeSpace * child->style()->positiveFlex() / totalPositiveFlexibility);
833             else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0  && flexSign == NegativeFlexibility)
834                 childSize += lroundf(availableFreeSpace * child->style()->negativeFlex() / totalNegativeFlexibility);
835
836             LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize, flexboxAvailableContentExtent);
837             childSizes.append(adjustedChildSize);
838             usedFreeSpace += adjustedChildSize - preferredChildSize;
839
840             LayoutUnit violation = adjustedChildSize - childSize;
841             if (violation > 0)
842                 minViolations.append(Violation(child, adjustedChildSize));
843             else if (violation < 0)
844                 maxViolations.append(Violation(child, adjustedChildSize));
845             totalViolation += violation;
846         }
847     }
848
849     if (totalViolation)
850         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems);
851     else
852         availableFreeSpace -= usedFreeSpace;
853
854     return !totalViolation;
855 }
856
857 static LayoutUnit initialPackingOffset(LayoutUnit availableFreeSpace, EFlexPack flexPack, unsigned numberOfChildren)
858 {
859     if (flexPack == PackEnd)
860         return availableFreeSpace;
861     if (flexPack == PackCenter)
862         return availableFreeSpace / 2;
863     if (flexPack == PackDistribute) {
864         if (availableFreeSpace > 0 && numberOfChildren)
865             return availableFreeSpace / (2 * numberOfChildren);
866         if (availableFreeSpace < 0)
867             return availableFreeSpace / 2;
868     }
869     return 0;
870 }
871
872 static LayoutUnit packingSpaceBetweenChildren(LayoutUnit availableFreeSpace, EFlexPack flexPack, unsigned numberOfChildren)
873 {
874     if (availableFreeSpace > 0 && numberOfChildren > 1) {
875         if (flexPack == PackJustify)
876             return availableFreeSpace / (numberOfChildren - 1);
877         if (flexPack == PackDistribute)
878             return availableFreeSpace / numberOfChildren;
879     }
880     return 0;
881 }
882
883 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
884 {
885     // FIXME: Rename setOverrideWidth/setOverrideHeight to setOverrideLogicalWidth/setOverrideLogicalHeight.
886     if (hasOrthogonalFlow(child))
887         child->setOverrideHeight(childPreferredSize);
888     else
889         child->setOverrideWidth(childPreferredSize);
890 }
891
892 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset)
893 {
894     ASSERT(child->isPositioned());
895     child->containingBlock()->insertPositionedObject(child);
896     RenderLayer* childLayer = child->layer();
897     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
898     if (style()->flexDirection() == FlowRowReverse)
899         inlinePosition = mainAxisExtent() - mainAxisOffset;
900     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
901
902     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
903     if (childLayer->staticBlockPosition() != staticBlockPosition) {
904         childLayer->setStaticBlockPosition(staticBlockPosition);
905         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
906             child->setChildNeedsLayout(true, MarkOnlyThis);
907     }
908 }
909
910 static EFlexAlign flexAlignForChild(RenderBox* child)
911 {
912     EFlexAlign align = child->style()->flexItemAlign();
913     if (align == AlignAuto)
914         align = child->parent()->style()->flexAlign();
915
916     if (child->parent()->style()->flexWrap() == FlexWrapReverse) {
917         if (align == AlignStart)
918             align = AlignEnd;
919         else if (align == AlignEnd)
920             align = AlignStart;
921     }
922
923     return align;
924 }
925
926 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, WTF::Vector<LineContext>& lineContexts)
927 {
928     ASSERT(childSizes.size() == children.size());
929
930     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
931     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
932     mainAxisOffset += initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
933     if (style()->flexDirection() == FlowRowReverse)
934         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
935
936     LayoutUnit totalMainExtent = mainAxisExtent();
937     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
938     LayoutUnit maxChildCrossAxisExtent = 0;
939     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
940     for (size_t i = 0; i < children.size(); ++i) {
941         RenderBox* child = children[i];
942         if (child->isPositioned()) {
943             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
944             mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
945             continue;
946         }
947         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
948         setLogicalOverrideSize(child, childPreferredSize);
949         child->setChildNeedsLayout(true);
950         child->layoutIfNeeded();
951
952         updateAutoMarginsInMainAxis(child, autoMarginOffset);
953
954         LayoutUnit childCrossAxisMarginBoxExtent;
955         if (flexAlignForChild(child) == AlignBaseline) {
956             LayoutUnit ascent = marginBoxAscentForChild(child);
957             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
958
959             maxAscent = std::max(maxAscent, ascent);
960             maxDescent = std::max(maxDescent, descent);
961
962             childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
963         } else
964             childCrossAxisMarginBoxExtent = crossAxisExtentForChild(child) + crossAxisMarginExtentForChild(child);
965         if (!isColumnFlow() && style()->logicalHeight().isAuto())
966             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
967         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
968
969         mainAxisOffset += flowAwareMarginStartForChild(child);
970
971         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
972         IntPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
973             crossAxisOffset + flowAwareMarginBeforeForChild(child));
974
975         // FIXME: Supporting layout deltas.
976         setFlowAwareLocationForChild(child, childLocation);
977         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
978
979         mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
980     }
981
982     if (isColumnFlow())
983         setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
984
985     if (style()->flexDirection() == FlowColumnReverse) {
986         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
987         // on the height of the flexbox, which we only know after we've positioned all the flex items.
988         computeLogicalHeight();
989         layoutColumnReverse(children, childSizes, crossAxisOffset, availableFreeSpace);
990     }
991
992     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
993     crossAxisOffset += maxChildCrossAxisExtent;
994 }
995
996 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
997 {
998     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
999     // starting from the end of the flexbox. We also don't need to layout anything since we're
1000     // just moving the children to a new position.
1001     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
1002     mainAxisOffset -= initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
1003     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
1004
1005     for (size_t i = 0; i < children.size(); ++i) {
1006         RenderBox* child = children[i];
1007         if (child->isPositioned()) {
1008             child->layer()->setStaticBlockPosition(mainAxisOffset);
1009             mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
1010             continue;
1011         }
1012         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
1013
1014         LayoutRect oldRect = child->frameRect();
1015         setFlowAwareLocationForChild(child, IntPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
1016         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1017             child->repaintDuringLayoutIfMoved(oldRect);
1018
1019         mainAxisOffset -= flowAwareMarginStartForChild(child);
1020         mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
1021     }
1022 }
1023
1024 static LayoutUnit initialLinePackingOffset(LayoutUnit availableFreeSpace, EFlexLinePack linePack, unsigned numberOfLines)
1025 {
1026     if (linePack == LinePackEnd)
1027         return availableFreeSpace;
1028     if (linePack == LinePackCenter)
1029         return availableFreeSpace / 2;
1030     if (linePack == LinePackDistribute) {
1031         if (availableFreeSpace > 0 && numberOfLines)
1032             return availableFreeSpace / (2 * numberOfLines);
1033         if (availableFreeSpace < 0)
1034             return availableFreeSpace / 2;
1035     }
1036     return 0;
1037 }
1038
1039 static LayoutUnit linePackingSpaceBetweenChildren(LayoutUnit availableFreeSpace, EFlexLinePack linePack, unsigned numberOfLines)
1040 {
1041     if (availableFreeSpace > 0 && numberOfLines > 1) {
1042         if (linePack == LinePackJustify)
1043             return availableFreeSpace / (numberOfLines - 1);
1044         if (linePack == LinePackDistribute || linePack == LinePackStretch)
1045             return availableFreeSpace / numberOfLines;
1046     }
1047     return 0;
1048 }
1049
1050 void RenderFlexibleBox::packFlexLines(FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
1051 {
1052     if (!isMultiline() || style()->flexLinePack() == LinePackStart)
1053         return;
1054
1055     LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
1056     for (size_t i = 0; i < lineContexts.size(); ++i)
1057         availableCrossAxisSpace -= lineContexts[i].crossAxisExtent;
1058
1059     RenderBox* child = iterator.first();
1060     LayoutUnit lineOffset = initialLinePackingOffset(availableCrossAxisSpace, style()->flexLinePack(), lineContexts.size());
1061     for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1062         lineContexts[lineNumber].crossAxisOffset += lineOffset;
1063         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next())
1064             adjustAlignmentForChild(child, lineOffset);
1065
1066         if (style()->flexLinePack() == LinePackStretch && availableCrossAxisSpace > 0)
1067             lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
1068
1069         lineOffset += linePackingSpaceBetweenChildren(availableCrossAxisSpace, style()->flexLinePack(), lineContexts.size());
1070     }
1071 }
1072
1073 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
1074 {
1075     LayoutRect oldRect = child->frameRect();
1076
1077     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
1078
1079     // If the child moved, we have to repaint it as well as any floating/positioned
1080     // descendants. An exception is if we need a layout. In this case, we know we're going to
1081     // repaint ourselves (and the child) anyway.
1082     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1083         child->repaintDuringLayoutIfMoved(oldRect);
1084 }
1085
1086 void RenderFlexibleBox::alignChildren(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
1087 {
1088     // Keep track of the space between the baseline edge and the after edge of the box for each line.
1089     WTF::Vector<LayoutUnit> minMarginAfterBaselines;
1090
1091     RenderBox* child = iterator.first();
1092     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1093         LayoutUnit minMarginAfterBaseline = MAX_LAYOUT_UNIT;
1094         LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1095         LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
1096
1097         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1098             ASSERT(child);
1099             switch (flexAlignForChild(child)) {
1100             case AlignAuto:
1101                 ASSERT_NOT_REACHED();
1102                 break;
1103             case AlignStretch: {
1104                 applyStretchAlignmentToChild(child, lineCrossAxisExtent);
1105                 // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1106                 if (style()->flexWrap() == FlexWrapReverse)
1107                     adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1108                 break;
1109             }
1110             case AlignStart:
1111                 break;
1112             case AlignEnd:
1113                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1114                 break;
1115             case AlignCenter:
1116                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1117                 break;
1118             case AlignBaseline: {
1119                 LayoutUnit ascent = marginBoxAscentForChild(child);
1120                 LayoutUnit startOffset = maxAscent - ascent;
1121                 adjustAlignmentForChild(child, startOffset);
1122
1123                 if (style()->flexWrap() == FlexWrapReverse)
1124                     minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) - startOffset);
1125                 break;
1126             }
1127             }
1128         }
1129         minMarginAfterBaselines.append(minMarginAfterBaseline);
1130     }
1131
1132     if (style()->flexWrap() != FlexWrapReverse)
1133         return;
1134
1135     // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
1136     // need to align the after edge of baseline elements with the after edge of the flex line.
1137     child = iterator.first();
1138     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1139         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1140         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1141             ASSERT(child);
1142             if (flexAlignForChild(child) == AlignBaseline && minMarginAfterBaseline)
1143                 adjustAlignmentForChild(child, minMarginAfterBaseline);
1144         }
1145     }
1146 }
1147
1148 void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox* child, LayoutUnit lineCrossAxisExtent)
1149 {
1150     if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
1151         LayoutUnit logicalHeightBefore = child->logicalHeight();
1152         LayoutUnit stretchedLogicalHeight = child->logicalHeight() + availableAlignmentSpaceForChild(lineCrossAxisExtent, child);
1153         if (stretchedLogicalHeight < logicalHeightBefore)
1154             return;
1155
1156         child->setLogicalHeight(stretchedLogicalHeight);
1157         child->computeLogicalHeight();
1158
1159         if (child->logicalHeight() != logicalHeightBefore) {
1160             child->setOverrideHeight(child->logicalHeight());
1161             child->setLogicalHeight(0);
1162             child->setChildNeedsLayout(true);
1163             child->layoutIfNeeded();
1164         }
1165     } else if (isColumnFlow() && child->style()->logicalWidth().isAuto() && isMultiline()) {
1166         // FIXME: Handle min-width and max-width.
1167         LayoutUnit childWidth = lineCrossAxisExtent - crossAxisMarginExtentForChild(child);
1168         child->setOverrideWidth(std::max(ZERO_LAYOUT_UNIT, childWidth));
1169         child->setChildNeedsLayout(true);
1170         child->layoutIfNeeded();
1171     }
1172 }
1173
1174 void RenderFlexibleBox::flipForRightToLeftColumn(FlexOrderIterator& iterator)
1175 {
1176     if (style()->isLeftToRightDirection() || !isColumnFlow())
1177         return;
1178
1179     LayoutUnit crossExtent = crossAxisExtent();
1180     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
1181         LayoutPoint location = flowAwareLocationForChild(child);
1182         location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
1183         setFlowAwareLocationForChild(child, location);
1184     }
1185 }
1186
1187 void RenderFlexibleBox::flipForWrapReverse(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts, LayoutUnit crossAxisStartEdge)
1188 {
1189     LayoutUnit contentExtent = crossAxisContentExtent();
1190     RenderBox* child = iterator.first();
1191     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1192         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1193             ASSERT(child);
1194             LayoutPoint location = flowAwareLocationForChild(child);
1195             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1196             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
1197             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
1198             location.setY(location.y() + newOffset - originalOffset);
1199
1200             LayoutRect oldRect = child->frameRect();
1201             setFlowAwareLocationForChild(child, location);
1202             if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1203                 child->repaintDuringLayoutIfMoved(oldRect);
1204         }
1205     }
1206 }
1207
1208 }