[css-grid] Preemptively store intrinsic sizes during layout

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 254 matching lines @@
     LayoutBox& child) const {
   GridTrackSizingDirection child_block_direction =
       FlowAwareDirectionForChild(GetLayoutGrid(), child, kForRows);
 
   // 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, kForRows)) {
     SetOverrideContainingBlockContentSizeForChild(child, child_block_direction,
                                                   LayoutUnit(-1));
-    SetGridItemNeedsLayout(child);
+    child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   }
 
   // We need to clear the stretched height to properly compute logical height
   // during layout.
   if (child.NeedsLayout())
     child.ClearOverrideLogicalContentHeight();
 
   child.LayoutIfNeeded();
   GridAxis baseline_axis = GetLayoutGrid()->IsOrthogonalChild(child)
                                ? kGridRowAxis
@@ skipping 38 matching lines @@
     if (GetLayoutGrid()->IsBaselineAlignmentForChild(child, kGridRowAxis) &&
         GetLayoutGrid()->IsBaselineContextComputed(kGridRowAxis)) {
       auto& group =
           GetLayoutGrid()->GetBaselineGroupForChild(child, kGridRowAxis);
       return group.MaxAscent() + group.MaxDescent();
     }
   }
 
   if (UpdateOverrideContainingBlockContentSizeForChild(child,
                                                        child_inline_direction))
-    SetGridItemNeedsLayout(child);
+    child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   return LogicalHeightForChild(child);
 }
 
 DISABLE_CFI_PERF
 LayoutUnit GridTrackSizingAlgorithmStrategy::MaxContentForChild(
     LayoutBox& child) const {
   GridTrackSizingDirection child_inline_direction =
       FlowAwareDirectionForChild(GetLayoutGrid(), child, kForColumns);
   if (Direction() == child_inline_direction) {
     // If |child| has a relative logical width, we shouldn't let it override its
@@ skipping 10 matching lines @@
     // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
     LayoutUnit margin_logical_width =
         child.NeedsLayout() ? ComputeMarginLogicalSizeForChild(
                                   kInlineDirection, GetLayoutGrid(), child)
                             : child.MarginLogicalWidth();
     return child.MaxPreferredLogicalWidth() + margin_logical_width;
   }
 
   if (UpdateOverrideContainingBlockContentSizeForChild(child,
                                                        child_inline_direction))
-    SetGridItemNeedsLayout(child);
+    child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   return LogicalHeightForChild(child);
 }
 
 LayoutUnit GridTrackSizingAlgorithmStrategy::MinSizeForChild(
     LayoutBox& child) const {
   GridTrackSizingDirection child_inline_direction =
       FlowAwareDirectionForChild(GetLayoutGrid(), child, kForColumns);
   bool is_row_axis = Direction() == child_inline_direction;
   const Length& child_size = is_row_axis ? child.StyleRef().LogicalWidth()
                                          : child.StyleRef().LogicalHeight();
@@ skipping 42 matching lines @@
   return algorithm_.FindFrUnitSize(tracks_span, left_over_space);
 }
 
 void GridTrackSizingAlgorithmStrategy::DistributeSpaceToTracks(
     Vector<GridTrack*>& tracks,
     LayoutUnit& available_logical_space) const {
   algorithm_.DistributeSpaceToTracks<kMaximizeTracks>(tracks, nullptr,
                                                       available_logical_space);
 }
 
-void GridTrackSizingAlgorithmStrategy::SetGridItemNeedsLayout(
-    LayoutBox& grid_item) const {
-  // Mac code can call computIntrinsicLogicalWidths() after the layout in
-  // content::RenderViewImpl::didUpdateLayout().
-  if (!GetLayoutGrid()->GetDocument().View()->IsInPerformLayout())
-    return;
-
-  grid_item.SetNeedsLayout(LayoutInvalidationReason::kGridChanged,
-                           kMarkOnlyThis);
-}
-
 LayoutUnit DefiniteSizeStrategy::MinLogicalWidthForChild(
     LayoutBox& child,
     Length child_min_size,
     GridTrackSizingDirection child_inline_direction) const {
   LayoutUnit margin_logical_width = ComputeMarginLogicalSizeForChild(
       kInlineDirection, GetLayoutGrid(), child);
   return child.ComputeLogicalWidthUsing(
              kMinSize, child_min_size,
              OverrideContainingBlockContentSizeForChild(child,
                                                         child_inline_direction),
              GetLayoutGrid()) +
          margin_logical_width;
 }
 
 void DefiniteSizeStrategy::LayoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool override_size_has_changed) const {
   if (override_size_has_changed)
-    SetGridItemNeedsLayout(child);
+    child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   child.LayoutIfNeeded();
 }
 
 void DefiniteSizeStrategy::MaximizeTracks(Vector<GridTrack>& tracks,
                                           Optional<LayoutUnit>& free_space) {
   size_t tracks_size = tracks.size();
   Vector<GridTrack*> tracks_for_distribution(tracks_size);
   for (size_t i = 0; i < tracks_size; ++i) {
     tracks_for_distribution[i] = tracks.data() + i;
     tracks_for_distribution[i]->SetPlannedSize(
@@ skipping 30 matching lines @@
              OverrideContainingBlockContentSizeForChild(child,
                                                         child_inline_direction),
              GetLayoutGrid()) +
          margin_logical_width;
 }
 
 void IndefiniteSizeStrategy::LayoutGridItemForMinSizeComputation(
     LayoutBox& child,
     bool override_size_has_changed) const {
   if (override_size_has_changed && Direction() != kForColumns)
-    SetGridItemNeedsLayout(child);
+    child.SetNeedsLayout(LayoutInvalidationReason::kGridChanged, kMarkOnlyThis);
   child.LayoutIfNeeded();
 }
 
 void IndefiniteSizeStrategy::MaximizeTracks(Vector<GridTrack>& tracks,
                                             Optional<LayoutUnit>&) {
   for (auto& track : tracks)
     track.SetBaseSize(track.GrowthLimit());
 }
 
 static inline double NormalizedFlexFraction(const GridTrack& track,
@@ skipping 983 matching lines @@
   DCHECK(algorithm_.IsValidTransition());
   DCHECK(!algorithm_.needs_setup_);
 }
 
 GridTrackSizingAlgorithm::StateMachine::~StateMachine() {
   algorithm_.AdvanceNextState();
   algorithm_.needs_setup_ = true;
 }
 
 }  // namespace blink