[css-grid] Move Grid into GridSizingData

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 376 matching lines @@
   size_t m_rowIndex;
   size_t m_columnIndex;
   size_t m_childIndex;
 };
 
 struct LayoutGrid::GridSizingData {
   WTF_MAKE_NONCOPYABLE(GridSizingData);
   STACK_ALLOCATED();
 
  public:
-  GridSizingData(size_t gridColumnCount, size_t gridRowCount)
-      : columnTracks(gridColumnCount), rowTracks(gridRowCount) {}
+  GridSizingData(size_t gridColumnCount, size_t gridRowCount, Grid& grid)
+      : columnTracks(gridColumnCount), rowTracks(gridRowCount), m_grid(grid) {}
 
   Vector<GridTrack> columnTracks;
   Vector<GridTrack> rowTracks;
   Vector<size_t> contentSizedTracksIndex;
 
   // Performance optimization: hold onto these Vectors until the end of Layout
   // to avoid repeated malloc / free.
   Vector<GridTrack*> filteredTracks;
   Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
   Vector<GridTrack*> growBeyondGrowthLimitsTracks;
@@ skipping 39 matching lines @@
       case ColumnSizingSecondIteration:
         return direction == ForColumns;
       case RowSizingFirstIteration:
       case RowSizingSecondIteration:
         return direction == ForRows;
     }
     NOTREACHED();
     return false;
   }
 
+  Grid& grid() const { return m_grid; }
+
  private:
   LayoutUnit freeSpaceForColumns{};
   LayoutUnit freeSpaceForRows{};
   // No need to store one per direction as it will be only used for computations
   // during each axis track sizing. It's cached here because we need it to
   // compute relative sizes.
   LayoutUnit m_availableSpace;
+
+  Grid& m_grid;
 };
 
 struct GridItemsSpanGroupRange {
   Vector<GridItemWithSpan>::iterator rangeStart;
   Vector<GridItemWithSpan>::iterator rangeEnd;
 };
 
 LayoutGrid::LayoutGrid(Element* element) : LayoutBlock(element), m_grid(this) {
   ASSERT(!childrenInline());
   if (!isAnonymous())
@@ skipping 66 matching lines @@
          oldStyle.namedGridColumnLines() != styleRef().namedGridColumnLines();
 }
 
 LayoutUnit LayoutGrid::computeTrackBasedLogicalHeight(
     const GridSizingData& sizingData) const {
   LayoutUnit logicalHeight;
 
   for (const auto& row : sizingData.rowTracks)
     logicalHeight += row.baseSize();
 
-  logicalHeight += guttersSize(ForRows, 0, sizingData.rowTracks.size(),
-                               sizingData.sizingOperation);
+  logicalHeight +=
+      guttersSize(sizingData.grid(), ForRows, 0, sizingData.rowTracks.size(),
+                  sizingData.sizingOperation);
 
   return logicalHeight;
 }
 
 void LayoutGrid::computeTrackSizesForDefiniteSize(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData,
     LayoutUnit availableSpace) const {
   DCHECK(sizingData.isValidTransition(direction));
   sizingData.setAvailableSpace(availableSpace);
   sizingData.freeSpace(direction) =
-      availableSpace - guttersSize(direction, 0, m_grid.numTracks(direction),
+      availableSpace - guttersSize(sizingData.grid(), direction, 0,
+                                   sizingData.grid().numTracks(direction),
                                    sizingData.sizingOperation);
   sizingData.sizingOperation = TrackSizing;
 
   LayoutUnit baseSizes, growthLimits;
   computeUsedBreadthOfGridTracks(direction, sizingData, baseSizes,
                                  growthLimits);
   ASSERT(tracksAreWiderThanMinTrackBreadth(direction, sizingData));
   sizingData.nextState();
 }
 
 void LayoutGrid::repeatTracksSizingIfNeeded(GridSizingData& sizingData,
                                             LayoutUnit availableSpaceForColumns,
                                             LayoutUnit availableSpaceForRows) {
   DCHECK(sizingData.sizingState > GridSizingData::RowSizingFirstIteration);
 
   // In orthogonal flow cases column track's size is determined by using the
   // computed row track's size, which it was estimated during the first cycle of
   // the sizing algorithm.
   // Hence we need to repeat computeUsedBreadthOfGridTracks for both, columns
   // and rows, to determine the final values.
   // TODO (lajava): orthogonal flows is just one of the cases which may require
   // a new cycle of the sizing algorithm; there may be more. In addition, not
   // all the cases with orthogonal flows require this extra cycle; we need a
   // more specific condition to detect whether child's min-content contribution
   // has changed or not.
-  if (m_grid.hasAnyOrthogonalGridItem()) {
+  if (sizingData.grid().hasAnyOrthogonalGridItem()) {
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
                                      availableSpaceForColumns);
     computeTrackSizesForDefiniteSize(ForRows, sizingData,
                                      availableSpaceForRows);
   }
 }
 
 void LayoutGrid::layoutBlock(bool relayoutChildren) {
   ASSERT(needsLayout());
 
@@ skipping 37 matching lines @@
     // computation is isolated from the LayoutGrid object state (it should not
     // touch any attribute) (see crbug.com/627812)
     size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
     if (autoRepeatColumns &&
         autoRepeatColumns !=
             computeAutoRepeatTracksCount(ForColumns, TrackSizing))
       dirtyGrid();
     placeItemsOnGrid(m_grid, TrackSizing);
 
     GridSizingData sizingData(numTracks(ForColumns, m_grid),
-                              numTracks(ForRows, m_grid));
+                              numTracks(ForRows, m_grid), m_grid);
 
     // 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).
     LayoutUnit availableSpaceForColumns = availableLogicalWidth();
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
@@ skipping 64 matching lines @@
   if (sizingOperation == TrackSizing && gap.isPercent())
     availableSize = direction == ForColumns
                         ? availableLogicalWidth()
                         : availableLogicalHeightForPercentageComputation();
 
   // TODO(rego): Maybe we could cache the computed percentage as a performance
   // improvement.
   return valueForLength(gap, availableSize);
 }
 
-LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction,
+LayoutUnit LayoutGrid::guttersSize(const Grid& grid,
+                                   GridTrackSizingDirection direction,
                                    size_t startLine,
                                    size_t span,
                                    SizingOperation sizingOperation) const {
   if (span <= 1)
     return LayoutUnit();
 
   LayoutUnit gap = gridGapForDirection(direction, sizingOperation);
 
   // Fast path, no collapsing tracks.
-  if (!m_grid.hasAutoRepeatEmptyTracks(direction))
+  if (!grid.hasAutoRepeatEmptyTracks(direction))
     return gap * (span - 1);
 
   // If there are collapsing tracks we need to be sure that gutters are properly
   // collapsed. Apart from that, if we have a collapsed track in the edges of
   // the span we're considering, we need to move forward (or backwards) in order
   // to know whether the collapsed tracks reach the end of the grid (so the gap
   // becomes 0) or there is a non empty track before that.
 
   LayoutUnit gapAccumulator;
   size_t endLine = startLine + span;
 
   for (size_t line = startLine; line < endLine - 1; ++line) {
-    if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
+    if (!grid.isEmptyAutoRepeatTrack(direction, line))
       gapAccumulator += gap;
   }
 
   // The above loop adds one extra gap for trailing collapsed tracks.
-  if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+  if (gapAccumulator && grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
     DCHECK_GE(gapAccumulator, gap);
     gapAccumulator -= gap;
   }
 
   // If the startLine is the start line of a collapsed track we need to go
   // backwards till we reach a non collapsed track. If we find a non collapsed
   // track we need to add that gap.
-  if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
+  if (startLine && grid.isEmptyAutoRepeatTrack(direction, startLine)) {
     size_t nonEmptyTracksBeforeStartLine = startLine;
-    auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
+    auto begin = grid.autoRepeatEmptyTracks(direction)->begin();
     for (auto it = begin; *it != startLine; ++it) {
       DCHECK(nonEmptyTracksBeforeStartLine);
       --nonEmptyTracksBeforeStartLine;
     }
     if (nonEmptyTracksBeforeStartLine)
       gapAccumulator += gap;
   }
 
   // If the endLine is the end line of a collapsed track we need to go forward
   // till we reach a non collapsed track. If we find a non collapsed track we
   // need to add that gap.
-  if (m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
-    size_t nonEmptyTracksAfterEndLine = m_grid.numTracks(direction) - endLine;
+  if (grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+    size_t nonEmptyTracksAfterEndLine = grid.numTracks(direction) - endLine;
     auto currentEmptyTrack =
-        m_grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
-    auto endEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->end();
+        grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
+    auto endEmptyTrack = grid.autoRepeatEmptyTracks(direction)->end();
     // HashSet iterators do not implement operator- so we have to manually
     // iterate to know the number of remaining empty tracks.
     for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) {
       DCHECK(nonEmptyTracksAfterEndLine);
       --nonEmptyTracksAfterEndLine;
     }
     if (nonEmptyTracksAfterEndLine)
       gapAccumulator += gap;
   }
 
   return gapAccumulator;
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   const_cast<LayoutGrid*>(this)->placeItemsOnGrid(const_cast<Grid&>(m_grid),
                                                   IntrinsicSizeComputation);
 
   GridSizingData sizingData(numTracks(ForColumns, m_grid),
-                            numTracks(ForRows, m_grid));
+                            numTracks(ForRows, m_grid),
+                            const_cast<Grid&>(m_grid));
   computeTrackSizesForIndefiniteSize(ForColumns, sizingData, minLogicalWidth,
                                      maxLogicalWidth);
 
   LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
   minLogicalWidth += scrollbarWidth;
   maxLogicalWidth += scrollbarWidth;
 }
 
 void LayoutGrid::computeTrackSizesForIndefiniteSize(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData,
     LayoutUnit& minIntrinsicSize,
     LayoutUnit& maxIntrinsicSize) const {
   DCHECK(sizingData.isValidTransition(direction));
   sizingData.setAvailableSpace(LayoutUnit());
   sizingData.freeSpace(direction) = LayoutUnit();
   sizingData.sizingOperation = IntrinsicSizeComputation;
 
   computeUsedBreadthOfGridTracks(direction, sizingData, minIntrinsicSize,
                                  maxIntrinsicSize);
 
   size_t numberOfTracks = direction == ForColumns
                               ? sizingData.columnTracks.size()
                               : sizingData.rowTracks.size();
   LayoutUnit totalGuttersSize =
-      guttersSize(direction, 0, numberOfTracks, sizingData.sizingOperation);
+      guttersSize(sizingData.grid(), direction, 0, numberOfTracks,
+                  sizingData.sizingOperation);
   minIntrinsicSize += totalGuttersSize;
   maxIntrinsicSize += totalGuttersSize;
 
 #if ENABLE(ASSERT)
   DCHECK(tracksAreWiderThanMinTrackBreadth(direction, sizingData));
 #endif
 }
 
 LayoutUnit LayoutGrid::computeIntrinsicLogicalContentHeightUsing(
     const Length& logicalHeightLength,
@@ skipping 41 matching lines @@
   sizingData.contentSizedTracksIndex.shrink(0);
 
   // Grid gutters were removed from freeSpace by the caller, but we must use
   // them to compute relative (i.e. percentages) sizes.
   LayoutUnit maxSize = sizingData.availableSpace().clampNegativeToZero();
   bool hasDefiniteFreeSpace = sizingData.sizingOperation == TrackSizing;
 
   // 1. Initialize per Grid track variables.
   for (size_t i = 0; i < tracks.size(); ++i) {
     GridTrack& track = tracks[i];
-    GridTrackSize trackSize =
-        gridTrackSize(direction, i, sizingData.sizingOperation);
+    GridTrackSize trackSize = gridTrackSize(direction, i, sizingData);
 
     track.setBaseSize(computeUsedBreadthOfMinLength(trackSize, maxSize));
     track.setGrowthLimit(
         computeUsedBreadthOfMaxLength(trackSize, track.baseSize(), maxSize));
     track.setInfinitelyGrowable(false);
 
     if (trackSize.isFitContent()) {
       GridLength gridLength = trackSize.fitContentTrackBreadth();
       if (!gridLength.hasPercentage() || hasDefiniteFreeSpace)
         track.setGrowthLimitCap(valueForLength(gridLength.length(), maxSize));
@@ skipping 46 matching lines @@
   }
 
   if (flexibleSizedTracksIndex.isEmpty())
     return;
 
   // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
   double flexFraction = 0;
   if (hasDefiniteFreeSpace) {
     flexFraction = findFlexFactorUnitSize(
         tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()),
-        direction, initialFreeSpace);
+        direction, initialFreeSpace, sizingData);
   } else {
-    for (const auto& trackIndex : flexibleSizedTracksIndex)
+    for (const auto& trackIndex : flexibleSizedTracksIndex) {
       flexFraction = std::max(
-          flexFraction,
-          normalizedFlexFraction(
-              tracks[trackIndex],
-              gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
+          flexFraction, normalizedFlexFraction(
+                            tracks[trackIndex],
+                            gridTrackSize(direction, trackIndex, sizingData)
+                                .maxTrackBreadth()
+                                .flex()));
+    }
 
-    if (m_grid.hasGridItems()) {
+    const Grid& grid = sizingData.grid();
+    if (grid.hasGridItems()) {
       for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
-        GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
+        GridIterator iterator(grid, direction, flexibleSizedTracksIndex[i]);
         while (LayoutBox* gridItem = iterator.nextGridItem()) {
-          const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
+          const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
 
           // Do not include already processed items.
           if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
             continue;
 
-          flexFraction = std::max(
-              flexFraction,
-              findFlexFactorUnitSize(
-                  tracks, span, direction,
-                  maxContentForChild(*gridItem, direction, sizingData)));
+          flexFraction =
+              std::max(flexFraction,
+                       findFlexFactorUnitSize(
+                           tracks, span, direction,
+                           maxContentForChild(*gridItem, direction, sizingData),
+                           sizingData));
         }
       }
     }
   }
 
   LayoutUnit totalGrowth;
   Vector<LayoutUnit> increments;
   increments.grow(flexibleSizedTracksIndex.size());
   computeFlexSizedTracksGrowth(direction, tracks, flexibleSizedTracksIndex,
-                               flexFraction, increments, totalGrowth);
+                               flexFraction, increments, totalGrowth,
+                               sizingData);
 
   // We only need to redo the flex fraction computation for indefinite heights
   // (definite sizes are already constrained by min/max sizes). Regarding
   // widths, they are always definite at layout time so we shouldn't ever have
   // to do this.
   if (!hasDefiniteFreeSpace && direction == ForRows) {
     auto minSize = computeContentLogicalHeight(
         MinSize, styleRef().logicalMinHeight(), LayoutUnit(-1));
     auto maxSize = computeContentLogicalHeight(
         MaxSize, styleRef().logicalMaxHeight(), LayoutUnit(-1));
 
     // Redo the flex fraction computation using min|max-height as definite
     // available space in case the total height is smaller than min-height or
     // larger than max-height.
     LayoutUnit rowsSize =
         totalGrowth + computeTrackBasedLogicalHeight(sizingData);
     bool checkMinSize = minSize && rowsSize < minSize;
     bool checkMaxSize = maxSize != -1 && rowsSize > maxSize;
     if (checkMinSize || checkMaxSize) {
       LayoutUnit freeSpace = checkMaxSize ? maxSize : LayoutUnit(-1);
       freeSpace = std::max(freeSpace, minSize) -
-                  guttersSize(ForRows, 0, m_grid.numTracks(ForRows),
+                  guttersSize(sizingData.grid(), ForRows, 0,
+                              sizingData.grid().numTracks(ForRows),
                               sizingData.sizingOperation);
 
       flexFraction = findFlexFactorUnitSize(
           tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()),
-          ForRows, freeSpace);
+          ForRows, freeSpace, sizingData);
 
       totalGrowth = LayoutUnit(0);
       computeFlexSizedTracksGrowth(ForRows, tracks, flexibleSizedTracksIndex,
-                                   flexFraction, increments, totalGrowth);
+                                   flexFraction, increments, totalGrowth,
+                                   sizingData);
     }
   }
 
   size_t i = 0;
   for (auto trackIndex : flexibleSizedTracksIndex) {
     auto& track = tracks[trackIndex];
     if (LayoutUnit increment = increments[i++])
       track.setBaseSize(track.baseSize() + increment);
   }
   freeSpace -= totalGrowth;
   growthLimitsWithoutMaximization += totalGrowth;
 }
 
 void LayoutGrid::computeFlexSizedTracksGrowth(
     GridTrackSizingDirection direction,
     Vector<GridTrack>& tracks,
     const Vector<size_t>& flexibleSizedTracksIndex,
     double flexFraction,
     Vector<LayoutUnit>& increments,
-    LayoutUnit& totalGrowth) const {
+    LayoutUnit& totalGrowth,
+    const GridSizingData& sizingData) const {
   size_t numFlexTracks = flexibleSizedTracksIndex.size();
   DCHECK_EQ(increments.size(), numFlexTracks);
   for (size_t i = 0; i < numFlexTracks; ++i) {
     size_t trackIndex = flexibleSizedTracksIndex[i];
-    auto trackSize = gridTrackSize(direction, trackIndex);
+    auto trackSize = gridTrackSize(direction, trackIndex, sizingData);
     DCHECK(trackSize.maxTrackBreadth().isFlex());
     LayoutUnit oldBaseSize = tracks[trackIndex].baseSize();
     LayoutUnit newBaseSize =
         std::max(oldBaseSize,
                  LayoutUnit(flexFraction * trackSize.maxTrackBreadth().flex()));
     increments[i] = newBaseSize - oldBaseSize;
     totalGrowth += increments[i];
   }
 }
 
@@ skipping 29 matching lines @@
          trackLength.isMaxContent());
   return LayoutUnit(infinity);
 }
 
 double LayoutGrid::computeFlexFactorUnitSize(
     const Vector<GridTrack>& tracks,
     GridTrackSizingDirection direction,
     double flexFactorSum,
     LayoutUnit& leftOverSpace,
     const Vector<size_t, 8>& flexibleTracksIndexes,
+    const GridSizingData& sizingData,
     std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const {
   // We want to avoid the effect of flex factors sum below 1 making the factor
   // unit size to grow exponentially.
   double hypotheticalFactorUnitSize =
       leftOverSpace / std::max<double>(1, flexFactorSum);
 
   // product of the hypothetical "flex factor unit" and any flexible track's
   // "flex factor" must be grater than such track's "base size".
   std::unique_ptr<TrackIndexSet> additionalTracksToTreatAsInflexible =
       std::move(tracksToTreatAsInflexible);
   bool validFlexFactorUnit = true;
   for (auto index : flexibleTracksIndexes) {
     if (additionalTracksToTreatAsInflexible &&
         additionalTracksToTreatAsInflexible->contains(index))
       continue;
     LayoutUnit baseSize = tracks[index].baseSize();
     double flexFactor =
-        gridTrackSize(direction, index).maxTrackBreadth().flex();
+        gridTrackSize(direction, index, sizingData).maxTrackBreadth().flex();
     // treating all such tracks as inflexible.
     if (baseSize > hypotheticalFactorUnitSize * flexFactor) {
       leftOverSpace -= baseSize;
       flexFactorSum -= flexFactor;
       if (!additionalTracksToTreatAsInflexible)
         additionalTracksToTreatAsInflexible = makeUnique<TrackIndexSet>();
       additionalTracksToTreatAsInflexible->add(index);
       validFlexFactorUnit = false;
     }
   }
-  if (!validFlexFactorUnit)
+  if (!validFlexFactorUnit) {
     return computeFlexFactorUnitSize(
         tracks, direction, flexFactorSum, leftOverSpace, flexibleTracksIndexes,
-        std::move(additionalTracksToTreatAsInflexible));
+        sizingData, std::move(additionalTracksToTreatAsInflexible));
+  }
   return hypotheticalFactorUnitSize;
 }
 
