[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;
 
   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(),

[Manuel Rego, 2016/11/22 09:57:24]

Why you don't use numTracks() here?

                   sizingData.sizingOperation);
   sizingData.sizingOperation = TrackSizing;
 
   LayoutUnit baseSizes, growthLimits;
   computeUsedBreadthOfGridTracks(direction, sizingData, baseSizes,
                                  growthLimits);
   ASSERT(tracksAreWiderThanMinTrackBreadth(direction, sizingData));
   sizingData.nextState();
 }
 
@@ skipping 54 matching lines @@
     }
 
     updateLogicalWidth();
     m_hasDefiniteLogicalHeight = hasDefiniteLogicalHeight();
 
     TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
     updateAutoRepeatTracksAndSetDirtyIfNeeded(TrackSizing);
     placeItemsOnGrid();
 
-    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 157 matching lines @@
   return gapAccumulator;
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   const_cast<LayoutGrid*>(this)->updateAutoRepeatTracksAndSetDirtyIfNeeded(
       IntrinsicSizeComputation);
   const_cast<LayoutGrid*>(this)->placeItemsOnGrid();
 
-  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 1316 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 68 matching lines @@
 }
 
 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();

[Manuel Rego, 2016/11/22 09:57:24]

Ditto.

   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));
@@ skipping 64 matching lines @@
     std::pair<size_t, size_t>& autoPlacementCursor) {
   GridSpan minorAxisPositions =
       cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
   ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection())
               .isTranslatedDefinite());
   size_t majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
       *style(), gridItem, autoPlacementMajorAxisDirection());
 
   const size_t endOfMajorAxis =
       (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount()
                                                         : gridRowCount();

[Manuel Rego, 2016/11/22 09:57:24]

Ditto.

   size_t majorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.second
           : autoPlacementCursor.first;
   size_t minorAxisAutoPlacementCursor =
       autoPlacementMajorAxisDirection() == ForColumns
           ? autoPlacementCursor.first
           : autoPlacementCursor.second;
 
   std::unique_ptr<GridArea> emptyGridArea;
@@ skipping 28 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();

[Manuel Rego, 2016/11/22 09:57:24]

Ditto.

         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 270 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