Source/WebCore/rendering/RenderFlexibleBox.cpp

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