[css-grid] Get rid of GridResolvedPosition
GridResolvedPosition was a small class just wrapping a size_t.
In the future it should actually wrap an integer
(as we want to support implicit tracks before the explicit grid).
The class itself is not providing any benefit,
so we can get rid of it and store directly 2 size_t in GridSpan.
This will make simpler future changes related to this task.
We keep the class just as a utility for the methods
that deal with the positions resolution.
But it should be renamed in a follow-up patch.
No new tests, no change of behavior.
BUG=444011
Review URL: https://codereview.chromium.org/1500433003
Cr-Commit-Position: refs/heads/master@{#363384}
diff --git a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
index 0fefa43..cf311f0b 100644
--- a/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
+++ b/third_party/WebKit/Source/core/css/CSSGridTemplateAreasValue.cpp
@@ -51,13 +51,13 @@
for (const auto& item : gridAreaMap) {
const GridCoordinate& coordinate = item.value;
- if (row >= coordinate.rows.resolvedInitialPosition().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
+ if (row >= coordinate.rows.resolvedInitialPosition() && row < coordinate.rows.resolvedFinalPosition())
candidates.append(item.key);
}
for (const auto& item : gridAreaMap) {
const GridCoordinate& coordinate = item.value;
- if (column >= coordinate.columns.resolvedInitialPosition().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && candidates.contains(item.key))
+ if (column >= coordinate.columns.resolvedInitialPosition() && column < coordinate.columns.resolvedFinalPosition() && candidates.contains(item.key))
return item.key;
}
diff --git a/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp b/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
index 033b23d..d33cdb3 100644
--- a/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
+++ b/third_party/WebKit/Source/core/css/parser/LegacyCSSPropertyParser.cpp
@@ -2720,18 +2720,18 @@
// The following checks test that the grid area is a single filled-in rectangle.
// 1. The new row is adjacent to the previously parsed row.
- if (rowCount != gridCoordinate.rows.resolvedFinalPosition().toInt())
+ if (rowCount != gridCoordinate.rows.resolvedFinalPosition())
return false;
// 2. The new area starts at the same position as the previously parsed area.
- if (currentCol != gridCoordinate.columns.resolvedInitialPosition().toInt())
+ if (currentCol != gridCoordinate.columns.resolvedInitialPosition())
return false;
// 3. The new area ends at the same position as the previously parsed area.
- if (lookAheadCol != gridCoordinate.columns.resolvedFinalPosition().toInt())
+ if (lookAheadCol != gridCoordinate.columns.resolvedFinalPosition())
return false;
- gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition().next());
+ gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition() + 1);
}
currentCol = lookAheadCol - 1;
}
diff --git a/third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp b/third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp
index 91cb9ea..4ed7a7c8 100644
--- a/third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp
+++ b/third_party/WebKit/Source/core/css/resolver/StyleBuilderConverter.cpp
@@ -521,12 +521,12 @@
GridSpan areaSpan = direction == ForRows ? namedGridAreaEntry.value.rows : namedGridAreaEntry.value.columns;
{
NamedGridLinesMap::AddResult startResult = namedGridLines.add(namedGridAreaEntry.key + "-start", Vector<size_t>());
- startResult.storedValue->value.append(areaSpan.resolvedInitialPosition().toInt());
+ startResult.storedValue->value.append(areaSpan.resolvedInitialPosition());
std::sort(startResult.storedValue->value.begin(), startResult.storedValue->value.end());
}
{
NamedGridLinesMap::AddResult endResult = namedGridLines.add(namedGridAreaEntry.key + "-end", Vector<size_t>());
- endResult.storedValue->value.append(areaSpan.resolvedFinalPosition().toInt());
+ endResult.storedValue->value.append(areaSpan.resolvedFinalPosition());
std::sort(endResult.storedValue->value.begin(), endResult.storedValue->value.end());
}
}
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
index e5cccec..d39d0b7 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
@@ -547,7 +547,7 @@
const GridSpan span = cachedGridSpan(*gridItem, direction);
// Do not include already processed items.
- if (i > 0 && span.resolvedInitialPosition().toInt() <= flexibleSizedTracksIndex[i - 1])
+ if (i > 0 && span.resolvedInitialPosition() <= flexibleSizedTracksIndex[i - 1])
continue;
flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData.columnTracks)));
@@ -631,8 +631,7 @@
double flexFactorSum = 0;
Vector<size_t, 8> flexibleTracksIndexes;
- for (const auto& resolvedPosition : tracksSpan) {
- size_t trackIndex = resolvedPosition.toInt();
+ for (const auto& trackIndex : tracksSpan) {
GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
if (!trackSize.maxTrackBreadth().isFlex()) {
leftOverSpace -= tracks[trackIndex].baseSize();
@@ -785,7 +784,7 @@
bool LayoutGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& span, GridTrackSizingDirection direction) const
{
for (const auto& trackPosition : span) {
- const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());
+ const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition);
if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
return true;
}
@@ -834,8 +833,8 @@
void LayoutGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, LayoutBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
{
- const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
- GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
+ const size_t trackPosition = span.resolvedInitialPosition();
+ GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
if (trackSize.hasMinContentMinTrackBreadth())
track.setBaseSize(std::max(track.baseSize(), minContentForChild(gridItem, direction, columnTracks)));
@@ -993,8 +992,8 @@
sizingData.filteredTracks.shrink(0);
LayoutUnit spanningTracksSize;
for (const auto& trackPosition : itemSpan) {
- GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
- GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition.toInt()] : sizingData.rowTracks[trackPosition.toInt()];
+ GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
+ GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
spanningTracksSize += trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
continue;
@@ -1106,11 +1105,11 @@
void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridCoordinate& coordinate)
{
RELEASE_ASSERT(coordinate.rows.isDefinite() && coordinate.columns.isDefinite());
- ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
+ ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.resolvedFinalPosition());
- for (GridSpan::iterator row = coordinate.rows.begin(); row != coordinate.rows.end(); ++row) {
- for (GridSpan::iterator column = coordinate.columns.begin(); column != coordinate.columns.end(); ++column)
- m_grid[row.toInt()][column.toInt()].append(&child);
+ for (const auto& row : coordinate.rows) {
+ for (const auto& column: coordinate.columns)
+ m_grid[row][column].append(&child);
}
}
@@ -1186,19 +1185,19 @@
// |positions| is 0 if we need to run the auto-placement algorithm.
if (rowPositions.isDefinite()) {
- maximumRowIndex = std::max<size_t>(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
+ maximumRowIndex = std::max<size_t>(maximumRowIndex, rowPositions.resolvedFinalPosition());
} else {
// Grow the grid for items with a definite row span, getting the largest such span.
- GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *child, ForRows, GridResolvedPosition(0));
- maximumRowIndex = std::max<size_t>(maximumRowIndex, positions.resolvedFinalPosition().toInt());
+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *child, ForRows, 0);
+ maximumRowIndex = std::max<size_t>(maximumRowIndex, positions.resolvedFinalPosition());
}
if (columnPositions.isDefinite()) {
- maximumColumnIndex = std::max<size_t>(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
+ maximumColumnIndex = std::max<size_t>(maximumColumnIndex, columnPositions.resolvedFinalPosition());
} else {
// Grow the grid for items with a definite column span, getting the largest such span.
- GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *child, ForColumns, GridResolvedPosition(0));
- maximumColumnIndex = std::max<size_t>(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *child, ForColumns, 0);
+ maximumColumnIndex = std::max<size_t>(maximumColumnIndex, positions.resolvedFinalPosition());
}
}
@@ -1211,7 +1210,7 @@
{
GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
const size_t endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
- GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, crossDirection, GridResolvedPosition(endOfCrossDirection));
+ GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, crossDirection, endOfCrossDirection);
return adoptPtr(new GridCoordinate(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions));
}
@@ -1229,10 +1228,10 @@
GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
ASSERT(majorAxisPositions.isDefinite());
ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isDefinite());
- GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
- unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition().toInt();
+ GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), *autoGridItem, autoPlacementMinorAxisDirection(), 0);
+ unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
- GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition().toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
+ GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
if (!emptyGridArea)
emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
@@ -1241,7 +1240,7 @@
insertItemIntoGrid(*autoGridItem, *emptyGridArea);
if (!isGridAutoFlowDense)
- minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition().toInt() : emptyGridArea->columns.resolvedInitialPosition().toInt());
+ minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitialPosition());
}
}
@@ -1265,7 +1264,7 @@
{
GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isDefinite());
- GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
+ GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, autoPlacementMajorAxisDirection(), 0);
const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
size_t majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
@@ -1274,18 +1273,18 @@
OwnPtr<GridCoordinate> emptyGridArea;
if (minorAxisPositions.isDefinite()) {
// Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
- if (minorAxisPositions.resolvedInitialPosition().toInt() < minorAxisAutoPlacementCursor)
+ if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
majorAxisAutoPlacementCursor++;
if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
- GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition().toInt(), majorAxisAutoPlacementCursor);
+ GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor);
emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisPositions.integerSpan());
}
if (!emptyGridArea)
emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), minorAxisPositions);
} else {
- GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
+ GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(*style(), gridItem, autoPlacementMinorAxisDirection(), 0);
for (size_t majorAxisIndex = majorAxisAutoPlacementCursor; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisIndex, minorAxisAutoPlacementCursor);
@@ -1293,9 +1292,9 @@
if (emptyGridArea) {
// Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
- GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
+ size_t minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
const size_t endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
- if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
+ if (minorAxisFinalPositionIndex <= endOfMinorAxis)
break;
// Discard empty grid area as it does not fit in the minor axis direction.
@@ -1314,8 +1313,8 @@
m_gridItemCoordinate.set(&gridItem, *emptyGridArea);
insertItemIntoGrid(gridItem, *emptyGridArea);
// Move auto-placement cursor to the new position.
- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
+ autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
+ autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
}
GridTrackSizingDirection LayoutGrid::autoPlacementMajorAxisDirection() const
@@ -1418,8 +1417,8 @@
#if ENABLE(ASSERT)
const GridCoordinate& coordinate = cachedGridCoordinate(*child);
- ASSERT(coordinate.columns.resolvedInitialPosition().toInt() < sizingData.columnTracks.size());
- ASSERT(coordinate.rows.resolvedInitialPosition().toInt() < sizingData.rowTracks.size());
+ ASSERT(coordinate.columns.resolvedInitialPosition() < sizingData.columnTracks.size());
+ ASSERT(coordinate.rows.resolvedInitialPosition() < sizingData.rowTracks.size());
#endif
child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
@@ -1488,22 +1487,22 @@
bool startIsAuto = startPosition.isAuto()
|| (startPosition.isNamedGridArea() && !GridResolvedPosition::isValidNamedLineOrArea(startPosition.namedGridLine(), styleRef(), GridResolvedPosition::initialPositionSide(direction)))
- || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
+ || (positions.resolvedInitialPosition() > lastTrackIndex);
bool endIsAuto = endPosition.isAuto()
|| (endPosition.isNamedGridArea() && !GridResolvedPosition::isValidNamedLineOrArea(endPosition.namedGridLine(), styleRef(), GridResolvedPosition::finalPositionSide(direction)))
- || (positions.resolvedFinalPosition().prev().toInt() > lastTrackIndex);
+ || (positions.resolvedFinalPosition() - 1 > lastTrackIndex);
- GridResolvedPosition firstPosition = GridResolvedPosition(0);
- GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
- GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
- GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition().prev();
+ size_t firstPosition = 0;
+ size_t initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
+ size_t lastPosition = lastTrackIndex;
+ size_t finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition() - 1;
// Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
- initialPosition = std::min<GridResolvedPosition>(initialPosition, lastPosition);
- finalPosition = std::min<GridResolvedPosition>(finalPosition, lastPosition);
+ initialPosition = std::min(initialPosition, lastPosition);
+ finalPosition = std::min(finalPosition, lastPosition);
- LayoutUnit start = startIsAuto ? LayoutUnit() : (direction == ForColumns) ? m_columnPositions[initialPosition.toInt()] : m_rowPositions[initialPosition.toInt()];
- LayoutUnit end = endIsAuto ? (direction == ForColumns) ? logicalWidth() : logicalHeight() : (direction == ForColumns) ? m_columnPositions[finalPosition.next().toInt()] : m_rowPositions[finalPosition.next().toInt()];
+ LayoutUnit start = startIsAuto ? LayoutUnit() : (direction == ForColumns) ? m_columnPositions[initialPosition] : m_rowPositions[initialPosition];
+ LayoutUnit end = endIsAuto ? (direction == ForColumns) ? logicalWidth() : logicalHeight() : (direction == ForColumns) ? m_columnPositions[finalPosition + 1] : m_rowPositions[finalPosition + 1];
breadth = end - start;
@@ -1545,8 +1544,8 @@
{
const GridSpan& span = cachedGridSpan(child, direction);
LayoutUnit gridAreaBreadth = 0;
- for (GridSpan::iterator trackPosition = span.begin(); trackPosition != span.end(); ++trackPosition)
- gridAreaBreadth += tracks[trackPosition.toInt()].baseSize();
+ for (const auto& trackPosition : span)
+ gridAreaBreadth += tracks[trackPosition].baseSize();
gridAreaBreadth += guttersSize(direction, span.integerSpan());
@@ -1560,10 +1559,10 @@
const Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
const GridSpan& span = cachedGridSpan(child, direction);
const Vector<LayoutUnit>& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
- LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition().toInt()];
- LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition().prev().toInt()];
+ LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition()];
+ LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition() - 1];
// Track Positions vector stores the 'start' grid line of each track, so w have to add last track's baseSize.
- return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition().prev().toInt()].baseSize();
+ return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition() - 1].baseSize();
}
void LayoutGrid::populateGridPositions(GridSizingData& sizingData)
@@ -1870,7 +1869,7 @@
LayoutUnit LayoutGrid::columnAxisOffsetForChild(const LayoutBox& child) const
{
const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
- size_t childStartLine = rowsSpan.resolvedInitialPosition().toInt();
+ size_t childStartLine = rowsSpan.resolvedInitialPosition();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
if (hasAutoMarginsInColumnAxis(child))
@@ -1881,7 +1880,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- size_t childEndLine = rowsSpan.resolvedFinalPosition().toInt();
+ size_t childEndLine = rowsSpan.resolvedFinalPosition();
LayoutUnit endOfRow = m_rowPositions[childEndLine];
// m_rowPositions include gutters so we need to substract them to get the actual end position for a given
// row (this does not have to be done for the last track as there are no more m_rowPositions after it)
@@ -1902,7 +1901,7 @@
LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child) const
{
const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
- size_t childStartLine = columnsSpan.resolvedInitialPosition().toInt();
+ size_t childStartLine = columnsSpan.resolvedInitialPosition();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
if (hasAutoMarginsInRowAxis(child))
@@ -1913,7 +1912,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- size_t childEndLine = columnsSpan.resolvedFinalPosition().toInt();
+ size_t childEndLine = columnsSpan.resolvedFinalPosition();
LayoutUnit endOfColumn = m_columnPositions[childEndLine];
// m_columnPositions include gutters so we need to substract them to get the actual end position for a given
// column (this does not have to be done for the last track as there are no more m_columnPositions after it)
diff --git a/third_party/WebKit/Source/core/paint/GridPainter.cpp b/third_party/WebKit/Source/core/paint/GridPainter.cpp
index 3fa13c8..d25a196 100644
--- a/third_party/WebKit/Source/core/paint/GridPainter.cpp
+++ b/third_party/WebKit/Source/core/paint/GridPainter.cpp
@@ -51,9 +51,9 @@
Vector<std::pair<LayoutBox*, size_t>> gridItemsToBePainted;
- for (GridSpan::iterator row = dirtiedRows.begin(); row != dirtiedRows.end(); ++row) {
- for (GridSpan::iterator column = dirtiedColumns.begin(); column != dirtiedColumns.end(); ++column) {
- const Vector<LayoutBox*, 1>& children = m_layoutGrid.gridCell(row.toInt(), column.toInt());
+ for (const auto& row : dirtiedRows) {
+ for (const auto& column : dirtiedColumns) {
+ const Vector<LayoutBox*, 1>& children = m_layoutGrid.gridCell(row, column);
for (auto* child : children)
gridItemsToBePainted.append(std::make_pair(child, m_layoutGrid.paintIndexForGridItem(child)));
}
diff --git a/third_party/WebKit/Source/core/style/GridCoordinate.h b/third_party/WebKit/Source/core/style/GridCoordinate.h
index 9287de3..bd1592f 100644
--- a/third_party/WebKit/Source/core/style/GridCoordinate.h
+++ b/third_party/WebKit/Source/core/style/GridCoordinate.h
@@ -50,7 +50,7 @@
USING_FAST_MALLOC(GridSpan);
public:
- static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
+ static GridSpan definiteGridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition)
{
return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
}
@@ -68,30 +68,40 @@
size_t integerSpan() const
{
ASSERT(isDefinite());
- return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
+ ASSERT(m_resolvedFinalPosition > m_resolvedInitialPosition);
+ return m_resolvedFinalPosition - m_resolvedInitialPosition;
}
- const GridResolvedPosition& resolvedInitialPosition() const
+ size_t resolvedInitialPosition() const
{
ASSERT(isDefinite());
return m_resolvedInitialPosition;
}
- const GridResolvedPosition& resolvedFinalPosition() const
+ size_t resolvedFinalPosition() const
{
ASSERT(isDefinite());
+ ASSERT(m_resolvedFinalPosition);
return m_resolvedFinalPosition;
}
- typedef GridResolvedPosition iterator;
+ struct GridSpanIterator {
+ GridSpanIterator(size_t v) : value(v) {}
- iterator begin() const
+ size_t operator*() const { return value; }
+ size_t operator++() { return value++; }
+ bool operator!=(GridSpanIterator other) const { return value != other.value; }
+
+ size_t value;
+ };
+
+ GridSpanIterator begin() const
{
ASSERT(isDefinite());
return m_resolvedInitialPosition;
}
- iterator end() const
+ GridSpanIterator end() const
{
ASSERT(isDefinite());
return m_resolvedFinalPosition;
@@ -106,16 +116,16 @@
enum GridSpanType {Definite, Indefinite};
- GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition, GridSpanType type)
- : m_resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
- , m_resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
+ GridSpan(size_t resolvedInitialPosition, size_t resolvedFinalPosition, GridSpanType type)
+ : m_resolvedInitialPosition(std::min(resolvedInitialPosition, kGridMaxTracks - 1))
+ , m_resolvedFinalPosition(std::min(resolvedFinalPosition, kGridMaxTracks))
, m_type(type)
{
ASSERT(resolvedInitialPosition < resolvedFinalPosition);
}
- GridResolvedPosition m_resolvedInitialPosition;
- GridResolvedPosition m_resolvedFinalPosition;
+ size_t m_resolvedInitialPosition;
+ size_t m_resolvedFinalPosition;
GridSpanType m_type;
};
diff --git a/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp b/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp
index 6b8dc94..b80e5fa 100644
--- a/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp
+++ b/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp
@@ -62,37 +62,38 @@
initialPosition.setSpanPosition(1, String());
}
-static GridSpan definiteGridSpanWithInitialNamedSpanAgainstOpposite(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines)
+static GridSpan definiteGridSpanWithInitialNamedSpanAgainstOpposite(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines)
{
if (resolvedOppositePosition == 0)
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
size_t firstLineBeforeOppositePositionIndex = 0;
- const size_t* firstLineBeforeOppositePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
+ const size_t* firstLineBeforeOppositePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition);
if (firstLineBeforeOppositePosition != gridLines.end())
firstLineBeforeOppositePositionIndex = firstLineBeforeOppositePosition - gridLines.begin();
size_t gridLineIndex = std::max<int>(0, firstLineBeforeOppositePositionIndex - position.spanPosition());
- GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
+ size_t resolvedGridLinePosition = gridLines[gridLineIndex];
if (resolvedGridLinePosition >= resolvedOppositePosition)
- resolvedGridLinePosition = resolvedOppositePosition.prev();
+ resolvedGridLinePosition = resolvedOppositePosition - 1;
return GridSpan::definiteGridSpan(resolvedGridLinePosition, resolvedOppositePosition);
}
-static GridSpan definiteGridSpanWithFinalNamedSpanAgainstOpposite(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines)
+static GridSpan definiteGridSpanWithFinalNamedSpanAgainstOpposite(size_t resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines)
{
+ ASSERT(gridLines.size());
size_t firstLineAfterOppositePositionIndex = gridLines.size() - 1;
- const size_t* firstLineAfterOppositePosition = std::upper_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
+ const size_t* firstLineAfterOppositePosition = std::upper_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition);
if (firstLineAfterOppositePosition != gridLines.end())
firstLineAfterOppositePositionIndex = firstLineAfterOppositePosition - gridLines.begin();
size_t gridLineIndex = std::min(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1);
- GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
+ size_t resolvedGridLinePosition = gridLines[gridLineIndex];
if (resolvedGridLinePosition <= resolvedOppositePosition)
- resolvedGridLinePosition = resolvedOppositePosition.next();
+ resolvedGridLinePosition = resolvedOppositePosition + 1;
return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
}
-static GridSpan definiteGridSpanWithNamedSpanAgainstOpposite(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<size_t>& gridLines)
+static GridSpan definiteGridSpanWithNamedSpanAgainstOpposite(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<size_t>& gridLines)
{
if (side == RowStartSide || side == ColumnStartSide)
return definiteGridSpanWithInitialNamedSpanAgainstOpposite(resolvedOppositePosition, position, gridLines);
@@ -100,7 +101,7 @@
return definiteGridSpanWithFinalNamedSpanAgainstOpposite(resolvedOppositePosition, position, gridLines);
}
-static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
{
ASSERT(position.isSpan());
ASSERT(!position.namedGridLine().isNull());
@@ -113,34 +114,34 @@
// If there is no named grid line of that name, we resolve the position to 'auto' (which is equivalent to 'span 1' in this case).
// See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
if (it == gridLinesNames.end()) {
- if ((side == ColumnStartSide || side == RowStartSide) && resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if ((side == ColumnStartSide || side == RowStartSide) && resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
}
return definiteGridSpanWithNamedSpanAgainstOpposite(resolvedOppositePosition, position, side, it->value);
}
-static GridSpan definiteGridSpanWithSpanAgainstOpposite(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan definiteGridSpanWithSpanAgainstOpposite(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
{
size_t positionOffset = position.spanPosition();
if (side == ColumnStartSide || side == RowStartSide) {
if (resolvedOppositePosition == 0)
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
- GridResolvedPosition initialResolvedPosition = GridResolvedPosition(std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset));
+ size_t initialResolvedPosition = std::max<int>(0, resolvedOppositePosition - positionOffset);
return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
}
- return GridSpan::definiteGridSpan(resolvedOppositePosition, GridResolvedPosition(resolvedOppositePosition.toInt() + positionOffset));
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
}
-static GridSpan resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
{
if (position.isAuto()) {
- if ((side == ColumnStartSide || side == RowStartSide) && resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if ((side == ColumnStartSide || side == RowStartSide) && resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
}
ASSERT(position.isSpan());
@@ -154,7 +155,7 @@
return definiteGridSpanWithSpanAgainstOpposite(resolvedOppositePosition, position, side);
}
-GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
+GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, size_t resolvedInitialPosition)
{
GridPosition initialPosition, finalPosition;
initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
@@ -164,7 +165,7 @@
// This method will only be used when both positions need to be resolved against the opposite one.
ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
- GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
+ size_t resolvedFinalPosition = resolvedInitialPosition + 1;
if (initialPosition.isSpan())
return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide);
@@ -189,7 +190,7 @@
return (side == ColumnStartSide || side == ColumnEndSide) ? GridResolvedPosition::explicitGridColumnCount(gridContainerStyle) : GridResolvedPosition::explicitGridRowCount(gridContainerStyle);
}
-static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
+static size_t resolveNamedGridLinePositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
{
ASSERT(!position.namedGridLine().isNull());
@@ -197,8 +198,8 @@
NamedGridLinesMap::const_iterator it = gridLinesNames.find(position.namedGridLine());
if (it == gridLinesNames.end()) {
if (position.isPositive())
- return GridResolvedPosition(0);
- const size_t lastLine = explicitGridSizeForSide(gridContainerStyle, side);
+ return 0;
+ size_t lastLine = explicitGridSizeForSide(gridContainerStyle, side);
return lastLine;
}
@@ -210,7 +211,7 @@
return it->value[namedGridLineIndex];
}
-static GridResolvedPosition resolveGridPositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
+static size_t resolveGridPositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
{
switch (position.type()) {
case ExplicitPosition: {
@@ -224,11 +225,11 @@
return position.integerPosition() - 1;
size_t resolvedPosition = abs(position.integerPosition()) - 1;
- const size_t endOfTrack = explicitGridSizeForSide(gridContainerStyle, side);
+ size_t endOfTrack = explicitGridSizeForSide(gridContainerStyle, 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 GridResolvedPosition(0);
+ return 0;
return endOfTrack - resolvedPosition;
}
@@ -255,16 +256,16 @@
// this function in GridResolvedPosition::resolveGridPositionsFromStyle(). We should be also covered by the
// ASSERT at the beginning of this block.
ASSERT_NOT_REACHED();
- return GridResolvedPosition(0);
+ return 0;
}
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 GridResolvedPosition(0);
+ return 0;
}
ASSERT_NOT_REACHED();
- return GridResolvedPosition(0);
+ return 0;
}
GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction)
@@ -282,23 +283,23 @@
if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
- GridResolvedPosition finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ size_t finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
}
if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
- GridResolvedPosition initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ size_t initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
}
- GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ size_t resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ size_t resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
if (resolvedFinalPosition < resolvedInitialPosition)
std::swap(resolvedFinalPosition, resolvedInitialPosition);
else if (resolvedFinalPosition == resolvedInitialPosition)
- resolvedFinalPosition = resolvedInitialPosition.next();
+ resolvedFinalPosition = resolvedInitialPosition + 1;
return GridSpan::definiteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
}
diff --git a/third_party/WebKit/Source/core/style/GridResolvedPosition.h b/third_party/WebKit/Source/core/style/GridResolvedPosition.h
index add326d..6d4a77e 100644
--- a/third_party/WebKit/Source/core/style/GridResolvedPosition.h
+++ b/third_party/WebKit/Source/core/style/GridResolvedPosition.h
@@ -26,73 +26,12 @@
ForRows
};
-// This class represents a line index into one of the dimensions of the grid array.
-// Wraps a size_t integer just for the purpose of knowing what we manipulate in the grid code.
+// This is a utility class with all the code related to grid items positions resolution.
+// TODO(rego): Rename class to GridPositionsResolver.
class GridResolvedPosition {
DISALLOW_NEW();
public:
- GridResolvedPosition(size_t position)
- : m_integerPosition(position)
- {
- }
-
- GridResolvedPosition& operator*()
- {
- return *this;
- }
-
- GridResolvedPosition& operator++()
- {
- m_integerPosition++;
- return *this;
- }
-
- bool operator==(const GridResolvedPosition& other) const
- {
- return m_integerPosition == other.m_integerPosition;
- }
-
- bool operator!=(const GridResolvedPosition& other) const
- {
- return m_integerPosition != other.m_integerPosition;
- }
-
- bool operator<(const GridResolvedPosition& other) const
- {
- return m_integerPosition < other.m_integerPosition;
- }
-
- bool operator>(const GridResolvedPosition& other) const
- {
- return m_integerPosition > other.m_integerPosition;
- }
-
- bool operator<=(const GridResolvedPosition& other) const
- {
- return m_integerPosition <= other.m_integerPosition;
- }
-
- bool operator>=(const GridResolvedPosition& other) const
- {
- return m_integerPosition >= other.m_integerPosition;
- }
-
- size_t toInt() const
- {
- return m_integerPosition;
- }
-
- GridResolvedPosition next() const
- {
- return GridResolvedPosition(m_integerPosition + 1);
- }
-
- GridResolvedPosition prev() const
- {
- return GridResolvedPosition(m_integerPosition > 0 ? m_integerPosition - 1 : 0);
- }
-
static size_t explicitGridColumnCount(const ComputedStyle&);
static size_t explicitGridRowCount(const ComputedStyle&);
@@ -101,12 +40,9 @@
static GridPositionSide initialPositionSide(GridTrackSizingDirection);
static GridPositionSide finalPositionSide(GridTrackSizingDirection);
- static GridSpan resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle&, const LayoutBox&, GridTrackSizingDirection, const GridResolvedPosition&);
+ static GridSpan resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle&, const LayoutBox&, GridTrackSizingDirection, size_t resolvedInitialPosition);
static GridSpan resolveGridPositionsFromStyle(const ComputedStyle&, const LayoutBox&, GridTrackSizingDirection);
-private:
-
- size_t m_integerPosition;
};
} // namespace blink
