[CSS Grid Layout] Introduce an explicit type for resolved grid positions

Source/core/rendering/RenderGrid.cpp

Index: Source/core/rendering/RenderGrid.cpp
diff --git a/Source/core/rendering/RenderGrid.cpp b/Source/core/rendering/RenderGrid.cpp
index 9961336223f36d9a1cb0c32c20ec5595ec46ceec..bfe0c981fca06aaead0e0f3f53b24a23e10b8bfb 100644
--- a/Source/core/rendering/RenderGrid.cpp
+++ b/Source/core/rendering/RenderGrid.cpp
@@ -198,7 +198,7 @@ void RenderGrid::addChild(RenderObject* newChild, RenderObject* beforeChild)
         // The new child requires the auto-placement algorithm to run so we need to recompute the grid fully.
         dirtyGrid();
     } else {
-        if (gridRowCount() <= rowPositions->finalPositionIndex || gridColumnCount() <= columnPositions->finalPositionIndex) {
+        if (gridRowCount() <= rowPositions->finalPositionIndex.integerPosition() || gridColumnCount() <= columnPositions->finalPositionIndex.integerPosition()) {
             // FIXME: We could just insert the new child provided we had a primitive to arbitrarily grow the grid.
             dirtyGrid();
         } else {
@@ -422,7 +422,7 @@ void RenderGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection directi
                 const GridSpan span = (direction == ForColumns) ? coordinate.columns : coordinate.rows;
 
                 // Do not include already processed items.
-                if (i > 0 && span.initialPositionIndex <= flexibleSizedTracksIndex[i - 1])
+                if (i > 0 && span.initialPositionIndex.integerPosition() <= flexibleSizedTracksIndex[i - 1])
                     continue;
 
                 double itemNormalizedFlexBreadth = computeNormalizedFractionBreadth(tracks, span, direction, maxContentForChild(gridItem, direction, sizingData.columnTracks));
@@ -487,7 +487,7 @@ double RenderGrid::computeNormalizedFractionBreadth(Vector<GridTrack>& tracks, c
     // |availableLogicalSpace| already accounts for the used breadths so no need to remove it here.
 
     Vector<GridTrackForNormalization> tracksForNormalization;
-    for (size_t i = tracksSpan.initialPositionIndex; i <= tracksSpan.finalPositionIndex; ++i) {
+    for (size_t i = tracksSpan.initialPositionIndex.integerPosition(); i <= tracksSpan.finalPositionIndex.integerPosition(); ++i) {
         const GridTrackSize& trackSize = gridTrackSize(direction, i);
         if (!trackSize.maxTrackBreadth().isFlex())
             continue;
@@ -632,8 +632,8 @@ void RenderGrid::resolveContentBasedTrackSizingFunctions(GridTrackSizingDirectio
 void RenderGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, RenderBox* gridItem, FilterFunction filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGetter, AccumulatorGrowFunction trackGrowthFunction)
 {
     const GridCoordinate coordinate = cachedGridCoordinate(gridItem);
-    const size_t initialTrackIndex = (direction == ForColumns) ? coordinate.columns.initialPositionIndex : coordinate.rows.initialPositionIndex;
-    const size_t finalTrackIndex = (direction == ForColumns) ? coordinate.columns.finalPositionIndex : coordinate.rows.finalPositionIndex;
+    const size_t initialTrackIndex = (direction == ForColumns) ? coordinate.columns.initialPositionIndex.integerPosition() : coordinate.rows.initialPositionIndex.integerPosition();
+    const size_t finalTrackIndex = (direction == ForColumns) ? coordinate.columns.finalPositionIndex.integerPosition() : coordinate.rows.finalPositionIndex.integerPosition();
 
     sizingData.filteredTracks.shrink(0);
     for (size_t trackIndex = initialTrackIndex; trackIndex <= finalTrackIndex; ++trackIndex) {
@@ -727,8 +727,8 @@ void RenderGrid::growGrid(GridTrackSizingDirection direction)
 
 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridCoordinate& coordinate)
 {
-    for (size_t row = coordinate.rows.initialPositionIndex; row <= coordinate.rows.finalPositionIndex; ++row) {
-        for (size_t column = coordinate.columns.initialPositionIndex; column <= coordinate.columns.finalPositionIndex; ++column)
+    for (size_t row = coordinate.rows.initialPositionIndex.integerPosition(); row <= coordinate.rows.finalPositionIndex.integerPosition(); ++row) {
+        for (size_t column = coordinate.columns.initialPositionIndex.integerPosition(); column <= coordinate.columns.finalPositionIndex.integerPosition(); ++column)
             m_grid[row][column].append(child);
     }
 
@@ -807,9 +807,9 @@ void RenderGrid::populateExplicitGridAndOrderIterator()
         // |positions| is 0 if we need to run the auto-placement algorithm. Our estimation ignores
         // this case as the auto-placement algorithm will grow the grid as needed.
         if (rowPositions)
-            maximumRowIndex = std::max(maximumRowIndex, rowPositions->finalPositionIndex + 1);
+            maximumRowIndex = std::max(maximumRowIndex, rowPositions->finalPositionIndex.integerPosition() + 1);
         if (columnPositions)
-            maximumColumnIndex = std::max(maximumColumnIndex, columnPositions->finalPositionIndex + 1);
+            maximumColumnIndex = std::max(maximumColumnIndex, columnPositions->finalPositionIndex.integerPosition() + 1);
     }
 
     m_grid.grow(maximumRowIndex);
@@ -821,16 +821,16 @@ void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& au
 {
     for (size_t i = 0; i < autoGridItems.size(); ++i) {
         OwnPtr<GridSpan> majorAxisPositions = resolveGridPositionsFromStyle(autoGridItems[i], autoPlacementMajorAxisDirection());
-        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions->initialPositionIndex);
+        GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions->initialPositionIndex.integerPosition());
         if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
-            insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
+            insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex.integerPosition(), emptyGridArea->columns.initialPositionIndex.integerPosition());
             continue;
         }
 
         growGrid(autoPlacementMinorAxisDirection());
         OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea();
         ASSERT(emptyGridArea);
-        insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
+        insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPositionIndex.integerPosition(), emptyGridArea->columns.initialPositionIndex.integerPosition());
     }
 }
 
@@ -846,10 +846,10 @@ void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem)
     ASSERT(!resolveGridPositionsFromStyle(gridItem, autoPlacementMajorAxisDirection()));
     size_t minorAxisIndex = 0;
     if (minorAxisPositions) {
-        minorAxisIndex = minorAxisPositions->initialPositionIndex;
+        minorAxisIndex = minorAxisPositions->initialPositionIndex.integerPosition();
         GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisIndex);
         if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
-            insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
+            insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex.integerPosition(), emptyGridArea->columns.initialPositionIndex.integerPosition());
             return;
         }
     } else {
@@ -857,7 +857,7 @@ void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem)
         for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
             GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisIndex);
             if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) {
-                insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex, emptyGridArea->columns.initialPositionIndex);
+                insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionIndex.integerPosition(), emptyGridArea->columns.initialPositionIndex.integerPosition());
                 return;
             }
         }
@@ -932,8 +932,8 @@ void RenderGrid::layoutGridItems()
 
 #ifndef NDEBUG
         const GridCoordinate& coordinate = cachedGridCoordinate(child);
-        ASSERT(coordinate.columns.initialPositionIndex < sizingData.columnTracks.size());
-        ASSERT(coordinate.rows.initialPositionIndex < sizingData.rowTracks.size());
+        ASSERT(coordinate.columns.initialPositionIndex.integerPosition() < sizingData.columnTracks.size());
+        ASSERT(coordinate.rows.initialPositionIndex.integerPosition() < sizingData.rowTracks.size());
 #endif
         child->setLogicalLocation(findChildLogicalPosition(child));
 
@@ -991,27 +991,27 @@ PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionsFromStyle(const RenderBox*
 
     if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
         // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
-        const size_t finalResolvedPosition = resolveGridPositionFromStyle(finalPosition, finalPositionSide);
+        GridResolvedPosition finalResolvedPosition = resolveGridPositionFromStyle(finalPosition, finalPositionSide);
         return resolveGridPositionAgainstOppositePosition(finalResolvedPosition, initialPosition, initialPositionSide);
     }
 
     if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
         // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
-        const size_t initialResolvedPosition = resolveGridPositionFromStyle(initialPosition, initialPositionSide);
+        GridResolvedPosition initialResolvedPosition = resolveGridPositionFromStyle(initialPosition, initialPositionSide);
         return resolveGridPositionAgainstOppositePosition(initialResolvedPosition, finalPosition, finalPositionSide);
     }
 
-    size_t resolvedInitialPosition = resolveGridPositionFromStyle(initialPosition, initialPositionSide);
-    size_t resolvedFinalPosition = resolveGridPositionFromStyle(finalPosition, finalPositionSide);
+    GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(initialPosition, initialPositionSide);
+    GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(finalPosition, finalPositionSide);
 
     // If 'grid-after' specifies a line at or before that specified by 'grid-before', it computes to 'span 1'.
-    if (resolvedFinalPosition < resolvedInitialPosition)
-        resolvedFinalPosition = resolvedInitialPosition;
+    if (resolvedFinalPosition.integerPosition() < resolvedInitialPosition.integerPosition())
+        resolvedFinalPosition.setIntegerPosition(resolvedInitialPosition.integerPosition());
 
-    return adoptPtr(new GridSpan(resolvedInitialPosition, resolvedFinalPosition));
+    return adoptPtr(new GridSpan(resolvedInitialPosition.integerPosition(), resolvedFinalPosition.integerPosition()));
 }
 
-size_t RenderGrid::resolveNamedGridLinePositionFromStyle(const GridPosition& position, GridPositionSide side) const
+GridResolvedPosition RenderGrid::resolveNamedGridLinePositionFromStyle(const GridPosition& position, GridPositionSide side) const
 {
     ASSERT(!position.namedGridLine().isNull());
 
@@ -1019,9 +1019,9 @@ size_t RenderGrid::resolveNamedGridLinePositionFromStyle(const GridPosition& pos
     NamedGridLinesMap::const_iterator it = gridLinesNames.find(position.namedGridLine());
     if (it == gridLinesNames.end()) {
         if (position.isPositive())
-            return 0;
+            return GridResolvedPosition();
         const size_t lastLine = explicitGridSizeForSide(side);
-        return GridPosition::adjustGridPositionForSide(lastLine, side);
+        return GridResolvedPosition::adjustGridPositionForSide(lastLine, side);
     }
 
     size_t namedGridLineIndex;
@@ -1029,10 +1029,10 @@ size_t RenderGrid::resolveNamedGridLinePositionFromStyle(const GridPosition& pos
         namedGridLineIndex = std::min<size_t>(position.integerPosition(), it->value.size()) - 1;
     else
         namedGridLineIndex = std::max<int>(it->value.size() - abs(position.integerPosition()), 0);
-    return GridPosition::adjustGridPositionForSide(it->value[namedGridLineIndex], side);
+    return GridResolvedPosition::adjustGridPositionForSide(it->value[namedGridLineIndex], side);
 }
 
-size_t RenderGrid::resolveGridPositionFromStyle(const GridPosition& position, GridPositionSide side) const
+GridResolvedPosition RenderGrid::resolveGridPositionFromStyle(const GridPosition& position, GridPositionSide side) const
 {
     switch (position.type()) {
     case ExplicitPosition: {
@@ -1043,16 +1043,16 @@ size_t RenderGrid::resolveGridPositionFromStyle(const GridPosition& position, Gr
 
         // Handle <integer> explicit position.
         if (position.isPositive())
-            return GridPosition::adjustGridPositionForSide(position.integerPosition() - 1, side);
+            return GridResolvedPosition::adjustGridPositionForSide(position.integerPosition() - 1, side);
 
         size_t resolvedPosition = abs(position.integerPosition()) - 1;
         const size_t endOfTrack = explicitGridSizeForSide(side);
 
         // Per http://lists.w3.org/Archives/Public/www-style/2013Mar/0589.html, we clamp negative value to the first line.
         if (endOfTrack < resolvedPosition)
-            return 0;
+            return GridResolvedPosition();
 
-        return GridPosition::adjustGridPositionForSide(endOfTrack - resolvedPosition, side);
+        return GridResolvedPosition::adjustGridPositionForSide(endOfTrack - resolvedPosition, side);
     }
     case NamedGridAreaPosition:
     {
@@ -1068,22 +1068,22 @@ size_t RenderGrid::resolveGridPositionFromStyle(const GridPosition& position, Gr
         case RowStartSide:
             return gridAreaCoordinate.rows.initialPositionIndex;
         case RowEndSide:
-            return gridAreaCoordinate.rows.finalPositionIndex;
+            return GridResolvedPosition(gridAreaCoordinate.rows.finalPositionIndex);
         }
         ASSERT_NOT_REACHED();
-        return 0;
+        return GridResolvedPosition();
     }
     case AutoPosition:
     case SpanPosition:
         // 'auto' and span depend on the opposite position for resolution (e.g. grid-row: auto / 1 or grid-column: span 3 / "myHeader").
         ASSERT_NOT_REACHED();
-        return 0;
+        return GridResolvedPosition();
     }
     ASSERT_NOT_REACHED();
-    return 0;
+    return GridResolvedPosition();
 }
 
-PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
+PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
 {
     if (position.isAuto())
         return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition);
@@ -1099,7 +1099,7 @@ PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(size
     return GridSpan::createWithSpanAgainstOpposite(resolvedOppositePosition, position, side);
 }
 
-PassOwnPtr<GridSpan> RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
+PassOwnPtr<GridSpan> RenderGrid::resolveNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) const
 {
     ASSERT(position.isSpan());
     ASSERT(!position.namedGridLine().isNull());
@@ -1122,7 +1122,7 @@ LayoutUnit RenderGrid::gridAreaBreadthForChild(const RenderBox* child, GridTrack
     const GridCoordinate& coordinate = cachedGridCoordinate(child);
     const GridSpan& span = (direction == ForColumns) ? coordinate.columns : coordinate.rows;
     LayoutUnit gridAreaBreadth = 0;
-    for (size_t trackIndex = span.initialPositionIndex; trackIndex <= span.finalPositionIndex; ++trackIndex)
+    for (size_t trackIndex = span.initialPositionIndex.integerPosition(); trackIndex <= span.finalPositionIndex.integerPosition(); ++trackIndex)
         gridAreaBreadth += tracks[trackIndex].m_usedBreadth;
     return gridAreaBreadth;
 }
@@ -1143,7 +1143,7 @@ void RenderGrid::populateGridPositions(const GridSizingData& sizingData)
 LayoutUnit RenderGrid::startOfColumnForChild(const RenderBox* child) const
 {
     const GridCoordinate& coordinate = cachedGridCoordinate(child);
-    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex];
+    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex.integerPosition()];
     // The grid items should be inside the grid container's border box, that's why they need to be shifted.
     // FIXME: This should account for the grid item's <overflow-position>.
     return startOfColumn + marginStartForChild(child);
@@ -1152,13 +1152,13 @@ LayoutUnit RenderGrid::startOfColumnForChild(const RenderBox* child) const
 LayoutUnit RenderGrid::endOfColumnForChild(const RenderBox* child) const
 {
     const GridCoordinate& coordinate = cachedGridCoordinate(child);
-    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex];
+    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex.integerPosition()];
     // The grid items should be inside the grid container's border box, that's why they need to be shifted.
     LayoutUnit columnPosition = startOfColumn + marginStartForChild(child);
 
-    LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionIndex + 1];
+    LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionIndex.integerPosition() + 1];
     // FIXME: This should account for the grid item's <overflow-position>.
-    return columnPosition + std::max<LayoutUnit>(0, endOfColumn - m_columnPositions[coordinate.columns.initialPositionIndex] - child->logicalWidth());
+    return columnPosition + std::max<LayoutUnit>(0, endOfColumn - m_columnPositions[coordinate.columns.initialPositionIndex.integerPosition()] - child->logicalWidth());
 }
 
 LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerStart(const RenderBox* child) const
@@ -1180,8 +1180,8 @@ LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerEnd(const RenderBox
 LayoutUnit RenderGrid::centeredColumnPositionForChild(const RenderBox* child) const
 {
     const GridCoordinate& coordinate = cachedGridCoordinate(child);
-    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex];
-    LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionIndex + 1];
+    LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPositionIndex.integerPosition()];
+    LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionIndex.integerPosition() + 1];
     LayoutUnit columnPosition = startOfColumn + marginStartForChild(child);
     return columnPosition + std::max<LayoutUnit>(0, endOfColumn - startOfColumn - child->logicalWidth()) / 2;
 }
@@ -1250,7 +1250,7 @@ LayoutUnit RenderGrid::rowPositionForChild(const RenderBox* child) const
     const GridCoordinate& coordinate = cachedGridCoordinate(child);
 
     // The grid items should be inside the grid container's border box, that's why they need to be shifted.
-    LayoutUnit startOfRow = m_rowPositions[coordinate.rows.initialPositionIndex];
+    LayoutUnit startOfRow = m_rowPositions[coordinate.rows.initialPositionIndex.integerPosition()];
     LayoutUnit rowPosition = startOfRow + marginBeforeForChild(child);
 
     // FIXME: This function should account for 'align-self'.
@@ -1285,11 +1285,11 @@ public:
         GridCoordinate first = m_renderer->cachedGridCoordinate(firstItem);
         GridCoordinate second = m_renderer->cachedGridCoordinate(secondItem);
 
-        if (first.rows.initialPositionIndex < second.rows.initialPositionIndex)
+        if (first.rows.initialPositionIndex.integerPosition() < second.rows.initialPositionIndex.integerPosition())
             return true;
-        if (first.rows.initialPositionIndex > second.rows.initialPositionIndex)
+        if (first.rows.initialPositionIndex.integerPosition() > second.rows.initialPositionIndex.integerPosition())
             return false;
-        return first.columns.finalPositionIndex < second.columns.finalPositionIndex;
+        return first.columns.finalPositionIndex.integerPosition() < second.columns.finalPositionIndex.integerPosition();
     }
 private:
     RenderGrid* m_renderer;
@@ -1297,17 +1297,17 @@ private:
 
 static inline bool isInSameRowBeforeDirtyArea(const GridCoordinate& coordinate, size_t row, const GridSpan& dirtiedColumns)
 {
-    return coordinate.rows.initialPositionIndex == row && coordinate.columns.initialPositionIndex < dirtiedColumns.initialPositionIndex;
+    return coordinate.rows.initialPositionIndex.integerPosition() == row && coordinate.columns.initialPositionIndex.integerPosition() < dirtiedColumns.initialPositionIndex.integerPosition();
 }
 
 static inline bool isInSameRowAfterDirtyArea(const GridCoordinate& coordinate, size_t row, const GridSpan& dirtiedColumns)
 {
-    return coordinate.rows.initialPositionIndex == row && coordinate.columns.initialPositionIndex >= dirtiedColumns.finalPositionIndex;
+    return coordinate.rows.initialPositionIndex.integerPosition() == row && coordinate.columns.initialPositionIndex.integerPosition() >= dirtiedColumns.finalPositionIndex.integerPosition();
 }
 
 static inline bool rowIsBeforeDirtyArea(const GridCoordinate& coordinate, const GridSpan& dirtiedRows)
 {
-    return coordinate.rows.initialPositionIndex < dirtiedRows.initialPositionIndex;
+    return coordinate.rows.initialPositionIndex.integerPosition() < dirtiedRows.initialPositionIndex.integerPosition();
 }
 
 void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
@@ -1335,14 +1335,14 @@ void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOff
                 populator.storeChild(*overflowIterator);
         }
 
-        for (size_t row = dirtiedRows.initialPositionIndex; row < dirtiedRows.finalPositionIndex; ++row) {
+        for (size_t row = dirtiedRows.initialPositionIndex.integerPosition(); row < dirtiedRows.finalPositionIndex.integerPosition(); ++row) {
 
             for (; overflowIterator != end && isInSameRowBeforeDirtyArea(cachedGridCoordinate(*overflowIterator), row, dirtiedColumns); ++overflowIterator) {
                 if ((*overflowIterator)->frameRect().intersects(localRepaintRect))
                     populator.storeChild(*overflowIterator);
             }
 
-            for (size_t column = dirtiedColumns.initialPositionIndex; column < dirtiedColumns.finalPositionIndex; ++column) {
+            for (size_t column = dirtiedColumns.initialPositionIndex.integerPosition(); column < dirtiedColumns.finalPositionIndex.integerPosition(); ++column) {
                 const Vector<RenderBox*, 1>& children = m_grid[row][column];
                 // FIXME: If we start adding spanning children in all grid areas they span, this
                 // would make us paint them several times, which is wrong!