[css-grid] Improve intrinsic size computation with orthogonal flows

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

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/GridTrackSizingAlgorithm.h"
 
+#include "core/frame/FrameView.h"
 #include "core/layout/Grid.h"
 #include "core/layout/LayoutGrid.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 class GridSizingData;
 
 LayoutUnit GridTrack::baseSize() const {
   DCHECK(isGrowthLimitBiggerThanBaseSize());
@@ skipping 242 matching lines @@
     LayoutBox& child) const {
   GridTrackSizingDirection childBlockDirection =
       flowAwareDirectionForChild(layoutGrid(), child, ForRows);
 
   // If |child| has a relative logical height, we shouldn't let it override its
   // intrinsic height, which is what we are interested in here. Thus we need to
   // set the block-axis override size to -1 (no possible resolution).
   if (shouldClearOverrideContainingBlockContentSizeForChild(child, ForRows)) {
     setOverrideContainingBlockContentSizeForChild(child, childBlockDirection,
                                                   LayoutUnit(-1));
-    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+    setGridItemNeedsLayout(child);
   }
 
   // We need to clear the stretched height to properly compute logical height
   // during layout.
   if (child.needsLayout())
     child.clearOverrideLogicalContentHeight();
 
   child.layoutIfNeeded();
   return child.logicalHeight() + child.marginLogicalHeight();
 }
@@ skipping 16 matching lines @@
     // FIXME: It's unclear if we should return the intrinsic width or the
     // preferred width.
     // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
     LayoutUnit marginLogicalWidth =
         child.needsLayout() ? computeMarginLogicalSizeForChild(
                                   InlineDirection, layoutGrid(), child)
                             : child.marginLogicalWidth();
     return child.minPreferredLogicalWidth() + marginLogicalWidth;
   }
 
-  // All orthogonal flow boxes were already laid out during an early layout
-  // phase performed in FrameView::performLayout.
-  // It's true that grid track sizing was not completed at that time and it may
-  // afffect the final height of a grid item, but since it's forbidden to
-  // perform a layout during intrinsic width computation, we have to use that
-  // computed height for now.
-  if (direction() == ForColumns &&
-      m_algorithm.m_sizingOperation == IntrinsicSizeComputation) {
-    DCHECK(layoutGrid()->isOrthogonalChild(child));
-    return child.logicalHeight() + child.marginLogicalHeight();
-  }
-
   if (updateOverrideContainingBlockContentSizeForChild(child,
                                                        childInlineDirection))
-    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+    setGridItemNeedsLayout(child);
   return logicalHeightForChild(child);
 }
 
 DISABLE_CFI_PERF
 LayoutUnit GridTrackSizingAlgorithmStrategy::maxContentForChild(
     LayoutBox& child) const {
   GridTrackSizingDirection childInlineDirection =
       flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
   if (direction() == childInlineDirection) {
     // If |child| has a relative logical width, we shouldn't let it override its
     // intrinsic width, which is what we are interested in here. Thus we need to
     // set the inline-axis override size to -1 (no possible resolution).
     if (shouldClearOverrideContainingBlockContentSizeForChild(child,
                                                               ForColumns)) {
       setOverrideContainingBlockContentSizeForChild(child, childInlineDirection,
                                                     LayoutUnit(-1));
     }
 
     // FIXME: It's unclear if we should return the intrinsic width or the
     // preferred width.
     // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
     LayoutUnit marginLogicalWidth =
         child.needsLayout() ? computeMarginLogicalSizeForChild(
                                   InlineDirection, layoutGrid(), child)
                             : child.marginLogicalWidth();
     return child.maxPreferredLogicalWidth() + marginLogicalWidth;
   }
 
-  if (direction() == ForColumns &&
-      m_algorithm.m_sizingOperation == IntrinsicSizeComputation) {
-    // All orthogonal flow boxes were already laid out during an early layout
-    // phase performed in FrameView::performLayout. It's true that grid track
-    // sizing was not completed at that time and it may afffect the final height
-    // of a grid item, but since it's forbidden to perform a layout during
-    // intrinsic width computation, we have to use that computed height for now.
-    DCHECK(layoutGrid()->isOrthogonalChild(child));
-    return child.logicalHeight() + child.marginLogicalHeight();
-  }
-
   if (updateOverrideContainingBlockContentSizeForChild(child,
                                                        childInlineDirection))
-    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+    setGridItemNeedsLayout(child);
   return logicalHeightForChild(child);
 }
 
 LayoutUnit GridTrackSizingAlgorithmStrategy::minSizeForChild(
     LayoutBox& child) const {
   GridTrackSizingDirection childInlineDirection =
       flowAwareDirectionForChild(layoutGrid(), child, ForColumns);
   bool isRowAxis = direction() == childInlineDirection;
   const Length& childSize = isRowAxis ? child.styleRef().logicalWidth()
                                       : child.styleRef().logicalHeight();
@@ skipping 39 matching lines @@
   return m_algorithm.findFrUnitSize(tracksSpan, leftOverSpace);
 }
 
 void GridTrackSizingAlgorithmStrategy::distributeSpaceToTracks(
     Vector<GridTrack*>& tracks,
     LayoutUnit& availableLogicalSpace) const {
   m_algorithm.distributeSpaceToTracks<MaximizeTracks>(tracks, nullptr,
                                                       availableLogicalSpace);
 }
 
+void GridTrackSizingAlgorithmStrategy::setGridItemNeedsLayout(
+    LayoutBox& gridItem) const {
+  // Mac code can call computIntrinsicLogicalWidths() after the layout in
+  // content::RenderViewImpl::didUpdateLayout().
+  if (!layoutGrid()->document().view()->isInPerformLayout())
+    return;
+
+  gridItem.setNeedsLayout(LayoutInvalidationReason::GridChanged, MarkOnlyThis);
+}
+
 LayoutUnit DefiniteSizeStrategy::minLogicalWidthForChild(
     LayoutBox& child,
     Length childMinSize,
     GridTrackSizingDirection childInlineDirection) const {
   LayoutUnit marginLogicalWidth =
       computeMarginLogicalSizeForChild(InlineDirection, layoutGrid(), child);
   return child.computeLogicalWidthUsing(
              MinSize, childMinSize, overrideContainingBlockContentSizeForChild(
                                         child, childInlineDirection),
              layoutGrid()) +
          marginLogicalWidth;
 }
 
 void DefiniteSizeStrategy::layoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool overrideSizeHasChanged) const {
   if (overrideSizeHasChanged)
-    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+    setGridItemNeedsLayout(child);
   child.layoutIfNeeded();
 }
 
 void DefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
                                           LayoutUnit& freeSpace) {
   size_t tracksSize = tracks.size();
   Vector<GridTrack*> tracksForDistribution(tracksSize);
   for (size_t i = 0; i < tracksSize; ++i) {
     tracksForDistribution[i] = tracks.data() + i;
     tracksForDistribution[i]->setPlannedSize(
@@ skipping 27 matching lines @@
              MinSize, childMinSize, overrideContainingBlockContentSizeForChild(
                                         child, childInlineDirection),
              layoutGrid()) +
          marginLogicalWidth;
 }
 
 void IndefiniteSizeStrategy::layoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool overrideSizeHasChanged) const {
   if (overrideSizeHasChanged && direction() != ForColumns)
-    child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+    setGridItemNeedsLayout(child);
   child.layoutIfNeeded();
 }
 
 void IndefiniteSizeStrategy::maximizeTracks(Vector<GridTrack>& tracks,
                                             LayoutUnit&) {
   for (auto& track : tracks)
     track.setBaseSize(track.growthLimit());
 }
 
 static inline double normalizedFlexFraction(const GridTrack& track,
@@ skipping 937 matching lines @@
   DCHECK(m_algorithm.isValidTransition());
   DCHECK(!m_algorithm.m_needsSetup);
 }
 
 GridTrackSizingAlgorithm::StateMachine::~StateMachine() {
   m_algorithm.advanceNextState();
   m_algorithm.m_needsSetup = true;
 }
 
 }  // namespace blink