[css-grid] Move more LayoutGrid attributes to Grid 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;
 
+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);
   }
 }
 
 void LayoutGrid::Grid::insert(LayoutBox& child,
                               const GridArea& area,
                               bool isOrthogonalChild) {
   DCHECK(area.rows.isTranslatedDefinite() &&
          area.columns.isTranslatedDefinite());
   ensureGridSize(area.rows.endLine(), area.columns.endLine());
@@ skipping 35 matching lines @@
                                              size_t order) {
   m_gridItemsIndexesMap.set(&item, order);
 }
 
 #if ENABLE(ASSERT)
 bool LayoutGrid::Grid::hasAnyGridItemPaintOrder() const {
   return !m_gridItemsIndexesMap.isEmpty();
 }
 #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();
   m_gridItemsIndexesMap.clear();
   m_hasAnyOrthogonalChildren = false;
   m_smallestRowStart = 0;
   m_smallestColumnStart = 0;
+  m_autoRepeatColumns = 0;
+  m_autoRepeatRows = 0;
+  m_autoRepeatEmptyColumns = nullptr;
+  m_autoRepeatEmptyRows = nullptr;
 }
 
 class GridTrack {
  public:
   GridTrack() : m_infinitelyGrowable(false) {}
 
   LayoutUnit baseSize() const {
     DCHECK(isGrowthLimitBiggerThanBaseSize());
     return m_baseSize;
   }
@@ skipping 268 matching lines @@
   // compute relative sizes.
   LayoutUnit m_availableSpace;
 };
 
 struct GridItemsSpanGroupRange {
   Vector<GridItemWithSpan>::iterator rangeStart;
   Vector<GridItemWithSpan>::iterator rangeEnd;
 };
 
 LayoutGrid::LayoutGrid(Element* element)
-    : LayoutBlock(element), m_gridIsDirty(true), m_orderIterator(this) {
+    : LayoutBlock(element), m_grid(this), m_gridIsDirty(true) {
   ASSERT(!childrenInline());
 }
 
 LayoutGrid::~LayoutGrid() {}
 
 LayoutGrid* LayoutGrid::createAnonymous(Document* document) {
   LayoutGrid* layoutGrid = new LayoutGrid(nullptr);
   layoutGrid->setDocumentForAnonymous(document);
   return layoutGrid;
 }
@@ skipping 49 matching lines @@
          oldStyle.gridAutoRepeatRows().size() !=
              styleRef().gridAutoRepeatRows().size();
 }
 
 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.numColumns();
-}
-
-size_t LayoutGrid::gridRowCount() const {
-  DCHECK(!m_gridIsDirty);
-  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(),
                                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,
-                  direction == ForRows ? gridRowCount() : gridColumnCount(),
-                  sizingData.sizingOperation);
+      availableSpace - guttersSize(direction, 0, m_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,
@@ skipping 53 matching lines @@
     }
 
     updateLogicalWidth();
     m_hasDefiniteLogicalHeight = hasDefiniteLogicalHeight();
 
     TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
     // TODO(svillar): we won't need to do this once the intrinsic width
     // computation is isolated from the LayoutGrid object state (it should not
     // touch any attribute) (see crbug.com/627812)
-    if (m_autoRepeatColumns &&
-        m_autoRepeatColumns !=
+    size_t autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
+    if (autoRepeatColumns &&
+        autoRepeatColumns !=
             computeAutoRepeatTracksCount(ForColumns, TrackSizing))
       dirtyGrid();
     placeItemsOnGrid(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
@@ skipping 53 matching lines @@
 
     computeOverflow(oldClientAfterEdge);
   }
 
   updateLayerTransformAfterLayout();
   updateAfterLayout();
 
   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 {
   LayoutUnit availableSize;
   const Length& gap = direction == ForColumns ? styleRef().gridColumnGap()
                                               : styleRef().gridRowGap();
   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,
                                    size_t startLine,
                                    size_t span,
                                    SizingOperation sizingOperation) const {
   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
   // 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 (!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;
   }
 
   // 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;
     }
     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 (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) {
       DCHECK(nonEmptyTracksAfterEndLine);
       --nonEmptyTracksAfterEndLine;
     }
     if (nonEmptyTracksAfterEndLine)
       gapAccumulator += gap;
   }
 
@@ skipping 167 matching lines @@
       flexFraction = std::max(
           flexFraction,
           normalizedFlexFraction(
               tracks[trackIndex],
               gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
 
     if (m_grid.hasInFlowGridItems()) {
       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])
             continue;
 
           flexFraction = std::max(
               flexFraction,
               findFlexFactorUnitSize(
                   tracks, span, direction,
                   maxContentForChild(*gridItem, direction, sizingData)));
@@ skipping 20 matching lines @@
 
     // 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, 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()),
           ForRows, freeSpace);
 
       totalGrowth = LayoutUnit(0);
       computeFlexSizedTracksGrowth(ForRows, tracks, flexibleSizedTracksIndex,
                                    flexFraction, increments, totalGrowth);
     }
   }
@@ skipping 214 matching lines @@
                                  autoRepeatTrackStyles.size()];
   }
 
   return trackStyles[untranslatedIndex - autoRepeatTracksCount];
 }
 
 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);
   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>.
@@ skipping 230 matching lines @@
   sizingData.itemsSortedByIncreasingSpan.shrink(0);
   if (m_grid.hasInFlowGridItems()) {
     HashSet<LayoutBox*> itemsSet;
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
       GridIterator iterator(m_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 = cachedGridSpan(*gridItem, direction);
+          const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
           if (span.integerSpan() == 1) {
             resolveContentBasedTrackSizingFunctionsForNonSpanningItems(
                 direction, span, *gridItem, track, sizingData);
           } else if (!spanningItemCrossesFlexibleSizedTracks(
                          span, direction, sizingData.sizingOperation)) {
             sizingData.itemsSortedByIncreasingSpan.append(
                 GridItemWithSpan(*gridItem, span));
           }
         }
       }
@@ skipping 534 matching lines @@
   }
   return emptyTrackIndexes;
 }
 
 void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
   if (!m_gridIsDirty)
     return;
 
   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();
 
   // We clear the dirty bit here as the grid sizes have been updated.
   m_gridIsDirty = false;
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
 #if ENABLE(ASSERT)
   DCHECK(!m_grid.hasAnyGridItemPaintOrder());
 #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;
 
     m_grid.setGridItemPaintOrder(*child, childIndex++);
 
     GridArea area = m_grid.gridItemArea(*child);
     if (!area.rows.isIndefinite())
       area.rows.translate(abs(m_grid.smallestTrackStart(ForRows)));
     if (!area.columns.isIndefinite())
       area.columns.translate(abs(m_grid.smallestTrackStart(ForColumns)));
 
     if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
       m_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, isOrthogonalChild(*child));
   }
 
 #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
 
   placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems);
   placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
 
   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;
 
     GridArea area = m_grid.gridItemArea(*child);
     ASSERT(area.rows.isTranslatedDefinite() &&
            area.columns.isTranslatedDefinite());
   }
 #endif
 }
 
 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()) {
     populator.collectChild(child);
 
     // This function bypasses the cache (gridItemArea()) as it is used to
     // 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.
     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
@@ skipping 22 matching lines @@
                         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 =
-      crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
+  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) {
   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 =
-        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();
 
     GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(),
                           majorAxisPositions.startLine(),
                           isGridAutoFlowDense
                               ? 0
                               : minorAxisCursors.get(majorAxisInitialPosition));
     std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(
@@ skipping 25 matching lines @@
       autoPlacementCursor.first = 0;
       autoPlacementCursor.second = 0;
     }
   }
 }
 
 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
           : autoPlacementCursor.first;
   size_t minorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.first
           : autoPlacementCursor.second;
 
   std::unique_ptr<GridArea> emptyGridArea;
@@ skipping 27 matching lines @@
 
       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 =
-            autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount()
-                                                            : gridRowCount();
+            m_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
@@ skipping 20 matching lines @@
 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const {
   return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
 }
 
 void LayoutGrid::dirtyGrid() {
   if (m_gridIsDirty)
     return;
 
   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(
     GridTrackSizingDirection direction) const {
   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;
 
-  bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
+  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)
     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;
     }
   }
 
   return tracks;
 }
 
 static const StyleContentAlignmentData& contentAlignmentNormalBehavior() {
   static const StyleContentAlignmentData normalBehavior = {
       ContentPositionNormal, ContentDistributionStretch};
@@ skipping 256 matching lines @@
                borderLogicalLeft();
 
       if (endLine > 0 && endLine < lastLine) {
         offset += guttersSize(direction, endLine - 1, 2, TrackSizing);
         offset += isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
       }
     }
   }
 }
 
-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 =
       containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
   for (auto trackPosition : span) {
     GridLength maxTrackSize =
         gridTrackSize(ForRows, trackPosition, sizingOperation)
             .maxTrackBreadth();
     if (maxTrackSize.isContentSized() || maxTrackSize.isFlex())
       gridAreaIsIndefinite = true;
@@ skipping 17 matching lines @@
   // 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);
 
   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();
 
   gridAreaBreadth +=
       guttersSize(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 = 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()];
   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 19 matching lines @@
       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;
   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 = hasAutoRepeatEmptyTracks(direction);
+    bool hasCollapsedTracks = m_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 = 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
           // for an arbitrary number of empty tracks between two non empty ones.
           bool allRemainingTracksAreEmpty =
               remainingEmptyTracks == (lastLine - i);
           if (!allRemainingTracksAreEmpty ||
-              !isEmptyAutoRepeatTrack(direction, i))
+              !m_grid.isEmptyAutoRepeatTrack(direction, i))
             gapAccumulator += gap;
         }
         positions[i] += gapAccumulator;
       }
       positions[lastLine] += gapAccumulator;
     }
   }
   auto& offsetBetweenTracks =
       isRowAxis ? m_offsetBetweenColumns : m_offsetBetweenRows;
   offsetBetweenTracks = offset.distributionOffset;
@@ skipping 229 matching lines @@
          !isOrthogonalChild(*child) && !hasAutoMarginsInColumnAxis(*child);
 }
 
 int LayoutGrid::firstLineBoxBaseline() const {
   if (isWritingModeRoot() || !m_grid.hasInFlowGridItems())
     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.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());
       // 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;
@@ skipping 197 matching lines @@
       break;
   }
 
   ASSERT_NOT_REACHED();
   return GridAxisStart;
 }
 
 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);
   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 = 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);
   if (hasAutoMarginsInRowAxis(child))
     return startPosition;
   GridAxisPosition axisPosition = rowAxisPositionForChild(child);
   switch (axisPosition) {
     case GridAxisStart:
       return startPosition;
     case GridAxisEnd:
@@ skipping 213 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.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