Refactor flexbox layout a bit

third_party/WebKit/Source/core/layout/LayoutFlexibleBox.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 44 matching lines @@
         , maxAscent(maxAscent)
     {
     }
 
     LayoutUnit crossAxisOffset;
     LayoutUnit crossAxisExtent;
     size_t numberOfChildren;
     LayoutUnit maxAscent;
 };
 
-struct LayoutFlexibleBox::Violation {
-    Violation(LayoutBox* child, LayoutUnit childSize, LayoutUnit childInnerFlexBaseSize)
-        : child(child)
-        , childSize(childSize)
-        , childInnerFlexBaseSize(childInnerFlexBaseSize)
+struct LayoutFlexibleBox::FlexItem {
+    FlexItem(LayoutBox* box, LayoutUnit innerFlexBaseSize, LayoutUnit hypotheticalMainSize)
+        : box(box)
+        , innerFlexBaseSize(innerFlexBaseSize)
+        , hypotheticalMainSize(hypotheticalMainSize)
+        , frozen(false)
     {
     }
 
-    LayoutBox* child;
-    LayoutUnit childSize;
-    LayoutUnit childInnerFlexBaseSize;
+    // This constructor is used for out-of-flow children
+    explicit FlexItem(LayoutBox* box)
+        : box(box)
+        , innerFlexBaseSize()
+        , hypotheticalMainSize()
+        , frozen(true)
+    {
+    }
+    LayoutBox* box;
+    const LayoutUnit innerFlexBaseSize;
+    const LayoutUnit hypotheticalMainSize;
+    LayoutUnit flexedContentSize;
+    bool frozen;
 };
 
-
 LayoutFlexibleBox::LayoutFlexibleBox(Element* element)
     : LayoutBlock(element)
     , m_orderIterator(this)
     , m_numberOfInFlowChildrenOnFirstLine(-1)
 {
     ASSERT(!childrenInline());
 }
 
 LayoutFlexibleBox::~LayoutFlexibleBox()
 {
@@ skipping 752 matching lines @@
 void LayoutFlexibleBox::layoutFlexItems(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     Vector<LineContext> lineContexts;
     OrderedFlexItemList orderedChildren;
     LayoutUnit sumFlexBaseSize;
     double totalFlexGrow;
     double totalFlexShrink;
     double totalWeightedFlexShrink;
     LayoutUnit sumHypotheticalMainSize;
 
-    Vector<LayoutUnit, 16> childSizes;
-
     PaintLayerScrollableArea::PreventRelayoutScope preventRelayoutScope(layoutScope);
 
     dirtyForLayoutFromPercentageHeightDescendants(layoutScope);
 
     m_orderIterator.first();
     LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
     while (computeNextFlexLine(orderedChildren, sumFlexBaseSize, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink, sumHypotheticalMainSize, relayoutChildren)) {
         LayoutUnit containerMainInnerSize = mainAxisContentExtent(sumHypotheticalMainSize);
         // availableFreeSpace is the initial amount of free space in this flexbox.
         // remainingFreeSpace starts out at the same value but as we place and lay out
         // flex items we subtract from it. Note that both values can be negative.
         const LayoutUnit availableFreeSpace = containerMainInnerSize - sumFlexBaseSize;
         LayoutUnit remainingFreeSpace = availableFreeSpace;
         FlexSign flexSign = (sumHypotheticalMainSize < containerMainInnerSize) ? PositiveFlexibility : NegativeFlexibility;
-        InflexibleFlexItemSize inflexibleItems;
-        childSizes.reserveCapacity(orderedChildren.size());
-        while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink, inflexibleItems, childSizes)) {
+        while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink)) {
             ASSERT(totalFlexGrow >= 0 && totalWeightedFlexShrink >= 0);
-            ASSERT(inflexibleItems.size() > 0);
         }
 
         // Recalculate the remaining free space. The adjustment for flex factors between 0..1 means we can't just
         // use remainingFreeSpace here.
         remainingFreeSpace = containerMainInnerSize;
         for (size_t i = 0; i < orderedChildren.size(); ++i) {
-            LayoutBox* child = orderedChildren[i];
+            LayoutBox* child = orderedChildren[i].box;
             if (child->isOutOfFlowPositioned())
                 continue;
-            remainingFreeSpace -= (childSizes[i] + mainAxisBorderAndPaddingExtentForChild(*child)
+            remainingFreeSpace -= (orderedChildren[i].flexedContentSize + mainAxisBorderAndPaddingExtentForChild(*child)
                 + (isHorizontalFlow() ? child->marginWidth() : child->marginHeight()));
         }
-        layoutAndPlaceChildren(crossAxisOffset, orderedChildren, childSizes, remainingFreeSpace, relayoutChildren, layoutScope, lineContexts);
+        layoutAndPlaceChildren(crossAxisOffset, orderedChildren, remainingFreeSpace, relayoutChildren, layoutScope, lineContexts);
     }
     if (hasLineIfEmpty()) {
         // Even if computeNextFlexLine returns true, the flexbox might not have
         // a line because all our children might be out of flow positioned.
         // Instead of just checking if we have a line, make sure the flexbox
         // has at least a line's worth of height to cover this case.
         LayoutUnit minHeight = minimumLogicalHeightForEmptyLine();
         if (size().height() < minHeight)
             setLogicalHeight(minHeight);
     }
 
     updateLogicalHeight();
     repositionLogicalHeightDependentFlexItems(lineContexts);
 }
 
 LayoutUnit LayoutFlexibleBox::autoMarginOffsetInMainAxis(const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace)
 {
     if (availableFreeSpace <= LayoutUnit())
         return LayoutUnit();
 
     int numberOfAutoMargins = 0;
     bool isHorizontal = isHorizontalFlow();
     for (size_t i = 0; i < children.size(); ++i) {
-        LayoutBox* child = children[i];
+        LayoutBox* child = children[i].box;
         if (child->isOutOfFlowPositioned())
             continue;
         if (isHorizontal) {
             if (child->style()->marginLeft().isAuto())
                 ++numberOfAutoMargins;
             if (child->style()->marginRight().isAuto())
                 ++numberOfAutoMargins;
         } else {
             if (child->style()->marginTop().isAuto())
                 ++numberOfAutoMargins;
@@ skipping 265 matching lines @@
 
     if (!m_orderIterator.currentChild())
         return false;
 
     LayoutUnit lineBreakLength = mainAxisContentExtent(LayoutUnit::max());
 
     bool lineHasInFlowItem = false;
 
     for (LayoutBox* child = m_orderIterator.currentChild(); child; child = m_orderIterator.next()) {
         if (child->isOutOfFlowPositioned()) {
-            orderedChildren.append(child);
+            orderedChildren.append(FlexItem(child));
             continue;
         }
 
         // If this condition is true, then computeMainAxisExtentForChild will call child.intrinsicContentLogicalHeight()
         // and child.scrollbarLogicalHeight(), so if the child has intrinsic min/max/preferred size,
         // run layout on it now to make sure its logical height and scroll bars are up to date.
         if (childHasIntrinsicMainAxisSize(*child) && child->needsLayout()) {
             child->clearOverrideSize();
             child->layoutIfNeeded();
             cacheChildMainSize(*child);
         }
 
         LayoutUnit childInnerFlexBaseSize = computeInnerFlexBaseSizeForChild(*child, relayoutChildren ? ForceLayout : LayoutIfNeeded);
         LayoutUnit childMainAxisMarginBorderPadding = mainAxisBorderAndPaddingExtentForChild(*child)
             + (isHorizontalFlow() ? child->marginWidth() : child->marginHeight());
         LayoutUnit childOuterFlexBaseSize = childInnerFlexBaseSize + childMainAxisMarginBorderPadding;
 
         LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(*child, childInnerFlexBaseSize);
         LayoutUnit childHypotheticalMainSize = childMinMaxAppliedMainAxisExtent + childMainAxisMarginBorderPadding;
 
         if (isMultiline() && sumHypotheticalMainSize + childHypotheticalMainSize > lineBreakLength && lineHasInFlowItem)
             break;
-        orderedChildren.append(child);
+        orderedChildren.append(FlexItem(child, childInnerFlexBaseSize, childMinMaxAppliedMainAxisExtent));
         lineHasInFlowItem  = true;
         sumFlexBaseSize += childOuterFlexBaseSize;
         totalFlexGrow += child->style()->flexGrow();
         totalFlexShrink += child->style()->flexShrink();
         totalWeightedFlexShrink += child->style()->flexShrink() * childInnerFlexBaseSize;
         sumHypotheticalMainSize += childHypotheticalMainSize;
     }
     return true;
 }
 
-void LayoutFlexibleBox::freezeViolations(const Vector<Violation>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems)
+void LayoutFlexibleBox::freezeViolations(Vector<FlexItem*>& violations, LayoutUnit& availableFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
 {
     for (size_t i = 0; i < violations.size(); ++i) {
-        LayoutBox* child = violations[i].child;
-        LayoutUnit childSize = violations[i].childSize;
-        availableFreeSpace -= childSize - violations[i].childInnerFlexBaseSize;
+        LayoutBox* child = violations[i]->box;
+        LayoutUnit childSize = violations[i]->flexedContentSize;
+        availableFreeSpace -= childSize - violations[i]->innerFlexBaseSize;
         totalFlexGrow -= child->style()->flexGrow();
         totalFlexShrink -= child->style()->flexShrink();
-        totalWeightedFlexShrink -= child->style()->flexShrink() * violations[i].childInnerFlexBaseSize;
+        totalWeightedFlexShrink -= child->style()->flexShrink() * violations[i]->innerFlexBaseSize;
         // totalWeightedFlexShrink can be negative when we exceed the precision of a double when we initially
         // calcuate totalWeightedFlexShrink. We then subtract each child's weighted flex shrink with full precision,
         // now leading to a negative result. See css3/flexbox/large-flex-shrink-assert.html
         totalWeightedFlexShrink = std::max(totalWeightedFlexShrink, 0.0);
-        inflexibleItems.set(child, childSize);
+        violations[i]->frozen = true;
     }
 }
 
 // Returns true if we successfully ran the algorithm and sized the flex items.
-bool LayoutFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit availableFreeSpace, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink, InflexibleFlexItemSize& inflexibleItems, Vector<LayoutUnit, 16>& childSizes)
+bool LayoutFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, OrderedFlexItemList& children, LayoutUnit availableFreeSpace, LayoutUnit& remainingFreeSpace, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink)
 {
-    childSizes.resize(0);
     LayoutUnit totalViolation;
     LayoutUnit usedFreeSpace;
-    Vector<Violation> minViolations;
-    Vector<Violation> maxViolations;
+    Vector<FlexItem*> minViolations;
+    Vector<FlexItem*> maxViolations;
 
     double sumFlexFactors = (flexSign == PositiveFlexibility) ? totalFlexGrow : totalFlexShrink;
     if (sumFlexFactors > 0 && sumFlexFactors < 1) {
         LayoutUnit fractional(availableFreeSpace * sumFlexFactors);
         if (fractional.abs() < remainingFreeSpace.abs())
             remainingFreeSpace = fractional;
     }
 
     for (size_t i = 0; i < children.size(); ++i) {
-        LayoutBox* child = children[i];
+        FlexItem& flexItem = children[i];
+        LayoutBox* child = flexItem.box;
         if (child->isOutOfFlowPositioned()) {
-            childSizes.append(0);
             continue;
         }
 
-        if (inflexibleItems.contains(child)) {
-            childSizes.append(inflexibleItems.get(child));
-        } else {
-            LayoutUnit childInnerFlexBaseSize = computeInnerFlexBaseSizeForChild(*child);
-            LayoutUnit childSize = childInnerFlexBaseSize;
-            double extraSpace = 0;
-            if (remainingFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow)) {
-                extraSpace = remainingFreeSpace * child->style()->flexGrow() / totalFlexGrow;
-            } else if (remainingFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink) && child->style()->flexShrink()) {
-                extraSpace = remainingFreeSpace * child->style()->flexShrink() * childInnerFlexBaseSize / totalWeightedFlexShrink;
-            }
-            if (std::isfinite(extraSpace))
-                childSize += LayoutUnit::fromFloatRound(extraSpace);
+        if (flexItem.frozen)
+            continue;
+        LayoutUnit childSize = flexItem.innerFlexBaseSize;
+        double extraSpace = 0;
+        if (remainingFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow)) {
+            extraSpace = remainingFreeSpace * child->style()->flexGrow() / totalFlexGrow;
+        } else if (remainingFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink) && child->style()->flexShrink()) {
+            extraSpace = remainingFreeSpace * child->style()->flexShrink() * flexItem.innerFlexBaseSize / totalWeightedFlexShrink;
+        }
+        if (std::isfinite(extraSpace))
+            childSize += LayoutUnit::fromFloatRound(extraSpace);
 
-            LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize);
-            ASSERT(adjustedChildSize >= 0);
-            childSizes.append(adjustedChildSize);
-            usedFreeSpace += adjustedChildSize - childInnerFlexBaseSize;
+        LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize);
+        DCHECK_GE(adjustedChildSize, 0);
+        flexItem.flexedContentSize = adjustedChildSize;
+        usedFreeSpace += adjustedChildSize - flexItem.innerFlexBaseSize;
 
-            LayoutUnit violation = adjustedChildSize - childSize;
-            if (violation > 0)
-                minViolations.append(Violation(child, adjustedChildSize, childInnerFlexBaseSize));
-            else if (violation < 0)
-                maxViolations.append(Violation(child, adjustedChildSize, childInnerFlexBaseSize));
-            totalViolation += violation;
-        }
+        LayoutUnit violation = adjustedChildSize - childSize;
+        if (violation > 0)
+            minViolations.append(&flexItem);
+        else if (violation < 0)
+            maxViolations.append(&flexItem);
+        totalViolation += violation;
     }
 
     if (totalViolation)
-        freezeViolations(totalViolation < 0 ? maxViolations : minViolations, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink, inflexibleItems);
+        freezeViolations(totalViolation < 0 ? maxViolations : minViolations, remainingFreeSpace, totalFlexGrow, totalFlexShrink, totalWeightedFlexShrink);
     else
         remainingFreeSpace -= usedFreeSpace;
 
     return !totalViolation;
 }
 
 static LayoutUnit initialJustifyContentOffset(LayoutUnit availableFreeSpace, ContentPosition justifyContent, ContentDistributionType justifyContentDistribution, unsigned numberOfChildren)
 {
     if (justifyContent == ContentPositionFlexEnd)
         return availableFreeSpace;
@@ skipping 154 matching lines @@
             align = ItemPositionFlexStart;
     }
 
     return align;
 }
 
 size_t LayoutFlexibleBox::numberOfInFlowPositionedChildren(const OrderedFlexItemList& children) const
 {
     size_t count = 0;
     for (size_t i = 0; i < children.size(); ++i) {
-        LayoutBox* child = children[i];
+        LayoutBox* child = children[i].box;
         if (!child->isOutOfFlowPositioned())
             ++count;
     }
     return count;
 }
 
 void LayoutFlexibleBox::resetAutoMarginsAndLogicalTopInCrossAxis(LayoutBox& child)
 {
     if (hasAutoMarginsInCrossAxis(child)) {
         child.updateLogicalHeight();
@@ skipping 49 matching lines @@
     return child.styleRef().overflowY();
 }
 
 EOverflow LayoutFlexibleBox::crossAxisOverflowForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return child.styleRef().overflowY();
     return child.styleRef().overflowX();
 }
 
