[css-grid] Move 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 39 matching lines @@
     for (size_t row = oldRowSize; row < numRows(); ++row)
       m_grid[row].grow(numColumns());
   }
 
   if (maximumColumnSize > numColumns()) {
     for (size_t row = 0; row < numRows(); ++row)
       m_grid[row].grow(maximumColumnSize);
   }
 }
 
-void LayoutGrid::Grid::insert(LayoutBox& child, const GridArea& area) {
+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());
 
   for (const auto& row : area.rows) {
     for (const auto& column : area.columns)
       m_grid[row][column].append(&child);
   }
+
+  setGridItemArea(child, area);
+
+  m_hasAnyOrthogonalChildren = m_hasAnyOrthogonalChildren || isOrthogonalChild;
 }
 
+void LayoutGrid::Grid::setSmallestTracksStart(int rowStart, int columnStart) {
+  m_smallestRowStart = rowStart;
+  m_smallestColumnStart = columnStart;
+}
+
+int LayoutGrid::Grid::smallestTrackStart(
+    GridTrackSizingDirection direction) const {
+  return direction == ForRows ? m_smallestRowStart : m_smallestColumnStart;
+}
+
+GridArea LayoutGrid::Grid::gridItemArea(const LayoutBox& item) const {
+  DCHECK(m_gridItemArea.contains(&item));
+  return m_gridItemArea.get(&item);
+}
+
+void LayoutGrid::Grid::setGridItemArea(const LayoutBox& item, GridArea area) {
+  m_gridItemArea.set(&item, area);
+}
+
+size_t LayoutGrid::Grid::gridItemPaintOrder(const LayoutBox& item) const {
+  return m_gridItemsIndexesMap.get(&item);
+}
+
+void LayoutGrid::Grid::setGridItemPaintOrder(const LayoutBox& item,
+                                             size_t order) {
+  m_gridItemsIndexesMap.set(&item, order);
+}
+
+#if ENABLE(ASSERT)
+bool LayoutGrid::Grid::hasAnyGridItemPaintOrder() const {
+  return !m_gridItemsIndexesMap.isEmpty();
+}
+#endif
+
 void LayoutGrid::Grid::clear() {
   m_grid.resize(0);
+  m_gridItemArea.clear();
+  m_gridItemsIndexesMap.clear();
+  m_hasAnyOrthogonalChildren = false;
+  m_smallestRowStart = 0;
+  m_smallestColumnStart = 0;
 }
 
 class GridTrack {
  public:
   GridTrack() : m_infinitelyGrowable(false) {}
 
   LayoutUnit baseSize() const {
     DCHECK(isGrowthLimitBiggerThanBaseSize());
     return m_baseSize;
   }
@@ skipping 396 matching lines @@
   // In orthogonal flow cases column track's size is determined by using the
   // computed row track's size, which it was estimated during the first cycle of
   // the sizing algorithm.
   // Hence we need to repeat computeUsedBreadthOfGridTracks for both, columns
   // and rows, to determine the final values.
   // TODO (lajava): orthogonal flows is just one of the cases which may require
   // a new cycle of the sizing algorithm; there may be more. In addition, not
   // all the cases with orthogonal flows require this extra cycle; we need a
   // more specific condition to detect whether child's min-content contribution
   // has changed or not.
-  if (m_hasAnyOrthogonalChildren) {
+  if (m_grid.hasAnyOrthogonalChildren()) {
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
                                      availableSpaceForColumns);
     computeTrackSizesForDefiniteSize(ForRows, sizingData,
                                      availableSpaceForRows);
   }
 }
 
 void LayoutGrid::layoutBlock(bool relayoutChildren) {
   ASSERT(needsLayout());
 
@@ skipping 375 matching lines @@
         tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()),
         direction, initialFreeSpace);
   } else {
     for (const auto& trackIndex : flexibleSizedTracksIndex)
       flexFraction = std::max(
           flexFraction,
           normalizedFlexFraction(
               tracks[trackIndex],
               gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
 
-    if (!m_gridItemArea.isEmpty()) {
+    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);
 
           // Do not include already processed items.
           if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
             continue;
 
           flexFraction = std::max(
@@ skipping 230 matching lines @@
                               : styleRef().gridAutoRepeatRowsInsertionPoint();
   size_t autoRepeatTracksCount = autoRepeatCountForDirection(direction);
 
   // We should not use GridPositionsResolver::explicitGridXXXCount() for this
   // because the explicit grid might be larger than the number of tracks in
   // grid-template-rows|columns (if grid-template-areas is specified for
   // example).
   size_t explicitTracksCount = trackStyles.size() + autoRepeatTracksCount;
 
   int untranslatedIndexAsInt =
-      translatedIndex +
-      (isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
+      translatedIndex + m_grid.smallestTrackStart(direction);
   size_t autoTrackStylesSize = autoTrackStyles.size();
   if (untranslatedIndexAsInt < 0) {
     int index = untranslatedIndexAsInt % static_cast<int>(autoTrackStylesSize);
     // We need to traspose the index because the first negative implicit line
     // will get the last defined auto track and so on.
     index += index ? autoTrackStylesSize : 0;
     return autoTrackStyles[index];
   }
 
   size_t untranslatedIndex = static_cast<size_t>(untranslatedIndexAsInt);
@@ skipping 253 matching lines @@
       return true;
   }
 
   return false;
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctions(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData) const {
   sizingData.itemsSortedByIncreasingSpan.shrink(0);
-  if (!m_gridItemArea.isEmpty()) {
+  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);
           if (span.integerSpan() == 1) {
@@ skipping 514 matching lines @@
   bool isRowAxis = direction == ForColumns;
   if ((isRowAxis && styleRef().gridAutoRepeatColumnsType() != AutoFit) ||
       (!isRowAxis && styleRef().gridAutoRepeatRowsType() != AutoFit))
     return nullptr;
 
   std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
   size_t insertionPoint = isRowAxis
                               ? styleRef().gridAutoRepeatColumnsInsertionPoint()
                               : styleRef().gridAutoRepeatRowsInsertionPoint();
   size_t firstAutoRepeatTrack =
-      insertionPoint +
-      std::abs(isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
+      insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
   size_t lastAutoRepeatTrack =
       firstAutoRepeatTrack + autoRepeatCountForDirection(direction);
 
-  if (m_gridItemArea.isEmpty()) {
+  if (!m_grid.hasInFlowGridItems()) {
     emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
     for (size_t trackIndex = firstAutoRepeatTrack;
          trackIndex < lastAutoRepeatTrack; ++trackIndex)
       emptyTrackIndexes->add(trackIndex);
   } else {
     for (size_t trackIndex = firstAutoRepeatTrack;
          trackIndex < lastAutoRepeatTrack; ++trackIndex) {
       GridIterator iterator(m_grid, direction, trackIndex);
       if (!iterator.nextGridItem()) {
         if (!emptyTrackIndexes)
           emptyTrackIndexes = wrapUnique(new OrderedTrackIndexSet);
         emptyTrackIndexes->add(trackIndex);
       }
     }
   }
   return emptyTrackIndexes;
 }
 
 void LayoutGrid::placeItemsOnGrid(SizingOperation sizingOperation) {
   if (!m_gridIsDirty)
     return;
 
-  DCHECK(m_gridItemArea.isEmpty());
+  DCHECK(!m_grid.hasInFlowGridItems());
 
   if (sizingOperation == IntrinsicSizeComputation) {
     m_autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
   } else {
     m_autoRepeatColumns =
         computeAutoRepeatTracksCount(ForColumns, sizingOperation);
   }
   m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
 
   populateExplicitGridAndOrderIterator();
 
   // We clear the dirty bit here as the grid sizes have been updated.
   m_gridIsDirty = false;
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
-  DCHECK(m_gridItemsIndexesMap.isEmpty());
+#if ENABLE(ASSERT)
+  DCHECK(!m_grid.hasAnyGridItemPaintOrder());
+#endif
+  DCHECK(!m_grid.hasAnyOrthogonalChildren());
   size_t childIndex = 0;
-  m_hasAnyOrthogonalChildren = false;
   for (LayoutBox* child = m_orderIterator.first(); child;
        child = m_orderIterator.next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
-    m_gridItemsIndexesMap.set(child, childIndex++);
+    m_grid.setGridItemPaintOrder(*child, childIndex++);
 
-    m_hasAnyOrthogonalChildren =
-        m_hasAnyOrthogonalChildren || isOrthogonalChild(*child);
-
-    GridArea area = cachedGridArea(*child);
+    GridArea area = m_grid.gridItemArea(*child);
     if (!area.rows.isIndefinite())
-      area.rows.translate(abs(m_smallestRowStart));
+      area.rows.translate(abs(m_grid.smallestTrackStart(ForRows)));
     if (!area.columns.isIndefinite())
-      area.columns.translate(abs(m_smallestColumnStart));
-    m_gridItemArea.set(child, area);
+      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);
+    m_grid.insert(*child, area, isOrthogonalChild(*child));
   }
 
 #if ENABLE(ASSERT)
-  if (!m_gridItemArea.isEmpty()) {
+  if (m_grid.hasInFlowGridItems()) {
     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);
 
 #if ENABLE(ASSERT)
   for (LayoutBox* child = m_orderIterator.first(); child;
        child = m_orderIterator.next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
-    GridArea area = cachedGridArea(*child);
+    GridArea area = m_grid.gridItemArea(*child);
     ASSERT(area.rows.isTranslatedDefinite() &&
            area.columns.isTranslatedDefinite());
   }
 #endif
 }
 
 void LayoutGrid::populateExplicitGridAndOrderIterator() {
   OrderIteratorPopulator populator(m_orderIterator);
-
-  m_smallestRowStart = m_smallestColumnStart = 0;
+  int smallestRowStart = 0;
+  int smallestColumnStart = 0;
 
   size_t maximumRowIndex =
       GridPositionsResolver::explicitGridRowCount(*style(), m_autoRepeatRows);
   size_t maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(
       *style(), m_autoRepeatColumns);
 
   for (LayoutBox* child = firstInFlowChildBox(); child;
        child = child->nextInFlowSiblingBox()) {
     populator.collectChild(child);
 
-    // This function bypasses the cache (cachedGridArea()) as it is used to
+    // This function bypasses the cache (gridItemArea()) as it is used to
     // build it.
     GridSpan rowPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
             *style(), *child, ForRows, m_autoRepeatRows);
     GridSpan columnPositions =
         GridPositionsResolver::resolveGridPositionsFromStyle(
             *style(), *child, ForColumns, m_autoRepeatColumns);
-    m_gridItemArea.set(child, GridArea(rowPositions, columnPositions));
+    m_grid.setGridItemArea(*child, GridArea(rowPositions, columnPositions));
 
     // |positions| is 0 if we need to run the auto-placement algorithm.
     if (!rowPositions.isIndefinite()) {
-      m_smallestRowStart =
-          std::min(m_smallestRowStart, rowPositions.untranslatedStartLine());
+      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
       // such span.
       size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
           *style(), *child, ForRows);
       maximumRowIndex = std::max(maximumRowIndex, spanSize);
     }
 
     if (!columnPositions.isIndefinite()) {
-      m_smallestColumnStart = std::min(m_smallestColumnStart,
-                                       columnPositions.untranslatedStartLine());
+      smallestColumnStart = std::min(smallestColumnStart,
+                                     columnPositions.untranslatedStartLine());
       maximumColumnIndex = std::max<int>(maximumColumnIndex,
                                          columnPositions.untranslatedEndLine());
     } else {
       // Grow the grid for items with a definite column span, getting the
       // largest such span.
       size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
           *style(), *child, ForColumns);
       maximumColumnIndex = std::max(maximumColumnIndex, spanSize);
     }
   }
 
-  m_grid.ensureGridSize(maximumRowIndex + abs(m_smallestRowStart),
-                        maximumColumnIndex + abs(m_smallestColumnStart));
+  m_grid.setSmallestTracksStart(smallestRowStart, smallestColumnStart);
+  m_grid.ensureGridSize(maximumRowIndex + abs(smallestRowStart),
+                        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 =
@@ skipping 37 matching lines @@
                           majorAxisPositions.startLine(),
                           isGridAutoFlowDense
                               ? 0
                               : minorAxisCursors.get(majorAxisInitialPosition));
     std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(
         majorAxisPositions.integerSpan(), minorAxisSpanSize);
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           *autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
 
-    m_gridItemArea.set(autoGridItem, *emptyGridArea);
-    m_grid.insert(*autoGridItem, *emptyGridArea);
+    m_grid.insert(*autoGridItem, *emptyGridArea,
+                  isOrthogonalChild(*autoGridItem));
 
     if (!isGridAutoFlowDense)
       minorAxisCursors.set(majorAxisInitialPosition,
                            isForColumns ? emptyGridArea->rows.startLine()
                                         : emptyGridArea->columns.startLine());
   }
 }
 
 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(
     const Vector<LayoutBox*>& autoGridItems) {
@@ skipping 86 matching lines @@
       // auto-placement cursor in the minor axis.
       minorAxisAutoPlacementCursor = 0;
     }
 
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           gridItem, autoPlacementMinorAxisDirection(),
           GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
   }
 
-  m_gridItemArea.set(&gridItem, *emptyGridArea);
-  m_grid.insert(gridItem, *emptyGridArea);
+  m_grid.insert(gridItem, *emptyGridArea, isOrthogonalChild(gridItem));
   // Move auto-placement cursor to the new position.
   autoPlacementCursor.first = emptyGridArea->rows.startLine();
   autoPlacementCursor.second = emptyGridArea->columns.startLine();
 }
 
 GridTrackSizingDirection LayoutGrid::autoPlacementMajorAxisDirection() const {
   return style()->isGridAutoFlowDirectionColumn() ? ForColumns : ForRows;
 }
 
 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const {
   return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
 }
 
 void LayoutGrid::dirtyGrid() {
   if (m_gridIsDirty)
     return;
 
   m_grid.clear();
-  m_gridItemArea.clear();
   m_gridItemsOverflowingGridArea.resize(0);
-  m_gridItemsIndexesMap.clear();
   m_autoRepeatColumns = 0;
   m_autoRepeatRows = 0;
   m_gridIsDirty = true;
   m_autoRepeatEmptyColumns = nullptr;
   m_autoRepeatEmptyRows = nullptr;
 }
 
 Vector<LayoutUnit> LayoutGrid::trackSizesForComputedStyle(
     GridTrackSizingDirection direction) const {
   bool isRowAxis = direction == ForColumns;
@@ skipping 131 matching lines @@
     // before stretching, are not set yet.
     applyStretchAlignmentToChildIfNeeded(*child);
 
     child->layoutIfNeeded();
 
     // We need pending layouts to be done in order to compute auto-margins
     // properly.
     updateAutoMarginsInColumnAxisIfNeeded(*child);
     updateAutoMarginsInRowAxisIfNeeded(*child);
 
-    const GridArea& area = cachedGridArea(*child);
+    const GridArea& area = m_grid.gridItemArea(*child);
 #if ENABLE(ASSERT)
     ASSERT(area.columns.startLine() < sizingData.columnTracks.size());
     ASSERT(area.rows.startLine() < sizingData.rowTracks.size());
 #endif
     child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
     // Keep track of children overflowing their grid area as we might need to
     // paint them even if the grid-area is not visible. Using physical
     // dimensions for simplicity, so we can forget about orthogonalty.
     LayoutUnit childGridAreaHeight =
@@ skipping 66 matching lines @@
       *style(), child, direction, autoRepeatCountForDirection(direction));
   if (positions.isIndefinite()) {
     offset = LayoutUnit();
     breadth = isForColumns ? clientLogicalWidth() : clientLogicalHeight();
     return;
   }
 
   // For positioned items we cannot use GridSpan::translate(). Because we could
   // end up with negative values, as the positioned items do not create implicit
   // tracks per spec.
-  int smallestStart =
-      abs(isForColumns ? m_smallestColumnStart : m_smallestRowStart);
+  int smallestStart = abs(m_grid.smallestTrackStart(direction));
   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 = numTracks(direction);
 
   bool startIsAuto =
@@ skipping 61 matching lines @@
                borderLogicalLeft();
 
       if (endLine > 0 && endLine < lastLine) {
         offset += guttersSize(direction, endLine - 1, 2, TrackSizing);
         offset += isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
       }
     }
   }
 }
 
-GridArea LayoutGrid::cachedGridArea(const LayoutBox& gridItem) const {
-  ASSERT(m_gridItemArea.contains(&gridItem));
-  return m_gridItemArea.get(&gridItem);
-}
-
 GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem,
                                     GridTrackSizingDirection direction) const {
-  GridArea area = cachedGridArea(gridItem);
+  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);
   LayoutUnit gridAreaSize;
   bool gridAreaIsIndefinite = false;
@@ skipping 360 matching lines @@
 
   return baseline + beforeMarginInLineDirection(direction);
 }
 
 bool LayoutGrid::isInlineBaselineAlignedChild(const LayoutBox* child) const {
   return alignSelfForChild(*child).position() == ItemPositionBaseline &&
          !isOrthogonalChild(*child) && !hasAutoMarginsInColumnAxis(*child);
 }
 
 int LayoutGrid::firstLineBoxBaseline() const {
-  if (isWritingModeRoot() || m_gridItemArea.isEmpty())
+  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 index = 0; index < m_grid.cell(0, column).size(); index++) {
       const LayoutBox* child = m_grid.cell(0, column)[index];
       DCHECK(!child->isOutOfFlowPositioned());
       // If an item participates in baseline alignmen, we select such item.
       if (isInlineBaselineAlignedChild(child)) {
         // TODO (lajava): self-baseline and content-baseline alignment
         // still not implemented.
         baselineChild = child;
         isBaselineAligned = true;
         break;
       }
       if (!baselineChild) {
         // Use dom order for items in the same cell.
-        if (!firstChild || (m_gridItemsIndexesMap.get(child) <
-                            m_gridItemsIndexesMap.get(firstChild)))
+        if (!firstChild || (m_grid.gridItemPaintOrder(*child) <
+                            m_grid.gridItemPaintOrder(*firstChild)))
           firstChild = child;
       }
     }
     if (!baselineChild && firstChild)
       baselineChild = firstChild;
   }
 
   if (!baselineChild)
     return -1;
 
@@ skipping 442 matching lines @@
   // See comment in findChildLogicalPosition() about why we need sometimes to
   // translate from RTL to LTR the rowAxisOffset coordinate.
   return LayoutPoint(style()->isLeftToRightDirection()
                          ? rowAxisOffset
                          : translateRTLCoordinate(rowAxisOffset),
                      columnAxisOffset);
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) const {
-  if (!m_gridItemArea.isEmpty())
+  if (m_grid.hasInFlowGridItems())
     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.numRows();
 
   return m_grid.numRows() ? m_grid.numColumns()
                           : GridPositionsResolver::explicitGridColumnCount(
                                 styleRef(), m_autoRepeatColumns);
 }
 
 }  // namespace blink