Strengthen the LayoutGrid dirtiness asserts.

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 20 matching lines @@
 #include "core/style/GridCoordinate.h"
 #include "core/style/ComputedStyle.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/GridPainter.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 static const int infinity = -1;
 
+class GridItemWithSpan;

[svillar, 2015/06/03 09:27:33]

Why this?

[esprehn, 2015/06/03 16:39:11]

That class doesn't appear to be used or defined outside the cpp file. So I moved
the forward decl into it.

+
 class GridTrack {
 public:
     GridTrack()
         : m_plannedIncrease(0)
         , m_increaseDuringDistribution(0)
         , m_baseSize(0)
         , m_growthLimit(0)
     {
     }
 
@@ skipping 206 matching lines @@
 }
 
 LayoutGrid::~LayoutGrid()
 {
 }
 
 void LayoutGrid::addChild(LayoutObject* newChild, LayoutObject* beforeChild)
 {
     LayoutBlock::addChild(newChild, beforeChild);
 
-    if (gridIsDirty())
-        return;
-
     // The grid needs to be recomputed as it might contain auto-placed items that will change their position.
     dirtyGrid();
-    return;
 }
 
 void LayoutGrid::removeChild(LayoutObject* child)
 {
     LayoutBlock::removeChild(child);
 
-    if (gridIsDirty())
-        return;
-
     // The grid needs to be recomputed as it might contain auto-placed items that will change their position.
     dirtyGrid();
-    return;
 }
 
 void LayoutGrid::styleDidChange(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     LayoutBlock::styleDidChange(diff, oldStyle);
     if (!oldStyle)
         return;
 
     // FIXME: The following checks could be narrowed down if we kept track of which type of grid items we have:
     // - explicit grid size changes impact negative explicitely positioned and auto-placed grid items.
@@ skipping 623 matching lines @@
         for (GridSpan::iterator column = coordinate.columns.begin(); column != coordinate.columns.end(); ++column)
             m_grid[row.toInt()][column.toInt()].append(&child);
     }
 
     RELEASE_ASSERT(!m_gridItemCoordinate.contains(&child));
     m_gridItemCoordinate.set(&child, coordinate);
 }
 
 void LayoutGrid::placeItemsOnGrid()
 {
-    if (!gridIsDirty())
+    if (!m_gridIsDirty)
         return;
 
     ASSERT(m_gridItemCoordinate.isEmpty());
 
     populateExplicitGridAndOrderIterator();
 
-    // We clear the dirty bit here as the grid sizes have been updated, this means
-    // that we can safely call gridRowCount() / gridColumnCount().
+    // We clear the dirty bit here as the grid sizes have been updated.
     m_gridIsDirty = false;
 
     Vector<LayoutBox*> autoMajorAxisAutoGridItems;
     Vector<LayoutBox*> specifiedMajorAxisAutoGridItems;
     for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
         if (child->isOutOfFlowPositioned())
             continue;
 
         OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(*style(), *child, ForRows);
         OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(*style(), *child, ForColumns);
@@ skipping 168 matching lines @@
     return style()->isGridAutoFlowDirectionColumn() ? ForColumns : ForRows;
 }
 
 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const
 {
     return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns;
 }
 
 void LayoutGrid::dirtyGrid()
 {
+    if (m_gridIsDirty)
+        return;
+
     // Even if this could be redundant, it could be seen as a defensive strategy against
     // style changes events happening during the layout phase or even while the painting process
     // is still ongoing.
     // Forcing a new layout for the Grid layout would cancel any ongoing painting and ensure
     // the grid and its children are correctly laid out according to the new style rules.
     setNeedsLayout(LayoutInvalidationReason::GridChanged);
 
     m_grid.resize(0);
     m_gridItemCoordinate.clear();
-    m_gridIsDirty = true;
     m_gridItemsOverflowingGridArea.resize(0);
     m_gridItemsIndexesMap.clear();
+    m_gridIsDirty = true;
 }
 
 void LayoutGrid::layoutGridItems()
 {
     placeItemsOnGrid();
 
     LayoutUnit availableSpaceForColumns = availableLogicalWidth();
     LayoutUnit availableSpaceForRows = availableLogicalHeight(IncludeMarginBorderPadding);
     GridSizingData sizingData(gridColumnCount(), gridRowCount());
     computeUsedBreadthOfGridTracks(ForColumns, sizingData, availableSpaceForColumns);
@@ skipping 686 matching lines @@
 
     return LayoutPoint(columnPosition, rowPositionForChild(child));
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink