Diff
Modified: trunk/Source/WebCore/ChangeLog (197399 => 197400)
--- trunk/Source/WebCore/ChangeLog 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/ChangeLog 2016-03-01 16:54:19 UTC (rev 197400)
@@ -1,3 +1,82 @@
+2016-03-01 Manuel Rego Casasnovas <[email protected]>
+
+ [css-grid] Get rid of GridResolvedPosition
+ https://bugs.webkit.org/show_bug.cgi?id=154818
+
+ Reviewed by Darin Adler.
+
+ GridResolvedPosition was a small class just wrapping a unsigned.
+ 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 unsigned 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.
+
+ * css/CSSGridTemplateAreasValue.cpp:
+ (WebCore::stringForPosition):
+ * css/CSSParser.cpp:
+ (WebCore::CSSParser::parseGridTemplateAreasRow):
+ * css/StyleBuilderConverter.h:
+ (WebCore::StyleBuilderConverter::createImplicitNamedGridLinesFromGridArea):
+ * rendering/RenderGrid.cpp:
+ (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
+ (WebCore::RenderGrid::findFlexFactorUnitSize):
+ (WebCore::RenderGrid::spanningItemCrossesFlexibleSizedTracks):
+ (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
+ (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForItems):
+ (WebCore::RenderGrid::insertItemIntoGrid):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
+ (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ * rendering/style/GridCoordinate.h:
+ (WebCore::GridSpan::definiteGridSpan):
+ (WebCore::GridSpan::integerSpan):
+ (WebCore::GridSpan::resolvedInitialPosition):
+ (WebCore::GridSpan::resolvedFinalPosition):
+ (WebCore::GridSpan::GridSpanIterator::GridSpanIterator):
+ (WebCore::GridSpan::GridSpanIterator::operator*):
+ (WebCore::GridSpan::GridSpanIterator::operator++):
+ (WebCore::GridSpan::GridSpanIterator::operator!=):
+ (WebCore::GridSpan::begin):
+ (WebCore::GridSpan::end):
+ (WebCore::GridSpan::GridSpan):
+ * rendering/style/GridResolvedPosition.cpp:
+ (WebCore::resolveNamedGridLinePositionFromStyle):
+ (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveGridPositionAgainstOppositePosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
+ (WebCore::resolveGridPositionFromStyle):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
+ * rendering/style/GridResolvedPosition.h:
+ (WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
+ (WebCore::GridResolvedPosition::operator*): Deleted.
+ (WebCore::GridResolvedPosition::operator++): Deleted.
+ (WebCore::GridResolvedPosition::operator==): Deleted.
+ (WebCore::GridResolvedPosition::operator!=): Deleted.
+ (WebCore::GridResolvedPosition::operator<): Deleted.
+ (WebCore::GridResolvedPosition::operator>): Deleted.
+ (WebCore::GridResolvedPosition::operator<=): Deleted.
+ (WebCore::GridResolvedPosition::operator>=): Deleted.
+ (WebCore::GridResolvedPosition::toInt): Deleted.
+ (WebCore::GridResolvedPosition::next): Deleted.
+ (WebCore::GridResolvedPosition::prev): Deleted.
+
2016-03-01 Andreas Kling <[email protected]>
MemoryCache::forEachResource() should guard resources across function invocation.
Modified: trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp (197399 => 197400)
--- trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-03-01 16:54:19 UTC (rev 197400)
@@ -55,13 +55,13 @@
for (const auto& it : gridAreaMap) {
const GridCoordinate& coordinate = it.value;
- if (row >= coordinate.rows.resolvedInitialPosition().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
+ if (row >= coordinate.rows.resolvedInitialPosition() && row < coordinate.rows.resolvedFinalPosition())
candidates.append(it.key);
}
for (const auto& it : gridAreaMap) {
const GridCoordinate& coordinate = it.value;
- if (column >= coordinate.columns.resolvedInitialPosition().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && candidates.contains(it.key))
+ if (column >= coordinate.columns.resolvedInitialPosition() && column < coordinate.columns.resolvedFinalPosition() && candidates.contains(it.key))
return it.key;
}
Modified: trunk/Source/WebCore/css/CSSParser.cpp (197399 => 197400)
--- trunk/Source/WebCore/css/CSSParser.cpp 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2016-03-01 16:54:19 UTC (rev 197400)
@@ -6245,18 +6245,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 (currentColumn != gridCoordinate.columns.resolvedInitialPosition().toInt())
+ if (currentColumn != gridCoordinate.columns.resolvedInitialPosition())
return false;
// 3. The new area ends at the same position as the previously parsed area.
- if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition().toInt())
+ if (lookAheadColumn != 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);
}
currentColumn = lookAheadColumn - 1;
}
Modified: trunk/Source/WebCore/css/StyleBuilderConverter.h (197399 => 197400)
--- trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-03-01 16:54:19 UTC (rev 197400)
@@ -886,12 +886,12 @@
GridSpan areaSpan = direction == ForRows ? area.value.rows : area.value.columns;
{
auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;
- startVector.append(areaSpan.resolvedInitialPosition().toInt());
+ startVector.append(areaSpan.resolvedInitialPosition());
std::sort(startVector.begin(), startVector.end());
}
{
auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
- endVector.append(areaSpan.resolvedFinalPosition().toInt());
+ endVector.append(areaSpan.resolvedFinalPosition());
std::sort(endVector.begin(), endVector.end());
}
}
Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (197399 => 197400)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-03-01 16:54:19 UTC (rev 197400)
@@ -577,7 +577,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)));
@@ -661,8 +661,7 @@
double flexFactorSum = 0;
Vector<unsigned, 8> flexibleTracksIndexes;
- for (const auto& resolvedPosition : tracksSpan) {
- unsigned trackIndex = resolvedPosition.toInt();
+ for (auto trackIndex : tracksSpan) {
GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
if (!trackSize.maxTrackBreadth().isFlex())
leftOverSpace -= tracks[trackIndex].baseSize();
@@ -811,7 +810,7 @@
bool RenderGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& itemSpan, GridTrackSizingDirection direction) const
{
for (auto trackPosition : itemSpan) {
- const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());
+ const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition);
if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
return true;
}
@@ -865,8 +864,8 @@
void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
{
- const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
- GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
+ unsigned trackPosition = span.resolvedInitialPosition();
+ GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
if (trackSize.hasMinContentMinTrackBreadth())
track.setBaseSize(std::max(track.baseSize(), minContentForChild(gridItem, direction, columnTracks)));
@@ -1020,9 +1019,9 @@
sizingData.filteredTracks.shrink(0);
sizingData.growBeyondGrowthLimitsTracks.shrink(0);
LayoutUnit spanningTracksSize;
- for (auto& trackPosition : itemSpan) {
- const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition.toInt());
- GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition.toInt()] : sizingData.rowTracks[trackPosition.toInt()];
+ for (auto trackPosition : itemSpan) {
+ const 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;
@@ -1139,11 +1138,11 @@
void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridCoordinate& coordinate)
{
ASSERT(coordinate.rows.isDefinite() && coordinate.columns.isDefinite());
- ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
+ ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.resolvedFinalPosition());
- for (auto& row : coordinate.rows) {
- for (auto& column : coordinate.columns)
- m_grid[row.toInt()][column.toInt()].append(&child);
+ for (auto row : coordinate.rows) {
+ for (auto column : coordinate.columns)
+ m_grid[row][column].append(&child);
}
}
@@ -1205,20 +1204,20 @@
GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
if (rowPositions.isDefinite()) {
- maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
+ maximumRowIndex = std::max(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(maximumRowIndex, positions.resolvedFinalPosition().toInt());
+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, 0);
+ maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition());
}
GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
if (columnPositions.isDefinite()) {
- maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
+ maximumColumnIndex = std::max(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(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, 0);
+ maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition());
}
m_gridItemCoordinate.set(child, GridCoordinate(rowPositions, columnPositions));
@@ -1233,7 +1232,7 @@
{
GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
- GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, crossDirection, GridResolvedPosition(endOfCrossDirection));
+ GridSpan crossDirectionPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, crossDirection, endOfCrossDirection);
return std::make_unique<GridCoordinate>(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions);
}
@@ -1251,10 +1250,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));
std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
if (!emptyGridArea)
emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
@@ -1263,7 +1262,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());
}
}
@@ -1285,7 +1284,7 @@
void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
{
ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isDefinite());
- GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
+ GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), 0);
const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
@@ -1295,18 +1294,18 @@
GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
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 (unsigned majorAxisIndex = majorAxisAutoPlacementCursor; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisIndex, minorAxisAutoPlacementCursor);
@@ -1314,9 +1313,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();
+ unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
const unsigned 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.
@@ -1334,8 +1333,8 @@
m_gridItemCoordinate.set(&gridItem, *emptyGridArea);
insertItemIntoGrid(gridItem, *emptyGridArea);
- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
+ autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
+ autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
}
GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
@@ -1480,22 +1479,22 @@
bool startIsAuto = startPosition.isAuto()
|| (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
- || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
+ || (positions.resolvedInitialPosition() > lastTrackIndex);
bool endIsAuto = endPosition.isAuto()
|| (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
- || (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();
+ unsigned firstPosition = 0;
+ unsigned initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
+ unsigned lastPosition = lastTrackIndex;
+ unsigned 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;
@@ -1537,8 +1536,8 @@
{
const GridSpan& span = cachedGridSpan(child, direction);
LayoutUnit gridAreaBreadth = 0;
- for (auto& trackPosition : span)
- gridAreaBreadth += tracks[trackPosition.toInt()].baseSize();
+ for (auto trackPosition : span)
+ gridAreaBreadth += tracks[trackPosition].baseSize();
gridAreaBreadth += guttersSize(direction, span.integerSpan());
@@ -1553,11 +1552,11 @@
const auto& span = cachedGridSpan(child, direction);
const auto& 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 we 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 RenderGrid::populateGridPositions(GridSizingData& sizingData)
@@ -1836,7 +1835,7 @@
LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
- unsigned childStartLine = rowsSpan.resolvedInitialPosition().toInt();
+ unsigned childStartLine = rowsSpan.resolvedInitialPosition();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
if (hasAutoMarginsInColumnAxis(child))
@@ -1847,7 +1846,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = rowsSpan.resolvedFinalPosition().toInt();
+ unsigned 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)
@@ -1870,7 +1869,7 @@
LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
- unsigned childStartLine = columnsSpan.resolvedInitialPosition().toInt();
+ unsigned childStartLine = columnsSpan.resolvedInitialPosition();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
if (hasAutoMarginsInRowAxis(child))
@@ -1881,7 +1880,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = columnsSpan.resolvedFinalPosition().toInt();
+ unsigned 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)
Modified: trunk/Source/WebCore/rendering/style/GridCoordinate.h (197399 => 197400)
--- trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-03-01 16:54:19 UTC (rev 197400)
@@ -49,7 +49,7 @@
class GridSpan {
public:
- static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
+ static GridSpan definiteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
{
return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
}
@@ -67,30 +67,41 @@
unsigned integerSpan() const
{
ASSERT(isDefinite());
- return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
+ return m_resolvedFinalPosition - m_resolvedInitialPosition;
}
- const GridResolvedPosition& resolvedInitialPosition() const
+ unsigned resolvedInitialPosition() const
{
ASSERT(isDefinite());
return m_resolvedInitialPosition;
}
- const GridResolvedPosition& resolvedFinalPosition() const
+ unsigned resolvedFinalPosition() const
{
ASSERT(isDefinite());
+ ASSERT(m_resolvedFinalPosition);
return m_resolvedFinalPosition;
}
- typedef GridResolvedPosition iterator;
+ struct GridSpanIterator {
+ GridSpanIterator(unsigned value)
+ : value(value)
+ {
+ }
- iterator begin() const
+ operator unsigned&() { return value; }
+ unsigned operator*() const { return value; }
+
+ unsigned value;
+ };
+
+ GridSpanIterator begin() const
{
ASSERT(isDefinite());
return m_resolvedInitialPosition;
}
- iterator end() const
+ GridSpanIterator end() const
{
ASSERT(isDefinite());
return m_resolvedFinalPosition;
@@ -105,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(unsigned resolvedInitialPosition, unsigned 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;
+ unsigned m_resolvedInitialPosition;
+ unsigned m_resolvedFinalPosition;
GridSpanType m_type;
Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp (197399 => 197400)
--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-03-01 16:54:19 UTC (rev 197400)
@@ -116,7 +116,7 @@
return isColumnSide(side) ? GridResolvedPosition::explicitGridColumnCount(gridContainerStyle) : GridResolvedPosition::explicitGridRowCount(gridContainerStyle);
}
-static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
+static unsigned resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
{
ASSERT(!position.namedGridLine().isNull());
@@ -137,25 +137,25 @@
return it->value[namedGridLineIndex];
}
-static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
+static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(unsigned resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
{
- if (!resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if (!resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
unsigned firstLineBeforePositionIndex = 0;
- auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
+ auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition);
if (firstLineBeforePosition != gridLines.end())
firstLineBeforePositionIndex = firstLineBeforePosition - gridLines.begin();
unsigned gridLineIndex = std::max<int>(0, firstLineBeforePositionIndex - position.spanPosition());
- GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
+ unsigned resolvedGridLinePosition = gridLines[gridLineIndex];
if (resolvedGridLinePosition >= resolvedOppositePosition)
- resolvedGridLinePosition = resolvedOppositePosition.prev();
- return GridSpan::definiteGridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
+ resolvedGridLinePosition = resolvedOppositePosition - 1;
+ return GridSpan::definiteGridSpan(std::min(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
}
-static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
+static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(unsigned resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
{
ASSERT(gridLines.size());
unsigned firstLineAfterOppositePositionIndex = gridLines.size() - 1;
@@ -164,13 +164,13 @@
firstLineAfterOppositePositionIndex = firstLineAfterOppositePosition - gridLines.begin();
unsigned gridLineIndex = std::min<unsigned>(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1);
- GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
+ unsigned resolvedGridLinePosition = gridLines[gridLineIndex];
if (resolvedGridLinePosition <= resolvedOppositePosition)
- resolvedGridLinePosition = resolvedOppositePosition.next();
+ resolvedGridLinePosition = resolvedOppositePosition + 1;
return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
}
-static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, unsigned resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
{
ASSERT(position.isSpan());
ASSERT(!position.namedGridLine().isNull());
@@ -183,9 +183,9 @@
// 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 (isStartSide(side) && resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if (isStartSide(side) && resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
}
if (side == RowStartSide || side == ColumnStartSide)
@@ -194,12 +194,12 @@
return resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(resolvedOppositePosition, position, it->value);
}
-static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, unsigned resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
{
if (position.isAuto()) {
- if (isStartSide(side) && resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if (isStartSide(side) && resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
}
ASSERT(position.isSpan());
@@ -214,17 +214,17 @@
// That's why the CSS span value is one more than the offset we apply.
unsigned positionOffset = position.spanPosition();
if (isStartSide(side)) {
- if (!resolvedOppositePosition.toInt())
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ if (!resolvedOppositePosition)
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
- unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
+ unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition - positionOffset);
return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
}
- return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
}
-GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
+GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, unsigned resolvedInitialPosition)
{
GridPosition initialPosition, finalPosition;
adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
@@ -233,7 +233,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();
+ unsigned resolvedFinalPosition = resolvedInitialPosition + 1;
if (initialPosition.isSpan())
return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide);
@@ -243,7 +243,7 @@
return GridSpan::definiteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
}
-static GridResolvedPosition resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
+static unsigned resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
{
switch (position.type()) {
case ExplicitPosition: {
@@ -294,10 +294,10 @@
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 RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
@@ -324,13 +324,13 @@
return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
}
- GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ unsigned resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ unsigned resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
if (resolvedInitialPosition > resolvedFinalPosition)
std::swap(resolvedInitialPosition, resolvedFinalPosition);
else if (resolvedInitialPosition == resolvedFinalPosition)
- resolvedFinalPosition = resolvedInitialPosition.next();
+ resolvedFinalPosition = resolvedInitialPosition + 1;
return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
}
Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.h (197399 => 197400)
--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-03-01 14:29:18 UTC (rev 197399)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-03-01 16:54:19 UTC (rev 197400)
@@ -46,79 +46,15 @@
ForRows
};
-// This class represents a line index into one of the dimensions of the grid array.
-// Wraps an unsigned integer just for the purpose of knowing what we manipulate in the grid code.
+// Class with all the code related to grid items positions resolution.
+// TODO(rego): Rename class to GridPositionsResolver.
class GridResolvedPosition {
public:
- GridResolvedPosition(unsigned 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;
- }
-
- unsigned toInt() const
- {
- return m_integerPosition;
- }
-
- GridResolvedPosition next() const
- {
- return GridResolvedPosition(m_integerPosition + 1);
- }
-
- GridResolvedPosition prev() const
- {
- return m_integerPosition ? m_integerPosition - 1 : 0;
- }
-
- static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, const GridResolvedPosition&);
+ static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, unsigned);
static GridSpan resolveGridPositionsFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
static unsigned explicitGridColumnCount(const RenderStyle&);
static unsigned explicitGridRowCount(const RenderStyle&);
static bool isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle&, GridPositionSide);
-
-private:
- unsigned m_integerPosition;
};
} // namespace WebCore
