[css-grid] Move more LayoutGrid attributes to Grid class

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

Index: third_party/WebKit/Source/core/layout/LayoutGrid.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
index d210ac81ce679c04faa54e1fb8bffeef8f3723af..a4f00f0e3742e6a289d9ac55975cefb5af2f50ca 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
@@ -42,17 +42,23 @@ static const int infinity = -1;
 
 class GridItemWithSpan;
 
+size_t LayoutGrid::Grid::numTracks(GridTrackSizingDirection direction) const {
+  if (direction == ForRows)
+    return m_grid.size();
+  return m_grid.size() ? m_grid[0].size() : 0;
+}
+
 void LayoutGrid::Grid::ensureGridSize(size_t maximumRowSize,
                                       size_t maximumColumnSize) {
-  const size_t oldRowSize = numRows();
+  const size_t oldRowSize = numTracks(ForRows);
   if (maximumRowSize > oldRowSize) {
     m_grid.grow(maximumRowSize);
-    for (size_t row = oldRowSize; row < numRows(); ++row)
-      m_grid[row].grow(numColumns());
+    for (size_t row = oldRowSize; row < numTracks(ForRows); ++row)
+      m_grid[row].grow(numTracks(ForColumns));
   }
 
-  if (maximumColumnSize > numColumns()) {
-    for (size_t row = 0; row < numRows(); ++row)
+  if (maximumColumnSize > numTracks(ForColumns)) {
+    for (size_t row = 0; row < numTracks(ForRows); ++row)
       m_grid[row].grow(maximumColumnSize);
   }
 }
@@ -108,6 +114,54 @@ bool LayoutGrid::Grid::hasAnyGridItemPaintOrder() const {
 }
 #endif
 
+void LayoutGrid::Grid::setAutoRepeatTracks(size_t autoRepeatRows,
+                                           size_t 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(
+    std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyColumns) {
+  m_autoRepeatEmptyColumns = std::move(autoRepeatEmptyColumns);
+}
+
+void LayoutGrid::Grid::setAutoRepeatEmptyRows(
+    std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyRows) {
+  m_autoRepeatEmptyRows = std::move(autoRepeatEmptyRows);
+}
+
+bool LayoutGrid::Grid::hasAutoRepeatEmptyTracks(
+    GridTrackSizingDirection direction) const {
+  return direction == ForColumns ? !!m_autoRepeatEmptyColumns
+                                 : !!m_autoRepeatEmptyRows;
+}
+
+bool LayoutGrid::Grid::isEmptyAutoRepeatTrack(
+    GridTrackSizingDirection direction,
+    size_t line) const {
+  DCHECK(hasAutoRepeatEmptyTracks(direction));
+  return autoRepeatEmptyTracks(direction)->contains(line);
+}
+
+LayoutGrid::OrderedTrackIndexSet* LayoutGrid::Grid::autoRepeatEmptyTracks(
+    GridTrackSizingDirection direction) const {
+  DCHECK(hasAutoRepeatEmptyTracks(direction));
+  return direction == ForColumns ? m_autoRepeatEmptyColumns.get()
+                                 : m_autoRepeatEmptyRows.get();
+}
+
+GridSpan LayoutGrid::Grid::gridItemSpan(
+    const LayoutBox& gridItem,
+    GridTrackSizingDirection direction) const {
+  GridArea area = gridItemArea(gridItem);
+  return direction == ForColumns ? area.columns : area.rows;
+}
+
 void LayoutGrid::Grid::clear() {
   m_grid.resize(0);
   m_gridItemArea.clear();
@@ -115,6 +169,10 @@ void LayoutGrid::Grid::clear() {
   m_hasAnyOrthogonalChildren = false;
   m_smallestRowStart = 0;
   m_smallestColumnStart = 0;
+  m_autoRepeatColumns = 0;
+  m_autoRepeatRows = 0;
+  m_autoRepeatEmptyColumns = nullptr;
+  m_autoRepeatEmptyRows = nullptr;
 }
 
 class GridTrack {
@@ -403,7 +461,7 @@ struct GridItemsSpanGroupRange {
 };
 
 LayoutGrid::LayoutGrid(Element* element)
-    : LayoutBlock(element), m_gridIsDirty(true), m_orderIterator(this) {
+    : LayoutBlock(element), m_grid(this), m_gridIsDirty(true) {
   ASSERT(!childrenInline());
 }
 
@@ -473,16 +531,6 @@ bool LayoutGrid::namedGridLinesDefinitionDidChange(
          oldStyle.namedGridColumnLines() != styleRef().namedGridColumnLines();
 }
 
-size_t LayoutGrid::gridColumnCount() const {
-  DCHECK(!m_gridIsDirty);
-  return m_grid.numColumns();
-}
-
-size_t LayoutGrid::gridRowCount() const {
-  DCHECK(!m_gridIsDirty);
-  return m_grid.numRows();
-}
-
 LayoutUnit LayoutGrid::computeTrackBasedLogicalHeight(
     const GridSizingData& sizingData) const {
   LayoutUnit logicalHeight;
@@ -503,10 +551,8 @@ void LayoutGrid::computeTrackSizesForDefiniteSize(
   DCHECK(sizingData.isValidTransition(direction));
   sizingData.setAvailableSpace(availableSpace);
   sizingData.freeSpace(direction) =
-      availableSpace -
-      guttersSize(direction, 0,
-                  direction == ForRows ? gridRowCount() : gridColumnCount(),
-                  sizingData.sizingOperation);
+      availableSpace - guttersSize(direction, 0, m_grid.numTracks(direction),
+                                   sizingData.sizingOperation);
   sizingData.sizingOperation = TrackSizing;
 
   LayoutUnit baseSizes, growthLimits;
@@ -580,8 +626,9 @@ void LayoutGrid::layoutBlock(bool relayoutChildren) {
     // 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 !=
+    size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
+    if (autoRepeatColumns &&
+        autoRepeatColumns !=
             computeAutoRepeatTracksCount(ForColumns, TrackSizing))
       dirtyGrid();
     placeItemsOnGrid(TrackSizing);
@@ -655,19 +702,6 @@ void LayoutGrid::layoutBlock(bool relayoutChildren) {
   clearNeedsLayout();
 }
 
-bool LayoutGrid::hasAutoRepeatEmptyTracks(
-    GridTrackSizingDirection direction) const {
-  return direction == ForColumns ? !!m_autoRepeatEmptyColumns
-                                 : !!m_autoRepeatEmptyRows;
-}
-
-bool LayoutGrid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction,
-                                        size_t line) const {
-  DCHECK(hasAutoRepeatEmptyTracks(direction));
-  return direction == ForColumns ? m_autoRepeatEmptyColumns->contains(line)
-                                 : m_autoRepeatEmptyRows->contains(line);
-}
-
 LayoutUnit LayoutGrid::gridGapForDirection(
     GridTrackSizingDirection direction,
     SizingOperation sizingOperation) const {
@@ -691,11 +725,10 @@ LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction,
   if (span <= 1)
     return LayoutUnit();
 
-  bool isRowAxis = direction == ForColumns;
   LayoutUnit gap = gridGapForDirection(direction, sizingOperation);
 
   // Fast path, no collapsing tracks.
-  if (!hasAutoRepeatEmptyTracks(direction))
+  if (!m_grid.hasAutoRepeatEmptyTracks(direction))
     return gap * (span - 1);
 
   // If there are collapsing tracks we need to be sure that gutters are properly
@@ -708,12 +741,12 @@ LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction,
   size_t endLine = startLine + span;
 
   for (size_t line = startLine; line < endLine - 1; ++line) {
-    if (!isEmptyAutoRepeatTrack(direction, line))
+    if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
       gapAccumulator += gap;
   }
 
   // The above loop adds one extra gap for trailing collapsed tracks.
-  if (gapAccumulator && isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+  if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
     DCHECK_GE(gapAccumulator, gap);
     gapAccumulator -= gap;
   }
@@ -721,10 +754,9 @@ LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction,
   // 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 && isEmptyAutoRepeatTrack(direction, startLine)) {
+  if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
     size_t nonEmptyTracksBeforeStartLine = startLine;
-    auto begin = isRowAxis ? m_autoRepeatEmptyColumns->begin()
-                           : m_autoRepeatEmptyRows->begin();
+    auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
     for (auto it = begin; *it != startLine; ++it) {
       DCHECK(nonEmptyTracksBeforeStartLine);
       --nonEmptyTracksBeforeStartLine;
@@ -736,14 +768,11 @@ LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction,
   // 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 (isEmptyAutoRepeatTrack(direction, endLine - 1)) {
-    size_t nonEmptyTracksAfterEndLine =
-        (isRowAxis ? gridColumnCount() : gridRowCount()) - endLine;
-    auto currentEmptyTrack = isRowAxis
-                                 ? m_autoRepeatEmptyColumns->find(endLine - 1)
-                                 : m_autoRepeatEmptyRows->find(endLine - 1);
-    auto endEmptyTrack = isRowAxis ? m_autoRepeatEmptyColumns->end()
-                                   : m_autoRepeatEmptyRows->end();
+  if (m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+    size_t nonEmptyTracksAfterEndLine = m_grid.numTracks(direction) - endLine;
+    auto currentEmptyTrack =
+        m_grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
+    auto endEmptyTrack = m_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) {
@@ -931,7 +960,7 @@ void LayoutGrid::computeUsedBreadthOfGridTracks(
       for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
         GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
         while (LayoutBox* gridItem = iterator.nextGridItem()) {
-          const GridSpan span = cachedGridSpan(*gridItem, direction);
+          const GridSpan span = m_grid.gridItemSpan(*gridItem, direction);

[jfernandez, 2016/11/24 17:28:14]

Why not using const GridSpan& span like you do some lines below. 

[svillar, 2016/11/25 12:31:42]

I'm not changing that, it was in the original code. But I can take the chance to
change it if you want.

 
           // Do not include already processed items.
           if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
@@ -972,9 +1001,9 @@ void LayoutGrid::computeUsedBreadthOfGridTracks(
     bool checkMaxSize = maxSize != -1 && rowsSize > maxSize;
     if (checkMinSize || checkMaxSize) {
       LayoutUnit freeSpace = checkMaxSize ? maxSize : LayoutUnit(-1);
-      freeSpace =
-          std::max(freeSpace, minSize) -
-          guttersSize(ForRows, 0, gridRowCount(), sizingData.sizingOperation);
+      freeSpace = std::max(freeSpace, minSize) -
+                  guttersSize(ForRows, 0, m_grid.numTracks(ForRows),
+                              sizingData.sizingOperation);
 
       flexFraction = findFlexFactorUnitSize(
           tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()),
@@ -1209,8 +1238,8 @@ GridTrackSize LayoutGrid::gridTrackSize(GridTrackSizingDirection direction,
                                         size_t translatedIndex,
                                         SizingOperation sizingOperation) const {
   // Collapse empty auto repeat tracks if auto-fit.
-  if (hasAutoRepeatEmptyTracks(direction) &&
-      isEmptyAutoRepeatTrack(direction, translatedIndex))
+  if (m_grid.hasAutoRepeatEmptyTracks(direction) &&
+      m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
     return {Length(Fixed), LengthTrackSizing};
 
   const GridTrackSize& trackSize = rawGridTrackSize(direction, translatedIndex);
@@ -1461,7 +1490,7 @@ void LayoutGrid::resolveContentBasedTrackSizingFunctions(
                              : sizingData.rowTracks[trackIndex];
       while (LayoutBox* gridItem = iterator.nextGridItem()) {
         if (itemsSet.add(gridItem).isNewEntry) {
-          const GridSpan& span = cachedGridSpan(*gridItem, direction);
+          const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
           if (span.integerSpan() == 1) {
             resolveContentBasedTrackSizingFunctionsForNonSpanningItems(
                 direction, span, *gridItem, track, sizingData);
@@ -2016,13 +2045,16 @@ void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
 
   DCHECK(!m_grid.hasInFlowGridItems());
 
+  size_t autoRepeatColumns;

[jfernandez, 2016/11/24 17:28:14]

I guess it's not that important, but we could save some assignment and a few
lines if we define the autoRepeatColumns with a ternary instruction. Perhaps the
line is too long and end up not very clear, so I trust your taste on following
or not this suggestion.

[svillar, 2016/11/25 12:31:42]

Yeah I like the ternary too. The thing is that with the new formatting it
becomes really messy sometimes.

In any case there is a hidden reason why I would not pay much attention to these
lines, and it's that they're going to go away soon ;)

+  size_t autoRepeatRows =
+      computeAutoRepeatTracksCount(ForRows, sizingOperation);
   if (sizingOperation == IntrinsicSizeComputation) {
-    m_autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
+    autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
   } else {
-    m_autoRepeatColumns =
+    autoRepeatColumns =
         computeAutoRepeatTracksCount(ForColumns, sizingOperation);
   }
-  m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
+  m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
 
   populateExplicitGridAndOrderIterator();
 
@@ -2036,8 +2068,8 @@ void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
 #endif
   DCHECK(!m_grid.hasAnyOrthogonalChildren());
   size_t childIndex = 0;
-  for (LayoutBox* child = m_orderIterator.first(); child;
-       child = m_orderIterator.next()) {
+  for (LayoutBox* child = m_grid.orderIterator().first(); child;
+       child = m_grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
@@ -2065,10 +2097,12 @@ void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
 
 #if ENABLE(ASSERT)
   if (m_grid.hasInFlowGridItems()) {
-    DCHECK_GE(gridRowCount(), GridPositionsResolver::explicitGridRowCount(
-                                  *style(), m_autoRepeatRows));
-    DCHECK_GE(gridColumnCount(), GridPositionsResolver::explicitGridColumnCount(
-                                     *style(), m_autoRepeatColumns));
+    DCHECK_GE(m_grid.numTracks(ForRows),
+              GridPositionsResolver::explicitGridRowCount(
+                  *style(), m_grid.autoRepeatTracks(ForRows)));
+    DCHECK_GE(m_grid.numTracks(ForColumns),
+              GridPositionsResolver::explicitGridColumnCount(
+                  *style(), m_grid.autoRepeatTracks(ForColumns)));
   }
 #endif
 
@@ -2078,12 +2112,12 @@ void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
   m_grid.shrinkToFit();
 
   // Compute collapsable tracks for auto-fit.
-  m_autoRepeatEmptyColumns = computeEmptyTracksForAutoRepeat(ForColumns);
-  m_autoRepeatEmptyRows = computeEmptyTracksForAutoRepeat(ForRows);
+  m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
+  m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
 
 #if ENABLE(ASSERT)
-  for (LayoutBox* child = m_orderIterator.first(); child;
-       child = m_orderIterator.next()) {
+  for (LayoutBox* child = m_grid.orderIterator().first(); child;
+       child = m_grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
@@ -2095,14 +2129,16 @@ void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
 }
 
 void LayoutGrid::populateExplicitGridAndOrderIterator() {
-  OrderIteratorPopulator populator(m_orderIterator);
+  OrderIteratorPopulator populator(m_grid.orderIterator());
   int smallestRowStart = 0;
   int smallestColumnStart = 0;
 
+  size_t autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
+  size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
   size_t maximumRowIndex =
-      GridPositionsResolver::explicitGridRowCount(*style(), m_autoRepeatRows);
+      GridPositionsResolver::explicitGridRowCount(*style(), autoRepeatRows);
   size_t maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(
-      *style(), m_autoRepeatColumns);
+      *style(), autoRepeatColumns);
 
   for (LayoutBox* child = firstInFlowChildBox(); child;
        child = child->nextInFlowSiblingBox()) {
@@ -2112,10 +2148,10 @@ void LayoutGrid::populateExplicitGridAndOrderIterator() {
     // build it.
     GridSpan rowPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
-            *style(), *child, ForRows, m_autoRepeatRows);
+            *style(), *child, ForRows, autoRepeatRows);
     GridSpan columnPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
-            *style(), *child, ForColumns, m_autoRepeatColumns);
+            *style(), *child, ForColumns, autoRepeatColumns);
     m_grid.setGridItemArea(*child, GridArea(rowPositions, columnPositions));
 
     // |positions| is 0 if we need to run the auto-placement algorithm.
@@ -2158,8 +2194,7 @@ LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
     const GridSpan& specifiedPositions) const {
   GridTrackSizingDirection crossDirection =
       specifiedDirection == ForColumns ? ForRows : ForColumns;
-  const size_t endOfCrossDirection =
-      crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
+  const size_t endOfCrossDirection = m_grid.numTracks(crossDirection);
   size_t crossDirectionSpanSize =
       GridPositionsResolver::spanSizeForAutoPlacedItem(*style(), gridItem,
                                                        crossDirection);
@@ -2187,10 +2222,11 @@ void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(
 
   for (const auto& autoGridItem : autoGridItems) {
     GridSpan majorAxisPositions =
-        cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
+        m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
     ASSERT(majorAxisPositions.isTranslatedDefinite());
-    ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection())
-                .isTranslatedDefinite());
+    DCHECK(
+        !m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection())
+             .isTranslatedDefinite());
     size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
         *style(), *autoGridItem, autoPlacementMinorAxisDirection());
     unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
@@ -2236,15 +2272,14 @@ void LayoutGrid::placeAutoMajorAxisItemOnGrid(
     LayoutBox& gridItem,
     std::pair<size_t, size_t>& autoPlacementCursor) {
   GridSpan minorAxisPositions =
-      cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
-  ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection())
+      m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
+  DCHECK(!m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection())
               .isTranslatedDefinite());
   size_t majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
       *style(), gridItem, autoPlacementMajorAxisDirection());
 
   const size_t endOfMajorAxis =
-      (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount()
-                                                        : gridRowCount();
+      m_grid.numTracks(autoPlacementMajorAxisDirection());
   size_t majorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.second
@@ -2292,8 +2327,7 @@ void LayoutGrid::placeAutoMajorAxisItemOnGrid(
                 ? emptyGridArea->columns.endLine()
                 : emptyGridArea->rows.endLine();
         const size_t endOfMinorAxis =
-            autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount()
-                                                            : gridRowCount();
+            m_grid.numTracks(autoPlacementMinorAxisDirection());
         if (minorAxisFinalPositionIndex <= endOfMinorAxis)
           break;
 
@@ -2334,11 +2368,7 @@ void LayoutGrid::dirtyGrid() {
 
   m_grid.clear();
   m_gridItemsOverflowingGridArea.resize(0);
-  m_autoRepeatColumns = 0;
-  m_autoRepeatRows = 0;
   m_gridIsDirty = true;
-  m_autoRepeatEmptyColumns = nullptr;
-  m_autoRepeatEmptyRows = nullptr;
 }
 
 Vector<LayoutUnit> LayoutGrid::trackSizesForComputedStyle(
@@ -2353,7 +2383,7 @@ Vector<LayoutUnit> LayoutGrid::trackSizesForComputedStyle(
   if (numPositions < 2)
     return tracks;
 
-  bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
+  bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
   LayoutUnit gap = !hasCollapsedTracks
                        ? gridGapForDirection(direction, TrackSizing)
                        : LayoutUnit();
@@ -2365,19 +2395,19 @@ Vector<LayoutUnit> LayoutGrid::trackSizesForComputedStyle(
   if (!hasCollapsedTracks)
     return tracks;
 
-  size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size()
-                                          : m_autoRepeatEmptyRows->size();
+  size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
   size_t lastLine = tracks.size();
   gap = gridGapForDirection(direction, TrackSizing);
   for (size_t i = 1; i < lastLine; ++i) {
-    if (isEmptyAutoRepeatTrack(direction, i - 1)) {
+    if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) {
       --remainingEmptyTracks;
     } else {
       // Remove the gap between consecutive non empty tracks. Remove it also
       // just once for an arbitrary number of empty tracks between two non empty
       // ones.
       bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
-      if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
+      if (!allRemainingTracksAreEmpty ||
+          !m_grid.isEmptyAutoRepeatTrack(direction, i))
         tracks[i - 1] -= gap;
     }
   }
@@ -2654,17 +2684,11 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(
   }
 }
 
-GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem,
-                                    GridTrackSizingDirection direction) const {
-  GridArea area = m_grid.gridItemArea(gridItem);
-  return direction == ForColumns ? area.columns : area.rows;
-}
-
 LayoutUnit LayoutGrid::assumedRowsSizeForOrthogonalChild(
     const LayoutBox& child,
     SizingOperation sizingOperation) const {
   DCHECK(isOrthogonalChild(child));
-  const GridSpan& span = cachedGridSpan(child, ForRows);
+  const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
   LayoutUnit gridAreaSize;
   bool gridAreaIsIndefinite = false;
   LayoutUnit containingBlockAvailableSize =
@@ -2702,7 +2726,7 @@ LayoutUnit LayoutGrid::gridAreaBreadthForChild(
 
   const Vector<GridTrack>& tracks =
       direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
-  const GridSpan& span = cachedGridSpan(child, direction);
+  const GridSpan& span = m_grid.gridItemSpan(child, direction);
   LayoutUnit gridAreaBreadth;
   for (const auto& trackPosition : span)
     gridAreaBreadth += tracks[trackPosition].baseSize();
@@ -2724,7 +2748,7 @@ LayoutUnit LayoutGrid::gridAreaBreadthForChildIncludingAlignmentOffsets(
   const Vector<GridTrack>& tracks = (direction == ForColumns)
                                         ? sizingData.columnTracks
                                         : sizingData.rowTracks;
-  const GridSpan& span = cachedGridSpan(child, direction);
+  const GridSpan& span = m_grid.gridItemSpan(child, direction);
   const Vector<LayoutUnit>& linePositions =
       (direction == ForColumns) ? m_columnPositions : m_rowPositions;
   LayoutUnit initialTrackPosition = linePositions[span.startLine()];
@@ -2764,7 +2788,7 @@ void LayoutGrid::populateGridPositionsForDirection(
     // 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 = hasAutoRepeatEmptyTracks(direction);
+    bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
     LayoutUnit gap =
         !hasCollapsedTracks
             ? gridGapForDirection(direction, sizingData.sizingOperation)
@@ -2781,11 +2805,11 @@ void LayoutGrid::populateGridPositionsForDirection(
     // they become 0.
     if (hasCollapsedTracks) {
       gap = gridGapForDirection(direction, sizingData.sizingOperation);
-      size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size()
-                                              : m_autoRepeatEmptyRows->size();
+      size_t remainingEmptyTracks =
+          m_grid.autoRepeatEmptyTracks(direction)->size();
       LayoutUnit gapAccumulator;
       for (size_t i = 1; i < lastLine; ++i) {
-        if (isEmptyAutoRepeatTrack(direction, i - 1)) {
+        if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) {
           --remainingEmptyTracks;
         } else {
           // Add gap between consecutive non empty tracks. Add it also just once
@@ -2793,7 +2817,7 @@ void LayoutGrid::populateGridPositionsForDirection(
           bool allRemainingTracksAreEmpty =
               remainingEmptyTracks == (lastLine - i);
           if (!allRemainingTracksAreEmpty ||
-              !isEmptyAutoRepeatTrack(direction, i))
+              !m_grid.isEmptyAutoRepeatTrack(direction, i))
             gapAccumulator += gap;
         }
         positions[i] += gapAccumulator;
@@ -3043,8 +3067,8 @@ int LayoutGrid::firstLineBoxBaseline() const {
   const LayoutBox* firstChild = nullptr;
   bool isBaselineAligned = false;
   // Finding the first grid item in grid order.
-  for (size_t column = 0; !isBaselineAligned && column < m_grid.numColumns();
-       column++) {
+  for (size_t column = 0;
+       !isBaselineAligned && column < m_grid.numTracks(ForColumns); column++) {
     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());
@@ -3262,7 +3286,7 @@ GridAxisPosition LayoutGrid::rowAxisPositionForChild(
 LayoutUnit LayoutGrid::columnAxisOffsetForChild(
     const LayoutBox& child,
     GridSizingData& sizingData) const {
-  const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
+  const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
   size_t childStartLine = rowsSpan.startLine();
   LayoutUnit startOfRow = m_rowPositions[childStartLine];
   LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
@@ -3305,7 +3329,7 @@ LayoutUnit LayoutGrid::columnAxisOffsetForChild(
 
 LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child,
                                              GridSizingData& sizingData) const {
-  const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
+  const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
   size_t childStartLine = columnsSpan.startLine();
   LayoutUnit startOfColumn = m_columnPositions[childStartLine];
   LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
@@ -3539,11 +3563,12 @@ size_t LayoutGrid::numTracks(GridTrackSizingDirection direction) const {
   // rows implies that there are no "normal" children (out-of-flow children are
   // not stored in m_grid).
   if (direction == ForRows)
-    return m_grid.numRows();
+    return m_grid.numTracks(ForRows);
 
-  return m_grid.numRows() ? m_grid.numColumns()
-                          : GridPositionsResolver::explicitGridColumnCount(
-                                styleRef(), m_autoRepeatColumns);
+  return m_grid.numTracks(ForRows)

[jfernandez, 2016/11/24 17:28:14]

It's not the first time I see this pattern I I have to say I don't get used to
it. It's unnatural to read that we return the number of columns if numRows is
not 0. I know this is because our internal structure requires to have rows in
order to store columns, but I thought the goal we pursued with this patch was to
decouple our logic from the grid internal structure. 

Can't we have some function that to retrieve the columns, which can check
internally if it's possible to compute them, returning 0 or a default value
otherwise ? 

Or perhaps less sophisticated, just a function that determines whether we can
compute columns or not. 

[svillar, 2016/11/25 12:31:42]

Yeah you're right. This method is basically the only one which still "knows"
that we're using a matrix to store the grid data. We should definitely fix this,
but I'd propose to do it in a followup patch.
 
Yeah, but that would force us to precompute the default value always even if not
needed. Perhaps not terribly expensive anyway.
Something like that will still mean that we know about the internal
representation.

+             ? m_grid.numTracks(ForColumns)
+             : GridPositionsResolver::explicitGridColumnCount(
+                   styleRef(), m_grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink