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