-void LayoutFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const Vector<LayoutUnit, 16>& childSizes, LayoutUnit availableFreeSpace, bool relayoutChildren, SubtreeLayoutScope& layoutScope, Vector<LineContext>& lineContexts)
+void LayoutFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, LayoutUnit availableFreeSpace, bool relayoutChildren, SubtreeLayoutScope& layoutScope, Vector<LineContext>& lineContexts)
 {
-    ASSERT(childSizes.size() == children.size());
-
     ContentPosition position = styleRef().resolvedJustifyContentPosition(normalValueBehavior());
     ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(normalValueBehavior());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
     if (style()->flexDirection() == FlowRowReverse && shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 
     LayoutUnit totalMainExtent = mainAxisExtent();
     if (!shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
         totalMainExtent -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
     LayoutUnit maxAscent, maxDescent; // Used when align-items: baseline.
     LayoutUnit maxChildCrossAxisExtent;
     size_t seenInFlowPositionedChildren = 0;
     bool shouldFlipMainAxis = !isColumnFlow() && !isLeftToRightFlow();
     for (size_t i = 0; i < children.size(); ++i) {
-        LayoutBox* child = children[i];
+        const FlexItem& flexItem = children[i];
+        LayoutBox* child = flexItem.box;
 
         if (child->isOutOfFlowPositioned()) {
             prepareChildForPositionedLayout(*child);
             continue;
         }
 
         child->setMayNeedPaintInvalidation();
 
-        LayoutUnit childPreferredSize = childSizes[i] + mainAxisBorderAndPaddingExtentForChild(*child);
+        LayoutUnit childPreferredSize = flexItem.flexedContentSize + mainAxisBorderAndPaddingExtentForChild(*child);
         setOverrideMainAxisSizeForChild(*child, childPreferredSize);
         if (childPreferredSize != mainAxisExtentForChild(*child)) {
             child->setChildNeedsLayout(MarkOnlyThis);
         } else {
             // To avoid double applying margin changes in updateAutoMarginsInCrossAxis, we reset the margins here.
             resetAutoMarginsAndLogicalTopInCrossAxis(*child);
         }
         // We may have already forced relayout for orthogonal flowing children in computeInnerFlexBaseSizeForChild.
         bool forceChildRelayout = relayoutChildren && !childFlexBaseSizeRequiresLayout(*child);
         if (child->isLayoutBlock() && toLayoutBlock(*child).hasPercentHeightDescendants() && m_relaidOutChildren.contains(child)) {
@@ skipping 67 matching lines @@
     // This is similar to the logic in layoutAndPlaceChildren, except we place the children
     // starting from the end of the flexbox. We also don't need to layout anything since we're
     // just moving the children to a new position.
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit mainAxisOffset = logicalHeight() - flowAwareBorderEnd() - flowAwarePaddingEnd();
     mainAxisOffset -= initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
     mainAxisOffset -= isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
 
     size_t seenInFlowPositionedChildren = 0;
     for (size_t i = 0; i < children.size(); ++i) {
-        LayoutBox* child = children[i];
+        LayoutBox* child = children[i].box;
 
         if (child->isOutOfFlowPositioned())
             continue;
 
         mainAxisOffset -= mainAxisExtentForChild(*child) + flowAwareMarginEndForChild(*child);
 
         setFlowAwareLocationForChild(*child, LayoutPoint(mainAxisOffset, crossAxisOffset + flowAwareMarginBeforeForChild(*child)));
 
         mainAxisOffset -= flowAwareMarginStartForChild(*child);
 
@@ skipping 189 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink