[css-flexbox] Cache whether our main axis size is definite

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 72 matching lines @@
     const LayoutUnit innerFlexBaseSize;
     const LayoutUnit hypotheticalMainSize;
     LayoutUnit flexedContentSize;
     bool frozen;
 };
 
 LayoutFlexibleBox::LayoutFlexibleBox(Element* element)
     : LayoutBlock(element)
     , m_orderIterator(this)
     , m_numberOfInFlowChildrenOnFirstLine(-1)
+    , m_hasDefiniteHeight(-1)
 {
     ASSERT(!childrenInline());
 }
 
 LayoutFlexibleBox::~LayoutFlexibleBox()
 {
 }
 
 LayoutFlexibleBox* LayoutFlexibleBox::createAnonymous(Document* document)
 {
@@ skipping 227 matching lines @@
     }
 }
 
 void LayoutFlexibleBox::layoutBlock(bool relayoutChildren)
 {
     ASSERT(needsLayout());
 
     if (!relayoutChildren && simplifiedLayout())
         return;
 
+    LayoutBox* firstChild = firstInFlowChildBox();
+    if (firstChild)
+        m_hasDefiniteHeight = firstChild->computePercentageLogicalHeight(Length(0, Percent)) != LayoutUnit(-1);
+
     m_relaidOutChildren.clear();
 
     if (updateLogicalWidthAndColumnWidth())
         relayoutChildren = true;
 
     SubtreeLayoutScope layoutScope(*this);
     LayoutUnit previousHeight = logicalHeight();
     setLogicalHeight(borderAndPaddingLogicalHeight() + scrollbarLogicalHeight());
 
     PaintLayerScrollableArea::DelayScrollPositionClampScope delayClampScope;
@@ skipping 23 matching lines @@
         computeOverflow(clientLogicalBottomAfterRepositioning());
     }
 
     updateLayerTransformAfterLayout();
 
     // Update our scroll information if we're overflow:auto/scroll/hidden now that we know if
     // we overflow or not.
     updateAfterLayout();
 
     clearNeedsLayout();
+
+    // We have to reset this, because changes to our ancestors' style
+    // can affect this value.
+    m_hasDefiniteHeight = -1;
 }
 
 void LayoutFlexibleBox::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     BlockPainter::paintChildrenOfFlexibleBox(*this, paintInfo, paintOffset);
 }
 
 void LayoutFlexibleBox::repositionLogicalHeightDependentFlexItems(Vector<LineContext>& lineContexts)
 {
     LayoutUnit crossAxisStartEdge = lineContexts.isEmpty() ? LayoutUnit() : lineContexts[0].crossAxisOffset;
@@ skipping 369 matching lines @@
 LayoutUnit LayoutFlexibleBox::mainAxisBorderAndPaddingExtentForChild(const LayoutBox& child) const
 {
     return isHorizontalFlow() ? child.borderAndPaddingWidth() : child.borderAndPaddingHeight();
 }
 
 bool LayoutFlexibleBox::mainAxisLengthIsDefinite(const LayoutBox& child, const Length& flexBasis) const
 {
     if (flexBasis.isAuto())
         return false;
     if (flexBasis.hasPercent()) {
-        return isColumnFlow() ?
-            child.computePercentageLogicalHeight(flexBasis) != -1 :
-            true;
+        if (!isColumnFlow() || m_hasDefiniteHeight == 1)
+            return true;
+        if (m_hasDefiniteHeight == 0)
+            return false;
+        return child.computePercentageLogicalHeight(flexBasis) != -1;
     }
     return true;
 }
 
 bool LayoutFlexibleBox::crossAxisLengthIsDefinite(const LayoutBox& child, const Length& length) const
 {
     if (length.isAuto())
         return false;
     if (length.hasPercent()) {
-        return hasOrthogonalFlow(child) ?
-            true :
-            child.computePercentageLogicalHeight(length) != -1;
+        if (hasOrthogonalFlow(child) || m_hasDefiniteHeight == 1)
+            return true;
+        if (m_hasDefiniteHeight == 0)
+            return false;
+        return child.computePercentageLogicalHeight(length) != -1;
     }
     // TODO(cbiesinger): Eventually we should support other types of sizes here. Requires updating
     // computeMainSizeFromAspectRatioUsing.
     return length.isFixed();
 }
 
 bool LayoutFlexibleBox::childFlexBaseSizeRequiresLayout(const LayoutBox& child) const
 {
     return (!mainAxisLengthIsDefinite(child, flexBasisForChild(child))
         && (hasOrthogonalFlow(child)
@@ skipping 345 matching lines @@
     // 2) of the flexbox spec.
     // We need to check for the flexbox to have a definite main size, and for the
     // flex item to have a definite flex basis.
     const Length& flexBasis = flexBasisForChild(child);
     if (!mainAxisLengthIsDefinite(child, flexBasis))
         return LayoutUnit(-1);
     if (!flexBasis.hasPercent()) {
         // If flex basis had a percentage, our size is guaranteed to be definite or the flex item's
         // size could not be definite.
         // Otherwise, we make up a percentage to check whether we have a definite size.
-        // TODO(cbiesinger): cache this somewhere
         if (!mainAxisLengthIsDefinite(child, Length(0, Percent)))
             return LayoutUnit(-1);
     }
 
     if (hasOrthogonalFlow(child))
         return child.hasOverrideLogicalContentHeight() ? child.overrideLogicalContentHeight() : LayoutUnit(-1);
     return child.hasOverrideLogicalContentWidth() ? child.overrideLogicalContentWidth() : LayoutUnit(-1);
 }
 
 LayoutUnit LayoutFlexibleBox::childLogicalHeightForPercentageResolution(const LayoutBox& child)
@@ skipping 722 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