[css-grid] Cleanup LayoutGrid::Grid

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 45 matching lines @@
     for (size_t row = oldRowSize; row < numTracks(ForRows); ++row)
       m_grid[row].grow(numTracks(ForColumns));
   }
 
   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) {
+void LayoutGrid::Grid::insert(LayoutBox& child, const GridArea& area) {
   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;
@@ skipping 64 matching lines @@
                                  : 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::setHasAnyOrthogonalGridItem(
+    bool hasAnyOrthogonalGridItem) {
+  m_hasAnyOrthogonalGridItem = hasAnyOrthogonalGridItem;
+}
+
 void LayoutGrid::Grid::clear() {
   m_grid.resize(0);
   m_gridItemArea.clear();
   m_gridItemsIndexesMap.clear();
-  m_hasAnyOrthogonalChildren = false;
+  m_hasAnyOrthogonalGridItem = false;
   m_smallestRowStart = 0;
   m_smallestColumnStart = 0;
   m_autoRepeatColumns = 0;
   m_autoRepeatRows = 0;
   m_autoRepeatEmptyColumns = nullptr;
   m_autoRepeatEmptyRows = nullptr;
 }
 
 class GridTrack {
  public:
@@ skipping 390 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_grid.hasAnyOrthogonalChildren()) {
+  if (m_grid.hasAnyOrthogonalGridItem()) {
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
                                      availableSpaceForColumns);
     computeTrackSizesForDefiniteSize(ForRows, sizingData,
                                      availableSpaceForRows);
   }
 }
 
 void LayoutGrid::layoutBlock(bool relayoutChildren) {
   ASSERT(needsLayout());
 
@@ skipping 358 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_grid.hasInFlowGridItems()) {
+    if (m_grid.hasGridItems()) {
       for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
         GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
         while (LayoutBox* gridItem = iterator.nextGridItem()) {
           const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
 
           // Do not include already processed items.
           if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
             continue;
 
           flexFraction = std::max(
@@ skipping 507 matching lines @@
       return true;
   }
 
   return false;
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctions(
     GridTrackSizingDirection direction,
     GridSizingData& sizingData) const {
   sizingData.itemsSortedByIncreasingSpan.shrink(0);
-  if (m_grid.hasInFlowGridItems()) {
+  if (m_grid.hasGridItems()) {
     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 = m_grid.gridItemSpan(*gridItem, direction);
           if (span.integerSpan() == 1) {
@@ skipping 518 matching lines @@
 
   std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
   size_t insertionPoint = isRowAxis
                               ? styleRef().gridAutoRepeatColumnsInsertionPoint()
                               : styleRef().gridAutoRepeatRowsInsertionPoint();
   size_t firstAutoRepeatTrack =
       insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
   size_t lastAutoRepeatTrack =
       firstAutoRepeatTrack + autoRepeatCountForDirection(direction);
 
-  if (!m_grid.hasInFlowGridItems()) {
+  if (!m_grid.hasGridItems()) {
     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_grid.hasInFlowGridItems());
+  DCHECK(!m_grid.hasGridItems());
 
   size_t autoRepeatColumns;
   size_t autoRepeatRows =
       computeAutoRepeatTracksCount(ForRows, sizingOperation);
   if (sizingOperation == IntrinsicSizeComputation) {
     autoRepeatColumns = styleRef().gridAutoRepeatColumns().size();
   } else {
     autoRepeatColumns =
         computeAutoRepeatTracksCount(ForColumns, sizingOperation);
   }
   m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
 
   populateExplicitGridAndOrderIterator();
 
   // We clear the dirty bit here as the grid sizes have been updated.
   m_gridIsDirty = false;
+  bool hasAnyOrthogonalGridItem = false;
 
   Vector<LayoutBox*> autoMajorAxisAutoGridItems;
   Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
 #if ENABLE(ASSERT)
   DCHECK(!m_grid.hasAnyGridItemPaintOrder());
 #endif
-  DCHECK(!m_grid.hasAnyOrthogonalChildren());
+  DCHECK(!m_grid.hasAnyOrthogonalGridItem());
   size_t childIndex = 0;
   for (LayoutBox* child = m_grid.orderIterator().first(); child;
        child = m_grid.orderIterator().next()) {
     if (child->isOutOfFlowPositioned())
       continue;
 
+    hasAnyOrthogonalGridItem =
+        hasAnyOrthogonalGridItem || isOrthogonalChild(*child);
     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));
+    m_grid.insert(*child, area);
   }
+  m_grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
 
 #if ENABLE(ASSERT)
-  if (m_grid.hasInFlowGridItems()) {
+  if (m_grid.hasGridItems()) {
     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);
@@ skipping 125 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_grid.insert(*autoGridItem, *emptyGridArea,
-                  isOrthogonalChild(*autoGridItem));
+    m_grid.insert(*autoGridItem, *emptyGridArea);
 
     if (!isGridAutoFlowDense)
       minorAxisCursors.set(majorAxisInitialPosition,
                            isForColumns ? emptyGridArea->rows.startLine()
                                         : emptyGridArea->columns.startLine());
   }
 }
 
 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(
     const Vector<LayoutBox*>& autoGridItems) {
@@ skipping 84 matching lines @@
       // auto-placement cursor in the minor axis.
       minorAxisAutoPlacementCursor = 0;
     }
 
     if (!emptyGridArea)
       emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(
           gridItem, autoPlacementMinorAxisDirection(),
           GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
   }
 
-  m_grid.insert(gridItem, *emptyGridArea, isOrthogonalChild(gridItem));
+  m_grid.insert(gridItem, *emptyGridArea);
   // 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 {
@@ skipping 692 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_grid.hasInFlowGridItems())
+  if (isWritingModeRoot() || !m_grid.hasGridItems())
     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.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());
@@ skipping 464 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_grid.hasInFlowGridItems())
+  if (m_grid.hasGridItems())
     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.numTracks(ForRows);
 
   return m_grid.numTracks(ForRows)
              ? m_grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), m_grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink