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