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
  39 namespace WebCore {
  40
  41 // Normally, -1 and 0 are not valid in a HashSet, but these are relatively likely flex-order values. Instead,
  42 // we make the two smallest int values invalid flex-order values (in the css parser code we clamp them to
  43 // int min + 2).
  44 struct RenderFlexibleBox::FlexOrderHashTraits : WTF::GenericHashTraits<int> {
  45     static const bool emptyValueIsZero = false;
  46     static int emptyValue() { return std::numeric_limits<int>::min(); }
  47     static void constructDeletedValue(int& slot) { slot = std::numeric_limits<int>::min() + 1; }
  48     static bool isDeletedValue(int value) { return value == std::numeric_limits<int>::min() + 1; }
  49 };
  50
  51 class RenderFlexibleBox::FlexOrderIterator {
  52 public:
  53     FlexOrderIterator(RenderFlexibleBox* flexibleBox, const FlexOrderHashSet& flexOrderValues)
  54         : m_flexibleBox(flexibleBox)
  55         , m_currentChild(0)
  56         , m_orderValuesIterator(0)
  57     {
  58         copyToVector(flexOrderValues, m_orderValues);
  59         std::sort(m_orderValues.begin(), m_orderValues.end());
  60         first();
  61     }
  62
  63     RenderBox* currentChild() { return m_currentChild; }
  64
  65     RenderBox* first()
  66     {
  67         reset();
  68         return next();
  69     }
  70
  71     RenderBox* next()
  72     {
  73         do {
  74             if (!m_currentChild) {
  75                 if (m_orderValuesIterator == m_orderValues.end())
  76                     return 0;
  77                 if (m_orderValuesIterator) {
  78                     ++m_orderValuesIterator;
  79                     if (m_orderValuesIterator == m_orderValues.end())
  80                         return 0;
  81                 } else
  82                     m_orderValuesIterator = m_orderValues.begin();
  83
  84                 m_currentChild = m_flexibleBox->firstChildBox();
  85             } else
  86                 m_currentChild = m_currentChild->nextSiblingBox();
  87         } while (!m_currentChild || m_currentChild->style()->flexOrder() != *m_orderValuesIterator);
  88
  89         return m_currentChild;
  90     }
  91
  92     void reset()
  93     {
  94         m_currentChild = 0;
  95         m_orderValuesIterator = 0;
  96     }
  97
  98 private:
  99     RenderFlexibleBox* m_flexibleBox;
 100     RenderBox* m_currentChild;
 101     Vector<int> m_orderValues;
 102     Vector<int>::const_iterator m_orderValuesIterator;
 103 };
 104
 105 struct RenderFlexibleBox::LineContext {
 106     LineContext(LayoutUnit crossAxisOffset, LayoutUnit crossAxisExtent, size_t numberOfChildren, LayoutUnit maxAscent)
 107         : crossAxisOffset(crossAxisOffset)
 108         , crossAxisExtent(crossAxisExtent)
 109         , numberOfChildren(numberOfChildren)
 110         , maxAscent(maxAscent)
 111     {
 112     }
 113
 114     LayoutUnit crossAxisOffset;
 115     LayoutUnit crossAxisExtent;
 116     size_t numberOfChildren;
 117     LayoutUnit maxAscent;
 118 };
 119
 120 struct RenderFlexibleBox::Violation {
 121     Violation(RenderBox* child, LayoutUnit childSize)
 122         : child(child)
 123         , childSize(childSize)
 124     {
 125     }
 126
 127     RenderBox* child;
 128     LayoutUnit childSize;
 129 };
 130
 131
 132 RenderFlexibleBox::RenderFlexibleBox(Node* node)
 133     : RenderBlock(node)
 134 {
 135     setChildrenInline(false); // All of our children must be block-level.
 136 }
 137
 138 RenderFlexibleBox::~RenderFlexibleBox()
 139 {
 140 }
 141
 142 const char* RenderFlexibleBox::renderName() const
 143 {
 144     return "RenderFlexibleBox";
 145 }
 146
 147 static LayoutUnit marginLogicalWidthForChild(RenderBox* child, RenderStyle* parentStyle)
 148 {
 149     // A margin has three types: fixed, percentage, and auto (variable).
 150     // Auto and percentage margins become 0 when computing min/max width.
 151     // Fixed margins can be added in as is.
 152     Length marginLeft = child->style()->marginStartUsing(parentStyle);
 153     Length marginRight = child->style()->marginEndUsing(parentStyle);
 154     LayoutUnit margin = 0;
 155     if (marginLeft.isFixed())
 156         margin += marginLeft.value();
 157     if (marginRight.isFixed())
 158         margin += marginRight.value();
 159     return margin;
 160 }
 161
 162 void RenderFlexibleBox::computePreferredLogicalWidths()
 163 {
 164     ASSERT(preferredLogicalWidthsDirty());
 165
 166     RenderStyle* styleToUse = style();
 167     if (styleToUse->logicalWidth().isFixed() && styleToUse->logicalWidth().value() > 0)
 168         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = computeContentBoxLogicalWidth(styleToUse->logicalWidth().value());
 169     else {
 170         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = 0;
 171
 172         for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
 173             if (child->isPositioned())
 174                 continue;
 175
 176             LayoutUnit margin = marginLogicalWidthForChild(child, style());
 177             bool hasOrthogonalWritingMode = child->isHorizontalWritingMode() != isHorizontalWritingMode();
 178             LayoutUnit minPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->minPreferredLogicalWidth();
 179             LayoutUnit maxPreferredLogicalWidth = hasOrthogonalWritingMode ? child->logicalHeight() : child->maxPreferredLogicalWidth();
 180             minPreferredLogicalWidth += margin;
 181             maxPreferredLogicalWidth += margin;
 182             if (!isColumnFlow()) {
 183                 m_maxPreferredLogicalWidth += maxPreferredLogicalWidth;
 184                 if (isMultiline()) {
 185                     // For multiline, the min preferred width is if you put a break between each item.
 186                     m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, minPreferredLogicalWidth);
 187                 } else
 188                     m_minPreferredLogicalWidth += minPreferredLogicalWidth;
 189             } else {
 190                 m_minPreferredLogicalWidth = std::max(minPreferredLogicalWidth, m_minPreferredLogicalWidth);
 191                 if (isMultiline()) {
 192                     // For multiline, the max preferred width is if you put a break between each item.
 193                     m_maxPreferredLogicalWidth += maxPreferredLogicalWidth;
 194                 } else
 195                     m_maxPreferredLogicalWidth = std::max(maxPreferredLogicalWidth, m_maxPreferredLogicalWidth);
 196             }
 197         }
 198
 199         m_maxPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
 200     }
 201
 202     LayoutUnit scrollbarWidth = 0;
 203     if (hasOverflowClip()) {
 204         if (isHorizontalWritingMode() && styleToUse->overflowY() == OSCROLL) {
 205             layer()->setHasVerticalScrollbar(true);
 206             scrollbarWidth = verticalScrollbarWidth();
 207         } else if (!isHorizontalWritingMode() && styleToUse->overflowX() == OSCROLL) {
 208             layer()->setHasHorizontalScrollbar(true);
 209             scrollbarWidth = horizontalScrollbarHeight();
 210         }
 211     }
 212
 213     m_maxPreferredLogicalWidth += scrollbarWidth;
 214     m_minPreferredLogicalWidth += scrollbarWidth;
 215
 216     if (styleToUse->logicalMinWidth().isFixed() && styleToUse->logicalMinWidth().value() > 0) {
 217         m_maxPreferredLogicalWidth = std::max(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
 218         m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMinWidth().value()));
 219     }
 220
 221     if (styleToUse->logicalMaxWidth().isFixed()) {
 222         m_maxPreferredLogicalWidth = std::min(m_maxPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
 223         m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, computeContentBoxLogicalWidth(styleToUse->logicalMaxWidth().value()));
 224     }
 225
 226     LayoutUnit borderAndPadding = borderAndPaddingLogicalWidth();
 227     m_minPreferredLogicalWidth += borderAndPadding;
 228     m_maxPreferredLogicalWidth += borderAndPadding;
 229
 230     setPreferredLogicalWidthsDirty(false);
 231 }
 232
 233 void RenderFlexibleBox::layoutBlock(bool relayoutChildren, int, BlockLayoutPass)
 234 {
 235     ASSERT(needsLayout());
 236
 237     if (!relayoutChildren && simplifiedLayout())
 238         return;
 239
 240     LayoutRepainter repainter(*this, checkForRepaintDuringLayout());
 241     LayoutStateMaintainer statePusher(view(), this, locationOffset(), hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode());
 242
 243     if (inRenderFlowThread()) {
 244         // Regions changing widths can force us to relayout our children.
 245         if (logicalWidthChangedInRegions())
 246             relayoutChildren = true;
 247     }
 248     computeInitialRegionRangeForBlock();
 249
 250     IntSize previousSize = size();
 251
 252     setLogicalHeight(0);
 253     computeLogicalWidth();
 254
 255     m_overflow.clear();
 256
 257     // For overflow:scroll blocks, ensure we have both scrollbars in place always.
 258     if (scrollsOverflow()) {
 259         if (style()->overflowX() == OSCROLL)
 260             layer()->setHasHorizontalScrollbar(true);
 261         if (style()->overflowY() == OSCROLL)
 262             layer()->setHasVerticalScrollbar(true);
 263     }
 264
 265     WTF::Vector<LineContext> lineContexts;
 266     FlexOrderHashSet flexOrderValues;
 267     computeMainAxisPreferredSizes(relayoutChildren, flexOrderValues);
 268     FlexOrderIterator flexIterator(this, flexOrderValues);
 269     layoutFlexItems(relayoutChildren, flexIterator, lineContexts);
 270
 271     LayoutUnit oldClientAfterEdge = clientLogicalBottom();
 272     computeLogicalHeight();
 273     repositionLogicalHeightDependentFlexItems(flexIterator, lineContexts, oldClientAfterEdge);
 274
 275     if (size() != previousSize)
 276         relayoutChildren = true;
 277
 278     layoutPositionedObjects(relayoutChildren || isRoot());
 279
 280     computeRegionRangeForBlock();
 281
 282     // FIXME: css3/flexbox/repaint-rtl-column.html seems to repaint more overflow than it needs to.
 283     computeOverflow(oldClientAfterEdge);
 284     statePusher.pop();
 285
 286     updateLayerTransform();
 287
 288     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
 289     // we overflow or not.
 290     updateScrollInfoAfterLayout();
 291
 292     repainter.repaintAfterLayout();
 293
 294     setNeedsLayout(false);
 295 }
 296
 297 void RenderFlexibleBox::repositionLogicalHeightDependentFlexItems(FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts, LayoutUnit& oldClientAfterEdge)
 298 {
 299     // If we have a single line flexbox, the line height is all the available space.
 300     // For flex-direction: row, this means we need to use the height, so we do this after calling computeLogicalHeight.
 301     if (!isMultiline() && lineContexts.size() == 1)
 302         lineContexts[0].crossAxisExtent = crossAxisContentExtent();
 303     alignChildren(iterator, lineContexts);
 304
 305     if (style()->flexWrap() == FlexWrapReverse) {
 306         if (isHorizontalFlow())
 307             oldClientAfterEdge = clientLogicalBottom();
 308         flipForWrapReverse(iterator, lineContexts);
 309     }
 310
 311     // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
 312     flipForRightToLeftColumn(iterator);
 313 }
 314
 315 bool RenderFlexibleBox::hasOrthogonalFlow(RenderBox* child) const
 316 {
 317     // FIXME: If the child is a flexbox, then we need to check isHorizontalFlow.
 318     return isHorizontalFlow() != child->isHorizontalWritingMode();
 319 }
 320
 321 bool RenderFlexibleBox::isColumnFlow() const
 322 {
 323     return style()->isColumnFlexDirection();
 324 }
 325
 326 bool RenderFlexibleBox::isHorizontalFlow() const
 327 {
 328     if (isHorizontalWritingMode())
 329         return !isColumnFlow();
 330     return isColumnFlow();
 331 }
 332
 333 bool RenderFlexibleBox::isLeftToRightFlow() const
 334 {
 335     if (isColumnFlow())
 336         return style()->writingMode() == TopToBottomWritingMode || style()->writingMode() == LeftToRightWritingMode;
 337     return style()->isLeftToRightDirection() ^ (style()->flexDirection() == FlowRowReverse);
 338 }
 339
 340 bool RenderFlexibleBox::isMultiline() const
 341 {
 342     return style()->flexWrap() != FlexWrapNone;
 343 }
 344
 345 Length RenderFlexibleBox::mainAxisLengthForChild(RenderBox* child) const
 346 {
 347     return isHorizontalFlow() ? child->style()->width() : child->style()->height();
 348 }
 349
 350 Length RenderFlexibleBox::crossAxisLength() const
 351 {
 352     return isHorizontalFlow() ? style()->height() : style()->width();
 353 }
 354
 355 void RenderFlexibleBox::setCrossAxisExtent(LayoutUnit extent)
 356 {
 357     if (isHorizontalFlow())
 358         setHeight(extent);
 359     else
 360         setWidth(extent);
 361 }
 362
 363 LayoutUnit RenderFlexibleBox::crossAxisExtentForChild(RenderBox* child)
 364 {
 365     return isHorizontalFlow() ? child->height() : child->width();
 366 }
 367
 368 LayoutUnit RenderFlexibleBox::mainAxisExtentForChild(RenderBox* child)
 369 {
 370     return isHorizontalFlow() ? child->width() : child->height();
 371 }
 372
 373 LayoutUnit RenderFlexibleBox::crossAxisExtent() const
 374 {
 375     return isHorizontalFlow() ? height() : width();
 376 }
 377
 378 LayoutUnit RenderFlexibleBox::mainAxisExtent() const
 379 {
 380     return isHorizontalFlow() ? width() : height();
 381 }
 382
 383 LayoutUnit RenderFlexibleBox::crossAxisContentExtent() const
 384 {
 385     return isHorizontalFlow() ? contentHeight() : contentWidth();
 386 }
 387
 388 LayoutUnit RenderFlexibleBox::mainAxisContentExtent() const
 389 {
 390     return isHorizontalFlow() ? contentWidth() : contentHeight();
 391 }
 392
 393 WritingMode RenderFlexibleBox::transformedWritingMode() const
 394 {
 395     WritingMode mode = style()->writingMode();
 396     if (!isColumnFlow())
 397         return mode;
 398
 399     switch (mode) {
 400     case TopToBottomWritingMode:
 401     case BottomToTopWritingMode:
 402         return style()->isLeftToRightDirection() ? LeftToRightWritingMode : RightToLeftWritingMode;
 403     case LeftToRightWritingMode:
 404     case RightToLeftWritingMode:
 405         return style()->isLeftToRightDirection() ? TopToBottomWritingMode : BottomToTopWritingMode;
 406     }
 407     ASSERT_NOT_REACHED();
 408     return TopToBottomWritingMode;
 409 }
 410
 411 LayoutUnit RenderFlexibleBox::flowAwareBorderStart() const
 412 {
 413     if (isHorizontalFlow())
 414         return isLeftToRightFlow() ? borderLeft() : borderRight();
 415     return isLeftToRightFlow() ? borderTop() : borderBottom();
 416 }
 417
 418 LayoutUnit RenderFlexibleBox::flowAwareBorderEnd() const
 419 {
 420     if (isHorizontalFlow())
 421         return isLeftToRightFlow() ? borderRight() : borderLeft();
 422     return isLeftToRightFlow() ? borderBottom() : borderTop();
 423 }
 424
 425 LayoutUnit RenderFlexibleBox::flowAwareBorderBefore() const
 426 {
 427     switch (transformedWritingMode()) {
 428     case TopToBottomWritingMode:
 429         return borderTop();
 430     case BottomToTopWritingMode:
 431         return borderBottom();
 432     case LeftToRightWritingMode:
 433         return borderLeft();
 434     case RightToLeftWritingMode:
 435         return borderRight();
 436     }
 437     ASSERT_NOT_REACHED();
 438     return borderTop();
 439 }
 440
 441 LayoutUnit RenderFlexibleBox::flowAwareBorderAfter() const
 442 {
 443     switch (transformedWritingMode()) {
 444     case TopToBottomWritingMode:
 445         return borderBottom();
 446     case BottomToTopWritingMode:
 447         return borderTop();
 448     case LeftToRightWritingMode:
 449         return borderRight();
 450     case RightToLeftWritingMode:
 451         return borderLeft();
 452     }
 453     ASSERT_NOT_REACHED();
 454     return borderTop();
 455 }
 456
 457 LayoutUnit RenderFlexibleBox::flowAwarePaddingStart() const
 458 {
 459     if (isHorizontalFlow())
 460         return isLeftToRightFlow() ? paddingLeft() : paddingRight();
 461     return isLeftToRightFlow() ? paddingTop() : paddingBottom();
 462 }
 463
 464 LayoutUnit RenderFlexibleBox::flowAwarePaddingEnd() const
 465 {
 466     if (isHorizontalFlow())
 467         return isLeftToRightFlow() ? paddingRight() : paddingLeft();
 468     return isLeftToRightFlow() ? paddingBottom() : paddingTop();
 469 }
 470
 471 LayoutUnit RenderFlexibleBox::flowAwarePaddingBefore() const
 472 {
 473     switch (transformedWritingMode()) {
 474     case TopToBottomWritingMode:
 475         return paddingTop();
 476     case BottomToTopWritingMode:
 477         return paddingBottom();
 478     case LeftToRightWritingMode:
 479         return paddingLeft();
 480     case RightToLeftWritingMode:
 481         return paddingRight();
 482     }
 483     ASSERT_NOT_REACHED();
 484     return paddingTop();
 485 }
 486
 487 LayoutUnit RenderFlexibleBox::flowAwarePaddingAfter() const
 488 {
 489     switch (transformedWritingMode()) {
 490     case TopToBottomWritingMode:
 491         return paddingBottom();
 492     case BottomToTopWritingMode:
 493         return paddingTop();
 494     case LeftToRightWritingMode:
 495         return paddingRight();
 496     case RightToLeftWritingMode:
 497         return paddingLeft();
 498     }
 499     ASSERT_NOT_REACHED();
 500     return paddingTop();
 501 }
 502
 503 LayoutUnit RenderFlexibleBox::flowAwareMarginStartForChild(RenderBox* child) const
 504 {
 505     if (isHorizontalFlow())
 506         return isLeftToRightFlow() ? child->marginLeft() : child->marginRight();
 507     return isLeftToRightFlow() ? child->marginTop() : child->marginBottom();
 508 }
 509
 510 LayoutUnit RenderFlexibleBox::flowAwareMarginEndForChild(RenderBox* child) const
 511 {
 512     if (isHorizontalFlow())
 513         return isLeftToRightFlow() ? child->marginRight() : child->marginLeft();
 514     return isLeftToRightFlow() ? child->marginBottom() : child->marginTop();
 515 }
 516
 517 LayoutUnit RenderFlexibleBox::flowAwareMarginBeforeForChild(RenderBox* child) const
 518 {
 519     switch (transformedWritingMode()) {
 520     case TopToBottomWritingMode:
 521         return child->marginTop();
 522     case BottomToTopWritingMode:
 523         return child->marginBottom();
 524     case LeftToRightWritingMode:
 525         return child->marginLeft();
 526     case RightToLeftWritingMode:
 527         return child->marginRight();
 528     }
 529     ASSERT_NOT_REACHED();
 530     return marginTop();
 531 }
 532
 533 LayoutUnit RenderFlexibleBox::flowAwareMarginAfterForChild(RenderBox* child) const
 534 {
 535     switch (transformedWritingMode()) {
 536     case TopToBottomWritingMode:
 537         return child->marginBottom();
 538     case BottomToTopWritingMode:
 539         return child->marginTop();
 540     case LeftToRightWritingMode:
 541         return child->marginRight();
 542     case RightToLeftWritingMode:
 543         return child->marginLeft();
 544     }
 545     ASSERT_NOT_REACHED();
 546     return marginBottom();
 547 }
 548
 549 LayoutUnit RenderFlexibleBox::crossAxisMarginExtentForChild(RenderBox* child) const
 550 {
 551     return isHorizontalFlow() ? child->marginHeight() : child->marginWidth();
 552 }
 553
 554 LayoutUnit RenderFlexibleBox::crossAxisScrollbarExtent() const
 555 {
 556     return isHorizontalFlow() ? horizontalScrollbarHeight() : verticalScrollbarWidth();
 557 }
 558
 559 LayoutPoint RenderFlexibleBox::flowAwareLocationForChild(RenderBox* child) const
 560 {
 561     return isHorizontalFlow() ? child->location() : child->location().transposedPoint();
 562 }
 563
 564 void RenderFlexibleBox::setFlowAwareLocationForChild(RenderBox* child, const LayoutPoint& location)
 565 {
 566     if (isHorizontalFlow())
 567         child->setLocation(location);
 568     else
 569         child->setLocation(location.transposedPoint());
 570 }
 571
 572 LayoutUnit RenderFlexibleBox::mainAxisBorderAndPaddingExtentForChild(RenderBox* child) const
 573 {
 574     return isHorizontalFlow() ? child->borderAndPaddingWidth() : child->borderAndPaddingHeight();
 575 }
 576
 577 LayoutUnit RenderFlexibleBox::mainAxisScrollbarExtentForChild(RenderBox* child) const
 578 {
 579     return isHorizontalFlow() ? child->verticalScrollbarWidth() : child->horizontalScrollbarHeight();
 580 }
 581
 582 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child) const
 583 {
 584     Length mainAxisLength = mainAxisLengthForChild(child);
 585     if (mainAxisLength.isAuto()) {
 586         LayoutUnit mainAxisExtent = hasOrthogonalFlow(child) ? child->logicalHeight() : child->maxPreferredLogicalWidth();
 587         return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
 588     }
 589     return miminumValueForLength(mainAxisLength, mainAxisContentExtent());
 590 }
 591
 592 LayoutUnit RenderFlexibleBox::computeAvailableFreeSpace(LayoutUnit preferredMainAxisExtent)
 593 {
 594     if (!isColumnFlow())
 595         return mainAxisContentExtent() - preferredMainAxisExtent;
 596
 597     if (hasOverrideHeight())
 598         return overrideHeight();
 599
 600     LayoutUnit heightResult = computeContentLogicalHeightUsing(style()->logicalHeight());
 601     if (heightResult == -1)
 602         heightResult = preferredMainAxisExtent;
 603     LayoutUnit minHeight = computeContentLogicalHeightUsing(style()->logicalMinHeight()); // Leave as -1 if unset.
 604     LayoutUnit maxHeight = style()->logicalMaxHeight().isUndefined() ? heightResult : computeContentLogicalHeightUsing(style()->logicalMaxHeight());
 605     if (maxHeight == -1)
 606         maxHeight = heightResult;
 607     heightResult = std::min(maxHeight, heightResult);
 608     heightResult = std::max(minHeight, heightResult);
 609
 610     return heightResult - preferredMainAxisExtent;
 611 }
 612
 613 void RenderFlexibleBox::layoutFlexItems(bool relayoutChildren, FlexOrderIterator& iterator, WTF::Vector<LineContext>& lineContexts)
 614 {
 615     OrderedFlexItemList orderedChildren;
 616     LayoutUnit preferredMainAxisExtent;
 617     float totalPositiveFlexibility;
 618     float totalNegativeFlexibility;
 619     LayoutUnit minMaxAppliedMainAxisExtent;
 620
 621     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
 622     while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility, minMaxAppliedMainAxisExtent)) {
 623         LayoutUnit availableFreeSpace = computeAvailableFreeSpace(preferredMainAxisExtent);
 624         FlexSign flexSign = (minMaxAppliedMainAxisExtent < preferredMainAxisExtent + availableFreeSpace) ? PositiveFlexibility : NegativeFlexibility;
 625         InflexibleFlexItemSize inflexibleItems;
 626         WTF::Vector<LayoutUnit> childSizes;
 627         while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
 628             ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
 629             ASSERT(inflexibleItems.size() > 0);
 630         }
 631
 632         layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, availableFreeSpace, lineContexts);
 633     }
 634 }
 635
 636 float RenderFlexibleBox::positiveFlexForChild(RenderBox* child) const
 637 {
 638     return isHorizontalFlow() ? child->style()->flexboxWidthPositiveFlex() : child->style()->flexboxHeightPositiveFlex();
 639 }
 640
 641 float RenderFlexibleBox::negativeFlexForChild(RenderBox* child) const
 642 {
 643     return isHorizontalFlow() ? child->style()->flexboxWidthNegativeFlex() : child->style()->flexboxHeightNegativeFlex();
 644 }
 645
 646 LayoutUnit RenderFlexibleBox::availableAlignmentSpaceForChild(LayoutUnit lineCrossAxisExtent, RenderBox* child)
 647 {
 648     LayoutUnit childCrossExtent = crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child);
 649     return lineCrossAxisExtent - childCrossExtent;
 650 }
 651
 652 LayoutUnit RenderFlexibleBox::marginBoxAscentForChild(RenderBox* child)
 653 {
 654     LayoutUnit ascent = child->firstLineBoxBaseline();
 655     if (ascent == -1)
 656         ascent = crossAxisExtentForChild(child) + flowAwareMarginAfterForChild(child);
 657     return ascent + flowAwareMarginBeforeForChild(child);
 658 }
 659
 660 void RenderFlexibleBox::computeMainAxisPreferredSizes(bool relayoutChildren, FlexOrderHashSet& flexOrderValues)
 661 {
 662     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
 663     for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
 664         flexOrderValues.add(child->style()->flexOrder());
 665
 666         if (child->isPositioned())
 667             continue;
 668
 669         child->clearOverrideSize();
 670         if (mainAxisLengthForChild(child).isAuto()) {
 671             if (!relayoutChildren)
 672                 child->setChildNeedsLayout(true);
 673             child->layoutIfNeeded();
 674         }
 675
 676         // We set the margins because we want to make sure 'auto' has a margin
 677         // of 0 and because if we're not auto sizing, we don't do a layout that
 678         // computes the start/end margins.
 679         if (isHorizontalFlow()) {
 680             child->setMarginLeft(miminumValueForLength(child->style()->marginLeft(), flexboxAvailableContentExtent));
 681             child->setMarginRight(miminumValueForLength(child->style()->marginRight(), flexboxAvailableContentExtent));
 682         } else {
 683             child->setMarginTop(miminumValueForLength(child->style()->marginTop(), flexboxAvailableContentExtent));
 684             child->setMarginBottom(miminumValueForLength(child->style()->marginBottom(), flexboxAvailableContentExtent));
 685         }
 686     }
 687 }
 688
 689 LayoutUnit RenderFlexibleBox::lineBreakLength()
 690 {
 691     if (!isColumnFlow())
 692         return mainAxisContentExtent();
 693
 694     LayoutUnit height = computeContentLogicalHeightUsing(style()->logicalHeight());
 695     if (height == -1)
 696         height = std::numeric_limits<LayoutUnit>::max();
 697     LayoutUnit maxHeight = computeContentLogicalHeightUsing(style()->logicalMaxHeight());
 698     if (maxHeight != -1)
 699         height = std::min(height, maxHeight);
 700     return height;
 701 }
 702
 703 LayoutUnit RenderFlexibleBox::adjustChildSizeForMinAndMax(RenderBox* child, LayoutUnit childSize, LayoutUnit flexboxAvailableContentExtent)
 704 {
 705     Length max = isHorizontalFlow() ? child->style()->maxWidth() : child->style()->maxHeight();
 706     Length min = isHorizontalFlow() ? child->style()->minWidth() : child->style()->minHeight();
 707     // FIXME: valueForLength isn't quite right in quirks mode: percentage heights should check parents until a value is found.
 708     // https://bugs.webkit.org/show_bug.cgi?id=81809
 709     if (max.isSpecified() && childSize > valueForLength(max, flexboxAvailableContentExtent))
 710         childSize = valueForLength(max, flexboxAvailableContentExtent);
 711     if (min.isSpecified() && childSize < valueForLength(min, flexboxAvailableContentExtent))
 712         childSize = valueForLength(min, flexboxAvailableContentExtent);
 713     return childSize;
 714 }
 715
 716 bool RenderFlexibleBox::computeNextFlexLine(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent)
 717 {
 718     orderedChildren.clear();
 719     preferredMainAxisExtent = 0;
 720     totalPositiveFlexibility = totalNegativeFlexibility = 0;
 721     minMaxAppliedMainAxisExtent = 0;
 722
 723     if (!iterator.currentChild())
 724         return false;
 725
 726     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
 727     LayoutUnit lineBreak = lineBreakLength();
 728
 729     for (RenderBox* child = iterator.currentChild(); child; child = iterator.next()) {
 730         if (child->isPositioned()) {
 731             orderedChildren.append(child);
 732             continue;
 733         }
 734
 735         LayoutUnit childMainAxisExtent = preferredMainAxisContentExtentForChild(child);
 736         LayoutUnit childMainAxisMarginBoxExtent = mainAxisBorderAndPaddingExtentForChild(child) + childMainAxisExtent;
 737         childMainAxisMarginBoxExtent += isHorizontalFlow() ? child->marginWidth() : child->marginHeight();
 738
 739         if (isMultiline() && preferredMainAxisExtent + childMainAxisMarginBoxExtent > lineBreak && orderedChildren.size() > 0)
 740             break;
 741         orderedChildren.append(child);
 742         preferredMainAxisExtent += childMainAxisMarginBoxExtent;
 743         totalPositiveFlexibility += positiveFlexForChild(child);
 744         totalNegativeFlexibility += negativeFlexForChild(child);
 745
 746         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent, flexboxAvailableContentExtent);
 747         minMaxAppliedMainAxisExtent += childMinMaxAppliedMainAxisExtent - childMainAxisExtent + childMainAxisMarginBoxExtent;
 748     }
 749     return true;
 750 }
 751
 752 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
 753 {
 754     for (size_t i = 0; i < violations.size(); ++i) {
 755         RenderBox* child = violations[i].child;
 756         LayoutUnit childSize = violations[i].childSize;
 757         availableFreeSpace -= childSize - preferredMainAxisContentExtentForChild(child);
 758         totalPositiveFlexibility -= positiveFlexForChild(child);
 759         totalNegativeFlexibility -= negativeFlexForChild(child);
 760         inflexibleItems.set(child, childSize);
 761     }
 762 }
 763
 764 // Returns true if we successfully ran the algorithm and sized the flex items.
 765 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
 766 {
 767     childSizes.clear();
 768
 769     LayoutUnit flexboxAvailableContentExtent = mainAxisContentExtent();
 770     LayoutUnit totalViolation = 0;
 771     WTF::Vector<Violation> minViolations;
 772     WTF::Vector<Violation> maxViolations;
 773     for (size_t i = 0; i < children.size(); ++i) {
 774         RenderBox* child = children[i];
 775         if (child->isPositioned()) {
 776             childSizes.append(0);
 777             continue;
 778         }
 779
 780         if (inflexibleItems.contains(child))
 781             childSizes.append(inflexibleItems.get(child));
 782         else {
 783             LayoutUnit childSize = preferredMainAxisContentExtentForChild(child);
 784             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0 && flexSign == PositiveFlexibility)
 785                 childSize += lroundf(availableFreeSpace * positiveFlexForChild(child) / totalPositiveFlexibility);
 786             else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0  && flexSign == NegativeFlexibility)
 787                 childSize += lroundf(availableFreeSpace * negativeFlexForChild(child) / totalNegativeFlexibility);
 788
 789             LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize, flexboxAvailableContentExtent);
 790             childSizes.append(adjustedChildSize);
 791
 792             LayoutUnit violation = adjustedChildSize - childSize;
 793             if (violation > 0)
 794                 minViolations.append(Violation(child, adjustedChildSize));
 795             else if (violation < 0)
 796                 maxViolations.append(Violation(child, adjustedChildSize));
 797             totalViolation += violation;
 798         }
 799     }
 800
 801     if (totalViolation)
 802         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems);
 803     return !totalViolation;
 804 }
 805
 806 static LayoutUnit initialPackingOffset(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
 807 {
 808     if (availableFreeSpace > 0) {
 809         if (flexPack == PackEnd)
 810             return availableFreeSpace;
 811         if (flexPack == PackCenter)
 812             return availableFreeSpace / 2;
 813         if (flexPack == PackDistribute && numberOfChildren)
 814             return availableFreeSpace / (2 * numberOfChildren);
 815     } else if (availableFreeSpace < 0) {
 816         if (flexPack == PackCenter || flexPack == PackDistribute)
 817             return availableFreeSpace / 2;
 818     }
 819     return 0;
 820 }
 821
 822 static LayoutUnit packingSpaceBetweenChildren(LayoutUnit availableFreeSpace, EFlexPack flexPack, size_t numberOfChildren)
 823 {
 824     if (availableFreeSpace > 0 && numberOfChildren > 1) {
 825         if (flexPack == PackJustify)
 826             return availableFreeSpace / (numberOfChildren - 1);
 827         if (flexPack == PackDistribute)
 828             return availableFreeSpace / numberOfChildren;
 829     }
 830     return 0;
 831 }
 832
 833 void RenderFlexibleBox::setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize)
 834 {
 835     // FIXME: Rename setOverrideWidth/setOverrideHeight to setOverrideLogicalWidth/setOverrideLogicalHeight.
 836     if (hasOrthogonalFlow(child))
 837         child->setOverrideHeight(childPreferredSize);
 838     else
 839         child->setOverrideWidth(childPreferredSize);
 840 }
 841
 842 void RenderFlexibleBox::prepareChildForPositionedLayout(RenderBox* child, LayoutUnit mainAxisOffset, LayoutUnit crossAxisOffset)
 843 {
 844     ASSERT(child->isPositioned());
 845     child->containingBlock()->insertPositionedObject(child);
 846     RenderLayer* childLayer = child->layer();
 847     LayoutUnit inlinePosition = isColumnFlow() ? crossAxisOffset : mainAxisOffset;
 848     if (style()->flexDirection() == FlowRowReverse)
 849         inlinePosition = mainAxisExtent() - mainAxisOffset;
 850     childLayer->setStaticInlinePosition(inlinePosition); // FIXME: Not right for regions.
 851
 852     LayoutUnit staticBlockPosition = isColumnFlow() ? mainAxisOffset : crossAxisOffset;
 853     if (childLayer->staticBlockPosition() != staticBlockPosition) {
 854         childLayer->setStaticBlockPosition(staticBlockPosition);
 855         if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
 856             child->setChildNeedsLayout(true, false);
 857     }
 858 }
 859
 860 static EFlexAlign flexAlignForChild(RenderBox* child)
 861 {
 862     EFlexAlign align = child->style()->flexItemAlign();
 863     if (align == AlignAuto)
 864         align = child->parent()->style()->flexAlign();
 865
 866     if (child->parent()->style()->flexWrap() == FlexWrapReverse) {
 867         if (align == AlignStart)
 868             align = AlignEnd;
 869         else if (align == AlignEnd)
 870             align = AlignStart;
 871     }
 872
 873     return align;
 874 }
 875
 876 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit availableFreeSpace, WTF::Vector<LineContext>& lineContexts)
 877 {
 878     ASSERT(childSizes.size() == children.size());
 879     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
 880     mainAxisOffset += initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
 881     if (style()->flexDirection() == FlowRowReverse)
 882         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 883
 884     LayoutUnit totalMainExtent = mainAxisExtent();
 885     LayoutUnit maxAscent = 0, maxDescent = 0; // Used when flex-align: baseline.
 886     LayoutUnit maxChildCrossAxisExtent = 0;
 887     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
 888     for (size_t i = 0; i < children.size(); ++i) {
 889         RenderBox* child = children[i];
 890         if (child->isPositioned()) {
 891             prepareChildForPositionedLayout(child, mainAxisOffset, crossAxisOffset);
 892             mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 893             continue;
 894         }
 895         LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(child);
 896         setLogicalOverrideSize(child, childPreferredSize);
 897         child->setChildNeedsLayout(true);
 898         child->layoutIfNeeded();
 899
 900         LayoutUnit childCrossAxisMarginBoxExtent;
 901         if (flexAlignForChild(child) == AlignBaseline) {
 902             LayoutUnit ascent = marginBoxAscentForChild(child);
 903             LayoutUnit descent = (crossAxisMarginExtentForChild(child) + crossAxisExtentForChild(child)) - ascent;
 904
 905             maxAscent = std::max(maxAscent, ascent);
 906             maxDescent = std::max(maxDescent, descent);
 907
 908             childCrossAxisMarginBoxExtent = maxAscent + maxDescent;
 909         } else
 910             childCrossAxisMarginBoxExtent = crossAxisExtentForChild(child) + crossAxisMarginExtentForChild(child);
 911         if (!isColumnFlow() && style()->logicalHeight().isAuto())
 912             setLogicalHeight(std::max(logicalHeight(), crossAxisOffset + flowAwareBorderAfter() + flowAwarePaddingAfter() + childCrossAxisMarginBoxExtent + crossAxisScrollbarExtent()));
 913         maxChildCrossAxisExtent = std::max(maxChildCrossAxisExtent, childCrossAxisMarginBoxExtent);
 914
 915         mainAxisOffset += flowAwareMarginStartForChild(child);
 916
 917         LayoutUnit childMainExtent = mainAxisExtentForChild(child);
 918         IntPoint childLocation(shouldFlipMainAxis ? totalMainExtent - mainAxisOffset - childMainExtent : mainAxisOffset,
 919             crossAxisOffset + flowAwareMarginBeforeForChild(child));
 920
 921         // FIXME: Supporting layout deltas.
 922         setFlowAwareLocationForChild(child, childLocation);
 923         mainAxisOffset += childMainExtent + flowAwareMarginEndForChild(child);
 924
 925         mainAxisOffset += packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 926     }
 927
 928     if (isColumnFlow())
 929         setLogicalHeight(mainAxisOffset + flowAwareBorderEnd() + flowAwarePaddingEnd() + scrollbarLogicalHeight());
 930
 931     if (style()->flexDirection() == FlowColumnReverse) {
 932         // We have to do an extra pass for column-reverse to reposition the flex items since the start depends
 933         // on the height of the flexbox, which we only know after we've positioned all the flex items.
 934         computeLogicalHeight();
 935         layoutColumnReverse(children, childSizes, crossAxisOffset, availableFreeSpace);
 936     }
 937
 938     lineContexts.append(LineContext(crossAxisOffset, maxChildCrossAxisExtent, children.size(), maxAscent));
 939     crossAxisOffset += maxChildCrossAxisExtent;
 940 }
 941
 942 void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, const WTF::Vector<LayoutUnit>& childSizes, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
 943 {
 944     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
 945     // starting from the end of the flexbox. We also don't need to layout anything since we're
 946     // just moving the children to a new position.
 947     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
 948     mainAxisOffset -= initialPackingOffset(availableFreeSpace, style()->flexPack(), childSizes.size());
 949     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 950
 951     for (size_t i = 0; i < children.size(); ++i) {
 952         RenderBox* child = children[i];
 953         if (child->isPositioned()) {
 954             child->layer()->setStaticBlockPosition(mainAxisOffset);
 955             mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 956             continue;
 957         }
 958         mainAxisOffset -= mainAxisExtentForChild(child) + flowAwareMarginEndForChild(child);
 959
 960         LayoutRect oldRect = child->frameRect();
 961         setFlowAwareLocationForChild(child, IntPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(child)));
 962         if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
 963             child->repaintDuringLayoutIfMoved(oldRect);
 964
 965         mainAxisOffset -= flowAwareMarginStartForChild(child);
 966         mainAxisOffset -= packingSpaceBetweenChildren(availableFreeSpace, style()->flexPack(), childSizes.size());
 967     }
 968 }
 969
 970 void RenderFlexibleBox::adjustAlignmentForChild(RenderBox* child, LayoutUnit delta)
 971 {
 972     LayoutRect oldRect = child->frameRect();
 973
 974     setFlowAwareLocationForChild(child, flowAwareLocationForChild(child) + LayoutSize(0, delta));
 975
 976     // If the child moved, we have to repaint it as well as any floating/positioned
 977     // descendants. An exception is if we need a layout. In this case, we know we're going to
 978     // repaint ourselves (and the child) anyway.
 979     if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
 980         child->repaintDuringLayoutIfMoved(oldRect);
 981 }
 982
 983 void RenderFlexibleBox::alignChildren(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
 984 {
 985     // Keep track of the space between the baseline edge and the after edge of the box for each line.
 986     WTF::Vector<LayoutUnit> minMarginAfterBaselines;
 987
 988     RenderBox* child = iterator.first();
 989     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
 990         LayoutUnit minMarginAfterBaseline = std::numeric_limits<LayoutUnit>::max();
 991         LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
 992         LayoutUnit maxAscent = lineContexts[lineNumber].maxAscent;
 993
 994         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
 995             ASSERT(child);
 996             switch (flexAlignForChild(child)) {
 997             case AlignAuto:
 998                 ASSERT_NOT_REACHED();
 999                 break;
1000             case AlignStretch: {
1001                 applyStretchAlignmentToChild(child, lineCrossAxisExtent);
1002                 // Since wrap-reverse flips cross start and cross end, strech children should be aligned with the cross end.
1003                 if (style()->flexWrap() == FlexWrapReverse)
1004                     adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1005                 break;
1006             }
1007             case AlignStart:
1008                 break;
1009             case AlignEnd:
1010                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child));
1011                 break;
1012             case AlignCenter:
1013                 adjustAlignmentForChild(child, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) / 2);
1014                 break;
1015             case AlignBaseline: {
1016                 LayoutUnit ascent = marginBoxAscentForChild(child);
1017                 LayoutUnit startOffset = maxAscent - ascent;
1018                 adjustAlignmentForChild(child, startOffset);
1019
1020                 if (style()->flexWrap() == FlexWrapReverse)
1021                     minMarginAfterBaseline = std::min(minMarginAfterBaseline, availableAlignmentSpaceForChild(lineCrossAxisExtent, child) - startOffset);
1022                 break;
1023             }
1024             }
1025         }
1026         minMarginAfterBaselines.append(minMarginAfterBaseline);
1027     }
1028
1029     if (style()->flexWrap() != FlexWrapReverse)
1030         return;
1031
1032     // wrap-reverse flips the cross axis start and end. For baseline alignment, this means we
1033     // need to align the after edge of baseline elements with the after edge of the flex line.
1034     child = iterator.first();
1035     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1036         LayoutUnit minMarginAfterBaseline = minMarginAfterBaselines[lineNumber];
1037         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1038             ASSERT(child);
1039             if (flexAlignForChild(child) == AlignBaseline && minMarginAfterBaseline)
1040                 adjustAlignmentForChild(child, minMarginAfterBaseline);
1041         }
1042     }
1043 }
1044
1045 void RenderFlexibleBox::applyStretchAlignmentToChild(RenderBox* child, LayoutUnit lineCrossAxisExtent)
1046 {
1047     if (!isColumnFlow() && child->style()->logicalHeight().isAuto()) {
1048         LayoutUnit logicalHeightBefore = child->logicalHeight();
1049         LayoutUnit stretchedLogicalHeight = child->logicalHeight() + availableAlignmentSpaceForChild(lineCrossAxisExtent, child);
1050         if (stretchedLogicalHeight < logicalHeightBefore)
1051             return;
1052
1053         child->setLogicalHeight(stretchedLogicalHeight);
1054         child->computeLogicalHeight();
1055
1056         if (child->logicalHeight() != logicalHeightBefore) {
1057             child->setOverrideHeight(child->logicalHeight());
1058             child->setLogicalHeight(0);
1059             child->setChildNeedsLayout(true);
1060             child->layoutIfNeeded();
1061         }
1062     } else if (isColumnFlow() && child->style()->logicalWidth().isAuto() && isMultiline()) {
1063         // FIXME: Handle min-width and max-width.
1064         LayoutUnit childWidth = lineCrossAxisExtent - crossAxisMarginExtentForChild(child);
1065         child->setOverrideWidth(std::max(0, childWidth));
1066         child->setChildNeedsLayout(true);
1067         child->layoutIfNeeded();
1068     }
1069 }
1070
1071 void RenderFlexibleBox::flipForRightToLeftColumn(FlexOrderIterator& iterator)
1072 {
1073     if (style()->isLeftToRightDirection() || !isColumnFlow())
1074         return;
1075
1076     LayoutUnit crossExtent = crossAxisExtent();
1077     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
1078         LayoutPoint location = flowAwareLocationForChild(child);
1079         location.setY(crossExtent - crossAxisExtentForChild(child) - location.y());
1080         setFlowAwareLocationForChild(child, location);
1081     }
1082 }
1083
1084 void RenderFlexibleBox::flipForWrapReverse(FlexOrderIterator& iterator, const WTF::Vector<LineContext>& lineContexts)
1085 {
1086     LayoutUnit contentExtent = crossAxisContentExtent();
1087     RenderBox* child = iterator.first();
1088     for (size_t lineNumber = 0; lineNumber < lineContexts.size(); ++lineNumber) {
1089         for (size_t childNumber = 0; childNumber < lineContexts[lineNumber].numberOfChildren; ++childNumber, child = iterator.next()) {
1090             ASSERT(child);
1091             LayoutPoint location = flowAwareLocationForChild(child);
1092             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
1093             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - lineContexts[0].crossAxisOffset;
1094             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
1095             location.setY(location.y() + newOffset - originalOffset);
1096
1097             LayoutRect oldRect = child->frameRect();
1098             setFlowAwareLocationForChild(child, location);
1099             if (!selfNeedsLayout() && child->checkForRepaintDuringLayout())
1100                 child->repaintDuringLayoutIfMoved(oldRect);
1101         }
1102     }
1103 }
1104
1105 }