apply cross axis constraints before aligning children in flexbox
[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, int, BlockLayoutPass)
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     IntSize 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(relayoutChildren, 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     updateScrollInfoAfterLayout();
291
292     repainter.repaintAfterLayout();
293
294     setNeedsLayout(false);
295 }
296
297 void RenderFlexibleBox::repositionLogicalHeightDependentFlexItems(FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts, LayoutUnit& oldClientAfterEdge)
298 {
299     // If we have a single line flexbox, the line height is all the available space.
300     // For flex-direction: row, this means we need to use the height, so we do this after calling computeLogicalHeight.
301     if (!isMultiline() && lineContexts.size() == 1)
302         lineContexts[0].crossAxisExtent = crossAxisContentExtent();
303     alignChildren(iterator, lineContexts);
304
305     if (style()->flexWrap() == FlexWrapReverse) {
306         if (isHorizontalFlow())
307             oldClientAfterEdge = clientLogicalBottom();
308         flipForWrapReverse(iterator, lineContexts);
309     }
310
311     // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
312     flipForRightToLeftColumn(iterator);
313 }
314
315 bool RenderFlexibleBox::hasOrthogonalFlow(RenderBox* child) const
316 {
317     // FIXME: If the child is a flexbox, then we need to check isHorizontalFlow.
318     return isHorizontalFlow() != child->isHorizontalWritingMode();
319 }
320
321 bool RenderFlexibleBox::isColumnFlow() const
322 {
323     return style()->isColumnFlexDirection();
324 }
325
326 bool RenderFlexibleBox::isHorizontalFlow() const
327 {
328     if (isHorizontalWritingMode())
329         return !isColumnFlow();
330     return isColumnFlow();
331 }
332
333 bool RenderFlexibleBox::isLeftToRightFlow() const
334 {
335     if (isColumnFlow())
336         return style()->writingMode() == TopToBottomWritingMode || style()->writingMode() == LeftToRightWritingMode;
337     return style()->isLeftToRightDirection() ^ (style()->flexDirection() == FlowRowReverse);
338 }
339
340 bool RenderFlexibleBox::isMultiline() const
341 {
342     return style()->flexWrap() != FlexWrapNone;
343 }
344
345 Length RenderFlexibleBox::mainAxisLengthForChild(RenderBox* child) const
346 {
347     return isHorizontalFlow() ? child->style()->width() : child->style()->height();
348 }
349
350 Length RenderFlexibleBox::crossAxisLength() const
351 {
352     return isHorizontalFlow() ? style()->height() : style()->width();
353 }
354
355 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
356 {
357     if (isHorizontalFlow())
358         setHeight(extent);
359     else
360         setWidth(extent);
361 }
362
363 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
364 {
365     return isHorizontalFlow() ? child->height() : child->width();
366 }
367
368 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
369 {
370     return isHorizontalFlow() ? child->width() : child->height();
371 }
372
373 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
374 {
375     return isHorizontalFlow() ? height() : width();
376 }
377
378 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
379 {
380     return isHorizontalFlow() ? width() : height();
381 }
382
383 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
384 {
385     return isHorizontalFlow() ? contentHeight() : contentWidth();
386 }
387
388 LayoutUnit RenderFlexibleBox::mainAxisContentExtent() const
389 {
390     return isHorizontalFlow() ? contentWidth() : contentHeight();
391 }
392
393 WritingMode RenderFlexibleBox::transformedWritingMode() const
394 {
395     WritingMode mode = style()->writingMode();
396     if (!isColumnFlow())
397         return mode;
398
399     switch (mode) {
400     case TopToBottomWritingMode:
401     case BottomToTopWritingMode:
402         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
403     case LeftToRightWritingMode:
404     case RightToLeftWritingMode:
405         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
406     }
407     ASSERT_NOT_REACHED();
408     return TopToBottomWritingMode;
409 }
410
411 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
412 {
413     if (isHorizontalFlow())
414         return isLeftToRightFlow() ? borderLeft() : borderRight();
415     return isLeftToRightFlow() ? borderTop() : borderBottom();
416 }
417
418 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
419 {
420     if (isHorizontalFlow())
421         return isLeftToRightFlow() ? borderRight() : borderLeft();
422     return isLeftToRightFlow() ? borderBottom() : borderTop();
423 }
424
425 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
426 {
427     switch (transformedWritingMode()) {
428     case TopToBottomWritingMode:
429         return borderTop();
430     case BottomToTopWritingMode:
431         return borderBottom();
432     case LeftToRightWritingMode:
433         return borderLeft();
434     case RightToLeftWritingMode:
435         return borderRight();
436     }
437     ASSERT_NOT_REACHED();
438     return borderTop();
439 }
440
441 LayoutUnit RenderFlexibleBox::flowAwareBorderAfter() const
442 {
443     switch (transformedWritingMode()) {
444     case TopToBottomWritingMode:
445         return borderBottom();
446     case BottomToTopWritingMode:
447         return borderTop();
448     case LeftToRightWritingMode:
449         return borderRight();
450     case RightToLeftWritingMode:
451         return borderLeft();
452     }
453     ASSERT_NOT_REACHED();
454     return borderTop();
455 }
456
457 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
458 {
459     if (isHorizontalFlow())
460         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
461     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
462 }
463
464 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
465 {
466     if (isHorizontalFlow())
467         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
468     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
469 }
470
471 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
472 {
473     switch (transformedWritingMode()) {
474     case TopToBottomWritingMode:
475         return paddingTop();
476     case BottomToTopWritingMode:
477         return paddingBottom();
478     case LeftToRightWritingMode:
479         return paddingLeft();
480     case RightToLeftWritingMode:
481         return paddingRight();
482     }
483     ASSERT_NOT_REACHED();
484     return paddingTop();
485 }
486
487 LayoutUnit RenderFlexibleBox::flowAwarePaddingAfter() const
488 {
489     switch (transformedWritingMode()) {
490     case TopToBottomWritingMode:
491         return paddingBottom();
492     case BottomToTopWritingMode:
493         return paddingTop();
494     case LeftToRightWritingMode:
495         return paddingRight();
496     case RightToLeftWritingMode:
497         return paddingLeft();
498     }
499     ASSERT_NOT_REACHED();
500     return paddingTop();
501 }
502
503 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
504 {
505     if (isHorizontalFlow())
506         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
507     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
508 }
509
510 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
511 {
512     if (isHorizontalFlow())
513         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
514     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
515 }
516
517 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
518 {
519     switch (transformedWritingMode()) {
520     case TopToBottomWritingMode:
521         return child->marginTop();
522     case BottomToTopWritingMode:
523         return child->marginBottom();
524     case LeftToRightWritingMode:
525         return child->marginLeft();
526     case RightToLeftWritingMode:
527         return child->marginRight();
528     }
529     ASSERT_NOT_REACHED();
530     return marginTop();
531 }
532
533 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
534 {
535     switch (transformedWritingMode()) {
536     case TopToBottomWritingMode:
537         return child->marginBottom();
538     case BottomToTopWritingMode:
539         return child->marginTop();
540     case LeftToRightWritingMode:
541         return child->marginRight();
542     case RightToLeftWritingMode:
543         return child->marginLeft();
544     }
545     ASSERT_NOT_REACHED();
546     return marginBottom();
547 }
548
549 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
550 {
551     return isHorizontalFlow() ? child->marginHeight() : child->marginWidth();
552 }
553
554 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
555 {
556     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
557 }
558
559 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
560 {
561     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
562 }
563
564 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
565 {
566     if (isHorizontalFlow())
567         child->setLocation(location);
568     else
569         child->setLocation(location.transposedPoint());
570 }
571
572 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
573 {
574     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
575 }
576
577 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
578 {
579     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
580 }
581
582 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child) const
583 {
584     Length mainAxisLength = mainAxisLengthForChild(child);
585     if (mainAxisLength.isAuto()) {
586         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
587         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
588     }
589     return miminumValueForLength(mainAxisLength, mainAxisContentExtent());
590 }
591
592 LayoutUnit RenderFlexibleBox::computeAvailableFreeSpace(LayoutUnit preferredMainAxisExtent)
593 {
594     if (!isColumnFlow())
595         return mainAxisContentExtent() - preferredMainAxisExtent;
596
597     if (hasOverrideHeight())
598         return overrideHeight();
599
600     LayoutUnit heightResult = computeContentLogicalHeightUsing(style()->logicalHeight());
601     if (heightResult == -1)
602         heightResult = preferredMainAxisExtent;
603     LayoutUnit minHeight = computeContentLogicalHeightUsing(style()->logicalMinHeight()); // Leave as -1 if unset.
604     LayoutUnit maxHeight = style()->logicalMaxHeight().isUndefined() ? heightResult : computeContentLogicalHeightUsing(style()->logicalMaxHeight());
605     if (maxHeight == -1)
606         maxHeight = heightResult;
607     heightResult = std::min(maxHeight, heightResult);
608     heightResult = std::max(minHeight, heightResult);
609
610     return heightResult - preferredMainAxisExtent;
611 }
612
613 void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren, FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
614 {
615     OrderedFlexItemList orderedChildren;
616     LayoutUnit preferredMainAxisExtent;
617     float totalPositiveFlexibility;
618     float totalNegativeFlexibility;
619     LayoutUnit minMaxAppliedMainAxisExtent;
620
621     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
622     while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility, minMaxAppliedMainAxisExtent)) {
623         LayoutUnit availableFreeSpace = computeAvailableFreeSpace(preferredMainAxisExtent);
624         FlexSign flexSign = (minMaxAppliedMainAxisExtent < preferredMainAxisExtent + availableFreeSpace) ? PositiveFlexibility : NegativeFlexibility;
625         InflexibleFlexItemSize inflexibleItems;
626         WTF::Vector<LayoutUnit> childSizes;
627         while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
628             ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
629             ASSERT(inflexibleItems.size() > 0);
630         }
631
632         layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, availableFreeSpace, lineContexts);
633     }
634 }
635
636 float RenderFlexibleBox::positiveFlexForChild(RenderBox* child) const
637 {
638     return isHorizontalFlow() ? child->style()->flexboxWidthPositiveFlex() : child->style()->flexboxHeightPositiveFlex();
639 }
640
641 float RenderFlexibleBox::negativeFlexForChild(RenderBox* child) const
642 {
643     return isHorizontalFlow() ? child->style()->flexboxWidthNegativeFlex() : child->style()->flexboxHeightNegativeFlex();
644 }
645
646 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(LayoutUnit lineCrossAxisExtent, RenderBox* child)
647 {
648     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
649     return lineCrossAxisExtent - childCrossExtent;
650 }
651
652 LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(RenderBox* child)
653 {
654     LayoutUnit ascent = child->firstLineBoxBaseline();
655     if (ascent == -1)
656         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
657     return ascent + flowAwareMarginBeforeForChild(child);
658 }
659
660 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, FlexOrderHashSet& flexOrderValues)
661 {
662     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
663     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
664         flexOrderValues.add(child->style()->flexOrder());
665
666         if (child->isPositioned())
667             continue;
668
669         child->clearOverrideSize();
670         if (mainAxisLengthForChild(child).isAuto()) {
671             if (!relayoutChildren)
672                 child->setChildNeedsLayout(true);
673             child->layoutIfNeeded();
674         }
675
676         // We set the margins because we want to make sure 'auto' has a margin
677         // of 0 and because if we're not auto sizing, we don't do a layout that
678         // computes the start/end margins.
679         if (isHorizontalFlow()) {
680             child->setMarginLeft(miminumValueForLength(child->style()->marginLeft(), flexboxAvailableContentExtent));
681             child->setMarginRight(miminumValueForLength(child->style()->marginRight(), flexboxAvailableContentExtent));
682         } else {
683             child->setMarginTop(miminumValueForLength(child->style()->marginTop(), flexboxAvailableContentExtent));
684             child->setMarginBottom(miminumValueForLength(child->style()->marginBottom(), flexboxAvailableContentExtent));
685         }
686     }
687 }
688
689 LayoutUnit RenderFlexibleBox::lineBreakLength()
690 {
691     if (!isColumnFlow())
692         return mainAxisContentExtent();
693
694     LayoutUnit height = computeContentLogicalHeightUsing(style()->logicalHeight());
695     if (height == -1)
696         height = std::numeric_limits<LayoutUnit>::max();
697     LayoutUnit maxHeight = computeContentLogicalHeightUsing(style()->logicalMaxHeight());
698     if (maxHeight != -1)
699         height = std::min(height, maxHeight);
700     return height;
701 }
702
703 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize, LayoutUnit flexboxAvailableContentExtent)
704 {
705     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
706     Length min = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
707     // FIXME: valueForLength isn't quite right in quirks mode: percentage heights should check parents until a value is found.
708     // https://bugs.webkit.org/show_bug.cgi?id=81809
709     if (max.isSpecified() && childSize > valueForLength(max, flexboxAvailableContentExtent))
710         childSize = valueForLength(max, flexboxAvailableContentExtent);
711     if (min.isSpecified() && childSize < valueForLength(min, flexboxAvailableContentExtent))
712         childSize = valueForLength(min, flexboxAvailableContentExtent);
713     return childSize;
714 }
715
716 bool RenderFlexibleBox::computeNextFlexLine(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent)
717 {
718     orderedChildren.clear();
719     preferredMainAxisExtent = 0;
720     totalPositiveFlexibility = totalNegativeFlexibility = 0;
721     minMaxAppliedMainAxisExtent = 0;
722
723     if (!iterator.currentChild())
724         return false;
725
726     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
727     LayoutUnit lineBreak = lineBreakLength();
728
729     for (RenderBox* child = iterator.currentChild(); child; child = iterator.next()) {
730         if (child->isPositioned()) {
731             orderedChildren.append(child);
732             continue;
733         }
734
735         LayoutUnit childMainAxisExtent = preferredMainAxisContentExtentForChild(child);
736         LayoutUnit childMainAxisMarginBoxExtent = mainAxisBorderAndPaddingExtentForChild(child) + childMainAxisExtent;
737         childMainAxisMarginBoxExtent += isHorizontalFlow() ? child->marginWidth() : child->marginHeight();
738
739         if (isMultiline() && preferredMainAxisExtent + childMainAxisMarginBoxExtent > lineBreak && orderedChildren.size() > 0)
740             break;
741         orderedChildren.append(child);
742         preferredMainAxisExtent += childMainAxisMarginBoxExtent;
743         totalPositiveFlexibility += positiveFlexForChild(child);
744         totalNegativeFlexibility += negativeFlexForChild(child);
745
746         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent, flexboxAvailableContentExtent);
747         minMaxAppliedMainAxisExtent += childMinMaxAppliedMainAxisExtent - childMainAxisExtent + childMainAxisMarginBoxExtent;
748     }
749     return true;
750 }
751
752 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
753 {
754     for (size_t i = 0; i < violations.size(); ++i) {
755         RenderBox* child = violations[i].child;
756         LayoutUnit childSize = violations[i].childSize;
757         availableFreeSpace -= childSize - preferredMainAxisContentExtentForChild(child);
758         totalPositiveFlexibility -= positiveFlexForChild(child);
759         totalNegativeFlexibility -= negativeFlexForChild(child);
760         inflexibleItems.set(child, childSize);
761     }
762 }
763
764 // Returns true if we successfully ran the algorithm and sized the flex items.
765 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
766 {
767     childSizes.clear();
768
769     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
770     LayoutUnit totalViolation = 0;
771     WTF::Vector<Violation> minViolations;
772     WTF::Vector<Violation> maxViolations;
773     for (size_t i = 0; i < children.size(); ++i) {
774         RenderBox* child = children[i];
775         if (child->isPositioned()) {
776             childSizes.append(0);
777             continue;
778         }
779
780         if (inflexibleItems.contains(child))
781             childSizes.append(inflexibleItems.get(child));
782         else {
783             LayoutUnit childSize = preferredMainAxisContentExtentForChild(child);
784             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0 && flexSign == PositiveFlexibility)
785                 childSize += lroundf(availableFreeSpace * positiveFlexForChild(child) / totalPositiveFlexibility);
786             else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0  && flexSign == NegativeFlexibility)
787                 childSize += lroundf(availableFreeSpace * negativeFlexForChild(child) / totalNegativeFlexibility);
788
789             LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize, flexboxAvailableContentExtent);
790             childSizes.append(adjustedChildSize);
791
792             LayoutUnit violation = adjustedChildSize - childSize;
793             if (violation > 0)
794                 minViolations.append(Violation(child, adjustedChildSize));
795             else if (violation < 0)
796                 maxViolations.append(Violation(child, adjustedChildSize));
797             totalViolation += violation;
798         }
799     }
800
801     if (totalViolation)
802         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems);
803     return !totalViolation;
804 }
805
806 static LayoutUnit initialPackingOffset(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
807 {
808     if (availableFreeSpace > 0) {
809         if (flexPack == PackEnd)
810             return availableFreeSpace;
811         if (flexPack == PackCenter)
812             return availableFreeSpace / 2;
813         if (flexPack == PackDistribute && numberOfChildren)
814             return availableFreeSpace / (2 * numberOfChildren);
815     } else if (availableFreeSpace < 0) {
816         if (flexPack == PackCenter || flexPack == PackDistribute)
817             return availableFreeSpace / 2;
818     }
819     return 0;
820 }
821
822 static LayoutUnit packingSpaceBetweenChildren(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
823 {
824     if (availableFreeSpace > 0 && numberOfChildren > 1) {
825         if (flexPack == PackJustify)
826             return availableFreeSpace / (numberOfChildren - 1);
827         if (flexPack == PackDistribute)
828             return availableFreeSpace / numberOfChildren;
829     }
830     return 0;
831 }
832
833 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
834 {
835     // FIXME: Rename setOverrideWidth/setOverrideHeight to setOverrideLogicalWidth/setOverrideLogicalHeight.
836     if (hasOrthogonalFlow(child))
837         child->setOverrideHeight(childPreferredSize);
838     else
839         child->setOverrideWidth(childPreferredSize);
840 }
841
842 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset)
843 {
844     ASSERT(child->isPositioned());
845     child->containingBlock()->insertPositionedObject(child);
846     RenderLayer* childLayer = child->layer();
847     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
848     if (style()->flexDirection() == FlowRowReverse)
849         inlinePosition = mainAxisExtent() - mainAxisOffset;
850     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
851
852     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
853     if (childLayer->staticBlockPosition() != staticBlockPosition) {
854         childLayer->setStaticBlockPosition(staticBlockPosition);
855         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
856             child->setChildNeedsLayout(true, false);
857     }
858 }
859
860 static EFlexAlign flexAlignForChild(RenderBox* child)
861 {
862     EFlexAlign align = child->style()->flexItemAlign();
863     if (align == AlignAuto)
864         align = child->parent()->style()->flexAlign();
865
866     if (child->parent()->style()->flexWrap() == FlexWrapReverse) {
867         if (align == AlignStart)
868             align = AlignEnd;
869         else if (align == AlignEnd)
870             align = AlignStart;
871     }
872
873     return align;
874 }
875
876 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, WTF::Vector<LineContext>& lineContexts)
877 {
878     ASSERT(childSizes.size() == children.size());
879     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
880     mainAxisOffset += initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
881     if (style()->flexDirection() == FlowRowReverse)
882         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
883
884     LayoutUnit totalMainExtent = mainAxisExtent();
885     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
886     LayoutUnit maxChildCrossAxisExtent = 0;
887     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
888     for (size_t i = 0; i < children.size(); ++i) {
889         RenderBox* child = children[i];
890         if (child->isPositioned()) {
891             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
892             mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
893             continue;
894         }
895         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
896         setLogicalOverrideSize(child, childPreferredSize);
897         child->setChildNeedsLayout(true);
898         child->layoutIfNeeded();
899
900         LayoutUnit childCrossAxisMarginBoxExtent;
901         if (flexAlignForChild(child) == AlignBaseline) {
902             LayoutUnit ascent = marginBoxAscentForChild(child);
903             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
904
905             maxAscent = std::max(maxAscent, ascent);
906             maxDescent = std::max(maxDescent, descent);
907
908             childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
909         } else
910             childCrossAxisMarginBoxExtent = crossAxisExtentForChild(child) + crossAxisMarginExtentForChild(child);
911         if (!isColumnFlow() && style()->logicalHeight().isAuto())
912             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
913         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
914
915         mainAxisOffset += flowAwareMarginStartForChild(child);
916
917         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
918         IntPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
919             crossAxisOffset + flowAwareMarginBeforeForChild(child));
920
921         // FIXME: Supporting layout deltas.
922         setFlowAwareLocationForChild(child, childLocation);
923         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
924
925         mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
926     }
927
928     if (isColumnFlow())
929         setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
930
931     if (style()->flexDirection() == FlowColumnReverse) {
932         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
933         // on the height of the flexbox, which we only know after we've positioned all the flex items.
934         computeLogicalHeight();
935         layoutColumnReverse(children, childSizes, crossAxisOffset, availableFreeSpace);
936     }
937
938     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
939     crossAxisOffset += maxChildCrossAxisExtent;
940 }
941
942 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
943 {
944     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
945     // starting from the end of the flexbox. We also don't need to layout anything since we're
946     // just moving the children to a new position.
947     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
948     mainAxisOffset -= initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
949     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
950
951     for (size_t i = 0; i < children.size(); ++i) {
952         RenderBox* child = children[i];
953         if (child->isPositioned()) {
954             child->layer()->setStaticBlockPosition(mainAxisOffset);
955             mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
956             continue;
957         }
958         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
959
960         LayoutRect oldRect = child->frameRect();
961         setFlowAwareLocationForChild(child, IntPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
962         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
963             child->repaintDuringLayoutIfMoved(oldRect);
964
965         mainAxisOffset -= flowAwareMarginStartForChild(child);
966         mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
967     }
968 }
969
970 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
971 {
972     LayoutRect oldRect = child->frameRect();
973
974     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
975
976     // If the child moved, we have to repaint it as well as any floating/positioned
977     // descendants. An exception is if we need a layout. In this case, we know we're going to
978     // repaint ourselves (and the child) anyway.
979     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
980         child->repaintDuringLayoutIfMoved(oldRect);
981 }
982
983 void RenderFlexibleBox::alignChildren(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
984 {
985     // Keep track of the space between the baseline edge and the after edge of the box for each line.
986     WTF::Vector<LayoutUnit> minMarginAfterBaselines;
987
988     RenderBox* child = iterator.first();
989     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
990         LayoutUnit minMarginAfterBaseline = std::numeric_limits<LayoutUnit>::max();
991         LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
992         LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
993
994         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
995             ASSERT(child);
996             switch (flexAlignForChild(child)) {
997             case AlignAuto:
998                 ASSERT_NOT_REACHED();
999                 break;
1000             case AlignStretch: {
1001                 applyStretchAlignmentToChild(child, lineCrossAxisExtent);
1002                 // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1003                 if (style()->flexWrap() == FlexWrapReverse)
1004                     adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1005                 break;
1006             }
1007             case AlignStart:
1008                 break;
1009             case AlignEnd:
1010                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1011                 break;
1012             case AlignCenter:
1013                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1014                 break;
1015             case AlignBaseline: {
1016                 LayoutUnit ascent = marginBoxAscentForChild(child);
1017                 LayoutUnit startOffset = maxAscent - ascent;
1018                 adjustAlignmentForChild(child, startOffset);
1019
1020                 if (style()->flexWrap() == FlexWrapReverse)
1021                     minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) - startOffset);
1022                 break;
1023             }
1024             }
1025         }
1026         minMarginAfterBaselines.append(minMarginAfterBaseline);
1027     }
1028
1029     if (style()->flexWrap() != FlexWrapReverse)
1030         return;
1031
1032     // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
1033     // need to align the after edge of baseline elements with the after edge of the flex line.
1034     child = iterator.first();
1035     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1036         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1037         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1038             ASSERT(child);
1039             if (flexAlignForChild(child) == AlignBaseline && minMarginAfterBaseline)
1040                 adjustAlignmentForChild(child, minMarginAfterBaseline);
1041         }
1042     }
1043 }
1044
1045 void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox* child, LayoutUnit lineCrossAxisExtent)
1046 {
1047     if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
1048         LayoutUnit logicalHeightBefore = child->logicalHeight();
1049         LayoutUnit stretchedLogicalHeight = child->logicalHeight() + availableAlignmentSpaceForChild(lineCrossAxisExtent, child);
1050         if (stretchedLogicalHeight < logicalHeightBefore)
1051             return;
1052
1053         child->setLogicalHeight(stretchedLogicalHeight);
1054         child->computeLogicalHeight();
1055
1056         if (child->logicalHeight() != logicalHeightBefore) {
1057             child->setOverrideHeight(child->logicalHeight());
1058             child->setLogicalHeight(0);
1059             child->setChildNeedsLayout(true);
1060             child->layoutIfNeeded();
1061         }
1062     } else if (isColumnFlow() && child->style()->logicalWidth().isAuto() && isMultiline()) {
1063         // FIXME: Handle min-width and max-width.
1064         LayoutUnit childWidth = lineCrossAxisExtent - crossAxisMarginExtentForChild(child);
1065         child->setOverrideWidth(std::max(0, childWidth));
1066         child->setChildNeedsLayout(true);
1067         child->layoutIfNeeded();
1068     }
1069 }
1070
1071 void RenderFlexibleBox::flipForRightToLeftColumn(FlexOrderIterator& iterator)
1072 {
1073     if (style()->isLeftToRightDirection() || !isColumnFlow())
1074         return;
1075
1076     LayoutUnit crossExtent = crossAxisExtent();
1077     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
1078         LayoutPoint location = flowAwareLocationForChild(child);
1079         location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
1080         setFlowAwareLocationForChild(child, location);
1081     }
1082 }
1083
1084 void RenderFlexibleBox::flipForWrapReverse(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
1085 {
1086     LayoutUnit contentExtent = crossAxisContentExtent();
1087     RenderBox* child = iterator.first();
1088     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1089         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1090             ASSERT(child);
1091             LayoutPoint location = flowAwareLocationForChild(child);
1092             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1093             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - lineContexts[0].crossAxisOffset;
1094             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
1095             location.setY(location.y() + newOffset - originalOffset);
1096
1097             LayoutRect oldRect = child->frameRect();
1098             setFlowAwareLocationForChild(child, location);
1099             if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1100                 child->repaintDuringLayoutIfMoved(oldRect);
1101         }
1102     }
1103 }
1104
1105 }