[GridNG] Refactor cache of properties for track spans

Previously, we only cached whether a span contained a track with an
intrinsic or flexible sizing function. Future changes will require to
cache more properties for track spans (i.e. spans with 'auto' min sizing
functions or non-fixed max sizing functions), but the implementation was
designed to consider only the two fields mentioned above.

1. Introducing `TrackSpanProperties`, an implementation of a bitmask
   that can be applied to any structure that span a set of tracks from
   the grid, which caches several properties from such tracks.

2. Refactoring several methods and classes to remove the use of
   separated boolean fields in favor of the new bitmask.

Bug: 1045599
Change-Id: Ib7f029945daa8ae70d34c7762fdcf342c848e7c2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2593231
Commit-Queue: Ethan Jimenez <ethavar@microsoft.com>
Reviewed-by: Jacques Newman <janewman@microsoft.com>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Reviewed-by: Kurt Catti-Schmidt <kschmi@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#838516}

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

@@ -34,7 +34,7 @@ class CORE_EXPORT NGGridLayoutAlgorithm
   };
 
   struct GridItemData {
-    explicit GridItemData(const NGBlockNode node);
+    explicit GridItemData(const NGBlockNode node) : node(node) {}
 
     AutoPlacementType AutoPlacement(
         GridTrackSizingDirection flow_direction) const;
@@ -46,6 +46,16 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     wtf_size_t EndLine(GridTrackSizingDirection track_direction) const;
     wtf_size_t SpanSize(GridTrackSizingDirection track_direction) const;
 
+    const TrackSpanProperties& GetTrackSpanProperties(
+        GridTrackSizingDirection track_direction) const;
+    void SetTrackSpanProperty(TrackSpanProperties::PropertyId property,
+                              GridTrackSizingDirection track_direction);
+
+    bool IsSpanningFlexibleTrack(
+        GridTrackSizingDirection track_direction) const;
+    bool IsSpanningIntrinsicTrack(
+        GridTrackSizingDirection track_direction) const;
+
     const NGBlockNode node;
     GridArea resolved_position;
 
@@ -66,8 +76,8 @@ class CORE_EXPORT NGGridLayoutAlgorithm
     bool is_inline_axis_stretched;
     bool is_block_axis_stretched;
 
-    bool is_spanning_flex_track : 1;
-    bool is_spanning_intrinsic_track : 1;
+    TrackSpanProperties column_span_properties;
+    TrackSpanProperties row_span_properties;
   };
 
   explicit NGGridLayoutAlgorithm(const NGLayoutAlgorithmParams& params);
@@ -164,9 +174,9 @@ class CORE_EXPORT NGGridLayoutAlgorithm
   void CacheItemSetIndices(
       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(
+  // 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(
       const NGGridLayoutAlgorithmTrackCollection& track_collection,
       Vector<GridItemData>* grid_items,
       Vector<wtf_size_t>* reordered_item_indices) const;
@@ -174,7 +184,8 @@ class CORE_EXPORT NGGridLayoutAlgorithm
   // Calculates from the min and max track sizing functions the used track size.
   void ComputeUsedTrackSizes(
       NGGridLayoutAlgorithmTrackCollection* track_collection,
-      Vector<GridItemData>* grid_items) const;
+      Vector<GridItemData>* grid_items,
+      Vector<wtf_size_t>* reordered_item_indices) 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.

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

@@ -55,13 +55,24 @@ class NGGridLayoutAlgorithmTest
     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)
+      reordered_item_indices[i] = i;
+
+    // Cache track span properties for grid items.
+    algorithm.CacheGridItemsTrackSpanProperties(
+        algorithm_column_track_collection_, &grid_items_,
+        &reordered_item_indices);
+    algorithm.CacheGridItemsTrackSpanProperties(
+        algorithm_row_track_collection_, &grid_items_, &reordered_item_indices);
+
     // Resolve inline size.
     algorithm.ComputeUsedTrackSizes(&algorithm_column_track_collection_,
-                                    &grid_items_);
-
+                                    &grid_items_, &reordered_item_indices);
     // Resolve block size.
     algorithm.ComputeUsedTrackSizes(&algorithm_row_track_collection_,
-                                    &grid_items_);
+                                    &grid_items_, &reordered_item_indices);
   }
 
   NGGridLayoutAlgorithmTrackCollection& TrackCollection(
@@ -111,32 +122,23 @@ class NGGridLayoutAlgorithmTest
     return results;
   }
 
-  void DetermineGridItemsSpanningIntrinsicOrFlexTracks(
+  Vector<wtf_size_t> GridItemsWithColumnSpanProperty(
       const NGGridLayoutAlgorithm& algorithm,
-      const NGGridLayoutAlgorithmTrackCollection& track_collection) {
-    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_collection, &grid_items_, &reordered_item_indices);
-  }
-
-  Vector<wtf_size_t> GridItemsSpanningIntrinsicTrack(
-      const NGGridLayoutAlgorithm& algorithm) {
+      TrackSpanProperties::PropertyId property) {
     Vector<wtf_size_t> results;
     for (wtf_size_t i = 0; i < grid_items_.size(); ++i) {
-      if (grid_items_[i].is_spanning_intrinsic_track)
+      if (grid_items_[i].column_span_properties.HasProperty(property))
         results.push_back(i);
     }
     return results;
   }
 
-  Vector<wtf_size_t> GridItemsSpanningFlexTrack(
-      const NGGridLayoutAlgorithm& algorithm) {
+  Vector<wtf_size_t> GridItemsWithRowSpanProperty(
+      const NGGridLayoutAlgorithm& algorithm,
+      TrackSpanProperties::PropertyId property) {
     Vector<wtf_size_t> results;
     for (wtf_size_t i = 0; i < grid_items_.size(); ++i) {
-      if (grid_items_[i].is_spanning_flex_track)
+      if (grid_items_[i].row_span_properties.HasProperty(property))
         results.push_back(i);
     }
     return results;
@@ -1191,35 +1193,37 @@ TEST_F(NGGridLayoutAlgorithmTest,
   NGGridLayoutAlgorithm algorithm({node, fragment_geometry, space});
   BuildGridItemsAndTrackCollections(algorithm);
 
-  DetermineGridItemsSpanningIntrinsicOrFlexTracks(algorithm,
-                                                  TrackCollection(kForColumns));
+  // Test grid items spanning intrinsic/flexible columns.
   Vector<wtf_size_t> expected_grid_items_spanning_intrinsic_track = {0, 1, 3};
   Vector<wtf_size_t> expected_grid_items_spanning_flex_track = {1};
 
-  Vector<wtf_size_t> actual_items = GridItemsSpanningIntrinsicTrack(algorithm);
+  Vector<wtf_size_t> actual_items = GridItemsWithColumnSpanProperty(
+      algorithm, TrackSpanProperties::kHasIntrinsicTrack);
   EXPECT_EQ(expected_grid_items_spanning_intrinsic_track.size(),
             actual_items.size());
   for (wtf_size_t i = 0; i < actual_items.size(); ++i)
     EXPECT_EQ(expected_grid_items_spanning_intrinsic_track[i], actual_items[i]);
 
-  actual_items = GridItemsSpanningFlexTrack(algorithm);
+  actual_items = GridItemsWithColumnSpanProperty(
+      algorithm, TrackSpanProperties::kHasFlexibleTrack);
   EXPECT_EQ(expected_grid_items_spanning_flex_track.size(),
             actual_items.size());
   for (wtf_size_t i = 0; i < actual_items.size(); ++i)
     EXPECT_EQ(expected_grid_items_spanning_flex_track[i], actual_items[i]);
 
-  DetermineGridItemsSpanningIntrinsicOrFlexTracks(algorithm,
-                                                  TrackCollection(kForRows));
+  // Test grid items spanning intrinsic/flexible rows.
   expected_grid_items_spanning_intrinsic_track = {1, 2, 3};
   expected_grid_items_spanning_flex_track = {2};
 
-  actual_items = GridItemsSpanningIntrinsicTrack(algorithm);
+  actual_items = GridItemsWithRowSpanProperty(
+      algorithm, TrackSpanProperties::kHasIntrinsicTrack);
   EXPECT_EQ(expected_grid_items_spanning_intrinsic_track.size(),
             actual_items.size());
   for (wtf_size_t i = 0; i < actual_items.size(); ++i)
     EXPECT_EQ(expected_grid_items_spanning_intrinsic_track[i], actual_items[i]);
 
-  actual_items = GridItemsSpanningFlexTrack(algorithm);
+  actual_items = GridItemsWithRowSpanProperty(
+      algorithm, TrackSpanProperties::kHasFlexibleTrack);
   EXPECT_EQ(expected_grid_items_spanning_flex_track.size(),
             actual_items.size());
   for (wtf_size_t i = 0; i < actual_items.size(); ++i)

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

@@ -136,6 +136,22 @@ bool NGGridTrackCollectionBase::RangeRepeatIterator::SetRangeIndex(
   return true;
 }
 
+bool NGGridBlockTrackCollection::Range::IsImplicit() const {
+  return properties.HasProperty(TrackSpanProperties::kIsImplicit);
+}
+
+bool NGGridBlockTrackCollection::Range::IsCollapsed() const {
+  return properties.HasProperty(TrackSpanProperties::kIsCollapsed);
+}
+
+void NGGridBlockTrackCollection::Range::SetIsImplicit() {
+  properties.SetProperty(TrackSpanProperties::kIsImplicit);
+}
+
+void NGGridBlockTrackCollection::Range::SetIsCollapsed() {
+  properties.SetProperty(TrackSpanProperties::kIsCollapsed);
+}
+
 NGGridBlockTrackCollection::NGGridBlockTrackCollection(
     GridTrackSizingDirection direction)
     : direction_(direction) {}
@@ -259,7 +275,7 @@ void NGGridBlockTrackCollection::FinalizeRanges() {
 
     // Compute repeater index and offset.
     if (repeater_index == kInvalidRangeIndex) {
-      range.is_implicit_range = true;
+      range.SetIsImplicit();
       if (implicit_tracks_->RepeaterCount() == 0) {
         // No specified implicit tracks, use auto tracks.
         range.repeater_index = kInvalidRangeIndex;
@@ -271,11 +287,12 @@ void NGGridBlockTrackCollection::FinalizeRanges() {
             current_range_track_start - repeater_track_start;
       }
     } else {
-      range.is_implicit_range = false;
       range.repeater_index = repeater_index;
       range.repeater_offset = current_range_track_start - repeater_track_start;
     }
-    range.is_collapsed = is_in_auto_fit_range && open_items_or_repeaters == 1u;
+
+    if (is_in_auto_fit_range && open_items_or_repeaters == 1u)
+      range.SetIsCollapsed();
 
     current_range_track_start += range.track_count;
     ranges_.push_back(range);
@@ -296,15 +313,13 @@ void NGGridBlockTrackCollection::FinalizeRanges() {
   ending_tracks_.clear();
 }
 
-const NGGridBlockTrackCollection::Range&
-NGGridBlockTrackCollection::RangeAtRangeIndex(wtf_size_t range_index) const {
+bool NGGridBlockTrackCollection::IsRangeImplicit(wtf_size_t range_index) const {
   DCHECK_LT(range_index, ranges_.size());
-  return ranges_[range_index];
+  return ranges_[range_index].IsImplicit();
 }
 
 const NGGridBlockTrackCollection::Range&
-NGGridBlockTrackCollection::RangeAtTrackNumber(wtf_size_t track_number) const {
-  wtf_size_t range_index = RangeIndexFromTrackNumber(track_number);
+NGGridBlockTrackCollection::RangeAtRangeIndex(wtf_size_t range_index) const {
   DCHECK_LT(range_index, ranges_.size());
   return ranges_[range_index];
 }
@@ -372,7 +387,7 @@ wtf_size_t NGGridBlockTrackCollection::RangeTrackCount(
 bool NGGridBlockTrackCollection::IsRangeCollapsed(
     wtf_size_t range_index) const {
   DCHECK_LT(range_index, RangeCount());
-  return ranges_[range_index].is_collapsed;
+  return ranges_[range_index].IsCollapsed();
 }
 
 wtf_size_t NGGridBlockTrackCollection::RangeCount() const {
@@ -483,7 +498,11 @@ NGGridLayoutAlgorithmTrackCollection::Range::Range(
     : starting_track_number(block_track_range.starting_track_number),
       track_count(block_track_range.track_count),
       starting_set_index(starting_set_index),
-      is_collapsed(block_track_range.is_collapsed) {}
+      properties(block_track_range.properties) {}
+
+bool NGGridLayoutAlgorithmTrackCollection::Range::IsCollapsed() const {
+  return properties.HasProperty(TrackSpanProperties::kIsCollapsed);
+}
 
 NGGridLayoutAlgorithmTrackCollection::NGGridLayoutAlgorithmTrackCollection(
     const NGGridBlockTrackCollection& block_track_collection,
@@ -494,7 +513,7 @@ NGGridLayoutAlgorithmTrackCollection::NGGridLayoutAlgorithmTrackCollection(
     const NGGridBlockTrackCollection::Range& block_track_range =
         block_track_collection.RangeAtRangeIndex(range_iterator.RangeIndex());
     AppendTrackRange(block_track_range,
-                     block_track_range.is_implicit_range
+                     block_track_range.IsImplicit()
                          ? block_track_collection.ImplicitTracks()
                          : block_track_collection.ExplicitTracks(),
                      is_content_box_size_indefinite);
@@ -507,18 +526,18 @@ void NGGridLayoutAlgorithmTrackCollection::AppendTrackRange(
     bool is_content_box_size_indefinite) {
   Range new_range(block_track_range, /* starting_set_index */ sets_.size());
 
-  if (block_track_range.is_collapsed ||
+  if (block_track_range.IsCollapsed() ||
       block_track_range.repeater_index == kInvalidRangeIndex) {
 #if DCHECK_IS_ON()
     // If there are no specified repeaters for this range, it must be implicit.
     if (block_track_range.repeater_index == kInvalidRangeIndex)
-      DCHECK(block_track_range.is_implicit_range);
+      DCHECK(block_track_range.IsImplicit());
 #endif
 
     // Append a single element for the entire range's set.
     new_range.set_count = 1;
     sets_.emplace_back(block_track_range.track_count,
-                       block_track_range.is_collapsed);
+                       block_track_range.IsCollapsed());
   } else {
     wtf_size_t repeater_size =
         specified_track_list.RepeatSize(block_track_range.repeater_index);
@@ -557,21 +576,27 @@ void NGGridLayoutAlgorithmTrackCollection::AppendTrackRange(
     }
   }
 
-  // Cache if this range contains an intrinsic or flexible track.
-  new_range.is_spanning_flex_track = false;
-  new_range.is_spanning_intrinsic_track = false;
+  // Cache this range's track span properties.
+  bool is_range_spanning_flexible_track = false;
+  bool is_range_spanning_intrinsic_track = false;
+
   for (wtf_size_t i = 0; i < new_range.set_count; ++i) {
     const NGGridSet& set = sets_[new_range.starting_set_index + i];
 
     // From https://drafts.csswg.org/css-grid-1/#algo-terms, a <flex> minimum
     // sizing function shouldn't happen as it would be normalized to 'auto'.
     DCHECK(!set.TrackSize().HasFlexMinTrackBreadth());
-    new_range.is_spanning_flex_track |=
+    is_range_spanning_flexible_track |=
         set.TrackSize().HasFlexMaxTrackBreadth();
-    new_range.is_spanning_intrinsic_track |=
+    is_range_spanning_intrinsic_track |=
         set.TrackSize().HasIntrinsicMinTrackBreadth() ||
         set.TrackSize().HasIntrinsicMaxTrackBreadth();
   }
+
+  if (is_range_spanning_flexible_track)
+    new_range.properties.SetProperty(TrackSpanProperties::kHasFlexibleTrack);
+  if (is_range_spanning_intrinsic_track)
+    new_range.properties.SetProperty(TrackSpanProperties::kHasIntrinsicTrack);
   ranges_.push_back(new_range);
 }
 
@@ -621,16 +646,11 @@ wtf_size_t NGGridLayoutAlgorithmTrackCollection::RangeStartingSetIndex(
   return ranges_[range_index].starting_set_index;
 }
 
-bool NGGridLayoutAlgorithmTrackCollection::IsRangeSpanningIntrinsicTrack(
-    wtf_size_t range_index) const {
-  DCHECK_LT(range_index, RangeCount());
-  return ranges_[range_index].is_spanning_intrinsic_track;
-}
-
-bool NGGridLayoutAlgorithmTrackCollection::IsRangeSpanningFlexTrack(
-    wtf_size_t range_index) const {
+bool NGGridLayoutAlgorithmTrackCollection::RangeHasTrackSpanProperty(
+    wtf_size_t range_index,
+    TrackSpanProperties::PropertyId property_id) const {
   DCHECK_LT(range_index, RangeCount());
-  return ranges_[range_index].is_spanning_flex_track;
+  return ranges_[range_index].properties.HasProperty(property_id);
 }
 
 wtf_size_t NGGridLayoutAlgorithmTrackCollection::RangeTrackNumber(
@@ -648,7 +668,7 @@ wtf_size_t NGGridLayoutAlgorithmTrackCollection::RangeTrackCount(
 bool NGGridLayoutAlgorithmTrackCollection::IsRangeCollapsed(
     wtf_size_t range_index) const {
   DCHECK_LT(range_index, RangeCount());
-  return ranges_[range_index].is_collapsed;
+  return ranges_[range_index].IsCollapsed();
 }
 
 wtf_size_t NGGridLayoutAlgorithmTrackCollection::RangeCount() const {

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

@@ -66,17 +66,39 @@ class CORE_EXPORT NGGridTrackCollectionBase {
   virtual wtf_size_t RangeCount() const = 0;
 };
 
+struct CORE_EXPORT TrackSpanProperties {
+ public:
+  enum PropertyId : unsigned {
+    kNone = 0,
+    kHasIntrinsicTrack = 1 << 0,
+    kHasFlexibleTrack = 1 << 1,
+    kHasAutoMinimumTrack = 1 << 2,
+    kIsCollapsed = 1 << 3,
+    kIsImplicit = 1 << 4
+  };
+
+  inline bool HasProperty(PropertyId id) const { return bitmask_ & id; }
+  inline void SetProperty(PropertyId id) { bitmask_ |= id; }
+
+ private:
+  uint8_t bitmask_{kNone};
+};
+
 class CORE_EXPORT NGGridBlockTrackCollection
     : public NGGridTrackCollectionBase {
  public:
   struct Range {
+    bool IsImplicit() const;
+    bool IsCollapsed() const;
+
+    void SetIsImplicit();
+    void SetIsCollapsed();
+
     wtf_size_t starting_track_number;
     wtf_size_t track_count;
     wtf_size_t repeater_index;
     wtf_size_t repeater_offset;
-
-    bool is_implicit_range : 1;
-    bool is_collapsed : 1;
+    TrackSpanProperties properties;
   };
 
   explicit NGGridBlockTrackCollection(
@@ -89,14 +111,12 @@ class CORE_EXPORT NGGridBlockTrackCollection
   // Ensures that after FinalizeRanges is called, a range will start at the
   // |track_number|, and a range will end at |track_number| + |span_length|
   void EnsureTrackCoverage(wtf_size_t track_number, wtf_size_t span_length);
-
   // Build the collection of ranges based on information provided by
   // SetSpecifiedTracks and EnsureTrackCoverage.
   void FinalizeRanges();
-  // Returns the range at the given range index.
+
+  bool IsRangeImplicit(wtf_size_t range_index) const;
   const Range& RangeAtRangeIndex(wtf_size_t range_index) const;
-  // Returns the range at the given track.
-  const Range& RangeAtTrackNumber(wtf_size_t track_number) const;
 
   GridTrackSizingDirection Direction() const { return direction_; }
   bool IsForColumns() const { return direction_ == kForColumns; }
@@ -226,14 +246,13 @@ class CORE_EXPORT NGGridLayoutAlgorithmTrackCollection
     Range(const NGGridBlockTrackCollection::Range& block_track_range,
           wtf_size_t starting_set_index);
 
+    bool IsCollapsed() const;
+
     wtf_size_t starting_track_number;
     wtf_size_t track_count;
     wtf_size_t starting_set_index;
     wtf_size_t set_count;
-
-    bool is_spanning_intrinsic_track : 1;
-    bool is_spanning_flex_track : 1;
-    bool is_collapsed : 1;
+    TrackSpanProperties properties;
   };
 
   template <bool is_const>
@@ -306,10 +325,11 @@ class CORE_EXPORT NGGridLayoutAlgorithmTrackCollection
   wtf_size_t RangeSetCount(wtf_size_t range_index) const;
   wtf_size_t RangeStartingSetIndex(wtf_size_t range_index) const;
 
-  // Returns true if the range contains a set with an intrinsic sizing function.
-  bool IsRangeSpanningIntrinsicTrack(wtf_size_t range_index) const;
-  // Returns true if the range contains a set with a flexible sizing function.
-  bool IsRangeSpanningFlexTrack(wtf_size_t range_index) const;
+  // Returns true if the specified property has been set in the track span
+  // properties bitmask of the range at position |range_index|.
+  bool RangeHasTrackSpanProperty(
+      wtf_size_t range_index,
+      TrackSpanProperties::PropertyId property_id) const;
 
   GridTrackSizingDirection Direction() const { return direction_; }
   bool IsForColumns() const { return direction_ == kForColumns; }

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

@@ -247,22 +247,22 @@ TEST_F(NGGridTrackCollectionTest, TestNGGridBlockTrackCollectionImplicit) {
   NGGridTrackCollectionBase::RangeRepeatIterator iterator(&block_collection,
                                                           0u);
   EXPECT_RANGE(0u, 3u, iterator);
-  EXPECT_FALSE(block_collection.RangeAtTrackNumber(0u).is_implicit_range);
+  EXPECT_FALSE(block_collection.IsRangeImplicit(iterator.RangeIndex()));
 
   EXPECT_TRUE(iterator.MoveToNextRange());
   EXPECT_RANGE(3u, 5u, iterator);
-  EXPECT_FALSE(block_collection.RangeAtTrackNumber(3).is_implicit_range);
+  EXPECT_FALSE(block_collection.IsRangeImplicit(iterator.RangeIndex()));
 
   EXPECT_TRUE(iterator.MoveToNextRange());
   EXPECT_RANGE(8u, 9u, iterator);
-  EXPECT_FALSE(block_collection.RangeAtTrackNumber(11).is_implicit_range);
+  EXPECT_FALSE(block_collection.IsRangeImplicit(iterator.RangeIndex()));
 
   EXPECT_TRUE(iterator.MoveToNextRange());
-  EXPECT_FALSE(block_collection.RangeAtTrackNumber(20).is_implicit_range);
+  EXPECT_FALSE(block_collection.IsRangeImplicit(iterator.RangeIndex()));
   EXPECT_RANGE(17u, 21u, iterator);
 
   EXPECT_TRUE(iterator.MoveToNextRange());
-  EXPECT_TRUE(block_collection.RangeAtTrackNumber(40).is_implicit_range);
+  EXPECT_TRUE(block_collection.IsRangeImplicit(iterator.RangeIndex()));
   EXPECT_RANGE(38u, 5u, iterator);
 
   EXPECT_FALSE(iterator.MoveToNextRange());
@@ -599,10 +599,10 @@ TEST_F(NGGridTrackCollectionTest,
   EXPECT_SET(GridTrackSize(Length::MinContent()), 1u, set_iterator);
   EXPECT_FALSE(set_iterator.MoveToNextSet());
   wtf_size_t current_range_index = range_iterator.RangeIndex();
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningIntrinsicTrack(current_range_index));
-  EXPECT_FALSE(
-      algorithm_collection.IsRangeSpanningFlexTrack(current_range_index));
+  EXPECT_FALSE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasFlexibleTrack));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasIntrinsicTrack));
   EXPECT_TRUE(range_iterator.MoveToNextRange());
 
   EXPECT_RANGE(1u, 2u, range_iterator);
@@ -613,10 +613,10 @@ TEST_F(NGGridTrackCollectionTest,
   EXPECT_SET(GridTrackSize(Length::Fixed(2)), 1u, set_iterator);
   EXPECT_FALSE(set_iterator.MoveToNextSet());
   current_range_index = range_iterator.RangeIndex();
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningIntrinsicTrack(current_range_index));
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningFlexTrack(current_range_index));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasFlexibleTrack));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasIntrinsicTrack));
   EXPECT_TRUE(range_iterator.MoveToNextRange());
 
   EXPECT_RANGE(3u, 4u, range_iterator);
@@ -631,10 +631,10 @@ TEST_F(NGGridTrackCollectionTest,
   EXPECT_SET(GridTrackSize(Length::Fixed(2)), 1u, set_iterator);
   EXPECT_FALSE(set_iterator.MoveToNextSet());
   current_range_index = range_iterator.RangeIndex();
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningIntrinsicTrack(current_range_index));
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningFlexTrack(current_range_index));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasFlexibleTrack));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasIntrinsicTrack));
   EXPECT_TRUE(range_iterator.MoveToNextRange());
 
   EXPECT_RANGE(7u, 1u, range_iterator);
@@ -643,10 +643,10 @@ TEST_F(NGGridTrackCollectionTest,
   EXPECT_SET(GridTrackSize(Length::Fixed(3)), 1u, set_iterator);
   EXPECT_FALSE(set_iterator.MoveToNextSet());
   current_range_index = range_iterator.RangeIndex();
-  EXPECT_FALSE(
-      algorithm_collection.IsRangeSpanningIntrinsicTrack(current_range_index));
-  EXPECT_FALSE(
-      algorithm_collection.IsRangeSpanningFlexTrack(current_range_index));
+  EXPECT_FALSE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasFlexibleTrack));
+  EXPECT_FALSE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasIntrinsicTrack));
   EXPECT_TRUE(range_iterator.MoveToNextRange());
 
   EXPECT_RANGE(8u, 3u, range_iterator);
@@ -655,10 +655,10 @@ TEST_F(NGGridTrackCollectionTest,
   EXPECT_SET(GridTrackSize(Length::Auto()), 3u, set_iterator);
   EXPECT_FALSE(set_iterator.MoveToNextSet());
   current_range_index = range_iterator.RangeIndex();
-  EXPECT_TRUE(
-      algorithm_collection.IsRangeSpanningIntrinsicTrack(current_range_index));
-  EXPECT_FALSE(
-      algorithm_collection.IsRangeSpanningFlexTrack(current_range_index));
+  EXPECT_FALSE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasFlexibleTrack));
+  EXPECT_TRUE(algorithm_collection.RangeHasTrackSpanProperty(
+      current_range_index, TrackSpanProperties::kHasIntrinsicTrack));
   EXPECT_FALSE(range_iterator.MoveToNextRange());
 }