[css-grid] Remove a duplicated auto repeat computation for intrinsic sizes

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 489 matching lines @@
         child->clearContainingBlockOverrideSize();
         child->forceLayout();
       }
     }
 
     updateLogicalWidth();
     m_hasDefiniteLogicalHeight = hasDefiniteLogicalHeight();
 
     TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
-    // TODO(svillar): we won't need to do this once the intrinsic width
-    // computation is isolated from the LayoutGrid object state (it should not
-    // touch any attribute) (see crbug.com/627812)
-    if (m_autoRepeatColumns &&
-        m_autoRepeatColumns !=
-            computeAutoRepeatTracksCount(ForColumns, TrackSizing))
-      dirtyGrid();
-    placeItemsOnGrid(TrackSizing);
+    updateAutoRepeatTracksAndSetDirtyIfNeeded(TrackSizing);
+    placeItemsOnGrid();
 
     GridSizingData sizingData(gridColumnCount(), gridRowCount());
 
     // 1- First, the track sizing algorithm is used to resolve the sizes of the
     // grid columns.
     // At this point the logical width is always definite as the above call to
     // updateLogicalWidth() properly resolves intrinsic sizes. We cannot do the
     // same for heights though because many code paths inside
     // updateLogicalHeight() require a previous call to setLogicalHeight() to
     // resolve heights properly (like for positioned items for example).
@@ skipping 149 matching lines @@
     if (nonEmptyTracksAfterEndLine)
       gapAccumulator += gap;
   }
 
   return gapAccumulator;
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
-  const_cast<LayoutGrid*>(this)->placeItemsOnGrid(IntrinsicSizeComputation);
+  const_cast<LayoutGrid*>(this)->updateAutoRepeatTracksAndSetDirtyIfNeeded(
+      IntrinsicSizeComputation);
+  const_cast<LayoutGrid*>(this)->placeItemsOnGrid();
 
   GridSizingData sizingData(gridColumnCount(), gridRowCount());
   computeTrackSizesForIndefiniteSize(ForColumns, sizingData, minLogicalWidth,
                                      maxLogicalWidth);
 
   LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
   minLogicalWidth += scrollbarWidth;
   maxLogicalWidth += scrollbarWidth;
 }
 
@@ skipping 1061 matching lines @@
   RELEASE_ASSERT(area.rows.isTranslatedDefinite() &&
                  area.columns.isTranslatedDefinite());
   ensureGridSize(area.rows.endLine(), area.columns.endLine());
 
   for (const auto& row : area.rows) {
     for (const auto& column : area.columns)
       m_grid[row][column].append(&child);
   }
 }
 
+void LayoutGrid::updateAutoRepeatTracksAndSetDirtyIfNeeded(
+    SizingOperation sizingOperation) {
+  size_t newAutoRepeatColumns =
+      computeAutoRepeatTracksCount(ForColumns, sizingOperation);
+  size_t newAutoRepeatRows =
+      computeAutoRepeatTracksCount(ForRows, sizingOperation);
+
+  if (m_autoRepeatColumns != newAutoRepeatColumns ||
+      m_autoRepeatRows != newAutoRepeatRows)
+    dirtyGrid();
+
+  m_autoRepeatColumns = newAutoRepeatColumns;
+  m_autoRepeatRows = newAutoRepeatRows;
+}
+
 size_t LayoutGrid::computeAutoRepeatTracksCount(
     GridTrackSizingDirection direction,
     SizingOperation sizingOperation) const {
   bool isRowAxis = direction == ForColumns;
   const auto& autoRepeatTracks = isRowAxis ? styleRef().gridAutoRepeatColumns()
                                            : styleRef().gridAutoRepeatRows();
   size_t autoRepeatTrackListLength = autoRepeatTracks.size();
 
   if (!autoRepeatTrackListLength)
     return 0;
@@ skipping 120 matching lines @@
       if (!iterator.nextGridItem()) {
         if (!emptyTrackIndexes)
           emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
         emptyTrackIndexes->add(trackIndex);
       }
     }
   }
   return emptyTrackIndexes;
 }
 
-void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
+void LayoutGrid::placeItemsOnGrid() {
   if (!m_gridIsDirty)
     return;
 
   DCHECK(m_gridItemArea.isEmpty());
   DCHECK(m_gridItemsIndexesMap.isEmpty());
 
-  if (sizingOperation == IntrinsicSizeComputation)
-    m_autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
-  else
-    m_autoRepeatColumns =
-        computeAutoRepeatTracksCount(ForColumns, sizingOperation);
-  m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
-
   populateExplicitGridAndOrderIterator();
 
   // We clear the dirty bit here as the grid sizes have been updated.
   m_gridIsDirty = false;
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
   m_hasAnyOrthogonalChildren = false;
   for (LayoutBox* child = m_orderIterator.first(); child;
        child = m_orderIterator.next()) {
@@ skipping 1389 matching lines @@
   if (!m_gridItemArea.isEmpty())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
 }  // namespace blink