[css-grid] Pass Grid as argument to the items' placements methods

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 614 matching lines @@
     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)
     size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
     if (autoRepeatColumns &&
         autoRepeatColumns !=
             computeAutoRepeatTracksCount(ForColumns, TrackSizing))
       dirtyGrid();
-    placeItemsOnGrid(TrackSizing);
+    placeItemsOnGrid(m_grid, TrackSizing);
 
     GridSizingData sizingData(numTracks(ForColumns), numTracks(ForRows));
 
     // 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 137 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)->placeItemsOnGrid(const_cast<Grid&>(m_grid),
+                                                  IntrinsicSizeComputation);
 
   GridSizingData sizingData(numTracks(ForColumns), numTracks(ForRows));
   computeTrackSizesForIndefiniteSize(ForColumns, sizingData, minLogicalWidth,
                                      maxLogicalWidth);
 
   LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
   minLogicalWidth += scrollbarWidth;
   maxLogicalWidth += scrollbarWidth;
 }
 
@@ skipping 1232 matching lines @@
       if (!iterator.nextGridItem()) {
         if (!emptyTrackIndexes)
           emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
         emptyTrackIndexes->add(trackIndex);
       }
     }
   }
   return emptyTrackIndexes;
 }
 
-void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
+void LayoutGrid::placeItemsOnGrid(LayoutGrid::Grid& grid,
+                                  SizingOperation sizingOperation) {
   if (!m_gridIsDirty)
     return;
 
-  DCHECK(!m_grid.hasGridItems());
+  DCHECK(!grid.hasGridItems());
 
   size_t autoRepeatColumns;
   size_t autoRepeatRows =
       computeAutoRepeatTracksCount(ForRows, sizingOperation);
   if (sizingOperation == IntrinsicSizeComputation) {
     autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
   } else {
     autoRepeatColumns =
         computeAutoRepeatTracksCount(ForColumns, sizingOperation);
   }
   m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
 
-  populateExplicitGridAndOrderIterator();
+  populateExplicitGridAndOrderIterator(grid);
 
   // We clear the dirty bit here as the grid sizes have been updated.
   m_gridIsDirty = false;
   bool hasAnyOrthogonalGridItem = false;
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
 #if ENABLE(ASSERT)
-  DCHECK(!m_grid.hasAnyGridItemPaintOrder());
+  DCHECK(!grid.hasAnyGridItemPaintOrder());
 #endif
-  DCHECK(!m_grid.hasAnyOrthogonalGridItem());
+  DCHECK(!grid.hasAnyOrthogonalGridItem());
   size_t childIndex = 0;
-  for (LayoutBox* child = m_grid.orderIterator().first(); child;
-       child = m_grid.orderIterator().next()) {
+  for (LayoutBox* child = grid.orderIterator().first(); child;
+       child = grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
     hasAnyOrthogonalGridItem =
         hasAnyOrthogonalGridItem || isOrthogonalChild(*child);
-    m_grid.setGridItemPaintOrder(*child, childIndex++);
+    grid.setGridItemPaintOrder(*child, childIndex++);
 
-    GridArea area = m_grid.gridItemArea(*child);
+    GridArea area = grid.gridItemArea(*child);
     if (!area.rows.isIndefinite())
-      area.rows.translate(abs(m_grid.smallestTrackStart(ForRows)));
+      area.rows.translate(abs(grid.smallestTrackStart(ForRows)));
     if (!area.columns.isIndefinite())
-      area.columns.translate(abs(m_grid.smallestTrackStart(ForColumns)));
+      area.columns.translate(abs(grid.smallestTrackStart(ForColumns)));
 
     if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
-      m_grid.setGridItemArea(*child, area);
+      grid.setGridItemArea(*child, area);
       GridSpan majorAxisPositions =
           (autoPlacementMajorAxisDirection() == ForColumns) ? area.columns
                                                             : area.rows;
       if (majorAxisPositions.isIndefinite())
         autoMajorAxisAutoGridItems.append(child);
       else
         specifiedMajorAxisAutoGridItems.append(child);
       continue;
     }
-    m_grid.insert(*child, area);
+    grid.insert(*child, area);
   }
   m_grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
 
 #if ENABLE(ASSERT)
-  if (m_grid.hasGridItems()) {
-    DCHECK_GE(m_grid.numTracks(ForRows),
+  if (grid.hasGridItems()) {
+    DCHECK_GE(grid.numTracks(ForRows),
               GridPositionsResolver::explicitGridRowCount(
-                  *style(), m_grid.autoRepeatTracks(ForRows)));
-    DCHECK_GE(m_grid.numTracks(ForColumns),
+                  *style(), grid.autoRepeatTracks(ForRows)));
+    DCHECK_GE(grid.numTracks(ForColumns),
               GridPositionsResolver::explicitGridColumnCount(
-                  *style(), m_grid.autoRepeatTracks(ForColumns)));
+                  *style(), grid.autoRepeatTracks(ForColumns)));
   }
 #endif
 
-  placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems);
-  placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
+  placeSpecifiedMajorAxisItemsOnGrid(grid, specifiedMajorAxisAutoGridItems);
+  placeAutoMajorAxisItemsOnGrid(grid, autoMajorAxisAutoGridItems);
 
-  m_grid.shrinkToFit();
+  grid.shrinkToFit();
 
   // Compute collapsable tracks for auto-fit.
-  m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
-  m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
+  grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
+  grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
 
 #if ENABLE(ASSERT)
-  for (LayoutBox* child = m_grid.orderIterator().first(); child;
-       child = m_grid.orderIterator().next()) {
+  for (LayoutBox* child = grid.orderIterator().first(); child;
+       child = grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
-    GridArea area = m_grid.gridItemArea(*child);
+    GridArea area = grid.gridItemArea(*child);
     ASSERT(area.rows.isTranslatedDefinite() &&
            area.columns.isTranslatedDefinite());
   }
 #endif
 }
 
-void LayoutGrid::populateExplicitGridAndOrderIterator() {
-  OrderIteratorPopulator populator(m_grid.orderIterator());
+void LayoutGrid::populateExplicitGridAndOrderIterator(Grid& grid) const {
+  OrderIteratorPopulator populator(grid.orderIterator());
   int smallestRowStart = 0;
   int smallestColumnStart = 0;
 
-  size_t autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
-  size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
+  size_t autoRepeatRows = grid.autoRepeatTracks(ForRows);
+  size_t autoRepeatColumns = grid.autoRepeatTracks(ForColumns);
   size_t maximumRowIndex =
       GridPositionsResolver::explicitGridRowCount(*style(), autoRepeatRows);
   size_t maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(
       *style(), autoRepeatColumns);
 
   for (LayoutBox* child = firstInFlowChildBox(); child;
        child = child->nextInFlowSiblingBox()) {
     populator.collectChild(child);
 
     // This function bypasses the cache (gridItemArea()) as it is used to
     // build it.
     GridSpan rowPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
             *style(), *child, ForRows, autoRepeatRows);
     GridSpan columnPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
             *style(), *child, ForColumns, autoRepeatColumns);
-    m_grid.setGridItemArea(*child, GridArea(rowPositions, columnPositions));
+    grid.setGridItemArea(*child, GridArea(rowPositions, columnPositions));
 
     // |positions| is 0 if we need to run the auto-placement algorithm.
     if (!rowPositions.isIndefinite()) {
       smallestRowStart =
           std::min(smallestRowStart, rowPositions.untranslatedStartLine());
       maximumRowIndex =
           std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
     } else {
       // Grow the grid for items with a definite row span, getting the largest
       // such span.
       size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
           *style(), *child, ForRows);
       maximumRowIndex = std::max(maximumRowIndex, spanSize);
     }
 
     if (!columnPositions.isIndefinite()) {
       smallestColumnStart = std::min(smallestColumnStart,
                                      columnPositions.untranslatedStartLine());
       maximumColumnIndex = std::max<int>(maximumColumnIndex,
                                          columnPositions.untranslatedEndLine());
     } else {
       // Grow the grid for items with a definite column span, getting the
       // largest such span.
       size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
           *style(), *child, ForColumns);
       maximumColumnIndex = std::max(maximumColumnIndex, spanSize);
     }
   }
 
-  m_grid.setSmallestTracksStart(smallestRowStart, smallestColumnStart);
-  m_grid.ensureGridSize(maximumRowIndex + abs(smallestRowStart),
-                        maximumColumnIndex + abs(smallestColumnStart));
+  grid.setSmallestTracksStart(smallestRowStart, smallestColumnStart);
+  grid.ensureGridSize(maximumRowIndex + abs(smallestRowStart),
+                      maximumColumnIndex + abs(smallestColumnStart));
 }
 
 std::unique_ptr<GridArea>
 LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
     const LayoutBox& gridItem,
     GridTrackSizingDirection specifiedDirection,
     const GridSpan& specifiedPositions) const {
   GridTrackSizingDirection crossDirection =
       specifiedDirection == ForColumns ? ForRows : ForColumns;
   const size_t endOfCrossDirection = m_grid.numTracks(crossDirection);
   size_t crossDirectionSpanSize =
       GridPositionsResolver::spanSizeForAutoPlacedItem(*style(), gridItem,
                                                        crossDirection);
   GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(
       endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
   return wrapUnique(
       new GridArea(specifiedDirection == ForColumns ? crossDirectionPositions
                                                     : specifiedPositions,
                    specifiedDirection == ForColumns ? specifiedPositions
                                                     : crossDirectionPositions));
 }
 
 void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(
-    const Vector<LayoutBox*>& autoGridItems) {
+    Grid& grid,
+    const Vector<LayoutBox*>& autoGridItems) const {
   bool isForColumns = autoPlacementMajorAxisDirection() == ForColumns;
   bool isGridAutoFlowDense = style()->isGridAutoFlowAlgorithmDense();
 
   // Mapping between the major axis tracks (rows or columns) and the last
   // auto-placed item's position inserted on that track. This is needed to
   // implement "sparse" packing for items locked to a given track.
   // See http://dev.w3.org/csswg/css-grid/#auto-placement-algo
   HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash,
           WTF::UnsignedWithZeroKeyHashTraits<unsigned>>
       minorAxisCursors;
 
   for (const auto& autoGridItem : autoGridItems) {
     GridSpan majorAxisPositions =
-        m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
+        grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
     ASSERT(majorAxisPositions.isTranslatedDefinite());
-    DCHECK(
-        !m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection())
-             .isTranslatedDefinite());
+    DCHECK(!grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection())
+                .isTranslatedDefinite());
     size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
         *style(), *autoGridItem, autoPlacementMinorAxisDirection());
     unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
 
-    GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(),
-                          majorAxisPositions.startLine(),
-                          isGridAutoFlowDense
-                              ? 0
-                              : minorAxisCursors.get(majorAxisInitialPosition));
+    GridIterator iterator(
+        grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(),
+        isGridAutoFlowDense ? 0
+                            : minorAxisCursors.get(majorAxisInitialPosition));
     std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(
         majorAxisPositions.integerSpan(), minorAxisSpanSize);
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           *autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
 
-    m_grid.insert(*autoGridItem, *emptyGridArea);
+    grid.insert(*autoGridItem, *emptyGridArea);
 
     if (!isGridAutoFlowDense)
       minorAxisCursors.set(majorAxisInitialPosition,
                            isForColumns ? emptyGridArea->rows.startLine()
                                         : emptyGridArea->columns.startLine());
   }
 }
 
 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(
-    const Vector<LayoutBox*>& autoGridItems) {
+    Grid& grid,
+    const Vector<LayoutBox*>& autoGridItems) const {
   std::pair<size_t, size_t> autoPlacementCursor = std::make_pair(0, 0);
   bool isGridAutoFlowDense = style()->isGridAutoFlowAlgorithmDense();
 
   for (const auto& autoGridItem : autoGridItems) {
-    placeAutoMajorAxisItemOnGrid(*autoGridItem, autoPlacementCursor);
+    placeAutoMajorAxisItemOnGrid(grid, *autoGridItem, autoPlacementCursor);
 
     // If grid-auto-flow is dense, reset auto-placement cursor.
     if (isGridAutoFlowDense) {
       autoPlacementCursor.first = 0;
       autoPlacementCursor.second = 0;
     }
   }
 }
 
 void LayoutGrid::placeAutoMajorAxisItemOnGrid(
+    Grid& grid,
     LayoutBox& gridItem,
-    std::pair<size_t, size_t>& autoPlacementCursor) {
+    std::pair<size_t, size_t>& autoPlacementCursor) const {
   GridSpan minorAxisPositions =
-      m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
-  DCHECK(!m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection())
+      grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
+  DCHECK(!grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection())
               .isTranslatedDefinite());
   size_t majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
       *style(), gridItem, autoPlacementMajorAxisDirection());
 
   const size_t endOfMajorAxis =
-      m_grid.numTracks(autoPlacementMajorAxisDirection());
+      grid.numTracks(autoPlacementMajorAxisDirection());
   size_t majorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.second
           : autoPlacementCursor.first;
   size_t minorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.first
           : autoPlacementCursor.second;
 
   std::unique_ptr<GridArea> emptyGridArea;
   if (minorAxisPositions.isTranslatedDefinite()) {
     // Move to the next track in major axis if initial position in minor axis is
     // before auto-placement cursor.
     if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
       majorAxisAutoPlacementCursor++;
 
     if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
-      GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(),
+      GridIterator iterator(grid, autoPlacementMinorAxisDirection(),
                             minorAxisPositions.startLine(),
                             majorAxisAutoPlacementCursor);
       emptyGridArea = iterator.nextEmptyGridArea(
           minorAxisPositions.integerSpan(), majorAxisSpanSize);
     }
 
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           gridItem, autoPlacementMinorAxisDirection(), minorAxisPositions);
   } else {
     size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
         *style(), gridItem, autoPlacementMinorAxisDirection());
 
     for (size_t majorAxisIndex = majorAxisAutoPlacementCursor;
          majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
-      GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(),
+      GridIterator iterator(grid, autoPlacementMajorAxisDirection(),
                             majorAxisIndex, minorAxisAutoPlacementCursor);
       emptyGridArea =
           iterator.nextEmptyGridArea(majorAxisSpanSize, minorAxisSpanSize);
 
       if (emptyGridArea) {
         // Check that it fits in the minor axis direction, as we shouldn't grow
         // in that direction here (it was already managed in
         // populateExplicitGridAndOrderIterator()).
         size_t minorAxisFinalPositionIndex =
             autoPlacementMinorAxisDirection() == ForColumns
                 ? emptyGridArea->columns.endLine()
                 : emptyGridArea->rows.endLine();
         const size_t endOfMinorAxis =
-            m_grid.numTracks(autoPlacementMinorAxisDirection());
+            grid.numTracks(autoPlacementMinorAxisDirection());
         if (minorAxisFinalPositionIndex <= endOfMinorAxis)
           break;
 
         // Discard empty grid area as it does not fit in the minor axis
         // direction. We don't need to create a new empty grid area yet as we
         // might find a valid one in the next iteration.
         emptyGridArea = nullptr;
       }
 
       // As we're moving to the next track in the major axis we should reset the
       // auto-placement cursor in the minor axis.
       minorAxisAutoPlacementCursor = 0;
     }
 
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           gridItem, autoPlacementMinorAxisDirection(),
           GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
   }
 
-  m_grid.insert(gridItem, *emptyGridArea);
+  grid.insert(gridItem, *emptyGridArea);
   // Move auto-placement cursor to the new position.
   autoPlacementCursor.first = emptyGridArea->rows.startLine();
   autoPlacementCursor.second = emptyGridArea->columns.startLine();
 }
 
 GridTrackSizingDirection LayoutGrid::autoPlacementMajorAxisDirection() const {
   return style()->isGridAutoFlowDirectionColumn() ? ForColumns : ForRows;
 }
 
 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const {
@@ skipping 1203 matching lines @@
   if (direction == ForRows)
     return m_grid.numTracks(ForRows);
 
   return m_grid.numTracks(ForRows)
              ? m_grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), m_grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink