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