-double LayoutGrid::findFlexFactorUnitSize(const Vector<GridTrack>& tracks,
-                                          const GridSpan& tracksSpan,
-                                          GridTrackSizingDirection direction,
-                                          LayoutUnit leftOverSpace) const {
+double LayoutGrid::findFlexFactorUnitSize(
+    const Vector<GridTrack>& tracks,
+    const GridSpan& tracksSpan,
+    GridTrackSizingDirection direction,
+    LayoutUnit leftOverSpace,
+    const GridSizingData& sizingData) const {
   if (leftOverSpace <= 0)
     return 0;
 
   double flexFactorSum = 0;
   Vector<size_t, 8> flexibleTracksIndexes;
   for (const auto& trackIndex : tracksSpan) {
-    GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
+    GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingData);
     if (!trackSize.maxTrackBreadth().isFlex()) {
       leftOverSpace -= tracks[trackIndex].baseSize();
     } else {
       flexibleTracksIndexes.append(trackIndex);
       flexFactorSum += trackSize.maxTrackBreadth().flex();
     }
   }
 
   // The function is not called if we don't have <flex> grid tracks
   ASSERT(!flexibleTracksIndexes.isEmpty());
 
   return computeFlexFactorUnitSize(tracks, direction, flexFactorSum,
-                                   leftOverSpace, flexibleTracksIndexes);
+                                   leftOverSpace, flexibleTracksIndexes,
+                                   sizingData);
 }
 
 static bool hasOverrideContainingBlockContentSizeForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) {
   return direction == ForColumns
              ? child.hasOverrideContainingBlockLogicalWidth()
              : child.hasOverrideContainingBlockLogicalHeight();
 }
 
@@ skipping 20 matching lines @@
     GridTrackSizingDirection direction) {
   if (direction == ForColumns)
     return child.hasRelativeLogicalWidth() ||
            child.styleRef().logicalWidth().isIntrinsicOrAuto();
   return child.hasRelativeLogicalHeight() ||
          child.styleRef().logicalHeight().isIntrinsicOrAuto();
 }
 
 const GridTrackSize& LayoutGrid::rawGridTrackSize(
     GridTrackSizingDirection direction,
-    size_t translatedIndex) const {
+    size_t translatedIndex,
+    const GridSizingData& sizingData) const {
   bool isRowAxis = direction == ForColumns;
   const Vector<GridTrackSize>& trackStyles =
       isRowAxis ? styleRef().gridTemplateColumns()
                 : styleRef().gridTemplateRows();
   const Vector<GridTrackSize>& autoRepeatTrackStyles =
       isRowAxis ? styleRef().gridAutoRepeatColumns()
                 : styleRef().gridAutoRepeatRows();
   const Vector<GridTrackSize>& autoTrackStyles =
       isRowAxis ? styleRef().gridAutoColumns() : styleRef().gridAutoRows();
   size_t insertionPoint = isRowAxis
                               ? styleRef().gridAutoRepeatColumnsInsertionPoint()
                               : styleRef().gridAutoRepeatRowsInsertionPoint();
-  size_t autoRepeatTracksCount = autoRepeatCountForDirection(direction);
+  size_t autoRepeatTracksCount = sizingData.grid().autoRepeatTracks(direction);
 
   // We should not use GridPositionsResolver::explicitGridXXXCount() for this
   // because the explicit grid might be larger than the number of tracks in
   // grid-template-rows|columns (if grid-template-areas is specified for
   // example).
   size_t explicitTracksCount = trackStyles.size() + autoRepeatTracksCount;
 
   int untranslatedIndexAsInt =
-      translatedIndex + m_grid.smallestTrackStart(direction);
+      translatedIndex + sizingData.grid().smallestTrackStart(direction);
   size_t autoTrackStylesSize = autoTrackStyles.size();
   if (untranslatedIndexAsInt < 0) {
     int index = untranslatedIndexAsInt % static_cast<int>(autoTrackStylesSize);
     // We need to traspose the index because the first negative implicit line
     // will get the last defined auto track and so on.
     index += index ? autoTrackStylesSize : 0;
     return autoTrackStyles[index];
   }
 
   size_t untranslatedIndex = static_cast<size_t>(untranslatedIndexAsInt);
   if (untranslatedIndex >= explicitTracksCount)
     return autoTrackStyles[(untranslatedIndex - explicitTracksCount) %
                            autoTrackStylesSize];
 
   if (LIKELY(!autoRepeatTracksCount) || untranslatedIndex < insertionPoint)
     return trackStyles[untranslatedIndex];
 
   if (untranslatedIndex < (insertionPoint + autoRepeatTracksCount)) {
     size_t autoRepeatLocalIndex = untranslatedIndexAsInt - insertionPoint;
     return autoRepeatTrackStyles[autoRepeatLocalIndex %
                                  autoRepeatTrackStyles.size()];
   }
 
   return trackStyles[untranslatedIndex - autoRepeatTracksCount];
 }
 
-GridTrackSize LayoutGrid::gridTrackSize(GridTrackSizingDirection direction,
-                                        size_t translatedIndex,
-                                        SizingOperation sizingOperation) const {
+GridTrackSize LayoutGrid::gridTrackSize(
+    GridTrackSizingDirection direction,
+    size_t translatedIndex,
+    const GridSizingData& sizingData) const {
   // Collapse empty auto repeat tracks if auto-fit.
-  if (m_grid.hasAutoRepeatEmptyTracks(direction) &&
-      m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
+  if (sizingData.grid().hasAutoRepeatEmptyTracks(direction) &&
+      sizingData.grid().isEmptyAutoRepeatTrack(direction, translatedIndex))
     return {Length(Fixed), LengthTrackSizing};
 
-  const GridTrackSize& trackSize = rawGridTrackSize(direction, translatedIndex);
+  const GridTrackSize& trackSize =
+      rawGridTrackSize(direction, translatedIndex, sizingData);
   if (trackSize.isFitContent())
     return trackSize;
 
   GridLength minTrackBreadth = trackSize.minTrackBreadth();
   GridLength maxTrackBreadth = trackSize.maxTrackBreadth();
   // If the logical width/height of the grid container is indefinite, percentage
   // values are treated as <auto>.
   if (minTrackBreadth.hasPercentage() || maxTrackBreadth.hasPercentage()) {
     // For the inline axis this only happens when we're computing the intrinsic
     // sizes (AvailableSpaceIndefinite).
-    if ((sizingOperation == IntrinsicSizeComputation) ||
+    if ((sizingData.sizingOperation == IntrinsicSizeComputation) ||
         (direction == ForRows && !cachedHasDefiniteLogicalHeight())) {
       if (minTrackBreadth.hasPercentage())
         minTrackBreadth = Length(Auto);
       if (maxTrackBreadth.hasPercentage())
         maxTrackBreadth = Length(Auto);
     }
   }
 
   // Flex sizes are invalid as a min sizing function. However we still can have
   // a flexible |minTrackBreadth| if the track had a flex size directly (e.g.
@@ skipping 200 matching lines @@
   }
 
  private:
   LayoutBox* m_gridItem;
   GridSpan m_gridSpan;
 };
 
 bool LayoutGrid::spanningItemCrossesFlexibleSizedTracks(
     const GridSpan& span,
     GridTrackSizingDirection direction,
-    SizingOperation sizingOperation) const {
+    const GridSizingData& sizingData) const {
   for (const auto& trackPosition : span) {
     const GridTrackSize& trackSize =
-        gridTrackSize(direction, trackPosition, sizingOperation);
+        gridTrackSize(direction, trackPosition, sizingData);
     if (trackSize.minTrackBreadth().isFlex() ||
         trackSize.maxTrackBreadth().isFlex())
       return true;
   }
 
   return false;
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctions(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData) const {
   sizingData.itemsSortedByIncreasingSpan.shrink(0);
-  if (m_grid.hasGridItems()) {
+  const Grid& grid = sizingData.grid();
+  if (grid.hasGridItems()) {
     HashSet<LayoutBox*> itemsSet;
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
-      GridIterator iterator(m_grid, direction, trackIndex);
+      GridIterator iterator(grid, direction, trackIndex);
       GridTrack& track = (direction == ForColumns)
                              ? sizingData.columnTracks[trackIndex]
                              : sizingData.rowTracks[trackIndex];
       while (LayoutBox* gridItem = iterator.nextGridItem()) {
         if (itemsSet.add(gridItem).isNewEntry) {
-          const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
+          const GridSpan& span = grid.gridItemSpan(*gridItem, direction);
           if (span.integerSpan() == 1) {
             resolveContentBasedTrackSizingFunctionsForNonSpanningItems(
                 direction, span, *gridItem, track, sizingData);
-          } else if (!spanningItemCrossesFlexibleSizedTracks(
-                         span, direction, sizingData.sizingOperation)) {
+          } else if (!spanningItemCrossesFlexibleSizedTracks(span, direction,
+                                                             sizingData)) {
             sizingData.itemsSortedByIncreasingSpan.append(
                 GridItemWithSpan(*gridItem, span));
           }
         }
       }
     }
     std::sort(sizingData.itemsSortedByIncreasingSpan.begin(),
               sizingData.itemsSortedByIncreasingSpan.end());
   }
 
@@ skipping 24 matching lines @@
   }
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(
     GridTrackSizingDirection direction,
     const GridSpan& span,
     LayoutBox& gridItem,
     GridTrack& track,
     GridSizingData& sizingData) const {
   const size_t trackPosition = span.startLine();
-  GridTrackSize trackSize =
-      gridTrackSize(direction, trackPosition, sizingData.sizingOperation);
+  GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData);
 
   if (trackSize.hasMinContentMinTrackBreadth())
     track.setBaseSize(std::max(
         track.baseSize(), minContentForChild(gridItem, direction, sizingData)));
   else if (trackSize.hasMaxContentMinTrackBreadth())
     track.setBaseSize(std::max(
         track.baseSize(), maxContentForChild(gridItem, direction, sizingData)));
   else if (trackSize.hasAutoMinTrackBreadth())
     track.setBaseSize(std::max(
         track.baseSize(), minSizeForChild(gridItem, direction, sizingData)));
@@ skipping 169 matching lines @@
   for (auto it = gridItemsWithSpan.rangeStart; it != gridItemsWithSpan.rangeEnd;
        ++it) {
     GridItemWithSpan& gridItemWithSpan = *it;
     ASSERT(gridItemWithSpan.getGridSpan().integerSpan() > 1);
     const GridSpan& itemSpan = gridItemWithSpan.getGridSpan();
 
     sizingData.growBeyondGrowthLimitsTracks.shrink(0);
     sizingData.filteredTracks.shrink(0);
     LayoutUnit spanningTracksSize;
     for (const auto& trackPosition : itemSpan) {
-      GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
+      GridTrackSize trackSize =
+          gridTrackSize(direction, trackPosition, sizingData);
       GridTrack& track = (direction == ForColumns)
                              ? sizingData.columnTracks[trackPosition]
                              : sizingData.rowTracks[trackPosition];
       spanningTracksSize +=
           trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
       if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
         continue;
 
       sizingData.filteredTracks.append(&track);
 
       if (trackShouldGrowBeyondGrowthLimitsForTrackSizeComputationPhase(
               phase, trackSize))
         sizingData.growBeyondGrowthLimitsTracks.append(&track);
     }
 
     if (sizingData.filteredTracks.isEmpty())
       continue;
 
     spanningTracksSize +=
-        guttersSize(direction, itemSpan.startLine(), itemSpan.integerSpan(),
-                    sizingData.sizingOperation);
+        guttersSize(sizingData.grid(), direction, itemSpan.startLine(),
+                    itemSpan.integerSpan(), sizingData.sizingOperation);
 
     LayoutUnit extraSpace =
         currentItemSizeForTrackSizeComputationPhase(
             phase, gridItemWithSpan.gridItem(), direction, sizingData) -
         spanningTracksSize;
     extraSpace = extraSpace.clampNegativeToZero();
     auto& tracksToGrowBeyondGrowthLimits =
         sizingData.growBeyondGrowthLimitsTracks.isEmpty()
             ? sizingData.filteredTracks
             : sizingData.growBeyondGrowthLimitsTracks;
@@ skipping 117 matching lines @@
 
 #if ENABLE(ASSERT)
 bool LayoutGrid::tracksAreWiderThanMinTrackBreadth(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData) const {
   const Vector<GridTrack>& tracks = (direction == ForColumns)
                                         ? sizingData.columnTracks
                                         : sizingData.rowTracks;
   LayoutUnit maxSize = sizingData.availableSpace().clampNegativeToZero();
   for (size_t i = 0; i < tracks.size(); ++i) {
-    GridTrackSize trackSize =
-        gridTrackSize(direction, i, sizingData.sizingOperation);
+    GridTrackSize trackSize = gridTrackSize(direction, i, sizingData);
     if (computeUsedBreadthOfMinLength(trackSize, maxSize) >
         tracks[i].baseSize())
       return false;
   }
   return true;
 }
 #endif
 
 size_t LayoutGrid::computeAutoRepeatTracksCount(
     GridTrackSizingDirection direction,
@@ skipping 479 matching lines @@
   bool isRowAxis = direction == ForColumns;
   auto& positions = isRowAxis ? m_columnPositions : m_rowPositions;
   size_t numPositions = positions.size();
   LayoutUnit offsetBetweenTracks =
       isRowAxis ? m_offsetBetweenColumns : m_offsetBetweenRows;
 
   Vector<LayoutUnit> tracks;
   if (numPositions < 2)
     return tracks;
 
+  DCHECK(!m_grid.needsItemsPlacement());
   bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
   LayoutUnit gap = !hasCollapsedTracks
                        ? gridGapForDirection(direction, TrackSizing)
                        : LayoutUnit();
   tracks.reserveCapacity(numPositions - 1);
   for (size_t i = 0; i < numPositions - 2; ++i)
     tracks.append(positions[i + 1] - positions[i] - offsetBetweenTracks - gap);
   tracks.append(positions[numPositions - 1] - positions[numPositions - 2]);
 
   if (!hasCollapsedTracks)
@@ skipping 38 matching lines @@
            contentAlignmentNormalBehavior()) != ContentDistributionStretch))
     return;
 
   // Spec defines auto-sized tracks as the ones with an 'auto' max-sizing
   // function.
   Vector<GridTrack>& tracks = (direction == ForColumns)
                                   ? sizingData.columnTracks
                                   : sizingData.rowTracks;
   Vector<unsigned> autoSizedTracksIndex;
   for (unsigned i = 0; i < tracks.size(); ++i) {
-    const GridTrackSize& trackSize = gridTrackSize(direction, i);
+    const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
     if (trackSize.hasAutoMaxTrackBreadth())
       autoSizedTracksIndex.append(i);
   }
 
   unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
   if (numberOfAutoSizedTracks < 1)
     return;
 
   LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
   for (const auto& trackIndex : autoSizedTracksIndex) {
@@ skipping 53 matching lines @@
     // before stretching, are not set yet.
     applyStretchAlignmentToChildIfNeeded(*child);
 
     child->layoutIfNeeded();
 
     // We need pending layouts to be done in order to compute auto-margins
     // properly.
     updateAutoMarginsInColumnAxisIfNeeded(*child);
     updateAutoMarginsInRowAxisIfNeeded(*child);
 
-    const GridArea& area = m_grid.gridItemArea(*child);
+    const GridArea& area = sizingData.grid().gridItemArea(*child);
 #if ENABLE(ASSERT)
     ASSERT(area.columns.startLine() < sizingData.columnTracks.size());
     ASSERT(area.rows.startLine() < sizingData.rowTracks.size());
 #endif
     child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
     // Keep track of children overflowing their grid area as we might need to
     // paint them even if the grid-area is not visible. Using physical
     // dimensions for simplicity, so we can forget about orthogonalty.
     LayoutUnit childGridAreaHeight =
@@ skipping 123 matching lines @@
         end = logicalWidth() -
               translateRTLCoordinate(m_columnPositions[endLine]) -
               borderLogicalRight();
     } else {
       end = m_rowPositions[endLine] - borderBefore();
     }
 
     // These vectors store line positions including gaps, but we shouldn't
     // consider them for the edges of the grid.
     if (endLine > 0 && endLine < lastLine) {
-      end -= guttersSize(direction, endLine - 1, 2, TrackSizing);
+      DCHECK(!m_grid.needsItemsPlacement());
+      end -= guttersSize(m_grid, direction, endLine - 1, 2, TrackSizing);
       end -= isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
     }
   }
 
   breadth = std::max(end - start, LayoutUnit());
   offset = start;
 
   if (isForColumns && !styleRef().isLeftToRightDirection() &&
       !child.styleRef().hasStaticInlinePosition(
           child.isHorizontalWritingMode())) {
     // If the child doesn't have a static inline position (i.e. "left" and/or
     // "right" aren't "auto", we need to calculate the offset from the left
     // (even if we're in RTL).
     if (endIsAuto) {
       offset = LayoutUnit();
     } else {
       offset = translateRTLCoordinate(m_columnPositions[endLine]) -
                borderLogicalLeft();
 
       if (endLine > 0 && endLine < lastLine) {
-        offset += guttersSize(direction, endLine - 1, 2, TrackSizing);
+        DCHECK(!m_grid.needsItemsPlacement());
+        offset += guttersSize(m_grid, direction, endLine - 1, 2, TrackSizing);
         offset += isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
       }
     }
   }
 }
 
 LayoutUnit LayoutGrid::assumedRowsSizeForOrthogonalChild(
     const LayoutBox& child,
-    SizingOperation sizingOperation) const {
+    const GridSizingData& sizingData) const {
   DCHECK(isOrthogonalChild(child));
-  const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
+  const Grid& grid = sizingData.grid();
+  const GridSpan& span = grid.gridItemSpan(child, ForRows);
   LayoutUnit gridAreaSize;
   bool gridAreaIsIndefinite = false;
   LayoutUnit containingBlockAvailableSize =
       containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
   for (auto trackPosition : span) {
     GridLength maxTrackSize =
-        gridTrackSize(ForRows, trackPosition, sizingOperation)
-            .maxTrackBreadth();
+        gridTrackSize(ForRows, trackPosition, sizingData).maxTrackBreadth();
     if (maxTrackSize.isContentSized() || maxTrackSize.isFlex())
       gridAreaIsIndefinite = true;
     else
       gridAreaSize +=
           valueForLength(maxTrackSize.length(), containingBlockAvailableSize);
   }
 
-  gridAreaSize += guttersSize(ForRows, span.startLine(), span.integerSpan(),
-                              sizingOperation);
+  gridAreaSize += guttersSize(grid, ForRows, span.startLine(),
+                              span.integerSpan(), sizingData.sizingOperation);
 
   return gridAreaIsIndefinite
              ? std::max(child.maxPreferredLogicalWidth(), gridAreaSize)
              : gridAreaSize;
 }
 
 LayoutUnit LayoutGrid::gridAreaBreadthForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction,
     const GridSizingData& sizingData) const {
   // To determine the column track's size based on an orthogonal grid item we
   // need it's logical height, which may depend on the row track's size. It's
   // possible that the row tracks sizing logic has not been performed yet, so we
   // will need to do an estimation.
   if (direction == ForRows &&
       sizingData.sizingState == GridSizingData::ColumnSizingFirstIteration)
-    return assumedRowsSizeForOrthogonalChild(child, sizingData.sizingOperation);
+    return assumedRowsSizeForOrthogonalChild(child, sizingData);
 
   const Vector<GridTrack>& tracks =
       direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
-  const GridSpan& span = m_grid.gridItemSpan(child, direction);
+  const GridSpan& span = sizingData.grid().gridItemSpan(child, direction);
   LayoutUnit gridAreaBreadth;
   for (const auto& trackPosition : span)
     gridAreaBreadth += tracks[trackPosition].baseSize();
 
   gridAreaBreadth +=
-      guttersSize(direction, span.startLine(), span.integerSpan(),
-                  sizingData.sizingOperation);
+      guttersSize(sizingData.grid(), direction, span.startLine(),
+                  span.integerSpan(), sizingData.sizingOperation);
 
   return gridAreaBreadth;
 }
 
 LayoutUnit LayoutGrid::gridAreaBreadthForChildIncludingAlignmentOffsets(
     const LayoutBox& child,
     GridTrackSizingDirection direction,
     const GridSizingData& sizingData) const {
   // We need the cached value when available because Content Distribution
   // alignment properties may have some influence in the final grid area
   // breadth.
   const Vector<GridTrack>& tracks = (direction == ForColumns)
                                         ? sizingData.columnTracks
                                         : sizingData.rowTracks;
-  const GridSpan& span = m_grid.gridItemSpan(child, direction);
+  const GridSpan& span = sizingData.grid().gridItemSpan(child, direction);
   const Vector<LayoutUnit>& linePositions =
       (direction == ForColumns) ? m_columnPositions : m_rowPositions;
   LayoutUnit initialTrackPosition = linePositions[span.startLine()];
   LayoutUnit finalTrackPosition = linePositions[span.endLine() - 1];
   // Track Positions vector stores the 'start' grid line of each track, so we
   // have to add last track's baseSize.
   return finalTrackPosition - initialTrackPosition +
          tracks[span.endLine() - 1].baseSize();
 }
 
@@ skipping 15 matching lines @@
   size_t numberOfTracks = tracks.size();
   size_t numberOfLines = numberOfTracks + 1;
   size_t lastLine = numberOfLines - 1;
   ContentAlignmentData offset = computeContentPositionAndDistributionOffset(
       direction, sizingData.freeSpace(direction), numberOfTracks);
   auto& positions = isRowAxis ? m_columnPositions : m_rowPositions;
   positions.resize(numberOfLines);
   auto borderAndPadding =
       isRowAxis ? borderAndPaddingLogicalLeft() : borderAndPaddingBefore();
   positions[0] = borderAndPadding + offset.positionOffset;
+  const Grid& grid = sizingData.grid();
   if (numberOfLines > 1) {
     // If we have collapsed tracks we just ignore gaps here and add them later
     // as we might not compute the gap between two consecutive tracks without
     // examining the surrounding ones.
-    bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
+    bool hasCollapsedTracks = grid.hasAutoRepeatEmptyTracks(direction);
     LayoutUnit gap =
         !hasCollapsedTracks
             ? gridGapForDirection(direction, sizingData.sizingOperation)
             : LayoutUnit();
     size_t nextToLastLine = numberOfLines - 2;
     for (size_t i = 0; i < nextToLastLine; ++i)
       positions[i + 1] =
           positions[i] + offset.distributionOffset + tracks[i].baseSize() + gap;
     positions[lastLine] =
         positions[nextToLastLine] + tracks[nextToLastLine].baseSize();
 
     // Adjust collapsed gaps. Collapsed tracks cause the surrounding gutters to
     // collapse (they coincide exactly) except on the edges of the grid where
     // they become 0.
     if (hasCollapsedTracks) {
       gap = gridGapForDirection(direction, sizingData.sizingOperation);
       size_t remainingEmptyTracks =
-          m_grid.autoRepeatEmptyTracks(direction)->size();
+          grid.autoRepeatEmptyTracks(direction)->size();
       LayoutUnit gapAccumulator;
       for (size_t i = 1; i < lastLine; ++i) {
-        if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) {
+        if (grid.isEmptyAutoRepeatTrack(direction, i - 1)) {
           --remainingEmptyTracks;
         } else {
           // Add gap between consecutive non empty tracks. Add it also just once
           // for an arbitrary number of empty tracks between two non empty ones.
           bool allRemainingTracksAreEmpty =
               remainingEmptyTracks == (lastLine - i);
           if (!allRemainingTracksAreEmpty ||
-              !m_grid.isEmptyAutoRepeatTrack(direction, i))
+              !grid.isEmptyAutoRepeatTrack(direction, i))
             gapAccumulator += gap;
         }
         positions[i] += gapAccumulator;
       }
       positions[lastLine] += gapAccumulator;
     }
   }
   auto& offsetBetweenTracks =
       isRowAxis ? m_offsetBetweenColumns : m_offsetBetweenRows;
   offsetBetweenTracks = offset.distributionOffset;
@@ skipping 446 matching lines @@
       break;
   }
 
   ASSERT_NOT_REACHED();
   return GridAxisStart;
 }
 
 LayoutUnit LayoutGrid::columnAxisOffsetForChild(
     const LayoutBox& child,
     GridSizingData& sizingData) const {
-  const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
+  const GridSpan& rowsSpan = sizingData.grid().gridItemSpan(child, ForRows);
   size_t childStartLine = rowsSpan.startLine();
   LayoutUnit startOfRow = m_rowPositions[childStartLine];
   LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
   if (hasAutoMarginsInColumnAxis(child))
     return startPosition;
   GridAxisPosition axisPosition = columnAxisPositionForChild(child);
   switch (axisPosition) {
     case GridAxisStart:
       return startPosition;
     case GridAxisEnd:
@@ skipping 22 matching lines @@
                                   : offsetFromStartPosition / 2);
     }
   }
 
   ASSERT_NOT_REACHED();
   return LayoutUnit();
 }
 
 LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child,
                                              GridSizingData& sizingData) const {
-  const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
+  const GridSpan& columnsSpan =
+      sizingData.grid().gridItemSpan(child, ForColumns);
   size_t childStartLine = columnsSpan.startLine();
   LayoutUnit startOfColumn = m_columnPositions[childStartLine];
   LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
   if (hasAutoMarginsInRowAxis(child))
     return startPosition;
   GridAxisPosition axisPosition = rowAxisPositionForChild(child);
   switch (axisPosition) {
     case GridAxisStart:
       return startPosition;
     case GridAxisEnd:
@@ skipping 196 matching lines @@
   // See comment in findChildLogicalPosition() about why we need sometimes to
   // translate from RTL to LTR the rowAxisOffset coordinate.
   return LayoutPoint(style()->isLeftToRightDirection()
                          ? rowAxisOffset
                          : translateRTLCoordinate(rowAxisOffset),
                      columnAxisOffset);
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) const {
+  DCHECK(!m_grid.needsItemsPlacement());
   if (m_grid.hasGridItems())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
 size_t LayoutGrid::numTracks(GridTrackSizingDirection direction,
                              const Grid& grid) const {
   // Due to limitations in our internal representation, we cannot know the
   // number of columns from m_grid *if* there is no row (because m_grid would be
   // empty). That's why in that case we need to get it from the style. Note that
   // we know for sure that there are't any implicit tracks, because not having
   // rows implies that there are no "normal" children (out-of-flow children are
   // not stored in m_grid).
+  DCHECK(!grid.needsItemsPlacement());
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink