[css-grid] Clamp the number of auto repeat tracks in all cases

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 97 matching lines @@
 }
 
 #if DCHECK_IS_ON()
 bool LayoutGrid::Grid::hasAnyGridItemPaintOrder() const {
   return !m_gridItemsIndexesMap.isEmpty();
 }
 #endif
 
 void LayoutGrid::Grid::setAutoRepeatTracks(size_t autoRepeatRows,
                                            size_t autoRepeatColumns) {
+  DCHECK_GE(static_cast<unsigned>(kGridMaxTracks),
+            numTracks(ForRows) + autoRepeatRows);
+  DCHECK_GE(static_cast<unsigned>(kGridMaxTracks),
+            numTracks(ForColumns) + autoRepeatColumns);
   m_autoRepeatRows = autoRepeatRows;
   m_autoRepeatColumns = autoRepeatColumns;
 }
 
 size_t LayoutGrid::Grid::autoRepeatTracks(
     GridTrackSizingDirection direction) const {
   return direction == ForRows ? m_autoRepeatRows : m_autoRepeatColumns;
 }
 
 void LayoutGrid::Grid::setAutoRepeatEmptyColumns(
@@ skipping 1907 matching lines @@
   size_t repetitions =
       1 + (freeSpace / (autoRepeatTracksSize + gapSize)).toInt();
 
   // Provided the grid container does not have a definite size or max-size in
   // the relevant axis, if the min size is definite then the number of
   // repetitions is the largest possible positive integer that fulfills that
   // minimum requirement.
   if (needsToFulfillMinimumSize)
     ++repetitions;
 
-  // Clamp the number of repetitions so we don't end up with too many tracks.
-  if (repetitions > kGridMaxTracks) {
-    DCHECK_GT(autoRepeatTrackListLength, 0u);
-    repetitions =
-        (kGridMaxTracks - trackSizes.size()) / autoRepeatTrackListLength;
-  }
-
   return repetitions * autoRepeatTrackListLength;
 }
 
 std::unique_ptr<LayoutGrid::OrderedTrackIndexSet>
 LayoutGrid::computeEmptyTracksForAutoRepeat(
     Grid& grid,
     GridTrackSizingDirection direction) const {
   bool isRowAxis = direction == ForColumns;
   if ((isRowAxis && styleRef().gridAutoRepeatColumnsType() != AutoFit) ||
       (!isRowAxis && styleRef().gridAutoRepeatRowsType() != AutoFit))
@@ skipping 20 matching lines @@
       if (!iterator.nextGridItem()) {
         if (!emptyTrackIndexes)
           emptyTrackIndexes = WTF::wrapUnique(new OrderedTrackIndexSet);
         emptyTrackIndexes->add(trackIndex);
       }
     }
   }
   return emptyTrackIndexes;
 }
 
+size_t LayoutGrid::clampAutoRepeatTracks(GridTrackSizingDirection direction,
+                                         size_t autoRepeatTracks) const {
+  if (!autoRepeatTracks)
+    return 0;
+
+  size_t insertionPoint = direction == ForColumns
+                              ? styleRef().gridAutoRepeatColumnsInsertionPoint()
+                              : styleRef().gridAutoRepeatRowsInsertionPoint();
+
+  if (insertionPoint == 0)
+    return std::min<size_t>(autoRepeatTracks, kGridMaxTracks);
+
+  if (insertionPoint >= kGridMaxTracks)
+    return 0;
+
+  return std::min(autoRepeatTracks,
+                  static_cast<size_t>(kGridMaxTracks) - insertionPoint);
+}
+
 void LayoutGrid::placeItemsOnGrid(LayoutGrid::Grid& grid,
                                   SizingOperation sizingOperation) const {
   size_t autoRepeatRows =
       computeAutoRepeatTracksCount(ForRows, sizingOperation);
   size_t autoRepeatColumns =
       computeAutoRepeatTracksCount(ForColumns, sizingOperation);
+
+  autoRepeatRows = clampAutoRepeatTracks(ForRows, autoRepeatRows);
+  autoRepeatColumns = clampAutoRepeatTracks(ForColumns, autoRepeatColumns);
+
   if (autoRepeatRows != grid.autoRepeatTracks(ForRows) ||
       autoRepeatColumns != grid.autoRepeatTracks(ForColumns)) {
     grid.setNeedsItemsPlacement(true);
     grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
   }
 
   if (!grid.needsItemsPlacement())
     return;
 
   DCHECK(!grid.hasGridItems());
@@ skipping 1520 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink