[css-grid] Isolate internal grid size from the actual grid size

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 382 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);
-  // 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).
-  return m_grid.size() ? m_grid[0].size()
-                       : GridPositionsResolver::explicitGridColumnCount(
-                             styleRef(), m_autoRepeatColumns);
+  return m_grid.size() ? m_grid[0].size() : 0;
 }
 
 size_t LayoutGrid::gridRowCount() const {
   DCHECK(!m_gridIsDirty);
   return m_grid.size();
 }
 
 LayoutUnit LayoutGrid::computeTrackBasedLogicalHeight(
     const GridSizingData& sizingData) const {
   LayoutUnit logicalHeight;
@@ skipping 90 matching lines @@
 
     // 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 !=
             computeAutoRepeatTracksCount(ForColumns, TrackSizing))
       dirtyGrid();
     placeItemsOnGrid(TrackSizing);
 
-    GridSizingData sizingData(gridColumnCount(), gridRowCount());
+    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).
     LayoutUnit availableSpaceForColumns = availableLogicalWidth();
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
@@ skipping 155 matching lines @@
   }
 
   return gapAccumulator;
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   const_cast<LayoutGrid*>(this)->placeItemsOnGrid(IntrinsicSizeComputation);
 
-  GridSizingData sizingData(gridColumnCount(), gridRowCount());
+  GridSizingData sizingData(numTracks(ForColumns), numTracks(ForRows));
   computeTrackSizesForIndefiniteSize(ForColumns, sizingData, minLogicalWidth,
                                      maxLogicalWidth);
 
   LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
   minLogicalWidth += scrollbarWidth;
   maxLogicalWidth += scrollbarWidth;
 }
 
 void LayoutGrid::computeTrackSizesForIndefiniteSize(
     GridTrackSizingDirection direction,
@@ skipping 1309 matching lines @@
                                                             : area.rows;
       if (majorAxisPositions.isIndefinite())
         autoMajorAxisAutoGridItems.append(child);
       else
         specifiedMajorAxisAutoGridItems.append(child);
       continue;
     }
     insertItemIntoGrid(*child, area);
   }
 
-  DCHECK_GE(gridRowCount(), GridPositionsResolver::explicitGridRowCount(
-                                *style(), m_autoRepeatRows));
-  DCHECK_GE(gridColumnCount(), GridPositionsResolver::explicitGridColumnCount(
-                                   *style(), m_autoRepeatColumns));
+#if ENABLE(ASSERT)
+  if (!m_gridItemArea.isEmpty()) {
+    DCHECK_GE(gridRowCount(), GridPositionsResolver::explicitGridRowCount(
+                                  *style(), m_autoRepeatRows));
+    DCHECK_GE(gridColumnCount(), GridPositionsResolver::explicitGridColumnCount(
+                                     *style(), m_autoRepeatColumns));
+  }
+#endif
 
   placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems);
   placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
 
   m_grid.shrinkToFit();
 
   // Compute collapsable tracks for auto-fit.
   m_autoRepeatEmptyColumns = computeEmptyTracksForAutoRepeat(ForColumns);
   m_autoRepeatEmptyRows = computeEmptyTracksForAutoRepeat(ForRows);
 
@@ skipping 493 matching lines @@
   // tracks per spec.
   int smallestStart =
       abs(isForColumns ? m_smallestColumnStart : m_smallestRowStart);
   int startLine = positions.untranslatedStartLine() + smallestStart;
   int endLine = positions.untranslatedEndLine() + smallestStart;
 
   GridPosition startPosition = isForColumns ? child.style()->gridColumnStart()
                                             : child.style()->gridRowStart();
   GridPosition endPosition = isForColumns ? child.style()->gridColumnEnd()
                                           : child.style()->gridRowEnd();
-  int lastLine = isForColumns ? gridColumnCount() : gridRowCount();
+  int lastLine = numTracks(direction);
 
   bool startIsAuto =
       startPosition.isAuto() ||
       (startPosition.isNamedGridArea() &&
        !NamedLineCollection::isValidNamedLineOrArea(
            startPosition.namedGridLine(), styleRef(),
            GridPositionsResolver::initialPositionSide(direction))) ||
       (startLine < 0) || (startLine > lastLine);
   bool endIsAuto = endPosition.isAuto() ||
                    (endPosition.isNamedGridArea() &&
@@ skipping 935 matching lines @@
                                const LayoutPoint& paintOffset) const {
   if (!m_gridItemArea.isEmpty())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
+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.size() ? m_grid[0].size()
+                       : GridPositionsResolver::explicitGridColumnCount(
+                             styleRef(), m_autoRepeatColumns);
+}
+
 }  // namespace blink