[css-flexbox] Only cache m_hasDefiniteHeight if we're inside of layoutBlock()

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 21 matching lines @@
 
 #include "core/frame/UseCounter.h"
 #include "core/layout/FlexibleBoxAlgorithm.h"
 #include "core/layout/LayoutState.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/TextAutosizer.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LengthFunctions.h"
+#include "wtf/AutoReset.h"
 #include "wtf/MathExtras.h"
 #include <limits>
 
 namespace blink {
 
 static bool hasAspectRatio(const LayoutBox& child) {
   return child.isImage() || child.isCanvas() || child.isVideo();
 }
 
 struct LayoutFlexibleBox::LineContext {
   LineContext(LayoutUnit crossAxisOffset,
               LayoutUnit crossAxisExtent,
               LayoutUnit maxAscent,
               Vector<FlexItem>&& flexItems)
       : crossAxisOffset(crossAxisOffset),
         crossAxisExtent(crossAxisExtent),
         maxAscent(maxAscent),
         flexItems(flexItems) {}
 
   LayoutUnit crossAxisOffset;
   LayoutUnit crossAxisExtent;
   LayoutUnit maxAscent;
   Vector<FlexItem> flexItems;
 };
 
 LayoutFlexibleBox::LayoutFlexibleBox(Element* element)
     : LayoutBlock(element),
       m_orderIterator(this),
       m_numberOfInFlowChildrenOnFirstLine(-1),
-      m_hasDefiniteHeight(SizeDefiniteness::Unknown) {
+      m_hasDefiniteHeight(SizeDefiniteness::Unknown),
+      m_inLayout(false) {
   DCHECK(!childrenInline());
   if (!isAnonymous())
     UseCounter::count(document(), UseCounter::CSSFlexibleBox);
 }
 
 LayoutFlexibleBox::~LayoutFlexibleBox() {}
 
 LayoutFlexibleBox* LayoutFlexibleBox::createAnonymous(Document* document) {
   LayoutFlexibleBox* layoutObject = new LayoutFlexibleBox(nullptr);
   layoutObject->setDocumentForAnonymous(document);
@@ skipping 264 matching lines @@
   }
 }
 
 void LayoutFlexibleBox::layoutBlock(bool relayoutChildren) {
   DCHECK(needsLayout());
 
   if (!relayoutChildren && simplifiedLayout())
     return;
 
   m_relaidOutChildren.clear();
+  WTF::AutoReset<bool> reset1(&m_inLayout, true);
+  DCHECK_EQ(m_hasDefiniteHeight, SizeDefiniteness::Unknown);
 
   if (updateLogicalWidthAndColumnWidth())
     relayoutChildren = true;
 
   SubtreeLayoutScope layoutScope(*this);
   LayoutUnit previousHeight = logicalHeight();
   setLogicalHeight(borderAndPaddingLogicalHeight() + scrollbarLogicalHeight());
 
   PaintLayerScrollableArea::DelayScrollOffsetClampScope delayClampScope;
 
@@ skipping 18 matching lines @@
 
     layoutPositionedObjects(relayoutChildren || isDocumentElement());
 
     // FIXME: css3/flexbox/repaint-rtl-column.html seems to issue paint
     // invalidations for more overflow than it needs to.
     computeOverflow(clientLogicalBottomAfterRepositioning());
   }
 
   updateLayerTransformAfterLayout();
 
+  // We have to reset this, because changes to our ancestors' style can affect
+  // this value. Also, this needs to be before we call updateAfterLayout, as
+  // that function may re-enter this one.
+  m_hasDefiniteHeight = SizeDefiniteness::Unknown;
+
   // 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 = SizeDefiniteness::Unknown;
 }
 
 void LayoutFlexibleBox::paintChildren(const PaintInfo& paintInfo,
                                       const LayoutPoint& paintOffset) const {
   BlockPainter::paintChildrenOfFlexibleBox(*this, paintInfo, paintOffset);
 }
 
 void LayoutFlexibleBox::repositionLogicalHeightDependentFlexItems(
     Vector<LineContext>& lineContexts) {
   LayoutUnit crossAxisStartEdge =
@@ skipping 412 matching lines @@
     const LayoutBox& child,
     const Length& flexBasis) const {
   if (flexBasis.isAuto())
     return false;
   if (flexBasis.isPercentOrCalc()) {
     if (!isColumnFlow() || m_hasDefiniteHeight == SizeDefiniteness::Definite)
       return true;
     if (m_hasDefiniteHeight == SizeDefiniteness::Indefinite)
       return false;
     bool definite = child.computePercentageLogicalHeight(flexBasis) != -1;
-    m_hasDefiniteHeight =
-        definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;
+    if (m_inLayout) {
+      // We can reach this code even while we're not laying ourselves out, such
+      // as from mainSizeForPercentageResolution.
+      m_hasDefiniteHeight =
+          definite ? SizeDefiniteness::Definite : SizeDefiniteness::Indefinite;
+    }
     return definite;
   }
   return true;
 }
 
 bool LayoutFlexibleBox::crossAxisLengthIsDefinite(const LayoutBox& child,
                                                   const Length& length) const {
   if (length.isAuto())
     return false;
   if (length.isPercentOrCalc()) {
@@ skipping 1326 matching lines @@
       LayoutUnit originalOffset =
           lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
       LayoutUnit newOffset =
           contentExtent - originalOffset - lineCrossAxisExtent;
       adjustAlignmentForChild(*flexItem.box, newOffset - originalOffset);
     }
   }
 }
 
 }  // namespace blink