[css-grid] Convert GridRepresentation into an actual class

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 24 matching lines @@
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 static const int infinity = -1;
 
 class GridItemWithSpan;
 
+void LayoutGrid::Grid::ensureGridSize(size_t maximumRowSize,
+                                      size_t maximumColumnSize) {
+  const size_t oldRowSize = numRows();
+  if (maximumRowSize > oldRowSize) {
+    m_grid.grow(maximumRowSize);
+    for (size_t row = oldRowSize; row < numRows(); ++row)
+      m_grid[row].grow(numColumns());
+  }
+
+  if (maximumColumnSize > numColumns()) {
+    for (size_t row = 0; row < numRows(); ++row)
+      m_grid[row].grow(maximumColumnSize);
+  }
+}
+
+void LayoutGrid::Grid::insert(LayoutBox& child, const GridArea& area) {
+  DCHECK(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::Grid::clear() {
+  m_grid.resize(0);
+}
+
 class GridTrack {
  public:
   GridTrack() : m_infinitelyGrowable(false) {}
 
   LayoutUnit baseSize() const {
     DCHECK(isGrowthLimitBiggerThanBaseSize());
     return m_baseSize;
   }
 
   LayoutUnit growthLimit() const {
@@ skipping 90 matching lines @@
   ForbidInfinity,
 };
 
 class LayoutGrid::GridIterator {
   WTF_MAKE_NONCOPYABLE(GridIterator);
 
  public:
   // |direction| is the direction that is fixed to |fixedTrackIndex| so e.g
   // GridIterator(m_grid, ForColumns, 1) will walk over the rows of the 2nd
   // column.
-  GridIterator(const GridRepresentation& grid,
+  GridIterator(const Grid& grid,
                GridTrackSizingDirection direction,
                size_t fixedTrackIndex,
                size_t varyingTrackIndex = 0)
-      : m_grid(grid),
+      : m_grid(grid.m_grid),
         m_direction(direction),
         m_rowIndex((direction == ForColumns) ? varyingTrackIndex
                                              : fixedTrackIndex),
         m_columnIndex((direction == ForColumns) ? fixedTrackIndex
                                                 : varyingTrackIndex),
         m_childIndex(0) {
     DCHECK(!m_grid.isEmpty());
     DCHECK(!m_grid[0].isEmpty());
     DCHECK(m_rowIndex < m_grid.size());
     DCHECK(m_columnIndex < m_grid[0].size());
@@ skipping 63 matching lines @@
         // Advance the iterator to avoid an infinite loop where we would return
         // the same grid area over and over.
         ++varyingTrackIndex;
         return result;
       }
     }
     return nullptr;
   }
 
  private:
-  const GridRepresentation& m_grid;
+  const GridAsMatrix& m_grid;
   GridTrackSizingDirection m_direction;
   size_t m_rowIndex;
   size_t m_columnIndex;
   size_t m_childIndex;
 };
 
 struct LayoutGrid::GridSizingData {
   WTF_MAKE_NONCOPYABLE(GridSizingData);
   STACK_ALLOCATED();
 
@@ skipping 139 matching lines @@
 }
 
 bool LayoutGrid::namedGridLinesDefinitionDidChange(
     const ComputedStyle& oldStyle) const {
   return oldStyle.namedGridRowLines() != styleRef().namedGridRowLines() ||
          oldStyle.namedGridColumnLines() != styleRef().namedGridColumnLines();
 }
 
 size_t LayoutGrid::gridColumnCount() const {
   DCHECK(!m_gridIsDirty);
-  return m_grid.size() ? m_grid[0].size() : 0;
+  return m_grid.numColumns();
 }
 
 size_t LayoutGrid::gridRowCount() const {
   DCHECK(!m_gridIsDirty);
-  return m_grid.size();
+  return m_grid.numRows();
 }
 
 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(),
@@ skipping 1371 matching lines @@
     GridTrackSize trackSize =
         gridTrackSize(direction, i, sizingData.sizingOperation);
     if (computeUsedBreadthOfMinLength(trackSize, maxSize) >
         tracks[i].baseSize())
       return false;
   }
   return true;
 }
 #endif
 
-void LayoutGrid::ensureGridSize(size_t maximumRowSize,
-                                size_t maximumColumnSize) {
-  const size_t oldRowSize = gridRowCount();
-  if (maximumRowSize > oldRowSize) {
-    m_grid.grow(maximumRowSize);
-    for (size_t row = oldRowSize; row < gridRowCount(); ++row)
-      m_grid[row].grow(gridColumnCount());
-  }
-
-  if (maximumColumnSize > gridColumnCount()) {
-    for (size_t row = 0; row < gridRowCount(); ++row)
-      m_grid[row].grow(maximumColumnSize);
-  }
-}
-
-void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridArea& area) {
-  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);
-  }
-}
-
 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 171 matching lines @@
     if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
       GridSpan majorAxisPositions =
           (autoPlacementMajorAxisDirection() == ForColumns) ? area.columns
                                                             : area.rows;
       if (majorAxisPositions.isIndefinite())
         autoMajorAxisAutoGridItems.append(child);
       else
         specifiedMajorAxisAutoGridItems.append(child);
       continue;
     }
-    insertItemIntoGrid(*child, area);
+    m_grid.insert(*child, area);
   }
 
 #if ENABLE(ASSERT)
   if (!m_gridItemArea.isEmpty()) {
     DCHECK_GE(gridRowCount(), GridPositionsResolver::explicitGridRowCount(
                                   *style(), m_autoRepeatRows));
     DCHECK_GE(gridColumnCount(), GridPositionsResolver::explicitGridColumnCount(
                                      *style(), m_autoRepeatColumns));
   }
 #endif
@@ skipping 65 matching lines @@
                                          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.grow(maximumRowIndex + abs(m_smallestRowStart));
-  for (auto& column : m_grid)
-    column.grow(maximumColumnIndex + abs(m_smallestColumnStart));
+  m_grid.ensureGridSize(maximumRowIndex + abs(m_smallestRowStart),
+                        maximumColumnIndex + abs(m_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 =
@@ skipping 38 matching lines @@
                           isGridAutoFlowDense
                               ? 0
                               : minorAxisCursors.get(majorAxisInitialPosition));
     std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(
         majorAxisPositions.integerSpan(), minorAxisSpanSize);
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           *autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
 
     m_gridItemArea.set(autoGridItem, *emptyGridArea);
-    insertItemIntoGrid(*autoGridItem, *emptyGridArea);
+    m_grid.insert(*autoGridItem, *emptyGridArea);
 
     if (!isGridAutoFlowDense)
       minorAxisCursors.set(majorAxisInitialPosition,
                            isForColumns ? emptyGridArea->rows.startLine()
                                         : emptyGridArea->columns.startLine());
   }
 }
 
 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(
     const Vector<LayoutBox*>& autoGridItems) {
@@ skipping 87 matching lines @@
       minorAxisAutoPlacementCursor = 0;
     }
 
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           gridItem, autoPlacementMinorAxisDirection(),
           GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
   }
 
   m_gridItemArea.set(&gridItem, *emptyGridArea);
-  insertItemIntoGrid(gridItem, *emptyGridArea);
+  m_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 {
   return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
 }
 
 void LayoutGrid::dirtyGrid() {
   if (m_gridIsDirty)
     return;
 
-  m_grid.resize(0);
+  m_grid.clear();
   m_gridItemArea.clear();
   m_gridItemsOverflowingGridArea.resize(0);
   m_gridItemsIndexesMap.clear();
   m_autoRepeatColumns = 0;
   m_autoRepeatRows = 0;
   m_gridIsDirty = true;
   m_autoRepeatEmptyColumns = nullptr;
   m_autoRepeatEmptyRows = nullptr;
 }
 
@@ skipping 692 matching lines @@
 
   return baseline + beforeMarginInLineDirection(direction);
 }
 
 bool LayoutGrid::isInlineBaselineAlignedChild(const LayoutBox* child) const {
   return alignSelfForChild(*child).position() == ItemPositionBaseline &&
          !isOrthogonalChild(*child) && !hasAutoMarginsInColumnAxis(*child);
 }
 
 int LayoutGrid::firstLineBoxBaseline() const {
-  if (isWritingModeRoot() || m_grid.isEmpty())
+  if (isWritingModeRoot() || m_gridItemArea.isEmpty())
     return -1;
   const LayoutBox* baselineChild = nullptr;
   const LayoutBox* firstChild = nullptr;
   bool isBaselineAligned = false;
   // Finding the first grid item in grid order.
-  for (size_t column = 0; !isBaselineAligned && column < m_grid[0].size();
+  for (size_t column = 0; !isBaselineAligned && column < m_grid.numColumns();
        column++) {
-    for (size_t index = 0; index < m_grid[0][column].size(); index++) {
-      const LayoutBox* child = m_grid[0][column][index];
+    for (size_t index = 0; index < m_grid.cell(0, column).size(); index++) {
+      const LayoutBox* child = m_grid.cell(0, column)[index];
       DCHECK(!child->isOutOfFlowPositioned());
       // If an item participates in baseline alignmen, we select such item.
       if (isInlineBaselineAlignedChild(child)) {
         // TODO (lajava): self-baseline and content-baseline alignment
         // still not implemented.
         baselineChild = child;
         isBaselineAligned = true;
         break;
       }
       if (!baselineChild) {
@@ skipping 472 matching lines @@
 }
 
 size_t LayoutGrid::numTracks(GridTrackSizingDirection direction) 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).
   if (direction == ForRows)
-    return m_grid.size();
+    return m_grid.numRows();
 
-  return m_grid.size() ? m_grid[0].size()
-                       : GridPositionsResolver::explicitGridColumnCount(
-                             styleRef(), m_autoRepeatColumns);
+  return m_grid.numRows() ? m_grid.numColumns()
+                          : GridPositionsResolver::explicitGridColumnCount(
+                                styleRef(), m_autoRepeatColumns);
 }
 
 }  // namespace blink