[GridNG] Refactor NGGridLayoutAlgorithm

Refactors NGGridLayoutAlgorithm to reduce member variable usage.
This change should not have any functional changes.
The helpers used in NGGridLayoutAlgorithm::Layout need to be used
to help compute the min/max sizes, to do this they must be static
or const. This refactor has an emphasis on moving data from the
class to the stack whenever possible.
This change also removes the state machine, as the added complexity
was determined to not be needed.

Bug: 1045599
Change-Id: I6af79bc2e3093ccfd33d8c6cb5cc6d46c2ed3698
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2542766
Commit-Queue: Jacques Newman <janewman@microsoft.com>
Reviewed-by: Kurt Catti-Schmidt <kschmi@microsoft.com>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Reviewed-by: Christian Biesinger <cbiesinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#832589}

third_party/blink/renderer/core/layout/ng/grid/ng_grid_layout_algorithm.cc

@@ -16,8 +16,7 @@ namespace blink {
 
 NGGridLayoutAlgorithm::NGGridLayoutAlgorithm(
     const NGLayoutAlgorithmParams& params)
-    : NGLayoutAlgorithm(params),
-      state_(GridLayoutAlgorithmState::kMeasuringItems) {
+    : NGLayoutAlgorithm(params) {
   DCHECK(params.space.IsNewFormattingContext());
   DCHECK(!params.break_token);
 
@@ -27,75 +26,44 @@ NGGridLayoutAlgorithm::NGGridLayoutAlgorithm(
 }
 
 scoped_refptr<const NGLayoutResult> NGGridLayoutAlgorithm::Layout() {
-  // Proceed by algorithm state, as some scenarios will involve a non-linear
-  // path through these steps (e.g. skipping or redoing some of them).
-  while (state_ != GridLayoutAlgorithmState::kCompletedLayout) {
-    switch (state_) {
-      case GridLayoutAlgorithmState::kMeasuringItems: {
-        SetSpecifiedTracks();
-        DetermineExplicitTrackStarts();
-        ConstructAndAppendGridItems();
-
-        // TODO(janewman): Split placement into its own GridLayoutAlgorithmState
-        NGGridPlacement(
-            automatic_row_repetitions_, automatic_column_repetitions_,
-            explicit_row_start_, explicit_column_start_,
-            Style().IsGridAutoFlowAlgorithmSparse()
-                ? NGGridPlacement::PackingBehavior::kSparse
-                : NGGridPlacement::PackingBehavior::kDense,
-            AutoFlowDirection(), Style(),
-            AutoFlowDirection() == kForRows ? column_count_ : row_count_,
-            block_row_track_collection_, block_column_track_collection_,
-            grid_items_)
-            .RunAutoPlacementAlgorithm();
-
-        block_column_track_collection_.FinalizeRanges();
-        block_row_track_collection_.FinalizeRanges();
-
-        DCHECK_NE(child_percentage_size_.inline_size, kIndefiniteSize);
-        algorithm_column_track_collection_ =
-            NGGridLayoutAlgorithmTrackCollection(
-                block_column_track_collection_,
-                /* is_content_box_size_indefinite */ false);
-
-        bool is_content_box_block_size_indefinite =
-            child_percentage_size_.block_size == kIndefiniteSize;
-        algorithm_row_track_collection_ = NGGridLayoutAlgorithmTrackCollection(
-            block_row_track_collection_, is_content_box_block_size_indefinite);
-
-        CacheItemSetIndices();
-        state_ = GridLayoutAlgorithmState::kResolvingInlineSize;
-        break;
-      }
-
-      case GridLayoutAlgorithmState::kResolvingInlineSize:
-        ComputeUsedTrackSizes(GridTrackSizingDirection::kForColumns);
-        state_ = GridLayoutAlgorithmState::kResolvingBlockSize;
-        break;
-
-      case GridLayoutAlgorithmState::kResolvingBlockSize:
-        ComputeUsedTrackSizes(GridTrackSizingDirection::kForRows);
-        state_ = GridLayoutAlgorithmState::kPlacingGridItems;
-        break;
-
-      case GridLayoutAlgorithmState::kPlacingGridItems:
-        PlaceGridItems();
-        state_ = GridLayoutAlgorithmState::kCompletedLayout;
-        break;
-
-      case GridLayoutAlgorithmState::kCompletedLayout:
-        NOTREACHED();
-        break;
-    }
-  }
-
-  intrinsic_block_size_ =
+  // Measure Items
+  Vector<GridItemData> grid_items;
+  Vector<GridItemData> out_of_flow_items;
+  ConstructAndAppendGridItems(&grid_items, &out_of_flow_items);
+
+  NGGridLayoutAlgorithmTrackCollection algorithm_column_track_collection;
+  NGGridLayoutAlgorithmTrackCollection algorithm_row_track_collection;
+  BuildAlgorithmTrackCollections(&grid_items,
+                                 &algorithm_column_track_collection,
+                                 &algorithm_row_track_collection);
+
+  // Cache set indices.
+  CacheItemSetIndices(GridTrackSizingDirection::kForColumns,
+                      &algorithm_column_track_collection, &grid_items);
+  CacheItemSetIndices(GridTrackSizingDirection::kForRows,
+                      &algorithm_row_track_collection, &grid_items);
+
+  // Resolve inline size.
+  ComputeUsedTrackSizes(GridTrackSizingDirection::kForColumns, &grid_items,
+                        &algorithm_column_track_collection);
+
+  // Resolve block size.
+  ComputeUsedTrackSizes(GridTrackSizingDirection::kForRows, &grid_items,
+                        &algorithm_row_track_collection);
+
+  // Place items.
+  LayoutUnit intrinsic_block_size;
+  PlaceGridItems(grid_items, out_of_flow_items,
+                 algorithm_column_track_collection,
+                 algorithm_row_track_collection, &intrinsic_block_size);
+
+  intrinsic_block_size =
       ClampIntrinsicBlockSize(ConstraintSpace(), Node(),
-                              BorderScrollbarPadding(), intrinsic_block_size_);
-  container_builder_.SetIntrinsicBlockSize(intrinsic_block_size_);
+                              BorderScrollbarPadding(), intrinsic_block_size);
+  container_builder_.SetIntrinsicBlockSize(intrinsic_block_size);
 
   LayoutUnit block_size = ComputeBlockSizeForFragment(
-      ConstraintSpace(), Style(), BorderPadding(), intrinsic_block_size_,
+      ConstraintSpace(), Style(), BorderPadding(), intrinsic_block_size,
       border_box_size_.inline_size);
   container_builder_.SetFragmentsTotalBlockSize(block_size);
 
@@ -108,16 +76,6 @@ MinMaxSizesResult NGGridLayoutAlgorithm::ComputeMinMaxSizes(
   return {MinMaxSizes(), /* depends_on_percentage_block_size */ true};
 }
 
-const NGGridLayoutAlgorithmTrackCollection&
-NGGridLayoutAlgorithm::ColumnTrackCollection() const {
-  return algorithm_column_track_collection_;
-}
-
-const NGGridLayoutAlgorithmTrackCollection&
-NGGridLayoutAlgorithm::RowTrackCollection() const {
-  return algorithm_row_track_collection_;
-}
-
 NGGridLayoutAlgorithm::GridItemData::GridItemData(const NGBlockNode node)
     : node(node) {}
 
@@ -230,22 +188,11 @@ NGGridLayoutAlgorithm::ReorderedGridItems::end() {
   return Iterator(reordered_item_indices_.end(), &grid_items_);
 }
 
-NGGridLayoutAlgorithm::ReorderedGridItems
-NGGridLayoutAlgorithm::GetReorderedGridItems() {
-  return ReorderedGridItems(reordered_item_indices_, grid_items_);
-}
-
-NGGridLayoutAlgorithmTrackCollection& NGGridLayoutAlgorithm::TrackCollection(
-    GridTrackSizingDirection track_direction) {
-  return (track_direction == kForColumns) ? algorithm_column_track_collection_
-                                          : algorithm_row_track_collection_;
-}
-
 NGGridLayoutAlgorithmTrackCollection::SetIterator
 NGGridLayoutAlgorithm::GetSetIteratorForItem(
     const GridItemData& item,
-    GridTrackSizingDirection track_direction) {
-  auto& track_collection = TrackCollection(track_direction);
+    GridTrackSizingDirection track_direction,
+    NGGridLayoutAlgorithmTrackCollection& track_collection) {
   return track_collection.GetSetIterator(
       (track_direction == kForColumns) ? item.columns_begin_set_index
                                        : item.rows_begin_set_index,
@@ -278,7 +225,11 @@ LayoutUnit NGGridLayoutAlgorithm::ContributionSizeForGridItem(
                           : LayoutUnit();
 }
 
-void NGGridLayoutAlgorithm::ConstructAndAppendGridItems() {
+void NGGridLayoutAlgorithm::ConstructAndAppendGridItems(
+    Vector<GridItemData>* grid_items,
+    Vector<GridItemData>* out_of_flow_items) const {
+  DCHECK(grid_items);
+  DCHECK(out_of_flow_items);
   NGGridChildIterator iterator(Node());
   for (NGBlockNode child = iterator.NextChild(); child;
        child = iterator.NextChild()) {
@@ -286,15 +237,10 @@ void NGGridLayoutAlgorithm::ConstructAndAppendGridItems() {
     // Store out-of-flow items separately, as they do not contribute to track
     // sizing or auto placement.
     if (child.IsOutOfFlowPositioned())
-      out_of_flow_items_.emplace_back(grid_item);
+      out_of_flow_items->emplace_back(grid_item);
     else
-      grid_items_.emplace_back(grid_item);
+      grid_items->emplace_back(grid_item);
   }
-
-  // Fill grid item indices vector in document order.
-  reordered_item_indices_.ReserveInitialCapacity(grid_items_.size());
-  for (wtf_size_t i = 0; i < grid_items_.size(); ++i)
-    reordered_item_indices_.push_back(i);
 }
 
 namespace {
@@ -393,7 +339,7 @@ AxisEdge AxisEdgeFromItemPosition(const ComputedStyle& container_style,
 }  // namespace
 
 NGGridLayoutAlgorithm::GridItemData NGGridLayoutAlgorithm::MeasureGridItem(
-    const NGBlockNode node) {
+    const NGBlockNode node) const {
   const auto& container_style = Style();
 
   // Before we take track sizing into account for column width contributions,
@@ -463,116 +409,193 @@ NGConstraintSpace NGGridLayoutAlgorithm::BuildSpaceForGridItem(
   return builder.ToConstraintSpace();
 }
 
-void NGGridLayoutAlgorithm::SetSpecifiedTracks() {
+void NGGridLayoutAlgorithm::BuildBlockTrackCollections(
+    Vector<GridItemData>* grid_items,
+    NGGridBlockTrackCollection* column_track_collection,
+    NGGridBlockTrackCollection* row_track_collection) const {
+  DCHECK(grid_items);
+  DCHECK(column_track_collection);
+  DCHECK(row_track_collection);
+  // TODO(kschmi): Auto track repeat count should be based on the number
+  // of children, rather than specified auto-column/track. Temporarily
+  // assign them to zero here to avoid DCHECK's until we implement this
+  // logic.
+  wtf_size_t automatic_column_repetitions = 0;
+  wtf_size_t automatic_row_repetitions = 0;
+
+  SetSpecifiedTracks(GridTrackSizingDirection::kForColumns,
+                     automatic_column_repetitions, column_track_collection);
+  SetSpecifiedTracks(GridTrackSizingDirection::kForRows,
+                     automatic_row_repetitions, row_track_collection);
+
+  wtf_size_t explicit_column_start;
+  wtf_size_t explicit_row_start;
+  wtf_size_t column_count;
+  wtf_size_t row_count;
+  DetermineExplicitTrackStarts(
+      automatic_column_repetitions, automatic_row_repetitions,
+      &explicit_column_start, &explicit_row_start, &column_count, &row_count);
+
+  NGGridPlacement(automatic_row_repetitions, automatic_column_repetitions,
+                  explicit_row_start, explicit_column_start,
+                  Style().IsGridAutoFlowAlgorithmSparse()
+                      ? NGGridPlacement::PackingBehavior::kSparse
+                      : NGGridPlacement::PackingBehavior::kDense,
+                  AutoFlowDirection(), Style(),
+                  AutoFlowDirection() == kForRows ? column_count : row_count,
+                  row_track_collection, column_track_collection, grid_items)
+      .RunAutoPlacementAlgorithm();
+
+  column_track_collection->FinalizeRanges();
+  row_track_collection->FinalizeRanges();
+}
+
+void NGGridLayoutAlgorithm::BuildAlgorithmTrackCollections(
+    Vector<GridItemData>* grid_items,
+    NGGridLayoutAlgorithmTrackCollection* column_track_collection,
+    NGGridLayoutAlgorithmTrackCollection* row_track_collection) const {
+  DCHECK(grid_items);
+  DCHECK(column_track_collection);
+  DCHECK(row_track_collection);
+  DCHECK_NE(child_percentage_size_.inline_size, kIndefiniteSize);
+  // Build track collections.
+  NGGridBlockTrackCollection column_block_track_collection;
+  NGGridBlockTrackCollection row_block_track_collection;
+  BuildBlockTrackCollections(grid_items, &column_block_track_collection,
+                             &row_block_track_collection);
+
+  // Build Algorithm track collections from the Block track collections.
+  *column_track_collection = NGGridLayoutAlgorithmTrackCollection(
+      column_block_track_collection,
+      /* is_content_box_size_indefinite */ false);
+
+  bool is_content_box_block_size_indefinite =
+      child_percentage_size_.block_size == kIndefiniteSize;
+  *row_track_collection = NGGridLayoutAlgorithmTrackCollection(
+      row_block_track_collection, is_content_box_block_size_indefinite);
+}
+
+void NGGridLayoutAlgorithm::SetSpecifiedTracks(
+    GridTrackSizingDirection track_direction,
+    wtf_size_t automatic_repetitions,
+    NGGridBlockTrackCollection* track_collection) const {
   const ComputedStyle& grid_style = Style();
-  // TODO(kschmi): Auto track repeat count should be based on the number of
-  // children, rather than specified auto-column/track. Temporarily assign them
-  // to zero here to avoid DCHECK's until we implement this logic.
-  automatic_column_repetitions_ = 0;
-  automatic_row_repetitions_ = 0;
-
-  // TODO(janewman): We need to implement calculation for track auto repeat
-  // count so this can be used outside of testing.
-  block_column_track_collection_.SetSpecifiedTracks(
-      &grid_style.GridTemplateColumns().NGTrackList(),
-      &grid_style.GridAutoColumns().NGTrackList(),
-      automatic_column_repetitions_);
-
-  block_row_track_collection_.SetSpecifiedTracks(
-      &grid_style.GridTemplateRows().NGTrackList(),
-      &grid_style.GridAutoRows().NGTrackList(), automatic_row_repetitions_);
+  const NGGridTrackList& template_track_list =
+      track_direction == GridTrackSizingDirection::kForColumns
+          ? grid_style.GridTemplateColumns().NGTrackList()
+          : grid_style.GridTemplateRows().NGTrackList();
+  const NGGridTrackList& auto_track_list =
+      track_direction == GridTrackSizingDirection::kForColumns
+          ? grid_style.GridAutoColumns().NGTrackList()
+          : grid_style.GridAutoRows().NGTrackList();
+  track_collection->SetSpecifiedTracks(&template_track_list, &auto_track_list,
+                                       automatic_repetitions);
 }
 
-void NGGridLayoutAlgorithm::DetermineExplicitTrackStarts() {
-  DCHECK_EQ(0u, explicit_column_start_);
-  DCHECK_EQ(0u, explicit_row_start_);
-  DCHECK_EQ(0u, column_count_);
-  DCHECK_EQ(0u, row_count_);
+void NGGridLayoutAlgorithm::DetermineExplicitTrackStarts(
+    wtf_size_t automatic_column_repetitions,
+    wtf_size_t automatic_row_repetitions,
+    wtf_size_t* explicit_column_start,
+    wtf_size_t* explicit_row_start,
+    wtf_size_t* column_count,
+    wtf_size_t* row_count) const {
+  DCHECK(explicit_column_start);
+  DCHECK(explicit_row_start);
+  DCHECK(column_count);
+  DCHECK(row_count);
+  *explicit_column_start = 0u;
+  *explicit_row_start = 0u;
+  *column_count = 0u;
+  *row_count = 0u;
 
   NGGridChildIterator iterator(Node());
   for (NGBlockNode child = iterator.NextChild(); child;
        child = iterator.NextChild()) {
     GridSpan column_span = GridPositionsResolver::ResolveGridPositionsFromStyle(
-        Style(), child.Style(), kForColumns,
-        AutoRepeatCountForDirection(kForColumns));
+        Style(), child.Style(), kForColumns, automatic_column_repetitions);
     GridSpan row_span = GridPositionsResolver::ResolveGridPositionsFromStyle(
-        Style(), child.Style(), kForRows,
-        AutoRepeatCountForDirection(kForRows));
+        Style(), child.Style(), kForRows, automatic_row_repetitions);
     if (!column_span.IsIndefinite()) {
-      explicit_column_start_ = std::max<int>(
-          explicit_column_start_, -column_span.UntranslatedStartLine());
-      column_count_ =
-          std::max<int>(column_count_, column_span.UntranslatedEndLine());
+      *explicit_column_start = std::max<int>(
+          *explicit_column_start, -column_span.UntranslatedStartLine());
+      *column_count =
+          std::max<int>(*column_count, column_span.UntranslatedEndLine());
     } else {
-      column_count_ = std::max<int>(
-          column_count_, GridPositionsResolver::SpanSizeForAutoPlacedItem(
+      *column_count = std::max<int>(
+          *column_count, GridPositionsResolver::SpanSizeForAutoPlacedItem(
                              child.Style(), kForColumns));
     }
     if (!row_span.IsIndefinite()) {
-      explicit_row_start_ =
-          std::max<int>(explicit_row_start_, -row_span.UntranslatedStartLine());
-      row_count_ = std::max<int>(row_count_, row_span.UntranslatedEndLine());
+      *explicit_row_start =
+          std::max<int>(*explicit_row_start, -row_span.UntranslatedStartLine());
+      *row_count = std::max<int>(*row_count, row_span.UntranslatedEndLine());
     } else {
-      row_count_ = std::max<int>(
-          row_count_, GridPositionsResolver::SpanSizeForAutoPlacedItem(
+      *row_count = std::max<int>(
+          *row_count, GridPositionsResolver::SpanSizeForAutoPlacedItem(
                           child.Style(), kForRows));
     }
   }
 }
 
-void NGGridLayoutAlgorithm::CacheItemSetIndices() {
-  auto CacheItemSetIndices = [this](GridTrackSizingDirection track_direction) {
-    const auto& track_collection = TrackCollection(track_direction);
-    for (GridItemData& item : grid_items_) {
-      wtf_size_t first_spanned_range =
-          track_collection.RangeIndexFromTrackNumber(
-              item.StartLine(track_direction));
-      wtf_size_t last_spanned_range =
-          track_collection.RangeIndexFromTrackNumber(
-              item.EndLine(track_direction) - 1);
-
-      DCHECK_LE(first_spanned_range, last_spanned_range);
-      wtf_size_t begin_set_index =
-          track_collection.RangeStartingSetIndex(first_spanned_range);
-      wtf_size_t end_set_index =
-          track_collection.RangeStartingSetIndex(last_spanned_range) +
-          track_collection.RangeSetCount(last_spanned_range);
-
-      DCHECK_LE(begin_set_index, end_set_index);
-      DCHECK_LE(end_set_index, track_collection.SetCount());
-
-      if (track_direction == kForColumns) {
-        item.columns_begin_set_index = begin_set_index;
-        item.columns_end_set_index = end_set_index;
-      } else {
-        item.rows_begin_set_index = begin_set_index;
-        item.rows_end_set_index = end_set_index;
-      }
+void NGGridLayoutAlgorithm::CacheItemSetIndices(
+    GridTrackSizingDirection track_direction,
+    const NGGridLayoutAlgorithmTrackCollection* track_collection,
+    Vector<GridItemData>* grid_items) const {
+  DCHECK(track_collection);
+  DCHECK(grid_items);
+  for (GridItemData& item : *grid_items) {
+    wtf_size_t first_spanned_range =
+        track_collection->RangeIndexFromTrackNumber(
+            item.StartLine(track_direction));
+    wtf_size_t last_spanned_range = track_collection->RangeIndexFromTrackNumber(
+        item.EndLine(track_direction) - 1);
+
+    DCHECK_LE(first_spanned_range, last_spanned_range);
+    wtf_size_t begin_set_index =
+        track_collection->RangeStartingSetIndex(first_spanned_range);
+    wtf_size_t end_set_index =
+        track_collection->RangeStartingSetIndex(last_spanned_range) +
+        track_collection->RangeSetCount(last_spanned_range);
+
+    DCHECK_LE(begin_set_index, end_set_index);
+    DCHECK_LE(end_set_index, track_collection->SetCount());
+
+    if (track_direction == kForColumns) {
+      item.columns_begin_set_index = begin_set_index;
+      item.columns_end_set_index = end_set_index;
+    } else {
+      item.rows_begin_set_index = begin_set_index;
+      item.rows_end_set_index = end_set_index;
     }
-  };
-  CacheItemSetIndices(kForColumns);
-  CacheItemSetIndices(kForRows);
+  }
 }
 
 void NGGridLayoutAlgorithm::DetermineGridItemsSpanningIntrinsicOrFlexTracks(
-    GridTrackSizingDirection track_direction) {
-  auto CompareGridItemsByStartLine =
-      [this, track_direction](wtf_size_t index_a, wtf_size_t index_b) -> bool {
-    return grid_items_[index_a].StartLine(track_direction) <
-           grid_items_[index_b].StartLine(track_direction);
+    GridTrackSizingDirection track_direction,
+    Vector<GridItemData>* grid_items,
+    Vector<wtf_size_t>* reordered_item_indices,
+    NGGridLayoutAlgorithmTrackCollection* track_collection) const {
+  DCHECK(grid_items);
+  DCHECK(track_collection);
+  DCHECK(reordered_item_indices);
+  auto CompareGridItemsByStartLine = [grid_items, track_direction](
+                                         wtf_size_t index_a,
+                                         wtf_size_t index_b) -> bool {
+    return grid_items->at(index_a).StartLine(track_direction) <
+           grid_items->at(index_b).StartLine(track_direction);
   };
-  std::sort(reordered_item_indices_.begin(), reordered_item_indices_.end(),
+  std::sort(reordered_item_indices->begin(), reordered_item_indices->end(),
             CompareGridItemsByStartLine);
 
   // At this point we have the grid items sorted by their start line in the
   // respective direction; this is important since we'll process both, the
   // ranges in the track collection and the grid items, incrementally.
-  const auto& track_collection = TrackCollection(track_direction);
-  auto range_spanning_flex_track_iterator = track_collection.RangeIterator();
+  auto range_spanning_flex_track_iterator = track_collection->RangeIterator();
   auto range_spanning_intrinsic_track_iterator =
-      track_collection.RangeIterator();
+      track_collection->RangeIterator();
 
-  for (GridItemData& grid_item : GetReorderedGridItems()) {
+  for (GridItemData& grid_item :
+       ReorderedGridItems(*reordered_item_indices, *grid_items)) {
     // We want to find the first range in the collection that:
     //   - Spans tracks located AFTER the start line of the current grid item;
     //   this can be done by checking that the last track number of the current
@@ -584,14 +607,14 @@ void NGGridLayoutAlgorithm::DetermineGridItemsSpanningIntrinsicOrFlexTracks(
     while (!range_spanning_intrinsic_track_iterator.IsAtEnd() &&
            (range_spanning_intrinsic_track_iterator.RangeTrackEnd() <
                 grid_item.StartLine(track_direction) ||
-            !track_collection.IsRangeSpanningIntrinsicTrack(
+            !track_collection->IsRangeSpanningIntrinsicTrack(
                 range_spanning_intrinsic_track_iterator.RangeIndex()))) {
       range_spanning_intrinsic_track_iterator.MoveToNextRange();
     }
     while (!range_spanning_flex_track_iterator.IsAtEnd() &&
            (range_spanning_flex_track_iterator.RangeTrackEnd() <
                 grid_item.StartLine(track_direction) ||
-            !track_collection.IsRangeSpanningFlexTrack(
+            !track_collection->IsRangeSpanningFlexTrack(
                 range_spanning_flex_track_iterator.RangeIndex()))) {
       range_spanning_flex_track_iterator.MoveToNextRange();
     }
@@ -617,14 +640,17 @@ void NGGridLayoutAlgorithm::DetermineGridItemsSpanningIntrinsicOrFlexTracks(
 
 // https://drafts.csswg.org/css-grid-1/#algo-track-sizing
 void NGGridLayoutAlgorithm::ComputeUsedTrackSizes(
-    GridTrackSizingDirection track_direction) {
-  auto& track_collection = TrackCollection(track_direction);
+    GridTrackSizingDirection track_direction,
+    Vector<GridItemData>* grid_items,
+    NGGridLayoutAlgorithmTrackCollection* track_collection) const {
+  DCHECK(grid_items);
+  DCHECK(track_collection);
   LayoutUnit content_box_size = (track_direction == kForColumns)
                                     ? child_percentage_size_.inline_size
                                     : child_percentage_size_.block_size;
 
   // 1. Initialize track sizes (https://drafts.csswg.org/css-grid-1/#algo-init).
-  for (auto set_iterator = track_collection.GetSetIterator();
+  for (auto set_iterator = track_collection->GetSetIterator();
        !set_iterator.IsAtEnd(); set_iterator.MoveToNextSet()) {
     NGGridSet& current_set = set_iterator.CurrentSet();
     const GridTrackSize& track_size = current_set.TrackSize();
@@ -663,8 +689,15 @@ void NGGridLayoutAlgorithm::ComputeUsedTrackSizes(
   }
 
   // 2. Resolve intrinsic track sizing functions to absolute lengths.
-  DetermineGridItemsSpanningIntrinsicOrFlexTracks(track_direction);
-  ResolveIntrinsicTrackSizes(track_direction);
+  // Fill grid item indices vector in document order.
+  Vector<wtf_size_t> reordered_item_indices;
+  reordered_item_indices.ReserveInitialCapacity(grid_items->size());
+  for (wtf_size_t i = 0; i < grid_items->size(); ++i)
+    reordered_item_indices.push_back(i);
+  DetermineGridItemsSpanningIntrinsicOrFlexTracks(
+      track_direction, grid_items, &reordered_item_indices, track_collection);
+  ResolveIntrinsicTrackSizes(track_direction, grid_items,
+                             &reordered_item_indices, track_collection);
 }
 
 // Helpers for the track sizing algorithm.
@@ -972,9 +1005,10 @@ void NGGridLayoutAlgorithm::IncreaseTrackSizesToAccommodateGridItems(
     GridTrackSizingDirection track_direction,
     ReorderedGridItems::Iterator group_begin,
     ReorderedGridItems::Iterator group_end,
-    GridItemContributionType contribution_type) {
-  auto& track_collection = TrackCollection(track_direction);
-  for (auto set_iterator = track_collection.GetSetIterator();
+    GridItemContributionType contribution_type,
+    NGGridLayoutAlgorithmTrackCollection* track_collection) const {
+  DCHECK(track_collection);
+  for (auto set_iterator = track_collection->GetSetIterator();
        !set_iterator.IsAtEnd(); set_iterator.MoveToNextSet()) {
     set_iterator.CurrentSet().SetPlannedIncrease(LayoutUnit());
   }
@@ -999,7 +1033,8 @@ void NGGridLayoutAlgorithm::IncreaseTrackSizesToAccommodateGridItems(
     // know our block size.
     LayoutUnit spanned_tracks_size =
         GridGap(track_direction) * (grid_item->SpanSize(track_direction) - 1);
-    for (auto set_iterator = GetSetIteratorForItem(*grid_item, track_direction);
+    for (auto set_iterator = GetSetIteratorForItem(*grid_item, track_direction,
+                                                   *track_collection);
          !set_iterator.IsAtEnd(); set_iterator.MoveToNextSet()) {
       NGGridSet& current_set = set_iterator.CurrentSet();
 
@@ -1029,7 +1064,7 @@ void NGGridLayoutAlgorithm::IncreaseTrackSizesToAccommodateGridItems(
                                             : &sets_to_grow_beyond_limit);
   }
 
-  for (auto set_iterator = track_collection.GetSetIterator();
+  for (auto set_iterator = track_collection->GetSetIterator();
        !set_iterator.IsAtEnd(); set_iterator.MoveToNextSet()) {
     GrowAffectedSizeByPlannedIncrease(set_iterator.CurrentSet(),
                                       contribution_type);
@@ -1038,7 +1073,13 @@ void NGGridLayoutAlgorithm::IncreaseTrackSizesToAccommodateGridItems(
 
 // https://drafts.csswg.org/css-grid-1/#algo-content
 void NGGridLayoutAlgorithm::ResolveIntrinsicTrackSizes(
-    GridTrackSizingDirection track_direction) {
+    GridTrackSizingDirection track_direction,
+    Vector<GridItemData>* grid_items,
+    Vector<wtf_size_t>* reordered_item_indices,
+    NGGridLayoutAlgorithmTrackCollection* track_collection) const {
+  DCHECK(grid_items);
+  DCHECK(reordered_item_indices);
+  DCHECK(track_collection);
   // Reorder grid items to process them as follows:
   //   - First, consider items spanning a single non-flexible track.
   //   - Next, consider items with span size of 2 not spanning a flexible track.
@@ -1046,24 +1087,26 @@ void NGGridLayoutAlgorithm::ResolveIntrinsicTrackSizes(
   //   not spanning a flexible track have been considered.
   //   - Finally, consider all items spanning a flexible track.
   auto CompareGridItemsForIntrinsicTrackResolution =
-      [this, track_direction](wtf_size_t index_a, wtf_size_t index_b) -> bool {
-    if (grid_items_[index_a].is_spanning_flex_track ||
-        grid_items_[index_b].is_spanning_flex_track) {
+      [grid_items, track_direction](wtf_size_t index_a,
+                                    wtf_size_t index_b) -> bool {
+    if (grid_items->at(index_a).is_spanning_flex_track ||
+        grid_items->at(index_b).is_spanning_flex_track) {
       // Ignore span sizes if one of the items spans a track with a flexible
       // sizing function; items not spanning such tracks should come first.
-      return !grid_items_[index_a].is_spanning_flex_track;
+      return !grid_items->at(index_a).is_spanning_flex_track;
     }
-    return grid_items_[index_a].SpanSize(track_direction) <
-           grid_items_[index_b].SpanSize(track_direction);
+    return grid_items->at(index_a).SpanSize(track_direction) <
+           grid_items->at(index_b).SpanSize(track_direction);
   };
-  std::sort(reordered_item_indices_.begin(), reordered_item_indices_.end(),
+  std::sort(reordered_item_indices->begin(), reordered_item_indices->end(),
             CompareGridItemsForIntrinsicTrackResolution);
 
   // First, process the items that don't span a flexible track.
-  ReorderedGridItems grid_items = GetReorderedGridItems();
-  ReorderedGridItems::Iterator current_group_begin = grid_items.begin();
+  ReorderedGridItems reordered_items =
+      ReorderedGridItems(*reordered_item_indices, *grid_items);
+  ReorderedGridItems::Iterator current_group_begin = reordered_items.begin();
 
-  while (current_group_begin != grid_items.end() &&
+  while (current_group_begin != reordered_items.end() &&
          !current_group_begin->is_spanning_flex_track) {
     // Each iteration considers all items with the same span size.
     wtf_size_t current_group_span_size =
@@ -1072,14 +1115,14 @@ void NGGridLayoutAlgorithm::ResolveIntrinsicTrackSizes(
     do {
       DCHECK(!current_group_end->is_spanning_flex_track);
       ++current_group_end;
-    } while (current_group_end != grid_items.end() &&
+    } while (current_group_end != reordered_items.end() &&
              !current_group_end->is_spanning_flex_track &&
              current_group_end->SpanSize(track_direction) ==
                  current_group_span_size);
 
     IncreaseTrackSizesToAccommodateGridItems(
         track_direction, current_group_begin, current_group_end,
-        GridItemContributionType::kForIntrinsicMinimums);
+        GridItemContributionType::kForIntrinsicMinimums, track_collection);
 
     // TODO(ethavar): Add remaining stages, mark infinitely growable sets...
     current_group_begin = current_group_end;
@@ -1090,34 +1133,28 @@ void NGGridLayoutAlgorithm::ResolveIntrinsicTrackSizes(
   // by span) all items that do span a track with a flexible sizing function.
 }
 
-void NGGridLayoutAlgorithm::SetAutomaticTrackRepetitionsForTesting(
-    wtf_size_t auto_column,
-    wtf_size_t auto_row) {
-  automatic_column_repetitions_ = auto_column;
-  automatic_row_repetitions_ = auto_row;
-}
-
-wtf_size_t NGGridLayoutAlgorithm::AutoRepeatCountForDirection(
-    GridTrackSizingDirection track_direction) const {
-  return (track_direction == kForColumns) ? automatic_column_repetitions_
-                                          : automatic_row_repetitions_;
-}
-
 GridTrackSizingDirection NGGridLayoutAlgorithm::AutoFlowDirection() const {
   return Style().IsGridAutoFlowDirectionRow() ? kForRows : kForColumns;
 }
 
-void NGGridLayoutAlgorithm::PlaceGridItems() {
+void NGGridLayoutAlgorithm::PlaceGridItems(
+    const Vector<GridItemData>& grid_items,
+    const Vector<GridItemData>& out_of_flow_items,
+    NGGridLayoutAlgorithmTrackCollection& column_track_collection,
+    NGGridLayoutAlgorithmTrackCollection& row_track_collection,
+    LayoutUnit* intrinsic_block_size) {
+  DCHECK(intrinsic_block_size);
   LayoutUnit column_grid_gap =
       GridGap(kForColumns, ChildAvailableSize().inline_size);
   LayoutUnit row_grid_gap = GridGap(kForRows, ChildAvailableSize().block_size);
   Vector<LayoutUnit> column_set_offsets =
-      ComputeSetOffsets(kForColumns, column_grid_gap);
+      ComputeSetOffsets(kForColumns, column_grid_gap, column_track_collection);
   Vector<LayoutUnit> row_set_offsets =
-      ComputeSetOffsets(kForRows, row_grid_gap);
+      ComputeSetOffsets(kForRows, row_grid_gap, row_track_collection);
 
-  // Store the total size of row definitions as the intrinsic block size.
-  intrinsic_block_size_ =
+  // Intrinsic block size is based on the final row offset.
+  // Because gaps are included in row offsets, subtract out the final gap.
+  *intrinsic_block_size =
       row_set_offsets.back() -
       (row_set_offsets.size() == 1 ? LayoutUnit() : row_grid_gap) +
       BorderScrollbarPadding().block_end;
@@ -1126,11 +1163,12 @@ void NGGridLayoutAlgorithm::PlaceGridItems() {
   // intrinsic size is known. However, the gap should not be added to the
   // intrinsic block size.
   if (IsRowGridGapUnresolvable(ChildAvailableSize().block_size)) {
-    row_grid_gap = GridGap(kForRows, intrinsic_block_size_);
-    row_set_offsets = ComputeSetOffsets(kForRows, row_grid_gap);
+    row_grid_gap = GridGap(kForRows, *intrinsic_block_size);
+    row_set_offsets =
+        ComputeSetOffsets(kForRows, row_grid_gap, row_track_collection);
   }
 
-  for (GridItemData& grid_item : grid_items_) {
+  for (const GridItemData& grid_item : grid_items) {
     wtf_size_t column_start_index = grid_item.columns_begin_set_index;
     wtf_size_t column_end_index = grid_item.columns_end_set_index;
     wtf_size_t row_start_index = grid_item.rows_begin_set_index;
@@ -1158,7 +1196,7 @@ void NGGridLayoutAlgorithm::PlaceGridItems() {
     PlaceGridItem(grid_item, offset, size);
   }
 
-  for (GridItemData& out_of_flow_item : out_of_flow_items_) {
+  for (const GridItemData& out_of_flow_item : out_of_flow_items) {
     // TODO(ansollan): Look up offsets based on specified row/column for
     // absolutely-positioned items, as described in
     // https://drafts.csswg.org/css-grid-1/#abspos, and pass the correct static
@@ -1229,7 +1267,7 @@ void NGGridLayoutAlgorithm::PlaceGridItem(const GridItemData& grid_item,
 
 LayoutUnit NGGridLayoutAlgorithm::GridGap(
     GridTrackSizingDirection track_direction,
-    LayoutUnit available_size) {
+    LayoutUnit available_size) const {
   const base::Optional<Length>& gap =
       track_direction == kForColumns ? Style().ColumnGap() : Style().RowGap();
 
@@ -1242,14 +1280,12 @@ LayoutUnit NGGridLayoutAlgorithm::GridGap(
 
 Vector<LayoutUnit> NGGridLayoutAlgorithm::ComputeSetOffsets(
     GridTrackSizingDirection track_direction,
-    LayoutUnit grid_gap) {
+    LayoutUnit grid_gap,
+    NGGridLayoutAlgorithmTrackCollection& track_collection) const {
   LayoutUnit set_offset = track_direction == kForColumns
                               ? BorderScrollbarPadding().inline_start
                               : BorderScrollbarPadding().block_start;
   Vector<LayoutUnit> set_offsets = {set_offset};
-  auto& track_collection = (track_direction == kForColumns)
-                               ? algorithm_column_track_collection_
-                               : algorithm_row_track_collection_;
   set_offsets.ReserveCapacity(track_collection.SetCount() + 1);
   for (auto set_iterator = track_collection.GetSetIterator();
        !set_iterator.IsAtEnd(); set_iterator.MoveToNextSet()) {
@@ -1261,7 +1297,7 @@ Vector<LayoutUnit> NGGridLayoutAlgorithm::ComputeSetOffsets(
 }
 
 bool NGGridLayoutAlgorithm::IsRowGridGapUnresolvable(
-    LayoutUnit available_size) {
+    LayoutUnit available_size) const {
   const base::Optional<Length>& row_gap = Style().RowGap();
   return row_gap && row_gap->IsPercentOrCalc() &&
          available_size == kIndefiniteSize;

third_party/blink/renderer/core/layout/ng/grid/ng_grid_layout_algorithm.h

@@ -76,9 +76,6 @@ class CORE_EXPORT NGGridLayoutAlgorithm
 
   MinMaxSizesResult ComputeMinMaxSizes(const MinMaxSizesInput&) const override;
 
-  const NGGridLayoutAlgorithmTrackCollection& ColumnTrackCollection() const;
-  const NGGridLayoutAlgorithmTrackCollection& RowTrackCollection() const;
-
  private:
   using NGGridSetVector = Vector<NGGridSet*, 16>;
 
@@ -120,15 +117,13 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     Vector<GridItemData>& grid_items_;
   };
 
-  ReorderedGridItems GetReorderedGridItems();
-  NGGridLayoutAlgorithmTrackCollection& TrackCollection(
-      GridTrackSizingDirection track_direction);
 
   // Returns an iterator for every |NGGridSet| contained within an item's span
   // in the relevant track collection.
-  NGGridLayoutAlgorithmTrackCollection::SetIterator GetSetIteratorForItem(
-      const GridItemData& item,
-      GridTrackSizingDirection track_direction);
+  static NGGridLayoutAlgorithmTrackCollection::SetIterator
+  GetSetIteratorForItem(const GridItemData& item,
+                        GridTrackSizingDirection track_direction,
+                        NGGridLayoutAlgorithmTrackCollection& track_collection);
 
   // Returns the size that a grid item will distribute across the tracks with an
   // intrinsic sizing function it spans in the relevant track direction.
@@ -137,48 +132,82 @@ class CORE_EXPORT NGGridLayoutAlgorithm
       GridTrackSizingDirection track_direction,
       GridItemContributionType contribution_type) const;
 
-  void ConstructAndAppendGridItems();
-  GridItemData MeasureGridItem(const NGBlockNode node);
+  void ConstructAndAppendGridItems(
+      Vector<GridItemData>* grid_items,
+      Vector<GridItemData>* out_of_flow_items) const;
+  GridItemData MeasureGridItem(const NGBlockNode node) const;
   NGConstraintSpace BuildSpaceForGridItem(const NGBlockNode node) const;
 
-  // Sets the specified tracks for row and column track lists.
-  void SetSpecifiedTracks();
+  void BuildBlockTrackCollections(
+      Vector<GridItemData>* grid_items,
+      NGGridBlockTrackCollection* column_track_collection,
+      NGGridBlockTrackCollection* row_track_collection) const;
+
+  void BuildAlgorithmTrackCollections(
+      Vector<GridItemData>* grid_items,
+      NGGridLayoutAlgorithmTrackCollection* column_track_collection,
+      NGGridLayoutAlgorithmTrackCollection* row_track_collection) const;
+
+  // Sets specified track lists on |track_collection|.
+  void SetSpecifiedTracks(GridTrackSizingDirection track_direction,
+                          wtf_size_t automatic_repetitions,
+                          NGGridBlockTrackCollection* track_collection) const;
   // Determines the explicit column and row track starts.
-  void DetermineExplicitTrackStarts();
+  void DetermineExplicitTrackStarts(wtf_size_t automatic_column_repetitions,
+                                    wtf_size_t automatic_row_repetitions,
+                                    wtf_size_t* explicit_column_start,
+                                    wtf_size_t* explicit_row_start,
+                                    wtf_size_t* column_count,
+                                    wtf_size_t* row_count) const;
 
   // For every item and track direction, computes and stores the pair of indices
   // "begin" and "end" such that the item spans every set from the respective
   // collection's |sets_| with an index in the range [begin, end).
-  void CacheItemSetIndices();
+  void CacheItemSetIndices(
+      GridTrackSizingDirection track_direction,
+      const NGGridLayoutAlgorithmTrackCollection* track_collection,
+      Vector<GridItemData>* grid_items) const;
   // For every grid item, determines if it spans a track with an intrinsic or
   // flexible sizing function and caches the answer in its |GridItemData|.
   void DetermineGridItemsSpanningIntrinsicOrFlexTracks(
-      GridTrackSizingDirection track_direction);
+      GridTrackSizingDirection track_direction,
+      Vector<GridItemData>* grid_items,
+      Vector<wtf_size_t>* reordered_item_indices,
+      NGGridLayoutAlgorithmTrackCollection* track_collection) const;
 
   // Calculates from the min and max track sizing functions the used track size.
-  void ComputeUsedTrackSizes(GridTrackSizingDirection track_direction);
+  void ComputeUsedTrackSizes(
+      GridTrackSizingDirection track_direction,
+      Vector<GridItemData>* grid_items,
+      NGGridLayoutAlgorithmTrackCollection* track_collection) const;
 
   // These methods implement the steps of the algorithm for intrinsic track size
   // resolution defined in https://drafts.csswg.org/css-grid-1/#algo-content.
-  void ResolveIntrinsicTrackSizes(GridTrackSizingDirection track_direction);
+  void ResolveIntrinsicTrackSizes(
+      GridTrackSizingDirection track_direction,
+      Vector<GridItemData>* grid_items,
+      Vector<wtf_size_t>* reordered_item_indices,
+      NGGridLayoutAlgorithmTrackCollection* track_collection) const;
   void IncreaseTrackSizesToAccommodateGridItems(
       GridTrackSizingDirection track_direction,
       ReorderedGridItems::Iterator group_begin,
       ReorderedGridItems::Iterator group_end,
-      GridItemContributionType contribution_type);
-  void DistributeExtraSpaceToSets(LayoutUnit extra_space,
-                                  GridItemContributionType contribution_type,
-                                  NGGridSetVector* sets_to_grow,
-                                  NGGridSetVector* sets_to_grow_beyond_limit);
-
-  // Allows a test to set the value for automatic track repetition.
-  void SetAutomaticTrackRepetitionsForTesting(wtf_size_t auto_column,
-                                              wtf_size_t auto_row);
-  wtf_size_t AutoRepeatCountForDirection(
-      GridTrackSizingDirection track_direction) const;
+      GridItemContributionType contribution_type,
+      NGGridLayoutAlgorithmTrackCollection* track_collection) const;
+
+  static void DistributeExtraSpaceToSets(
+      LayoutUnit extra_space,
+      GridItemContributionType contribution_type,
+      NGGridSetVector* sets_to_grow,
+      NGGridSetVector* sets_to_grow_beyond_limit);
 
   // Lays out and computes inline and block offsets for grid items.
-  void PlaceGridItems();
+  void PlaceGridItems(
+      const Vector<GridItemData>& grid_items,
+      const Vector<GridItemData>& out_of_flow_items,
+      NGGridLayoutAlgorithmTrackCollection& column_track_collection,
+      NGGridLayoutAlgorithmTrackCollection& row_track_collection,
+      LayoutUnit* intrinsic_block_size);
 
   // Lays out |grid_item| based on the offsets and sizes provided.
   void PlaceGridItem(const GridItemData& grid_item,
@@ -187,42 +216,22 @@ class CORE_EXPORT NGGridLayoutAlgorithm
 
   // Gets the row or column gap of the grid.
   LayoutUnit GridGap(GridTrackSizingDirection track_direction,
-                     LayoutUnit available_size = kIndefiniteSize);
+                     LayoutUnit available_size = kIndefiniteSize) const;
 
   // Calculates inline and block offsets for all tracks.
-  Vector<LayoutUnit> ComputeSetOffsets(GridTrackSizingDirection track_direction,
-                                       LayoutUnit grid_gap);
+  Vector<LayoutUnit> ComputeSetOffsets(
+      GridTrackSizingDirection track_direction,
+      LayoutUnit grid_gap,
+      NGGridLayoutAlgorithmTrackCollection& track_collection) const;
 
   // Tests whether the row gap is unresolvable based on its type and the
   // available size.
-  bool IsRowGridGapUnresolvable(LayoutUnit available_size);
+  bool IsRowGridGapUnresolvable(LayoutUnit available_size) const;
 
   GridTrackSizingDirection AutoFlowDirection() const;
 
-  GridLayoutAlgorithmState state_;
   LogicalSize border_box_size_;
   LogicalSize child_percentage_size_;
-  LayoutUnit intrinsic_block_size_;
-
-  Vector<GridItemData> grid_items_;
-  Vector<GridItemData> out_of_flow_items_;
-  Vector<wtf_size_t> reordered_item_indices_;
-
-  NGGridBlockTrackCollection block_column_track_collection_;
-  NGGridBlockTrackCollection block_row_track_collection_;
-
-  NGGridLayoutAlgorithmTrackCollection algorithm_column_track_collection_;
-  NGGridLayoutAlgorithmTrackCollection algorithm_row_track_collection_;
-
-  wtf_size_t explicit_column_start_ = 0;
-  wtf_size_t explicit_row_start_ = 0;
-  wtf_size_t column_count_ = 0;
-  wtf_size_t row_count_ = 0;
-
-  wtf_size_t automatic_column_repetitions_ =
-      NGGridBlockTrackCollection::kInvalidRangeIndex;
-  wtf_size_t automatic_row_repetitions_ =
-      NGGridBlockTrackCollection::kInvalidRangeIndex;
 };
 
 }  // namespace blink

third_party/blink/renderer/core/layout/ng/grid/ng_grid_layout_algorithm_test.cc

@@ -41,16 +41,49 @@ class NGGridLayoutAlgorithmTest
     style_ = ComputedStyle::Create();
   }
 
+  void BuildGridItemsAndTrackCollections(NGGridLayoutAlgorithm& algorithm) {
+    // Measure Items
+    algorithm.ConstructAndAppendGridItems(&grid_items_, &out_of_flow_items_);
+
+    algorithm.BuildAlgorithmTrackCollections(
+        &grid_items_, &algorithm_column_track_collection_,
+        &algorithm_row_track_collection_);
+
+    // Cache set indices.
+    algorithm.CacheItemSetIndices(GridTrackSizingDirection::kForColumns,
+                                  &algorithm_column_track_collection_,
+                                  &grid_items_);
+    algorithm.CacheItemSetIndices(GridTrackSizingDirection::kForRows,
+                                  &algorithm_row_track_collection_,
+                                  &grid_items_);
+
+    // Resolve inline size.
+    algorithm.ComputeUsedTrackSizes(GridTrackSizingDirection::kForColumns,
+                                    &grid_items_,
+                                    &algorithm_column_track_collection_);
+
+    // Resolve block size.
+    algorithm.ComputeUsedTrackSizes(GridTrackSizingDirection::kForRows,
+                                    &grid_items_,
+                                    &algorithm_row_track_collection_);
+  }
+
+  NGGridLayoutAlgorithmTrackCollection& TrackCollection(
+      GridTrackSizingDirection track_direction) {
+    return (track_direction == kForColumns) ? algorithm_column_track_collection_
+                                            : algorithm_row_track_collection_;
+  }
+
   // Helper methods to access private data on NGGridLayoutAlgorithm. This class
   // is a friend of NGGridLayoutAlgorithm but the individual tests are not.
   wtf_size_t GridItemCount(const NGGridLayoutAlgorithm& algorithm) {
-    return algorithm.grid_items_.size();
+    return grid_items_.size();
   }
 
   Vector<LayoutUnit> GridItemInlineSizes(
       const NGGridLayoutAlgorithm& algorithm) {
     Vector<LayoutUnit> results;
-    for (const auto& item : algorithm.grid_items_) {
+    for (const auto& item : grid_items_) {
       results.push_back(item.inline_size);
     }
     return results;
@@ -59,7 +92,7 @@ class NGGridLayoutAlgorithmTest
   Vector<LayoutUnit> GridItemInlineMarginSum(
       const NGGridLayoutAlgorithm& algorithm) {
     Vector<LayoutUnit> results;
-    for (const auto& item : algorithm.grid_items_) {
+    for (const auto& item : grid_items_) {
       results.push_back(item.margins.InlineSum());
     }
     return results;
@@ -68,7 +101,7 @@ class NGGridLayoutAlgorithmTest
   Vector<MinMaxSizes> GridItemMinMaxSizes(
       const NGGridLayoutAlgorithm& algorithm) {
     Vector<MinMaxSizes> results;
-    for (const auto& item : algorithm.grid_items_) {
+    for (const auto& item : grid_items_) {
       results.push_back(item.min_max_sizes);
     }
     return results;
@@ -76,7 +109,7 @@ class NGGridLayoutAlgorithmTest
 
   Vector<GridArea> GridItemGridAreas(const NGGridLayoutAlgorithm& algorithm) {
     Vector<GridArea> results;
-    for (const auto& item : algorithm.grid_items_) {
+    for (const auto& item : grid_items_) {
       results.push_back(item.resolved_position);
     }
     return results;
@@ -85,14 +118,20 @@ class NGGridLayoutAlgorithmTest
   void DetermineGridItemsSpanningIntrinsicOrFlexTracks(
       NGGridLayoutAlgorithm& algorithm,
       GridTrackSizingDirection track_direction) {
-    algorithm.DetermineGridItemsSpanningIntrinsicOrFlexTracks(track_direction);
+    Vector<wtf_size_t> reordered_item_indices;
+    reordered_item_indices.ReserveInitialCapacity(grid_items_.size());
+    for (wtf_size_t i = 0; i < grid_items_.size(); ++i)
+      reordered_item_indices.push_back(i);
+    algorithm.DetermineGridItemsSpanningIntrinsicOrFlexTracks(
+        track_direction, &grid_items_, &reordered_item_indices,
+        &TrackCollection(track_direction));
   }
 
   Vector<wtf_size_t> GridItemsSpanningIntrinsicTrack(
       const NGGridLayoutAlgorithm& algorithm) {
     Vector<wtf_size_t> results;
-    for (wtf_size_t i = 0; i < algorithm.grid_items_.size(); ++i) {
-      if (algorithm.grid_items_[i].is_spanning_intrinsic_track)
+    for (wtf_size_t i = 0; i < grid_items_.size(); ++i) {
+      if (grid_items_[i].is_spanning_intrinsic_track)
         results.push_back(i);
     }
     return results;
@@ -101,25 +140,17 @@ class NGGridLayoutAlgorithmTest
   Vector<wtf_size_t> GridItemsSpanningFlexTrack(
       const NGGridLayoutAlgorithm& algorithm) {
     Vector<wtf_size_t> results;
-    for (wtf_size_t i = 0; i < algorithm.grid_items_.size(); ++i) {
-      if (algorithm.grid_items_[i].is_spanning_flex_track)
+    for (wtf_size_t i = 0; i < grid_items_.size(); ++i) {
+      if (grid_items_[i].is_spanning_flex_track)
         results.push_back(i);
     }
     return results;
   }
 
-  void SetAutoTrackRepeat(NGGridLayoutAlgorithm& algorithm,
-                          wtf_size_t auto_column,
-                          wtf_size_t auto_row) {
-    algorithm.SetAutomaticTrackRepetitionsForTesting(auto_column, auto_row);
-  }
-
   Vector<LayoutUnit> BaseSizes(NGGridLayoutAlgorithm& algorithm,
                                GridTrackSizingDirection track_direction) {
     NGGridLayoutAlgorithmTrackCollection& collection =
-        (track_direction == kForColumns)
-            ? algorithm.algorithm_column_track_collection_
-            : algorithm.algorithm_row_track_collection_;
+        TrackCollection(track_direction);
 
     Vector<LayoutUnit> base_sizes;
     for (auto set_iterator = collection.GetSetIterator();
@@ -132,9 +163,7 @@ class NGGridLayoutAlgorithmTest
   Vector<LayoutUnit> GrowthLimits(NGGridLayoutAlgorithm& algorithm,
                                   GridTrackSizingDirection track_direction) {
     NGGridLayoutAlgorithmTrackCollection& collection =
-        (track_direction == kForColumns)
-            ? algorithm.algorithm_column_track_collection_
-            : algorithm.algorithm_row_track_collection_;
+        TrackCollection(track_direction);
 
     Vector<LayoutUnit> growth_limits;
     for (auto set_iterator = collection.GetSetIterator();
@@ -166,6 +195,11 @@ class NGGridLayoutAlgorithmTest
 
     return fragment->DumpFragmentTree(flags);
   }
+  Vector<NGGridLayoutAlgorithm::GridItemData> grid_items_;
+  Vector<NGGridLayoutAlgorithm::GridItemData> out_of_flow_items_;
+
+  NGGridLayoutAlgorithmTrackCollection algorithm_column_track_collection_;
+  NGGridLayoutAlgorithmTrackCollection algorithm_row_track_collection_;
 
   scoped_refptr<ComputedStyle> style_;
 };
@@ -310,7 +344,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmMeasuring) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 9U);
 
   Vector<LayoutUnit> actual_inline_sizes = GridItemInlineSizes(algorithm);
@@ -387,18 +421,18 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRanges) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
   EXPECT_RANGE(1u, 999u, row_iterator);
   EXPECT_FALSE(row_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
   EXPECT_RANGE(1u, 1u, column_iterator);
@@ -444,12 +478,11 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesWithAutoRepeater) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  SetAutoTrackRepeat(algorithm, 3, 3);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
   EXPECT_RANGE(1u, 19u, row_iterator);
@@ -461,7 +494,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesWithAutoRepeater) {
   EXPECT_FALSE(row_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
 
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
@@ -531,11 +564,11 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicit) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
 
@@ -546,7 +579,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicit) {
   EXPECT_FALSE(column_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
 
@@ -602,12 +635,11 @@ TEST_F(NGGridLayoutAlgorithmTest,
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  SetAutoTrackRepeat(algorithm, 0, 0);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
 
@@ -615,7 +647,7 @@ TEST_F(NGGridLayoutAlgorithmTest,
   EXPECT_FALSE(column_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
 
@@ -670,12 +702,11 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicitAutoRows) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  SetAutoTrackRepeat(algorithm, 0, 0);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
 
@@ -686,7 +717,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicitAutoRows) {
   EXPECT_FALSE(column_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
 
@@ -730,12 +761,11 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicitMixed) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  SetAutoTrackRepeat(algorithm, 0, 0);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 5U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
 
@@ -743,7 +773,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmRangesImplicitMixed) {
   EXPECT_FALSE(column_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
 
@@ -819,7 +849,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmAutoGridPositions) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 4U);
 
   Vector<GridArea> grid_positions = GridItemGridAreas(algorithm);
@@ -948,7 +978,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmAutoDense) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 16U);
 
   Vector<GridArea> grid_positions = GridItemGridAreas(algorithm);
@@ -1033,18 +1063,18 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmGridPositions) {
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   EXPECT_EQ(GridItemCount(algorithm), 0U);
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
   EXPECT_EQ(GridItemCount(algorithm), 3U);
 
   NGGridTrackCollectionBase::RangeRepeatIterator column_iterator(
-      &algorithm.ColumnTrackCollection(), 0u);
+      &TrackCollection(kForColumns), 0u);
   EXPECT_RANGE(0u, 1u, column_iterator);
   EXPECT_TRUE(column_iterator.MoveToNextRange());
   EXPECT_RANGE(1u, 1u, column_iterator);
   EXPECT_FALSE(column_iterator.MoveToNextRange());
 
   NGGridTrackCollectionBase::RangeRepeatIterator row_iterator(
-      &algorithm.RowTrackCollection(), 0u);
+      &TrackCollection(kForRows), 0u);
   EXPECT_RANGE(0u, 1u, row_iterator);
   EXPECT_TRUE(row_iterator.MoveToNextRange());
   EXPECT_RANGE(1u, 2u, row_iterator);
@@ -1084,7 +1114,7 @@ TEST_F(NGGridLayoutAlgorithmTest, NGGridLayoutAlgorithmResolveFixedTrackSizes) {
       CalculateInitialFragmentGeometry(space, node);
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
 
   Vector<LayoutUnit> expected_column_base_sizes = {
       LayoutUnit(25), LayoutUnit(60), LayoutUnit(15)};
@@ -1164,7 +1194,7 @@ TEST_F(NGGridLayoutAlgorithmTest,
       CalculateInitialFragmentGeometry(space, node);
 
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
-  algorithm.Layout();
+  BuildGridItemsAndTrackCollections(algorithm);
 
   DetermineGridItemsSpanningIntrinsicOrFlexTracks(algorithm, kForColumns);
   Vector<wtf_size_t> expected_grid_items_spanning_intrinsic_track = {0, 1, 3};

third_party/blink/renderer/core/layout/ng/grid/ng_grid_placement.cc

@@ -16,9 +16,9 @@ NGGridPlacement::NGGridPlacement(
     const GridTrackSizingDirection major_direction,
     const ComputedStyle& grid_style,
     wtf_size_t minor_max_end_line,
-    NGGridBlockTrackCollection& row_collection,
-    NGGridBlockTrackCollection& column_collection,
-    Vector<NGGridLayoutAlgorithm::GridItemData>& items)
+    NGGridBlockTrackCollection* row_collection,
+    NGGridBlockTrackCollection* column_collection,
+    Vector<NGGridLayoutAlgorithm::GridItemData>* items)
     : row_auto_repeat_(row_auto_repeat),
       column_auto_repeat_(column_auto_repeat),
       row_explicit_start_(row_explicit_start),
@@ -30,9 +30,10 @@ NGGridPlacement::NGGridPlacement(
       minor_max_end_line_(minor_max_end_line),
       row_collection_(row_collection),
       column_collection_(column_collection),
-      items_(items)
-
-{
+      items_(items) {
+  DCHECK(row_collection_);
+  DCHECK(column_collection_);
+  DCHECK(items_);
   placement_cursor_major = ExplicitStart(major_direction_);
   placement_cursor_minor = ExplicitStart(minor_direction_);
 }
@@ -60,10 +61,10 @@ void NGGridPlacement::RunAutoPlacementAlgorithm() {
     DCHECK(grid_item);
     switch (grid_item->AutoPlacement(major_direction_)) {
       case NGGridLayoutAlgorithm::AutoPlacementType::kBoth:
-        PlaceAutoBothAxisGridItem(*grid_item);
+        PlaceAutoBothAxisGridItem(grid_item);
         break;
       case NGGridLayoutAlgorithm::AutoPlacementType::kMajor:
-        PlaceAutoMajorAxisGridItem(*grid_item);
+        PlaceAutoMajorAxisGridItem(grid_item);
         break;
       case NGGridLayoutAlgorithm::AutoPlacementType::kMinor:
       case NGGridLayoutAlgorithm::AutoPlacementType::kNotNeeded:
@@ -73,11 +74,11 @@ void NGGridPlacement::RunAutoPlacementAlgorithm() {
 }
 
 bool NGGridPlacement::PlaceNonAutoGridItems() {
-  for (NGGridLayoutAlgorithm::GridItemData& grid_item : items_) {
+  for (NGGridLayoutAlgorithm::GridItemData& grid_item : *items_) {
     bool has_definite_major_placement =
-        PlaceGridItem(major_direction_, grid_item);
+        PlaceGridItem(major_direction_, &grid_item);
     bool has_definite_minor_placement =
-        PlaceGridItem(minor_direction_, grid_item);
+        PlaceGridItem(minor_direction_, &grid_item);
 
     // If the item has definite positions on both axis then no auto placement is
     // needed.
@@ -131,104 +132,107 @@ void NGGridPlacement::PlaceGridItemsLockedToMajorAxis() {
     // Update placement and ensure track coverage.
     UpdatePlacementAndEnsureTrackCoverage(
         GridSpan::TranslatedDefiniteGridSpan(minor_start, minor_end),
-        minor_direction_, *grid_item);
+        minor_direction_, grid_item);
     }
   }
 
-void NGGridPlacement::PlaceAutoMajorAxisGridItem(
-    NGGridLayoutAlgorithm::GridItemData& grid_item) {
-  wtf_size_t major_span_size = GridPositionsResolver::SpanSizeForAutoPlacedItem(
-      grid_item.node.Style(), major_direction_);
-  switch (packing_behavior_) {
-    case PackingBehavior::kSparse:
-      // Set the minor position of the cursor to the grid item’s minor starting
-      // line. If this is less than the previous column position of the cursor,
-      // increment the major position by 1.
-      if (grid_item.StartLine(minor_direction_) < placement_cursor_minor) {
-        placement_cursor_major++;
-      }
-      break;
-    case PackingBehavior::kDense:
-      placement_cursor_major = ExplicitStart(major_direction_);
-      break;
-  }
-
-  placement_cursor_minor = grid_item.StartLine(minor_direction_);
-  // Increment the cursor’s major position until a value is found where the grid
-  // item does not overlap any occupied grid cells
-  while (DoesItemOverlap(placement_cursor_major,
-                         placement_cursor_major + major_span_size,
-                         grid_item.StartLine(minor_direction_),
-                         grid_item.EndLine(minor_direction_))) {
-    placement_cursor_major++;
-  }
-
-  // Update item and track placement.
-  UpdatePlacementAndEnsureTrackCoverage(
-      GridSpan::TranslatedDefiniteGridSpan(
-          placement_cursor_major, placement_cursor_major + major_span_size),
-      major_direction_, grid_item);
-}
+  void NGGridPlacement::PlaceAutoMajorAxisGridItem(
+      NGGridLayoutAlgorithm::GridItemData* grid_item) {
+    wtf_size_t major_span_size =
+        GridPositionsResolver::SpanSizeForAutoPlacedItem(
+            grid_item->node.Style(), major_direction_);
+    switch (packing_behavior_) {
+      case PackingBehavior::kSparse:
+        // Set the minor position of the cursor to the grid item’s minor
+        // starting line. If this is less than the previous column position of
+        // the cursor, increment the major position by 1.
+        if (grid_item->StartLine(minor_direction_) < placement_cursor_minor) {
+          placement_cursor_major++;
+        }
+        break;
+      case PackingBehavior::kDense:
+        placement_cursor_major = ExplicitStart(major_direction_);
+        break;
+    }
 
-void NGGridPlacement::PlaceAutoBothAxisGridItem(
-    NGGridLayoutAlgorithm::GridItemData& grid_item) {
-  if (packing_behavior_ == PackingBehavior::kDense) {
-    // Set the cursor’s major and minor positions to start-most row and column
-    // lines in the implicit grid.
-    placement_cursor_major = ExplicitStart(major_direction_);
-    placement_cursor_minor = ExplicitStart(minor_direction_);
-  }
-  wtf_size_t major_span_size = GridPositionsResolver::SpanSizeForAutoPlacedItem(
-      grid_item.node.Style(), major_direction_);
-  wtf_size_t minor_span_size = GridPositionsResolver::SpanSizeForAutoPlacedItem(
-      grid_item.node.Style(), minor_direction_);
-  // Check to see if there would be overlap if this item was placed at the
-  // cursor. If overlap exists, increment minor position until no conflict
-  // exists or the item would overflow the minor axis.
-  while (DoesItemOverlap(
-      placement_cursor_major, placement_cursor_major + major_span_size,
-      placement_cursor_minor, placement_cursor_minor + minor_span_size)) {
-    placement_cursor_minor++;
-    if (placement_cursor_minor + minor_span_size > ending_minor_line_) {
-      // If the cursor overflows the minor axis, increment cursor on the major
-      // axis and start from the beginning.
+    placement_cursor_minor = grid_item->StartLine(minor_direction_);
+    // Increment the cursor’s major position until a value is found where the
+    // grid item does not overlap any occupied grid cells
+    while (DoesItemOverlap(placement_cursor_major,
+                           placement_cursor_major + major_span_size,
+                           grid_item->StartLine(minor_direction_),
+                           grid_item->EndLine(minor_direction_))) {
       placement_cursor_major++;
-      placement_cursor_minor = starting_minor_line_;
     }
+
+    // Update item and track placement.
+    UpdatePlacementAndEnsureTrackCoverage(
+        GridSpan::TranslatedDefiniteGridSpan(
+            placement_cursor_major, placement_cursor_major + major_span_size),
+        major_direction_, grid_item);
   }
 
-  UpdatePlacementAndEnsureTrackCoverage(
-      GridSpan::TranslatedDefiniteGridSpan(
-          placement_cursor_major, placement_cursor_major + major_span_size),
-      major_direction_, grid_item);
-  UpdatePlacementAndEnsureTrackCoverage(
-      GridSpan::TranslatedDefiniteGridSpan(
-          placement_cursor_minor, placement_cursor_minor + minor_span_size),
-      minor_direction_, grid_item);
-}
+  void NGGridPlacement::PlaceAutoBothAxisGridItem(
+      NGGridLayoutAlgorithm::GridItemData* grid_item) {
+    if (packing_behavior_ == PackingBehavior::kDense) {
+      // Set the cursor’s major and minor positions to start-most row and column
+      // lines in the implicit grid.
+      placement_cursor_major = ExplicitStart(major_direction_);
+      placement_cursor_minor = ExplicitStart(minor_direction_);
+    }
+    wtf_size_t major_span_size =
+        GridPositionsResolver::SpanSizeForAutoPlacedItem(
+            grid_item->node.Style(), major_direction_);
+    wtf_size_t minor_span_size =
+        GridPositionsResolver::SpanSizeForAutoPlacedItem(
+            grid_item->node.Style(), minor_direction_);
+    // Check to see if there would be overlap if this item was placed at the
+    // cursor. If overlap exists, increment minor position until no conflict
+    // exists or the item would overflow the minor axis.
+    while (DoesItemOverlap(
+        placement_cursor_major, placement_cursor_major + major_span_size,
+        placement_cursor_minor, placement_cursor_minor + minor_span_size)) {
+      placement_cursor_minor++;
+      if (placement_cursor_minor + minor_span_size > ending_minor_line_) {
+        // If the cursor overflows the minor axis, increment cursor on the major
+        // axis and start from the beginning.
+        placement_cursor_major++;
+        placement_cursor_minor = starting_minor_line_;
+      }
+    }
 
-bool NGGridPlacement::PlaceGridItem(
-    GridTrackSizingDirection direction,
-    NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData& grid_item) {
-  GridSpan span = GridPositionsResolver::ResolveGridPositionsFromStyle(
-      grid_style_, grid_item.node.Style(), direction, AutoRepeat(direction));
-  // Indefinite positions are resolved with the auto placement algorithm.
-  if (span.IsIndefinite())
-    return false;
+    UpdatePlacementAndEnsureTrackCoverage(
+        GridSpan::TranslatedDefiniteGridSpan(
+            placement_cursor_major, placement_cursor_major + major_span_size),
+        major_direction_, grid_item);
+    UpdatePlacementAndEnsureTrackCoverage(
+        GridSpan::TranslatedDefiniteGridSpan(
+            placement_cursor_minor, placement_cursor_minor + minor_span_size),
+        minor_direction_, grid_item);
+  }
 
-  span.Translate(ExplicitStart(direction));
-  UpdatePlacementAndEnsureTrackCoverage(span, direction, grid_item);
-  return true;
-}
+  bool NGGridPlacement::PlaceGridItem(
+      GridTrackSizingDirection direction,
+      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData* grid_item) {
+    GridSpan span = GridPositionsResolver::ResolveGridPositionsFromStyle(
+        grid_style_, grid_item->node.Style(), direction, AutoRepeat(direction));
+    // Indefinite positions are resolved with the auto placement algorithm.
+    if (span.IsIndefinite())
+      return false;
 
-void NGGridPlacement::UpdatePlacementAndEnsureTrackCoverage(
-    GridSpan span,
-    GridTrackSizingDirection track_direction,
-    NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData& grid_item) {
-  grid_item.SetSpan(span, track_direction);
-  BlockCollection(track_direction)
-      .EnsureTrackCoverage(span.StartLine(), span.IntegerSpan());
-}
+    span.Translate(ExplicitStart(direction));
+    UpdatePlacementAndEnsureTrackCoverage(span, direction, grid_item);
+    return true;
+  }
+
+  void NGGridPlacement::UpdatePlacementAndEnsureTrackCoverage(
+      GridSpan span,
+      GridTrackSizingDirection track_direction,
+      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData* grid_item) {
+    grid_item->SetSpan(span, track_direction);
+    BlockCollection(track_direction)
+        .EnsureTrackCoverage(span.StartLine(), span.IntegerSpan());
+  }
 
 bool NGGridPlacement::DoesItemOverlap(wtf_size_t major_start,
                                       wtf_size_t major_end,
@@ -238,7 +242,7 @@ bool NGGridPlacement::DoesItemOverlap(wtf_size_t major_start,
   DCHECK_LE(minor_start, minor_end);
   // TODO(janewman): Implement smarter collision detection, iterating over all
   // items is not ideal and has large performance implications.
-  for (const NGGridLayoutAlgorithm::GridItemData& grid_item : items_) {
+  for (const NGGridLayoutAlgorithm::GridItemData& grid_item : *items_) {
     if (grid_item.Span(major_direction_).IsIndefinite())
       continue;
     // Only test against definite positions.
@@ -287,9 +291,9 @@ NGGridBlockTrackCollection& NGGridPlacement::BlockCollection(
     GridTrackSizingDirection direction) {
   switch (direction) {
     case kForRows:
-      return row_collection_;
+      return *row_collection_;
     case kForColumns:
-      return column_collection_;
+      return *column_collection_;
   }
 }
 

third_party/blink/renderer/core/layout/ng/grid/ng_grid_placement.h

@@ -27,9 +27,9 @@ class CORE_EXPORT NGGridPlacement {
                            const GridTrackSizingDirection major_direction,
                            const ComputedStyle& grid_style,
                            wtf_size_t minor_max_end_line,
-                           NGGridBlockTrackCollection& row_collection,
-                           NGGridBlockTrackCollection& column_collection,
-                           Vector<NGGridLayoutAlgorithm::GridItemData>& items);
+                           NGGridBlockTrackCollection* row_collection,
+                           NGGridBlockTrackCollection* column_collection,
+                           Vector<NGGridLayoutAlgorithm::GridItemData>* items);
   void RunAutoPlacementAlgorithm();
 
  private:
@@ -42,21 +42,21 @@ class CORE_EXPORT NGGridPlacement {
   // Place item that has a definite position on the minor axis but need auto
   // placement on the major axis.
   void PlaceAutoMajorAxisGridItem(
-      NGGridLayoutAlgorithm::GridItemData& item_data);
+      NGGridLayoutAlgorithm::GridItemData* item_data);
   // Place items that need automatic placement on both the major and minor axis.
   void PlaceAutoBothAxisGridItem(
-      NGGridLayoutAlgorithm::GridItemData& item_data);
+      NGGridLayoutAlgorithm::GridItemData* item_data);
   // Places a grid item if it has a definite position in the given direction,
   // returns true if item was able to be positioned, false if item needs auto
   // positioning in the given direction.
   bool PlaceGridItem(
       GridTrackSizingDirection grid_direction,
-      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData& item_data);
+      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData* item_data);
 
   void UpdatePlacementAndEnsureTrackCoverage(
       GridSpan span,
       GridTrackSizingDirection track_direction,
-      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData& item_data);
+      NGGridLayoutAlgorithm::NGGridLayoutAlgorithm::GridItemData* item_data);
 
   // Returns true if the given placement would overlap with a placed item.
   bool DoesItemOverlap(wtf_size_t major_start,
@@ -83,9 +83,9 @@ class CORE_EXPORT NGGridPlacement {
   // major line.
   wtf_size_t minor_max_end_line_ = 0;
 
-  NGGridBlockTrackCollection& row_collection_;
-  NGGridBlockTrackCollection& column_collection_;
-  Vector<NGGridLayoutAlgorithm::GridItemData>& items_;
+  NGGridBlockTrackCollection* row_collection_;
+  NGGridBlockTrackCollection* column_collection_;
+  Vector<NGGridLayoutAlgorithm::GridItemData>* items_;
 
   wtf_size_t starting_minor_line_ = 0;
   wtf_size_t ending_minor_line_ = 0;