Refactor duplicate code into RenderFlexibleBox::mainAxisContentExtent
[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     computeInitialRegionRangeForBlock();
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     float totalFlexGrow;
619     float 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     LayoutUnit childCrossExtent = 0;
693     if (!child->isOutOfFlowPositioned())
694         childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
695     return lineCrossAxisExtent - childCrossExtent;
696 }
697
698 bool RenderFlexibleBox::updateAutoMarginsInCrossAxis(RenderBox* child, LayoutUnit availableAlignmentSpace)
699 {
700     bool isHorizontal = isHorizontalFlow();
701     Length start = isHorizontal ? child->style()->marginTop() : child->style()->marginLeft();
702     Length end = isHorizontal ? child->style()->marginBottom() : child->style()->marginRight();
703     if (start.isAuto() && end.isAuto()) {
704         adjustAlignmentForChild(child, availableAlignmentSpace / 2);
705         if (isHorizontal) {
706             child->setMarginTop(availableAlignmentSpace / 2);
707             child->setMarginBottom(availableAlignmentSpace / 2);
708         } else {
709             child->setMarginLeft(availableAlignmentSpace / 2);
710             child->setMarginRight(availableAlignmentSpace / 2);
711         }
712         return true;
713     }
714     if (start.isAuto()) {
715         adjustAlignmentForChild(child, availableAlignmentSpace);
716         if (isHorizontal)
717             child->setMarginTop(availableAlignmentSpace);
718         else
719             child->setMarginLeft(availableAlignmentSpace);
720         return true;
721     }
722     if (end.isAuto()) {
723         if (isHorizontal)
724             child->setMarginBottom(availableAlignmentSpace);
725         else
726             child->setMarginRight(availableAlignmentSpace);
727         return true;
728     }
729     return false;
730 }
731
732 LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(RenderBox* child)
733 {
734     LayoutUnit ascent = child->firstLineBoxBaseline();
735     if (ascent == -1)
736         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
737     return ascent + flowAwareMarginBeforeForChild(child);
738 }
739
740 LayoutUnit RenderFlexibleBox::computeChildMarginValue(Length margin, RenderView* view)
741 {
742     // When resolving the margins, we use the content size for resolving percent and calc (for percents in calc expressions) margins.
743     // Fortunately, percent margins are always computed with respect to the block's width, even for margin-top and margin-bottom.
744     LayoutUnit availableSize = contentLogicalWidth();
745     return minimumValueForLength(margin, availableSize, view);
746 }
747
748 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, OrderHashSet& orderValues)
749 {
750     RenderView* renderView = view();
751     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
752         orderValues.add(child->style()->order());
753
754         if (child->isOutOfFlowPositioned())
755             continue;
756
757         child->clearOverrideSize();
758         // Only need to layout here if we will need to get the logicalHeight of the child in computeNextFlexLine.
759         Length childMainAxisMin = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
760         if (hasOrthogonalFlow(child) && (flexBasisForChild(child).isAuto() || childMainAxisMin.isAuto())) {
761             if (!relayoutChildren)
762                 child->setChildNeedsLayout(true, MarkOnlyThis);
763             child->layoutIfNeeded();
764         }
765
766         // Before running the flex algorithm, 'auto' has a margin of 0.
767         // Also, if we're not auto sizing, we don't do a layout that computes the start/end margins.
768         if (isHorizontalFlow()) {
769             child->setMarginLeft(computeChildMarginValue(child->style()->marginLeft(), renderView));
770             child->setMarginRight(computeChildMarginValue(child->style()->marginRight(), renderView));
771         } else {
772             child->setMarginTop(computeChildMarginValue(child->style()->marginTop(), renderView));
773             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom(), renderView));
774         }
775     }
776 }
777
778 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize)
779 {
780     // FIXME: Support intrinsic min/max lengths.
781     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
782     if (max.isSpecified()) {
783         LayoutUnit maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
784         if (maxExtent != -1 && childSize > maxExtent)
785             childSize = maxExtent;
786     }
787
788     Length min = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
789     LayoutUnit minExtent = 0;
790     if (min.isSpecified())
791         minExtent = computeMainAxisExtentForChild(child, MinSize, min);
792     else if (min.isAuto()) {
793         minExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->minPreferredLogicalWidth();
794         minExtent -= mainAxisBorderAndPaddingExtentForChild(child);
795     }
796     return std::max(childSize, minExtent);
797 }
798
799 bool RenderFlexibleBox::computeNextFlexLine(OrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalFlexGrow, float& totalWeightedFlexShrink, LayoutUnit& minMaxAppliedMainAxisExtent)
800 {
801     orderedChildren.clear();
802     preferredMainAxisExtent = 0;
803     totalFlexGrow = totalWeightedFlexShrink = 0;
804     minMaxAppliedMainAxisExtent = 0;
805
806     if (!iterator.currentChild())
807         return false;
808
809     LayoutUnit lineBreakLength = mainAxisContentExtent(MAX_LAYOUT_UNIT);
810
811     for (RenderBox* child = iterator.currentChild(); child; child = iterator.next()) {
812         if (child->isOutOfFlowPositioned()) {
813             orderedChildren.append(child);
814             continue;
815         }
816
817         LayoutUnit childMainAxisExtent = preferredMainAxisContentExtentForChild(child);
818         LayoutUnit childMainAxisMarginBoxExtent = mainAxisBorderAndPaddingExtentForChild(child) + childMainAxisExtent;
819         childMainAxisMarginBoxExtent += isHorizontalFlow() ? child->marginWidth() : child->marginHeight();
820
821         if (isMultiline() && preferredMainAxisExtent + childMainAxisMarginBoxExtent > lineBreakLength && orderedChildren.size() > 0)
822             break;
823         orderedChildren.append(child);
824         preferredMainAxisExtent += childMainAxisMarginBoxExtent;
825         totalFlexGrow += child->style()->flexGrow();
826         totalWeightedFlexShrink += child->style()->flexShrink() * childMainAxisExtent;
827
828         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent);
829         minMaxAppliedMainAxisExtent += childMinMaxAppliedMainAxisExtent - childMainAxisExtent + childMainAxisMarginBoxExtent;
830     }
831     return true;
832 }
833
834 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalFlexGrow, float& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems)
835 {
836     for (size_t i = 0; i < violations.size(); ++i) {
837         RenderBox* child = violations[i].child;
838         LayoutUnit childSize = violations[i].childSize;
839         LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
840         availableFreeSpace -= childSize - preferredChildSize;
841         totalFlexGrow -= child->style()->flexGrow();
842         totalWeightedFlexShrink -= child->style()->flexShrink() * preferredChildSize;
843         inflexibleItems.set(child, childSize);
844     }
845 }
846
847 // Returns true if we successfully ran the algorithm and sized the flex items.
848 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalFlexGrow, float& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
849 {
850     childSizes.clear();
851     LayoutUnit totalViolation = 0;
852     LayoutUnit usedFreeSpace = 0;
853     WTF::Vector<Violation> minViolations;
854     WTF::Vector<Violation> maxViolations;
855     for (size_t i = 0; i < children.size(); ++i) {
856         RenderBox* child = children[i];
857         if (child->isOutOfFlowPositioned()) {
858             childSizes.append(0);
859             continue;
860         }
861
862         if (inflexibleItems.contains(child))
863             childSizes.append(inflexibleItems.get(child));
864         else {
865             LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
866             LayoutUnit childSize = preferredChildSize;
867             if (availableFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && isfinite(totalFlexGrow))
868                 childSize += roundedLayoutUnit(availableFreeSpace * child->style()->flexGrow() / totalFlexGrow);
869             else if (availableFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && isfinite(totalWeightedFlexShrink))
870                 childSize += roundedLayoutUnit(availableFreeSpace * child->style()->flexShrink() * preferredChildSize / totalWeightedFlexShrink);
871
872             LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize);
873             childSizes.append(adjustedChildSize);
874             usedFreeSpace += adjustedChildSize - preferredChildSize;
875
876             LayoutUnit violation = adjustedChildSize - childSize;
877             if (violation > 0)
878                 minViolations.append(Violation(child, adjustedChildSize));
879             else if (violation < 0)
880                 maxViolations.append(Violation(child, adjustedChildSize));
881             totalViolation += violation;
882         }
883     }
884
885     if (totalViolation)
886         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalFlexGrow, totalWeightedFlexShrink, inflexibleItems);
887     else
888         availableFreeSpace -= usedFreeSpace;
889
890     return !totalViolation;
891 }
892
893 static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
894 {
895     if (justifyContent == JustifyFlexEnd)
896         return availableFreeSpace;
897     if (justifyContent == JustifyCenter)
898         return availableFreeSpace / 2;
899     if (justifyContent == JustifySpaceAround) {
900         if (availableFreeSpace > 0 && numberOfChildren)
901             return availableFreeSpace / (2 * numberOfChildren);
902         if (availableFreeSpace < 0)
903             return availableFreeSpace / 2;
904     }
905     return 0;
906 }
907
908 static LayoutUnit justifyContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, EJustifyContent justifyContent, unsigned numberOfChildren)
909 {
910     if (availableFreeSpace > 0 && numberOfChildren > 1) {
911         if (justifyContent == JustifySpaceBetween)
912             return availableFreeSpace / (numberOfChildren - 1);
913         if (justifyContent == JustifySpaceAround)
914             return availableFreeSpace / numberOfChildren;
915     }
916     return 0;
917 }
918
919 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
920 {
921     if (hasOrthogonalFlow(child))
922         child->setOverrideLogicalContentHeight(childPreferredSize - child->borderAndPaddingLogicalHeight());
923     else
924         child->setOverrideLogicalContentWidth(childPreferredSize - child->borderAndPaddingLogicalWidth());
925 }
926
927 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset, PositionedLayoutMode layoutMode)
928 {
929     ASSERT(child->isOutOfFlowPositioned());
930     child->containingBlock()->insertPositionedObject(child);
931     RenderLayer* childLayer = child->layer();
932     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
933     if (layoutMode == FlipForRowReverse && style()->flexDirection() == FlowRowReverse)
934         inlinePosition = mainAxisExtent() - mainAxisOffset;
935     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
936
937     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
938     if (childLayer->staticBlockPosition() != staticBlockPosition) {
939         childLayer->setStaticBlockPosition(staticBlockPosition);
940         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
941             child->setChildNeedsLayout(true, MarkOnlyThis);
942     }
943 }
944
945 static EAlignItems alignmentForChild(RenderBox* child)
946 {
947     EAlignItems align = child->style()->alignSelf();
948     if (align == AlignAuto)
949         align = child->parent()->style()->alignItems();
950
951     if (child->parent()->style()->flexWrap() == FlexWrapReverse) {
952         if (align == AlignFlexStart)
953             align = AlignFlexEnd;
954         else if (align == AlignFlexEnd)
955             align = AlignFlexStart;
956     }
957
958     return align;
959 }
960
961 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, WTF::Vector<LineContext>& lineContexts)
962 {
963     ASSERT(childSizes.size() == children.size());
964
965     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
966     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
967     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), childSizes.size());
968     if (style()->flexDirection() == FlowRowReverse)
969         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
970
971     LayoutUnit totalMainExtent = mainAxisExtent();
972     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when align-items: baseline.
973     LayoutUnit maxChildCrossAxisExtent = 0;
974     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
975     for (size_t i = 0; i < children.size(); ++i) {
976         RenderBox* child = children[i];
977         if (child->isOutOfFlowPositioned()) {
978             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset, FlipForRowReverse);
979             mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), childSizes.size());
980             continue;
981         }
982         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
983         setLogicalOverrideSize(child, childPreferredSize);
984         // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
985         child->setChildNeedsLayout(true, MarkOnlyThis);
986         child->layoutIfNeeded();
987
988         updateAutoMarginsInMainAxis(child, autoMarginOffset);
989
990         LayoutUnit childCrossAxisMarginBoxExtent;
991         if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child)) {
992             LayoutUnit ascent = marginBoxAscentForChild(child);
993             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
994
995             maxAscent = std::max(maxAscent, ascent);
996             maxDescent = std::max(maxDescent, descent);
997
998             childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
999         } else
1000             childCrossAxisMarginBoxExtent = crossAxisExtentForChild(child) + crossAxisMarginExtentForChild(child);
1001         if (!isColumnFlow() && style()->logicalHeight().isAuto())
1002             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
1003         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
1004
1005         mainAxisOffset += flowAwareMarginStartForChild(child);
1006
1007         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
1008         LayoutPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
1009             crossAxisOffset + flowAwareMarginBeforeForChild(child));
1010
1011         // FIXME: Supporting layout deltas.
1012         setFlowAwareLocationForChild(child, childLocation);
1013         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
1014
1015         mainAxisOffset += justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), childSizes.size());
1016     }
1017
1018     if (isColumnFlow())
1019         setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
1020
1021     if (style()->flexDirection() == FlowColumnReverse) {
1022         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
1023         // on the height of the flexbox, which we only know after we've positioned all the flex items.
1024         updateLogicalHeight();
1025         layoutColumnReverse(children, childSizes, crossAxisOffset, availableFreeSpace);
1026     }
1027
1028     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
1029     crossAxisOffset += maxChildCrossAxisExtent;
1030 }
1031
1032 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
1033 {
1034     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
1035     // starting from the end of the flexbox. We also don't need to layout anything since we're
1036     // just moving the children to a new position.
1037     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
1038     mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), childSizes.size());
1039     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
1040
1041     for (size_t i = 0; i < children.size(); ++i) {
1042         RenderBox* child = children[i];
1043         if (child->isOutOfFlowPositioned()) {
1044             child->layer()->setStaticBlockPosition(mainAxisOffset);
1045             mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), childSizes.size());
1046             continue;
1047         }
1048         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
1049
1050         LayoutRect oldRect = child->frameRect();
1051         setFlowAwareLocationForChild(child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
1052         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1053             child->repaintDuringLayoutIfMoved(oldRect);
1054
1055         mainAxisOffset -= flowAwareMarginStartForChild(child);
1056         mainAxisOffset -= justifyContentSpaceBetweenChildren(availableFreeSpace, style()->justifyContent(), childSizes.size());
1057     }
1058 }
1059
1060 static LayoutUnit initialAlignContentOffset(LayoutUnit availableFreeSpace, EAlignContent alignContent, unsigned numberOfLines)
1061 {
1062     if (alignContent == AlignContentFlexEnd)
1063         return availableFreeSpace;
1064     if (alignContent == AlignContentCenter)
1065         return availableFreeSpace / 2;
1066     if (alignContent == AlignContentSpaceAround) {
1067         if (availableFreeSpace > 0 && numberOfLines)
1068             return availableFreeSpace / (2 * numberOfLines);
1069         if (availableFreeSpace < 0)
1070             return availableFreeSpace / 2;
1071     }
1072     return 0;
1073 }
1074
1075 static LayoutUnit alignContentSpaceBetweenChildren(LayoutUnit availableFreeSpace, EAlignContent alignContent, unsigned numberOfLines)
1076 {
1077     if (availableFreeSpace > 0 && numberOfLines > 1) {
1078         if (alignContent == AlignContentSpaceBetween)
1079             return availableFreeSpace / (numberOfLines - 1);
1080         if (alignContent == AlignContentSpaceAround || alignContent == AlignContentStretch)
1081             return availableFreeSpace / numberOfLines;
1082     }
1083     return 0;
1084 }
1085
1086 void RenderFlexibleBox::alignFlexLines(OrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
1087 {
1088     if (!isMultiline() || style()->alignContent() == AlignContentFlexStart)
1089         return;
1090
1091     LayoutUnit availableCrossAxisSpace = crossAxisContentExtent();
1092     for (size_t i = 0; i < lineContexts.size(); ++i)
1093         availableCrossAxisSpace -= lineContexts[i].crossAxisExtent;
1094
1095     RenderBox* child = iterator.first();
1096     LayoutUnit lineOffset = initialAlignContentOffset(availableCrossAxisSpace, style()->alignContent(), lineContexts.size());
1097     for (unsigned lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1098         lineContexts[lineNumber].crossAxisOffset += lineOffset;
1099         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next())
1100             adjustAlignmentForChild(child, lineOffset);
1101
1102         if (style()->alignContent() == AlignContentStretch && availableCrossAxisSpace > 0)
1103             lineContexts[lineNumber].crossAxisExtent += availableCrossAxisSpace / static_cast<unsigned>(lineContexts.size());
1104
1105         lineOffset += alignContentSpaceBetweenChildren(availableCrossAxisSpace, style()->alignContent(), lineContexts.size());
1106     }
1107 }
1108
1109 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
1110 {
1111     if (child->isOutOfFlowPositioned()) {
1112         LayoutUnit staticInlinePosition = child->layer()->staticInlinePosition();
1113         LayoutUnit staticBlockPosition = child->layer()->staticBlockPosition();
1114         LayoutUnit mainAxis = isColumnFlow() ? staticBlockPosition : staticInlinePosition;
1115         LayoutUnit crossAxis = isColumnFlow() ? staticInlinePosition : staticBlockPosition;
1116         crossAxis += delta;
1117         prepareChildForPositionedLayout(child, mainAxis, crossAxis, NoFlipForRowReverse);
1118         return;
1119     }
1120
1121     LayoutRect oldRect = child->frameRect();
1122     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
1123
1124     // If the child moved, we have to repaint it as well as any floating/positioned
1125     // descendants. An exception is if we need a layout. In this case, we know we're going to
1126     // repaint ourselves (and the child) anyway.
1127     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1128         child->repaintDuringLayoutIfMoved(oldRect);
1129 }
1130
1131 void RenderFlexibleBox::alignChildren(OrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
1132 {
1133     // Keep track of the space between the baseline edge and the after edge of the box for each line.
1134     WTF::Vector<LayoutUnit> minMarginAfterBaselines;
1135
1136     RenderBox* child = iterator.first();
1137     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1138         LayoutUnit minMarginAfterBaseline = MAX_LAYOUT_UNIT;
1139         LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1140         LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
1141
1142         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1143             ASSERT(child);
1144             if (updateAutoMarginsInCrossAxis(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child)))
1145                 continue;
1146
1147             switch (alignmentForChild(child)) {
1148             case AlignAuto:
1149                 ASSERT_NOT_REACHED();
1150                 break;
1151             case AlignStretch: {
1152                 applyStretchAlignmentToChild(child, lineCrossAxisExtent);
1153                 // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1154                 if (style()->flexWrap() == FlexWrapReverse)
1155                     adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1156                 break;
1157             }
1158             case AlignFlexStart:
1159                 break;
1160             case AlignFlexEnd:
1161                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1162                 break;
1163             case AlignCenter:
1164                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1165                 break;
1166             case AlignBaseline: {
1167                 LayoutUnit ascent = marginBoxAscentForChild(child);
1168                 LayoutUnit startOffset = maxAscent - ascent;
1169                 adjustAlignmentForChild(child, startOffset);
1170
1171                 if (style()->flexWrap() == FlexWrapReverse)
1172                     minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) - startOffset);
1173                 break;
1174             }
1175             }
1176         }
1177         minMarginAfterBaselines.append(minMarginAfterBaseline);
1178     }
1179
1180     if (style()->flexWrap() != FlexWrapReverse)
1181         return;
1182
1183     // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
1184     // need to align the after edge of baseline elements with the after edge of the flex line.
1185     child = iterator.first();
1186     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1187         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1188         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1189             ASSERT(child);
1190             if (alignmentForChild(child) == AlignBaseline && !hasAutoMarginsInCrossAxis(child) && minMarginAfterBaseline)
1191                 adjustAlignmentForChild(child, minMarginAfterBaseline);
1192         }
1193     }
1194 }
1195
1196 void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox* child, LayoutUnit lineCrossAxisExtent)
1197 {
1198     if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
1199         // FIXME: If the child has orthogonal flow, then it already has an override height set, so use it.
1200         if (!hasOrthogonalFlow(child)) {
1201             LayoutUnit stretchedLogicalHeight = child->logicalHeight() + availableAlignmentSpaceForChild(lineCrossAxisExtent, child);
1202             LayoutUnit desiredLogicalHeight = child->constrainLogicalHeightByMinMax(stretchedLogicalHeight);
1203
1204             // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
1205             if (desiredLogicalHeight != child->logicalHeight()) {
1206                 child->setOverrideLogicalContentHeight(desiredLogicalHeight - child->borderAndPaddingLogicalHeight());
1207                 child->setLogicalHeight(0);
1208                 child->setChildNeedsLayout(true, MarkOnlyThis);
1209                 child->layoutIfNeeded();
1210             }
1211         }
1212     } else if (isColumnFlow() && child->style()->logicalWidth().isAuto()) {
1213         // FIXME: If the child doesn't have orthogonal flow, then it already has an override width set, so use it.
1214         if (hasOrthogonalFlow(child)) {
1215             LayoutUnit childWidth = std::max(ZERO_LAYOUT_UNIT, lineCrossAxisExtent - crossAxisMarginExtentForChild(child));
1216             childWidth = child->constrainLogicalWidthInRegionByMinMax(childWidth, childWidth, this);
1217
1218             if (childWidth != child->logicalWidth()) {
1219                 child->setOverrideLogicalContentWidth(childWidth);
1220                 child->setChildNeedsLayout(true, MarkOnlyThis);
1221                 child->layoutIfNeeded();
1222             }
1223         }
1224     }
1225 }
1226
1227 void RenderFlexibleBox::flipForRightToLeftColumn(OrderIterator& iterator)
1228 {
1229     if (style()->isLeftToRightDirection() || !isColumnFlow())
1230         return;
1231
1232     LayoutUnit crossExtent = crossAxisExtent();
1233     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
1234         if (child->isOutOfFlowPositioned())
1235             continue;
1236         LayoutPoint location = flowAwareLocationForChild(child);
1237         location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
1238         setFlowAwareLocationForChild(child, location);
1239     }
1240 }
1241
1242 void RenderFlexibleBox::flipForWrapReverse(OrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts, LayoutUnit crossAxisStartEdge)
1243 {
1244     LayoutUnit contentExtent = crossAxisContentExtent();
1245     RenderBox* child = iterator.first();
1246     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1247         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1248             ASSERT(child);
1249             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1250             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
1251             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
1252             adjustAlignmentForChild(child, newOffset - originalOffset);
1253         }
1254     }
1255 }
1256
1257 }