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