flexbox assert fails with auto-sized item with padding
[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 = adjustContentBoxLogicalWidthForBoxSizing(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, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMinWidth().value()));
221         m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(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, adjustContentBoxLogicalWidthForBoxSizing(styleToUse->logicalMaxWidth().value()));
227         m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(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     updateRegionsAndExclusionsLogicalSize();
253
254     LayoutSize previousSize = size();
255
256     setLogicalHeight(0);
257     updateLogicalWidth();
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     updateLogicalHeight();
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 updateLogicalHeight.
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 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
364 {
365     if (isHorizontalFlow())
366         setHeight(extent);
367     else
368         setWidth(extent);
369 }
370
371 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
372 {
373     return isHorizontalFlow() ? child->height() : child->width();
374 }
375
376 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
377 {
378     return isHorizontalFlow() ? child->width() : child->height();
379 }
380
381 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
382 {
383     return isHorizontalFlow() ? height() : width();
384 }
385
386 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
387 {
388     return isHorizontalFlow() ? width() : height();
389 }
390
391 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
392 {
393     return isHorizontalFlow() ? contentHeight() : contentWidth();
394 }
395
396 LayoutUnit RenderFlexibleBox::mainAxisContentExtent(LayoutUnit contentLogicalHeight)
397 {
398     if (isColumnFlow()) {
399         LogicalExtentComputedValues computedValues;
400         computeLogicalHeight(contentLogicalHeight, logicalTop(), computedValues);
401         return std::max(LayoutUnit(0), computedValues.m_extent - borderAndPaddingLogicalHeight() - scrollbarLogicalHeight());
402     }
403     return contentLogicalWidth();
404 }
405
406 LayoutUnit RenderFlexibleBox::computeMainAxisExtentForChild(RenderBox* child, SizeType sizeType, const Length& size)
407 {
408     // FIXME: This is wrong for orthogonal flows. It should use the flexbox's writing-mode, not the child's in order
409     // to figure out the logical height/width.
410     if (isColumnFlow())
411         return child->computeContentLogicalHeight(sizeType, size);
412     return child->adjustContentBoxLogicalWidthForBoxSizing(valueForLength(size, contentLogicalWidth(), view()));
413 }
414
415 WritingMode RenderFlexibleBox::transformedWritingMode() const
416 {
417     WritingMode mode = style()->writingMode();
418     if (!isColumnFlow())
419         return mode;
420
421     switch (mode) {
422     case TopToBottomWritingMode:
423     case BottomToTopWritingMode:
424         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
425     case LeftToRightWritingMode:
426     case RightToLeftWritingMode:
427         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
428     }
429     ASSERT_NOT_REACHED();
430     return TopToBottomWritingMode;
431 }
432
433 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
434 {
435     if (isHorizontalFlow())
436         return isLeftToRightFlow() ? borderLeft() : borderRight();
437     return isLeftToRightFlow() ? borderTop() : borderBottom();
438 }
439
440 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
441 {
442     if (isHorizontalFlow())
443         return isLeftToRightFlow() ? borderRight() : borderLeft();
444     return isLeftToRightFlow() ? borderBottom() : borderTop();
445 }
446
447 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
448 {
449     switch (transformedWritingMode()) {
450     case TopToBottomWritingMode:
451         return borderTop();
452     case BottomToTopWritingMode:
453         return borderBottom();
454     case LeftToRightWritingMode:
455         return borderLeft();
456     case RightToLeftWritingMode:
457         return borderRight();
458     }
459     ASSERT_NOT_REACHED();
460     return borderTop();
461 }
462
463 LayoutUnit RenderFlexibleBox::flowAwareBorderAfter() const
464 {
465     switch (transformedWritingMode()) {
466     case TopToBottomWritingMode:
467         return borderBottom();
468     case BottomToTopWritingMode:
469         return borderTop();
470     case LeftToRightWritingMode:
471         return borderRight();
472     case RightToLeftWritingMode:
473         return borderLeft();
474     }
475     ASSERT_NOT_REACHED();
476     return borderTop();
477 }
478
479 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
480 {
481     if (isHorizontalFlow())
482         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
483     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
484 }
485
486 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
487 {
488     if (isHorizontalFlow())
489         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
490     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
491 }
492
493 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
494 {
495     switch (transformedWritingMode()) {
496     case TopToBottomWritingMode:
497         return paddingTop();
498     case BottomToTopWritingMode:
499         return paddingBottom();
500     case LeftToRightWritingMode:
501         return paddingLeft();
502     case RightToLeftWritingMode:
503         return paddingRight();
504     }
505     ASSERT_NOT_REACHED();
506     return paddingTop();
507 }
508
509 LayoutUnit RenderFlexibleBox::flowAwarePaddingAfter() const
510 {
511     switch (transformedWritingMode()) {
512     case TopToBottomWritingMode:
513         return paddingBottom();
514     case BottomToTopWritingMode:
515         return paddingTop();
516     case LeftToRightWritingMode:
517         return paddingRight();
518     case RightToLeftWritingMode:
519         return paddingLeft();
520     }
521     ASSERT_NOT_REACHED();
522     return paddingTop();
523 }
524
525 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
526 {
527     if (isHorizontalFlow())
528         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
529     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
530 }
531
532 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
533 {
534     if (isHorizontalFlow())
535         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
536     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
537 }
538
539 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
540 {
541     switch (transformedWritingMode()) {
542     case TopToBottomWritingMode:
543         return child->marginTop();
544     case BottomToTopWritingMode:
545         return child->marginBottom();
546     case LeftToRightWritingMode:
547         return child->marginLeft();
548     case RightToLeftWritingMode:
549         return child->marginRight();
550     }
551     ASSERT_NOT_REACHED();
552     return marginTop();
553 }
554
555 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
556 {
557     switch (transformedWritingMode()) {
558     case TopToBottomWritingMode:
559         return child->marginBottom();
560     case BottomToTopWritingMode:
561         return child->marginTop();
562     case LeftToRightWritingMode:
563         return child->marginRight();
564     case RightToLeftWritingMode:
565         return child->marginLeft();
566     }
567     ASSERT_NOT_REACHED();
568     return marginBottom();
569 }
570
571 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
572 {
573     return isHorizontalFlow() ? child->marginHeight() : child->marginWidth();
574 }
575
576 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
577 {
578     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
579 }
580
581 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
582 {
583     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
584 }
585
586 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
587 {
588     if (isHorizontalFlow())
589         child->setLocation(location);
590     else
591         child->setLocation(location.transposedPoint());
592 }
593
594 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
595 {
596     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
597 }
598
599 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
600 {
601     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
602 }
603
604 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child)
605 {
606     Length flexBasis = flexBasisForChild(child);
607     if (flexBasis.isAuto()) {
608         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
609         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
610     }
611     return std::max(LayoutUnit(0), computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis));
612 }
613
614 void RenderFlexibleBox::layoutFlexItems(OrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
615 {
616     OrderedFlexItemList orderedChildren;
617     LayoutUnit preferredMainAxisExtent;
618     double totalFlexGrow;
619     double totalWeightedFlexShrink;
620     LayoutUnit minMaxAppliedMainAxisExtent;
621
622     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
623     while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalFlexGrow, totalWeightedFlexShrink, minMaxAppliedMainAxisExtent)) {
624         LayoutUnit availableFreeSpace = mainAxisContentExtent(preferredMainAxisExtent) - preferredMainAxisExtent;
625         FlexSign flexSign = (minMaxAppliedMainAxisExtent < preferredMainAxisExtent + availableFreeSpace) ? PositiveFlexibility : NegativeFlexibility;
626         InflexibleFlexItemSize inflexibleItems;
627         WTF::Vector<LayoutUnit> childSizes;
628         while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalFlexGrow, totalWeightedFlexShrink, inflexibleItems, childSizes)) {
629             ASSERT(totalFlexGrow >= 0 && totalWeightedFlexShrink >= 0);
630             ASSERT(inflexibleItems.size() > 0);
631         }
632
633         layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, availableFreeSpace, lineContexts);
634     }
635 }
636
637 LayoutUnit RenderFlexibleBox::autoMarginOffsetInMainAxis(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace)
638 {
639     if (availableFreeSpace <= 0)
640         return 0;
641
642     int numberOfAutoMargins = 0;
643     bool isHorizontal = isHorizontalFlow();
644     for (size_t i = 0; i < children.size(); ++i) {
645         RenderBox* child = children[i];
646         if (child->isOutOfFlowPositioned())
647             continue;
648         if (isHorizontal) {
649             if (child->style()->marginLeft().isAuto())
650                 ++numberOfAutoMargins;
651             if (child->style()->marginRight().isAuto())
652                 ++numberOfAutoMargins;
653         } else {
654             if (child->style()->marginTop().isAuto())
655                 ++numberOfAutoMargins;
656             if (child->style()->marginBottom().isAuto())
657                 ++numberOfAutoMargins;
658         }
659     }
660     if (!numberOfAutoMargins)
661         return 0;
662
663     LayoutUnit sizeOfAutoMargin = availableFreeSpace / numberOfAutoMargins;
664     availableFreeSpace = 0;
665     return sizeOfAutoMargin;
666 }
667
668 void RenderFlexibleBox::updateAutoMarginsInMainAxis(RenderBox* child, LayoutUnit autoMarginOffset)
669 {
670     if (isHorizontalFlow()) {
671         if (child->style()->marginLeft().isAuto())
672             child->setMarginLeft(autoMarginOffset);
673         if (child->style()->marginRight().isAuto())
674             child->setMarginRight(autoMarginOffset);
675     } else {
676         if (child->style()->marginTop().isAuto())
677             child->setMarginTop(autoMarginOffset);
678         if (child->style()->marginBottom().isAuto())
679             child->setMarginBottom(autoMarginOffset);
680     }
681 }
682
683 bool RenderFlexibleBox::hasAutoMarginsInCrossAxis(RenderBox* child)
684 {
685     if (isHorizontalFlow())
686         return child->style()->marginTop().isAuto() || child->style()->marginBottom().isAuto();
687     return child->style()->marginLeft().isAuto() || child->style()->marginRight().isAuto();
688 }
689
690 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(LayoutUnit lineCrossAxisExtent, RenderBox* child)
691 {
692     ASSERT(!child->isOutOfFlowPositioned());
693     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
694     return lineCrossAxisExtent - childCrossExtent;
695 }
696
697 bool RenderFlexibleBox::updateAutoMarginsInCrossAxis(RenderBox* child, LayoutUnit availableAlignmentSpace)
698 {
699     ASSERT(!child->isOutOfFlowPositioned());
700
701     bool isHorizontal = isHorizontalFlow();
702     Length start = isHorizontal ? child->style()->marginTop() : child->style()->marginLeft();
703     Length end = isHorizontal ? child->style()->marginBottom() : child->style()->marginRight();
704     if (start.isAuto() && end.isAuto()) {
705         adjustAlignmentForChild(child, availableAlignmentSpace / 2);
706         if (isHorizontal) {
707             child->setMarginTop(availableAlignmentSpace / 2);
708             child->setMarginBottom(availableAlignmentSpace / 2);
709         } else {
710             child->setMarginLeft(availableAlignmentSpace / 2);
711             child->setMarginRight(availableAlignmentSpace / 2);
712         }
713         return true;
714     }
715     if (start.isAuto()) {
716         adjustAlignmentForChild(child, availableAlignmentSpace);
717         if (isHorizontal)
718             child->setMarginTop(availableAlignmentSpace);
719         else
720             child->setMarginLeft(availableAlignmentSpace);
721         return true;
722     }
723     if (end.isAuto()) {
724         if (isHorizontal)
725             child->setMarginBottom(availableAlignmentSpace);
726         else
727             child->setMarginRight(availableAlignmentSpace);
728         return true;
729     }
730     return false;
731 }
732
733 LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(RenderBox* child)
734 {
735     LayoutUnit ascent = child->firstLineBoxBaseline();
736     if (ascent == -1)
737         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
738     return ascent + flowAwareMarginBeforeForChild(child);
739 }
740
741 LayoutUnit RenderFlexibleBox::computeChildMarginValue(Length margin, RenderView* view)
742 {
743     // When resolving the margins, we use the content size for resolving percent and calc (for percents in calc expressions) margins.
744     // Fortunately, percent margins are always computed with respect to the block's width, even for margin-top and margin-bottom.
745     LayoutUnit availableSize = contentLogicalWidth();
746     return minimumValueForLength(margin, availableSize, view);
747 }
748
749 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, OrderHashSet& orderValues)
750 {
751     RenderView* renderView = view();
752     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
753         orderValues.add(child->style()->order());
754
755         if (child->isOutOfFlowPositioned())
756             continue;
757
758         child->clearOverrideSize();
759         // Only need to layout here if we will need to get the logicalHeight of the child in computeNextFlexLine.
760         Length childMainAxisMin = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
761         if (hasOrthogonalFlow(child) && (flexBasisForChild(child).isAuto() || childMainAxisMin.isAuto())) {
762             if (!relayoutChildren)
763                 child->setChildNeedsLayout(true, MarkOnlyThis);
764             child->layoutIfNeeded();
765         }
766
767         // Before running the flex algorithm, 'auto' has a margin of 0.
768         // Also, if we're not auto sizing, we don't do a layout that computes the start/end margins.
769         if (isHorizontalFlow()) {
770             child->setMarginLeft(computeChildMarginValue(child->style()->marginLeft(), renderView));
771             child->setMarginRight(computeChildMarginValue(child->style()->marginRight(), renderView));
772         } else {
773             child->setMarginTop(computeChildMarginValue(child->style()->marginTop(), renderView));
774             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom(), renderView));
775         }
776     }
777 }
778
779 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize)
780 {
781     // FIXME: Support intrinsic min/max lengths.
782     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
783     if (max.isSpecified()) {
784         LayoutUnit maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
785         if (maxExtent != -1 && childSize > maxExtent)
786             childSize = maxExtent;
787     }
788
789     Length min = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
790     LayoutUnit minExtent = 0;
791     if (min.isSpecified())
792         minExtent = computeMainAxisExtentForChild(child, MinSize, min);
793     else if (min.isAuto()) {
794         minExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->minPreferredLogicalWidth();
795         minExtent -= mainAxisBorderAndPaddingExtentForChild(child);
796     }
797     return std::max(childSize, minExtent);
798 }
799
800 bool RenderFlexibleBox::computeNextFlexLine(OrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, double& totalFlexGrow, double& totalWeightedFlexShrink, LayoutUnit& minMaxAppliedMainAxisExtent)
801 {
802     orderedChildren.clear();
803     preferredMainAxisExtent = 0;
804     totalFlexGrow = totalWeightedFlexShrink = 0;
805     minMaxAppliedMainAxisExtent = 0;
806
807     if (!iterator.currentChild())
808         return false;
809
810     LayoutUnit lineBreakLength = mainAxisContentExtent(MAX_LAYOUT_UNIT);
811
812     for (RenderBox* child = iterator.currentChild(); child; child = iterator.next()) {
813         if (child->isOutOfFlowPositioned()) {
814             orderedChildren.append(child);
815             continue;
816         }
817
818         LayoutUnit childMainAxisExtent = preferredMainAxisContentExtentForChild(child);
819         LayoutUnit childMainAxisMarginBoxExtent = mainAxisBorderAndPaddingExtentForChild(child) + childMainAxisExtent;
820         childMainAxisMarginBoxExtent += isHorizontalFlow() ? child->marginWidth() : child->marginHeight();
821
822         if (isMultiline() && preferredMainAxisExtent + childMainAxisMarginBoxExtent > lineBreakLength && orderedChildren.size() > 0)
823             break;
824         orderedChildren.append(child);
825         preferredMainAxisExtent += childMainAxisMarginBoxExtent;
826         totalFlexGrow += child->style()->flexGrow();
827         totalWeightedFlexShrink += child->style()->flexShrink() * childMainAxisExtent;
828
829         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent);
830         minMaxAppliedMainAxisExtent += childMinMaxAppliedMainAxisExtent - childMainAxisExtent + childMainAxisMarginBoxExtent;
831     }
832     return true;
833 }
834
835 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems)
836 {
837     for (size_t i = 0; i < violations.size(); ++i) {
838         RenderBox* child = violations[i].child;
839         LayoutUnit childSize = violations[i].childSize;
840         LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
841         availableFreeSpace -= childSize - preferredChildSize;
842         totalFlexGrow -= child->style()->flexGrow();
843         totalWeightedFlexShrink -= child->style()->flexShrink() * preferredChildSize;
844         inflexibleItems.set(child, childSize);
845     }
846 }
847
848 // Returns true if we successfully ran the algorithm and sized the flex items.
849 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
850 {
851     childSizes.clear();
852     LayoutUnit totalViolation = 0;
853     LayoutUnit usedFreeSpace = 0;
854     WTF::Vector<Violation> minViolations;
855     WTF::Vector<Violation> maxViolations;
856     for (size_t i = 0; i < children.size(); ++i) {
857         RenderBox* child = children[i];
858         if (child->isOutOfFlowPositioned()) {
859             childSizes.append(0);
860             continue;
861         }
862
863         if (inflexibleItems.contains(child))
864             childSizes.append(inflexibleItems.get(child));
865         else {
866             LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
867             LayoutUnit childSize = preferredChildSize;
868             if (availableFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && isfinite(totalFlexGrow))
869                 childSize += roundedLayoutUnit(availableFreeSpace * child->style()->flexGrow() / totalFlexGrow);
870             else if (availableFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && isfinite(totalWeightedFlexShrink))
871                 childSize += roundedLayoutUnit(availableFreeSpace * child->style()->flexShrink() * preferredChildSize / totalWeightedFlexShrink);
872
873             LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize);
874             childSizes.append(adjustedChildSize);
875             usedFreeSpace += adjustedChildSize - preferredChildSize;
876
877             LayoutUnit violation = adjustedChildSize - childSize;
878             if (violation > 0)
879                 minViolations.append(Violation(child, adjustedChildSize));
880             else if (violation < 0)
881                 maxViolations.append(Violation(child, adjustedChildSize));
882             totalViolation += violation;
883         }
884     }
885
886     if (totalViolation)
887         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalFlexGrow, totalWeightedFlexShrink, inflexibleItems);
888     else
889         availableFreeSpace -= usedFreeSpace;
890
891     return !totalViolation;
892 }
893
894 static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
895 {
896     if (justifyContent == JustifyFlexEnd)
897         return availableFreeSpace;
898     if (justifyContent == JustifyCenter)
899         return availableFreeSpace / 2;
900     if (justifyContent == JustifySpaceAround) {
901         if (availableFreeSpace > 0 && numberOfChildren)
902             return availableFreeSpace / (2 * numberOfChildren);
903         else
904             return availableFreeSpace / 2;
905     }
906     return 0;
907 }
908
909 static LayoutUnit justifyContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
910 {
911     if (availableFreeSpace > 0 && numberOfChildren > 1) {
912         if (justifyContent == JustifySpaceBetween)
913             return availableFreeSpace / (numberOfChildren - 1);
914         if (justifyContent == JustifySpaceAround)
915             return availableFreeSpace / numberOfChildren;
916     }
917     return 0;
918 }
919
920 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
921 {
922     if (hasOrthogonalFlow(child))
923         child->setOverrideLogicalContentHeight(childPreferredSize - child->borderAndPaddingLogicalHeight());
924     else
925         child->setOverrideLogicalContentWidth(childPreferredSize - child->borderAndPaddingLogicalWidth());
926 }
927
928 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset, PositionedLayoutMode layoutMode)
929 {
930     ASSERT(child->isOutOfFlowPositioned());
931     child->containingBlock()->insertPositionedObject(child);
932     RenderLayer* childLayer = child->layer();
933     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
934     if (layoutMode == FlipForRowReverse && style()->flexDirection() == FlowRowReverse)
935         inlinePosition = mainAxisExtent() - mainAxisOffset;
936     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
937
938     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
939     if (childLayer->staticBlockPosition() != staticBlockPosition) {
940         childLayer->setStaticBlockPosition(staticBlockPosition);
941         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
942             child->setChildNeedsLayout(true, MarkOnlyThis);
943     }
944 }
945
946 static EAlignItems alignmentForChild(RenderBox* child)
947 {
948     EAlignItems align = child->style()->alignSelf();
949     if (align == AlignAuto)
950         align = child->parent()->style()->alignItems();
951
952     if (child->parent()->style()->flexWrap() == FlexWrapReverse) {
953         if (align == AlignFlexStart)
954             align = AlignFlexEnd;
955         else if (align == AlignFlexEnd)
956             align = AlignFlexStart;
957     }
958
959     return align;
960 }
961
962 size_t RenderFlexibleBox::numberOfInFlowPositionedChildren(const OrderedFlexItemList& children) const
963 {
964     size_t count = 0;
965     for (size_t i = 0; i < children.size(); ++i) {
966         RenderBox* child = children[i];
967         if (!child->isOutOfFlowPositioned())
968             ++count;
969     }
970     return count;
971 }
972
973 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, WTF::Vector<LineContext>& lineContexts)
974 {
975     ASSERT(childSizes.size() == children.size());
976
977     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
978     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
979     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
980     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), numberOfChildrenForJustifyContent);
981     if (style()->flexDirection() == FlowRowReverse)
982         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
983
984     LayoutUnit totalMainExtent = mainAxisExtent();
985     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when align-items: baseline.
986     LayoutUnit maxChildCrossAxisExtent = 0;
987     size_t seenInFlowPositionedChildren = 0;
988     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
989     for (size_t i = 0; i < children.size(); ++i) {
990         RenderBox* child = children[i];
991         if (child->isOutOfFlowPositioned()) {
992             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset, FlipForRowReverse);
993             continue;
994         }
995         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
996         setLogicalOverrideSize(child, childPreferredSize);
997         // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
998         child->setChildNeedsLayout(true, MarkOnlyThis);
999         child->layoutIfNeeded();
1000
1001         updateAutoMarginsInMainAxis(child, autoMarginOffset);
1002
1003         LayoutUnit childCrossAxisMarginBoxExtent;
1004         if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child)) {
1005             LayoutUnit ascent = marginBoxAscentForChild(child);
1006             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
1007
1008             maxAscent = std::max(maxAscent, ascent);
1009             maxDescent = std::max(maxDescent, descent);
1010
1011             childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
1012         } else
1013             childCrossAxisMarginBoxExtent = crossAxisExtentForChild(child) + crossAxisMarginExtentForChild(child);
1014         if (!isColumnFlow() && style()->logicalHeight().isAuto())
1015             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
1016         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
1017
1018         mainAxisOffset += flowAwareMarginStartForChild(child);
1019
1020         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
1021         LayoutPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
1022             crossAxisOffset + flowAwareMarginBeforeForChild(child));
1023
1024         // FIXME: Supporting layout deltas.
1025         setFlowAwareLocationForChild(child, childLocation);
1026         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
1027
1028         ++seenInFlowPositionedChildren;
1029         if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
1030             mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), numberOfChildrenForJustifyContent);
1031     }
1032
1033     if (isColumnFlow())
1034         setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
1035
1036     if (style()->flexDirection() == FlowColumnReverse) {
1037         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
1038         // on the height of the flexbox, which we only know after we've positioned all the flex items.
1039         updateLogicalHeight();
1040         layoutColumnReverse(children, crossAxisOffset, availableFreeSpace);
1041     }
1042
1043     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
1044     crossAxisOffset += maxChildCrossAxisExtent;
1045 }
1046
1047 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
1048 {
1049     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
1050     // starting from the end of the flexbox. We also don't need to layout anything since we're
1051     // just moving the children to a new position.
1052     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
1053     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
1054     mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), numberOfChildrenForJustifyContent);
1055     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
1056
1057     size_t seenInFlowPositionedChildren = 0;
1058     for (size_t i = 0; i < children.size(); ++i) {
1059         RenderBox* child = children[i];
1060         if (child->isOutOfFlowPositioned()) {
1061             child->layer()->setStaticBlockPosition(mainAxisOffset);
1062             continue;
1063         }
1064         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
1065
1066         LayoutRect oldRect = child->frameRect();
1067         setFlowAwareLocationForChild(child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
1068         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1069             child->repaintDuringLayoutIfMoved(oldRect);
1070
1071         mainAxisOffset -= flowAwareMarginStartForChild(child);
1072
1073         ++seenInFlowPositionedChildren;
1074         if (seenInFlowPositionedChildren < numberOfChildrenForJustifyContent)
1075             mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), numberOfChildrenForJustifyContent);
1076     }
1077 }
1078
1079 static LayoutUnit initialAlignContentOffset(LayoutUnit availableFreeSpace, EAlignContent alignContent, unsigned numberOfLines)
1080 {
1081     if (alignContent == AlignContentFlexEnd)
1082         return availableFreeSpace;
1083     if (alignContent == AlignContentCenter)
1084         return availableFreeSpace / 2;
1085     if (alignContent == AlignContentSpaceAround) {
1086         if (availableFreeSpace > 0 && numberOfLines)
1087             return availableFreeSpace / (2 * numberOfLines);
1088         if (availableFreeSpace < 0)
1089             return availableFreeSpace / 2;
1090     }
1091     return 0;
1092 }
1093
1094 static LayoutUnit alignContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, EAlignContent alignContent, unsigned numberOfLines)
1095 {
1096     if (availableFreeSpace > 0 && numberOfLines > 1) {
1097         if (alignContent == AlignContentSpaceBetween)
1098             return availableFreeSpace / (numberOfLines - 1);
1099         if (alignContent == AlignContentSpaceAround || alignContent == AlignContentStretch)
1100             return availableFreeSpace / numberOfLines;
1101     }
1102     return 0;
1103 }
1104
1105 void RenderFlexibleBox::alignFlexLines(OrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
1106 {
1107     if (!isMultiline() || style()->alignContent() == AlignContentFlexStart)
1108         return;
1109
1110     LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
1111     for (size_t i = 0; i < lineContexts.size(); ++i)
1112         availableCrossAxisSpace -= lineContexts[i].crossAxisExtent;
1113
1114     RenderBox* child = iterator.first();
1115     LayoutUnit lineOffset = initialAlignContentOffset(availableCrossAxisSpace, style()->alignContent(), lineContexts.size());
1116     for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1117         lineContexts[lineNumber].crossAxisOffset += lineOffset;
1118         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next())
1119             adjustAlignmentForChild(child, lineOffset);
1120
1121         if (style()->alignContent() == AlignContentStretch && availableCrossAxisSpace > 0)
1122             lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
1123
1124         lineOffset += alignContentSpaceBetweenChildren(availableCrossAxisSpace, style()->alignContent(), lineContexts.size());
1125     }
1126 }
1127
1128 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
1129 {
1130     if (child->isOutOfFlowPositioned()) {
1131         LayoutUnit staticInlinePosition = child->layer()->staticInlinePosition();
1132         LayoutUnit staticBlockPosition = child->layer()->staticBlockPosition();
1133         LayoutUnit mainAxis = isColumnFlow() ? staticBlockPosition : staticInlinePosition;
1134         LayoutUnit crossAxis = isColumnFlow() ? staticInlinePosition : staticBlockPosition;
1135         crossAxis += delta;
1136         prepareChildForPositionedLayout(child, mainAxis, crossAxis, NoFlipForRowReverse);
1137         return;
1138     }
1139
1140     LayoutRect oldRect = child->frameRect();
1141     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
1142
1143     // If the child moved, we have to repaint it as well as any floating/positioned
1144     // descendants. An exception is if we need a layout. In this case, we know we're going to
1145     // repaint ourselves (and the child) anyway.
1146     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1147         child->repaintDuringLayoutIfMoved(oldRect);
1148 }
1149
1150 void RenderFlexibleBox::alignChildren(OrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
1151 {
1152     // Keep track of the space between the baseline edge and the after edge of the box for each line.
1153     WTF::Vector<LayoutUnit> minMarginAfterBaselines;
1154
1155     RenderBox* child = iterator.first();
1156     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1157         LayoutUnit minMarginAfterBaseline = MAX_LAYOUT_UNIT;
1158         LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1159         LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
1160
1161         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1162             ASSERT(child);
1163             if (child->isOutOfFlowPositioned()) {
1164                 if (style()->flexWrap() == FlexWrapReverse)
1165                     adjustAlignmentForChild(child, lineCrossAxisExtent);
1166                 continue;
1167             }
1168
1169             if (updateAutoMarginsInCrossAxis(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child)))
1170                 continue;
1171
1172             switch (alignmentForChild(child)) {
1173             case AlignAuto:
1174                 ASSERT_NOT_REACHED();
1175                 break;
1176             case AlignStretch: {
1177                 applyStretchAlignmentToChild(child, lineCrossAxisExtent);
1178                 // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1179                 if (style()->flexWrap() == FlexWrapReverse)
1180                     adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1181                 break;
1182             }
1183             case AlignFlexStart:
1184                 break;
1185             case AlignFlexEnd:
1186                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1187                 break;
1188             case AlignCenter:
1189                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1190                 break;
1191             case AlignBaseline: {
1192                 LayoutUnit ascent = marginBoxAscentForChild(child);
1193                 LayoutUnit startOffset = maxAscent - ascent;
1194                 adjustAlignmentForChild(child, startOffset);
1195
1196                 if (style()->flexWrap() == FlexWrapReverse)
1197                     minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) - startOffset);
1198                 break;
1199             }
1200             }
1201         }
1202         minMarginAfterBaselines.append(minMarginAfterBaseline);
1203     }
1204
1205     if (style()->flexWrap() != FlexWrapReverse)
1206         return;
1207
1208     // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
1209     // need to align the after edge of baseline elements with the after edge of the flex line.
1210     child = iterator.first();
1211     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1212         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1213         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1214             ASSERT(child);
1215             if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child) && minMarginAfterBaseline)
1216                 adjustAlignmentForChild(child, minMarginAfterBaseline);
1217         }
1218     }
1219 }
1220
1221 void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox* child, LayoutUnit lineCrossAxisExtent)
1222 {
1223     if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
1224         // FIXME: If the child has orthogonal flow, then it already has an override height set, so use it.
1225         if (!hasOrthogonalFlow(child)) {
1226             LayoutUnit stretchedLogicalHeight = child->logicalHeight() + availableAlignmentSpaceForChild(lineCrossAxisExtent, child);
1227             LayoutUnit desiredLogicalHeight = child->constrainLogicalHeightByMinMax(stretchedLogicalHeight);
1228
1229             // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
1230             if (desiredLogicalHeight != child->logicalHeight()) {
1231                 child->setOverrideLogicalContentHeight(desiredLogicalHeight - child->borderAndPaddingLogicalHeight());
1232                 child->setLogicalHeight(0);
1233                 child->setChildNeedsLayout(true, MarkOnlyThis);
1234                 child->layoutIfNeeded();
1235             }
1236         }
1237     } else if (isColumnFlow() && child->style()->logicalWidth().isAuto()) {
1238         // FIXME: If the child doesn't have orthogonal flow, then it already has an override width set, so use it.
1239         if (hasOrthogonalFlow(child)) {
1240             LayoutUnit childWidth = std::max(ZERO_LAYOUT_UNIT, lineCrossAxisExtent - crossAxisMarginExtentForChild(child));
1241             childWidth = child->constrainLogicalWidthInRegionByMinMax(childWidth, childWidth, this);
1242
1243             if (childWidth != child->logicalWidth()) {
1244                 child->setOverrideLogicalContentWidth(childWidth);
1245                 child->setChildNeedsLayout(true, MarkOnlyThis);
1246                 child->layoutIfNeeded();
1247             }
1248         }
1249     }
1250 }
1251
1252 void RenderFlexibleBox::flipForRightToLeftColumn(OrderIterator& iterator)
1253 {
1254     if (style()->isLeftToRightDirection() || !isColumnFlow())
1255         return;
1256
1257     LayoutUnit crossExtent = crossAxisExtent();
1258     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
1259         if (child->isOutOfFlowPositioned())
1260             continue;
1261         LayoutPoint location = flowAwareLocationForChild(child);
1262         location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
1263         setFlowAwareLocationForChild(child, location);
1264     }
1265 }
1266
1267 void RenderFlexibleBox::flipForWrapReverse(OrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts, LayoutUnit crossAxisStartEdge)
1268 {
1269     LayoutUnit contentExtent = crossAxisContentExtent();
1270     RenderBox* child = iterator.first();
1271     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1272         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1273             ASSERT(child);
1274             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1275             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
1276             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
1277             adjustAlignmentForChild(child, newOffset - originalOffset);
1278         }
1279     }
1280 }
1281
1282 }