[GridNG] Refactor item set indices and grid lines for out of flow items

1. Previously, we were storing the set indices of each item directly in
GridItemData. This is not necessary as they can be computed on demand.
`CacheItemSetIndices` was renamed to `ComputeItemSetIndices` and was
changed to return `ItemSetIndices` instead.

2. `ResolveOutOfFlowItemGridLines` was moved to `NGGridPlacement`
addressing a TODO. Now the variables `automatic_repetitions` and
`explicit_start` can be directly obtained from the placement instance.

This change does not add nor remove any functionality.

Bug: 1045599
Change-Id: Ib0d3898f9979788cb4e9f7311ab9ad7a1c03504f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626356
Commit-Queue: Ana Sollano Kim <ansollan@microsoft.com>
Reviewed-by: Ethan Jimenez <ethavar@microsoft.com>
Reviewed-by: Christian Biesinger <cbiesinger@chromium.org>
Reviewed-by: Kurt Catti-Schmidt <kschmi@microsoft.com>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Reviewed-by: Jacques Newman <janewman@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#845846}

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

@@ -36,6 +36,11 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     kForMaxContentMaximums
   };
 
+  struct ItemSetIndices {
+    wtf_size_t begin;
+    wtf_size_t end;
+  };
+
   struct GridItemData {
     explicit GridItemData(const NGBlockNode node) : node(node) {}
 
@@ -59,6 +64,13 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     bool IsSpanningIntrinsicTrack(
         GridTrackSizingDirection track_direction) const;
 
+    // For this 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).
+    ItemSetIndices SetIndices(
+        const NGGridLayoutAlgorithmTrackCollection& track_collection,
+        NGGridPlacement* grid_placement = nullptr);
+
     const NGBlockNode node;
     GridArea resolved_position;
 
@@ -66,13 +78,6 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     LayoutUnit inline_size;
     MinMaxSizes min_max_sizes;
 
-    // These fields are used to determine the sets this item spans in the
-    // respective track collection; see |CacheItemSetIndices|.
-    wtf_size_t columns_begin_set_index;
-    wtf_size_t columns_end_set_index;
-    wtf_size_t rows_begin_set_index;
-    wtf_size_t rows_end_set_index;
-
     AxisEdge inline_axis_alignment;
     AxisEdge block_axis_alignment;
 
@@ -83,6 +88,12 @@ class CORE_EXPORT NGGridLayoutAlgorithm
 
     TrackSpanProperties column_span_properties;
     TrackSpanProperties row_span_properties;
+
+    // These fields are used to determine the sets this item spans in the
+    // respective track collection; see |SetIndices|. We use optional since some
+    // scenarios don't require to compute the indices at all.
+    base::Optional<ItemSetIndices> column_set_indices;
+    base::Optional<ItemSetIndices> row_set_indices;
   };
 
   explicit NGGridLayoutAlgorithm(const NGLayoutAlgorithmParams& params);
@@ -132,13 +143,6 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     Vector<GridItemData>& grid_items_;
   };
 
-
-  // Returns an iterator for every |NGGridSet| contained within an item's span
-  // in the relevant track collection.
-  static NGGridLayoutAlgorithmTrackCollection::SetIterator
-  GetSetIteratorForItem(const GridItemData& item,
-                        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.
   LayoutUnit ContributionSizeForGridItem(
@@ -175,18 +179,6 @@ class CORE_EXPORT NGGridLayoutAlgorithm
       const Vector<GridItemData>& grid_items,
       NGGridBlockTrackCollection* track_collection) 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(
-      const NGGridLayoutAlgorithmTrackCollection& track_collection,
-      Vector<GridItemData>* items) const;
-  // Helper function to resolve start and end lines of out of flow items.
-  void ResolveOutOfFlowItemGridLines(
-      const GridItemData& out_of_flow_item,
-      const NGGridLayoutAlgorithmTrackCollection& track_collection,
-      wtf_size_t* start_line,
-      wtf_size_t* end_line) const;
   // For every grid item, caches properties of the track sizing functions it
   // spans (i.e. whether an item spans intrinsic or flexible tracks).
   void CacheGridItemsTrackSpanProperties(
@@ -221,10 +213,11 @@ class CORE_EXPORT NGGridLayoutAlgorithm
 
   // Lays out and computes inline and block offsets for grid items.
   void PlaceItems(
-      const Vector<GridItemData>& grid_items,
       const NGGridLayoutAlgorithmTrackCollection& column_track_collection,
       const NGGridLayoutAlgorithmTrackCollection& row_track_collection,
+      Vector<GridItemData>* grid_items,
       Vector<GridItemData>* out_of_flow_items,
+      NGGridPlacement* grid_placement,
       LayoutUnit* intrinsic_block_size,
       LayoutUnit* block_size);
 
@@ -236,21 +229,18 @@ class CORE_EXPORT NGGridLayoutAlgorithm
   void PlaceGridItems(const Vector<GridItemData>& grid_items,
                       const Vector<LayoutUnit>& column_set_offsets,
                       const Vector<LayoutUnit>& row_set_offsets,
-                      LayoutUnit intrinsic_block_size,
+                      LayoutUnit block_size,
                       LayoutUnit column_grid_gap,
                       LayoutUnit row_grid_gap);
 
   // Computes the static position, grid area and its offset of out of flow
   // elements in the grid.
-  void PlaceOutOfFlowItems(
-      const Vector<LayoutUnit>& column_set_offsets,
-      const Vector<LayoutUnit>& row_set_offsets,
-      const NGGridLayoutAlgorithmTrackCollection& column_track_collection,
-      const NGGridLayoutAlgorithmTrackCollection& row_track_collection,
-      LayoutUnit block_size,
-      LayoutUnit column_grid_gap,
-      LayoutUnit row_grid_gap,
-      Vector<GridItemData>* out_of_flow_items);
+  void PlaceOutOfFlowItems(const Vector<GridItemData>& out_of_flow_items,
+                           const Vector<LayoutUnit>& column_set_offsets,
+                           const Vector<LayoutUnit>& row_set_offsets,
+                           LayoutUnit block_size,
+                           LayoutUnit column_grid_gap,
+                           LayoutUnit row_grid_gap);
 
   // Helper method that computes the offset and size of an item.
   void ComputeOffsetAndSize(

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

@@ -54,12 +54,6 @@ class NGGridLayoutAlgorithmTest
         &grid_items_, &algorithm_column_track_collection_,
         &algorithm_row_track_collection_, &grid_placement);
 
-    // Cache set indices.
-    algorithm.CacheItemSetIndices(algorithm_column_track_collection_,
-                                  &grid_items_);
-    algorithm.CacheItemSetIndices(algorithm_row_track_collection_,
-                                  &grid_items_);
-
     // Create a vector of grid item indices using |NGGridChildIterator| order.
     Vector<wtf_size_t> reordered_item_indices(grid_items_.size());
     for (wtf_size_t i = 0; i < grid_items_.size(); ++i)

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

@@ -328,4 +328,46 @@ bool NGGridPlacement::HasSparsePacking() const {
   return packing_behavior_ == PackingBehavior::kSparse;
 }
 
+void NGGridPlacement::ResolveOutOfFlowItemGridLines(
+    const NGGridLayoutAlgorithmTrackCollection& track_collection,
+    const ComputedStyle& out_of_flow_item_style,
+    wtf_size_t* start_line,
+    wtf_size_t* end_line) const {
+  DCHECK(start_line);
+  DCHECK(end_line);
+
+  const GridTrackSizingDirection track_direction = track_collection.Direction();
+  GridSpan span = GridPositionsResolver::ResolveGridPositionsFromStyle(
+      grid_style_, out_of_flow_item_style, track_direction,
+      AutoRepeatTrackCount(track_direction));
+
+  if (span.IsIndefinite()) {
+    *start_line = kNotFound;
+    *end_line = kNotFound;
+    return;
+  }
+
+  if (span.UntranslatedStartLine() > -1) {
+    // TODO(ansollan): Handle out of flow positioned items with negative
+    // indexes.
+    span.Translate(StartOffset(track_direction));
+  }
+
+  *start_line = span.StartLine();
+  *end_line = span.EndLine();
+
+  bool is_start_line_auto =
+      (track_direction == kForColumns)
+          ? out_of_flow_item_style.GridColumnStart().IsAuto()
+          : out_of_flow_item_style.GridRowStart().IsAuto();
+  if (is_start_line_auto || !track_collection.IsTrackWithinBounds(*start_line))
+    *start_line = kNotFound;
+
+  bool is_end_line_auto = (track_direction == kForColumns)
+                              ? out_of_flow_item_style.GridColumnEnd().IsAuto()
+                              : out_of_flow_item_style.GridRowEnd().IsAuto();
+  if (is_end_line_auto || !track_collection.IsTrackWithinBounds(*end_line - 1))
+    *end_line = kNotFound;
+}
+
 }  // namespace blink

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

@@ -28,6 +28,13 @@ class CORE_EXPORT NGGridPlacement {
                   const wtf_size_t row_auto_repetitions);
 
   void RunAutoPlacementAlgorithm(Vector<GridItemData>* grid_items);
+  // Helper function to resolve start and end lines of out of flow items.
+  void ResolveOutOfFlowItemGridLines(
+      const NGGridLayoutAlgorithmTrackCollection& track_collection,
+      const ComputedStyle& out_of_flow_item_style,
+      wtf_size_t* start_line,
+      wtf_size_t* end_line) const;
+
   wtf_size_t AutoRepetitions(GridTrackSizingDirection track_direction) const;
 
  private: