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