Diff
Modified: trunk/Source/WebCore/ChangeLog (196690 => 196691)
--- trunk/Source/WebCore/ChangeLog 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/ChangeLog 2016-02-17 11:45:30 UTC (rev 196691)
@@ -1,3 +1,77 @@
+2016-02-17 Manuel Rego Casasnovas <[email protected]>
+
+ [css-grid] GridSpan refactoring
+ https://bugs.webkit.org/show_bug.cgi?id=153868
+
+ Reviewed by Sergio Villar Senin.
+
+ Add new enum to know if a GridSpan is definite or indefinite.
+ That way we don't need GridUnresolvedSpan class (which is removed).
+ We can always have two GridSpans in GridCoordinate,
+ if the position is "auto" the GridSpan will be marked as indefinite.
+ This will allow in a follow-up patch to avoid repeated calls
+ to methods that resolve positions.
+
+ Most operations in GridSpan are restricted to definite GridSpans (access
+ to positions, iterator, etc.). For indefinite GridSpans we only need to
+ know that they're indefinite, we shouldn't use the rest of the data.
+
+ 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::GridIterator::nextEmptyGridArea):
+ (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
+ (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
+ (WebCore::RenderGrid::insertItemIntoGrid):
+ (WebCore::RenderGrid::placeItemsOnGrid):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
+ (WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
+ (WebCore::RenderGrid::populateGridPositions): Deleted.
+ * rendering/style/GridCoordinate.h:
+ (WebCore::GridSpan::definiteGridSpan):
+ (WebCore::GridSpan::indefiniteGridSpan):
+ (WebCore::GridSpan::operator==):
+ (WebCore::GridSpan::integerSpan):
+ (WebCore::GridSpan::resolvedInitialPosition):
+ (WebCore::GridSpan::resolvedFinalPosition):
+ (WebCore::GridSpan::begin):
+ (WebCore::GridSpan::end):
+ (WebCore::GridSpan::isDefinite):
+ (WebCore::GridSpan::GridSpan):
+ (WebCore::GridCoordinate::GridCoordinate):
+ * rendering/style/GridResolvedPosition.cpp:
+ (WebCore::initialPositionSide):
+ (WebCore::finalPositionSide):
+ (WebCore::adjustGridPositionsFromStyle):
+ (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveGridPositionAgainstOppositePosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
+ (WebCore::implicitNamedGridLineForSide): Deleted.
+ (WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Deleted.
+ (WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
+ (WebCore::resolveGridPositionFromStyle): Deleted.
+ * rendering/style/GridResolvedPosition.h:
+ (WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
+ (WebCore::GridResolvedPosition::operator*): Deleted.
+ (WebCore::GridResolvedPosition::operator++): Deleted.
+ (WebCore::GridResolvedPosition::operator==): Deleted.
+
2016-02-17 Chris Dumez <[email protected]>
Window should have its 'constructor' property on the prototype
Modified: trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp (196690 => 196691)
--- trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-02-17 11:45:30 UTC (rev 196691)
@@ -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().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
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().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && candidates.contains(it.key))
return it.key;
}
Modified: trunk/Source/WebCore/css/CSSParser.cpp (196690 => 196691)
--- trunk/Source/WebCore/css/CSSParser.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2016-02-17 11:45:30 UTC (rev 196691)
@@ -6217,24 +6217,24 @@
auto gridAreaIterator = gridAreaMap.find(gridAreaName);
if (gridAreaIterator == gridAreaMap.end())
- gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount + 1), GridSpan(currentColumn, lookAheadColumn)));
+ gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::definiteGridSpan(rowCount, rowCount + 1), GridSpan::definiteGridSpan(currentColumn, lookAheadColumn)));
else {
GridCoordinate& gridCoordinate = gridAreaIterator->value;
// 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().toInt())
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().toInt())
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().toInt())
return false;
- ++gridCoordinate.rows.resolvedFinalPosition;
+ gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition().next());
}
currentColumn = lookAheadColumn - 1;
}
Modified: trunk/Source/WebCore/css/StyleBuilderConverter.h (196690 => 196691)
--- trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-02-17 11:45:30 UTC (rev 196691)
@@ -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().toInt());
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().toInt());
std::sort(endVector.begin(), endVector.end());
}
}
Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (196690 => 196691)
--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-02-17 11:45:30 UTC (rev 196691)
@@ -190,7 +190,7 @@
const unsigned endOfVaryingTrackIndex = (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
if (isEmptyAreaEnough(rowSpan, columnSpan)) {
- std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan(m_columnIndex, m_columnIndex + columnSpan));
+ std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan::definiteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::definiteGridSpan(m_columnIndex, m_columnIndex + columnSpan));
// Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
++varyingTrackIndex;
return result;
@@ -566,7 +566,7 @@
// 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
double flexFraction = 0;
if (hasDefiniteFreeSpace)
- flexFraction = findFlexFactorUnitSize(tracks, GridSpan(0, tracks.size()), direction, initialFreeSpace.value());
+ flexFraction = findFlexFactorUnitSize(tracks, GridSpan::definiteGridSpan(0, tracks.size()), direction, initialFreeSpace.value());
else {
for (const auto& trackIndex : flexibleSizedTracksIndex)
flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
@@ -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().toInt() <= flexibleSizedTracksIndex[i - 1])
continue;
flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData.columnTracks)));
@@ -865,7 +865,7 @@
void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
{
- const GridResolvedPosition trackPosition = span.resolvedInitialPosition;
+ const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
if (trackSize.hasMinContentMinTrackBreadth())
@@ -1138,7 +1138,7 @@
void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridCoordinate& coordinate)
{
- ensureGridSize(coordinate.rows.resolvedFinalPosition.toInt(), coordinate.columns.resolvedFinalPosition.toInt());
+ ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
for (auto& row : coordinate.rows) {
for (auto& column : coordinate.columns)
@@ -1160,21 +1160,18 @@
if (child->isOutOfFlowPositioned())
continue;
- auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
- auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
+ GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
+ GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
- if (unresolvedRowPositions.requiresAutoPlacement() || unresolvedColumnPositions.requiresAutoPlacement()) {
-
+ if (!rowPositions.isDefinite() || !columnPositions.isDefinite()) {
bool majorAxisDirectionIsForColumns = autoPlacementMajorAxisDirection() == ForColumns;
- if ((majorAxisDirectionIsForColumns && unresolvedColumnPositions.requiresAutoPlacement())
- || (!majorAxisDirectionIsForColumns && unresolvedRowPositions.requiresAutoPlacement()))
+ if ((majorAxisDirectionIsForColumns && !columnPositions.isDefinite())
+ || (!majorAxisDirectionIsForColumns && !rowPositions.isDefinite()))
autoMajorAxisAutoGridItems.append(child);
else
specifiedMajorAxisAutoGridItems.append(child);
continue;
}
- GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
- GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
insertItemIntoGrid(*child, GridCoordinate(rowPositions, columnPositions));
}
@@ -1197,24 +1194,22 @@
populator.collectChild(*child);
- auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
- if (!unresolvedRowPositions.requiresAutoPlacement()) {
- GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
- maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.toInt());
+ GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
+ if (rowPositions.isDefinite()) {
+ maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
} 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());
+ maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition().toInt());
}
- auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
- if (!unresolvedColumnPositions.requiresAutoPlacement()) {
- GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
- maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.toInt());
+ GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
+ if (columnPositions.isDefinite()) {
+ maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
} 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());
+ maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
}
}
@@ -1242,20 +1237,19 @@
HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> minorAxisCursors;
for (auto& autoGridItem : autoGridItems) {
- auto unresolvedMajorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
- ASSERT(!unresolvedMajorAxisPositions.requiresAutoPlacement());
- GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMajorAxisPositions, style());
+ GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
+ ASSERT(majorAxisPositions.isDefinite());
GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
- unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition.toInt();
+ unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition().toInt();
- GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition.toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
+ GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition().toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
if (!emptyGridArea)
emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
insertItemIntoGrid(*autoGridItem, *emptyGridArea);
if (!isGridAutoFlowDense)
- minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition.toInt() : emptyGridArea->columns.resolvedInitialPosition.toInt());
+ minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition().toInt() : emptyGridArea->columns.resolvedInitialPosition().toInt());
}
}
@@ -1276,7 +1270,7 @@
void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
{
- ASSERT(GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).requiresAutoPlacement());
+ ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).isDefinite());
GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
@@ -1284,16 +1278,14 @@
unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
std::unique_ptr<GridCoordinate> emptyGridArea;
- auto unresolvedMinorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMinorAxisDirection());
- if (!unresolvedMinorAxisPositions.requiresAutoPlacement()) {
- GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMinorAxisPositions, style());
-
+ GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), 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().toInt() < minorAxisAutoPlacementCursor)
majorAxisAutoPlacementCursor++;
if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
- GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition.toInt(), majorAxisAutoPlacementCursor);
+ GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition().toInt(), majorAxisAutoPlacementCursor);
emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisPositions.integerSpan());
}
@@ -1308,7 +1300,7 @@
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;
+ GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
break;
@@ -1327,8 +1319,8 @@
}
insertItemIntoGrid(gridItem, *emptyGridArea);
- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition.toInt();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition.toInt();
+ autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
+ autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
}
GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
@@ -1460,8 +1452,8 @@
{
ASSERT(child.isHorizontalWritingMode() == isHorizontalWritingMode());
- auto unresolvedPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), child, direction);
- if (unresolvedPositions.requiresAutoPlacement()) {
+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), child, direction);
+ if (!positions.isDefinite()) {
offset = LayoutUnit();
breadth = (direction == ForColumns) ? clientLogicalWidth() : clientLogicalHeight();
return;
@@ -1471,18 +1463,17 @@
GridPosition endPosition = (direction == ForColumns) ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
size_t lastTrackIndex = (direction == ForColumns ? gridColumnCount() : gridRowCount()) - 1;
- GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedPositions, style());
bool startIsAuto = startPosition.isAuto()
|| (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
- || (positions.resolvedInitialPosition.toInt() > lastTrackIndex);
+ || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
bool endIsAuto = endPosition.isAuto()
|| (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
- || (positions.resolvedFinalPosition.prev().toInt() > lastTrackIndex);
+ || (positions.resolvedFinalPosition().prev().toInt() > lastTrackIndex);
GridResolvedPosition firstPosition = GridResolvedPosition(0);
- GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
+ GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
- GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition.prev();
+ GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition().prev();
// 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);
@@ -1542,11 +1533,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().toInt()];
+ LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition().prev().toInt()];
// 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().prev().toInt()].baseSize();
}
void RenderGrid::populateGridPositions(GridSizingData& sizingData)
@@ -1825,7 +1816,7 @@
LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
- unsigned childStartLine = rowsSpan.resolvedInitialPosition.toInt();
+ unsigned childStartLine = rowsSpan.resolvedInitialPosition().toInt();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
if (hasAutoMarginsInColumnAxis(child))
@@ -1836,7 +1827,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = rowsSpan.resolvedFinalPosition.toInt();
+ unsigned childEndLine = rowsSpan.resolvedFinalPosition().toInt();
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)
@@ -1859,7 +1850,7 @@
LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
- unsigned childStartLine = columnsSpan.resolvedInitialPosition.toInt();
+ unsigned childStartLine = columnsSpan.resolvedInitialPosition().toInt();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
if (hasAutoMarginsInRowAxis(child))
@@ -1870,7 +1861,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = columnsSpan.resolvedFinalPosition.toInt();
+ unsigned childEndLine = columnsSpan.resolvedFinalPosition().toInt();
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 (196690 => 196691)
--- trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-02-17 11:45:30 UTC (rev 196691)
@@ -48,37 +48,76 @@
// Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
class GridSpan {
public:
- GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
- : resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
- , resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
+
+ static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
{
- ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+ return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
}
+ static GridSpan indefiniteGridSpan()
+ {
+ return GridSpan(0, 1, Indefinite);
+ }
+
bool operator==(const GridSpan& o) const
{
- return resolvedInitialPosition == o.resolvedInitialPosition && resolvedFinalPosition == o.resolvedFinalPosition;
+ return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
}
unsigned integerSpan() const
{
- return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt();
+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
}
- GridResolvedPosition resolvedInitialPosition;
- GridResolvedPosition resolvedFinalPosition;
+ const GridResolvedPosition& resolvedInitialPosition() const
+ {
+ ASSERT(isDefinite());
+ return m_resolvedInitialPosition;
+ }
+ const GridResolvedPosition& resolvedFinalPosition() const
+ {
+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition;
+ }
+
typedef GridResolvedPosition iterator;
iterator begin() const
{
- return resolvedInitialPosition;
+ ASSERT(isDefinite());
+ return m_resolvedInitialPosition;
}
iterator end() const
{
- return resolvedFinalPosition;
+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition;
}
+
+ bool isDefinite() const
+ {
+ return m_type == Definite;
+ }
+
+private:
+
+ 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))
+ , m_type(type)
+ {
+ ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+ }
+
+ GridResolvedPosition m_resolvedInitialPosition;
+ GridResolvedPosition m_resolvedFinalPosition;
+ GridSpanType m_type;
+
+
};
// This represents a grid area that spans in both rows' and columns' direction.
@@ -86,8 +125,8 @@
public:
// HashMap requires a default constuctor.
GridCoordinate()
- : columns(0, 1)
- , rows(0, 1)
+ : columns(GridSpan::indefiniteGridSpan())
+ , rows(GridSpan::indefiniteGridSpan())
{
}
Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp (196690 => 196691)
--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-02-17 11:45:30 UTC (rev 196691)
@@ -48,6 +48,16 @@
return side == ColumnStartSide || side == RowStartSide;
}
+static inline GridPositionSide initialPositionSide(GridTrackSizingDirection direction)
+{
+ return direction == ForColumns ? ColumnStartSide : RowStartSide;
+}
+
+static inline GridPositionSide finalPositionSide(GridTrackSizingDirection direction)
+{
+ return direction == ForColumns ? ColumnEndSide : RowEndSide;
+}
+
static const NamedGridLinesMap& gridLinesForSide(const RenderStyle& style, GridPositionSide side)
{
return isColumnSide(side) ? style.namedGridColumnLines() : style.namedGridRowLines();
@@ -64,34 +74,31 @@
return !gridLineNames.contains(implicitNamedGridLineForSide(lineName, side)) && !gridLineNames.contains(lineName);
}
-bool GridUnresolvedSpan::requiresAutoPlacement() const
+static void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
{
- return m_initialPosition.shouldBeResolvedAgainstOppositePosition() && m_finalPosition.shouldBeResolvedAgainstOppositePosition();
-}
+ bool isForColumns = direction == ForColumns;
+ initialPosition = isForColumns ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
+ finalPosition = isForColumns ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
-void GridUnresolvedSpan::adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle)
-{
- ASSERT(isColumnSide(m_initialPositionSide) == isColumnSide(m_finalPositionSide));
-
// We must handle the placement error handling code here instead of in the StyleAdjuster because we don't want to
// overwrite the specified values.
- if (m_initialPosition.isSpan() && m_finalPosition.isSpan())
- m_finalPosition.setAutoPosition();
+ if (initialPosition.isSpan() && finalPosition.isSpan())
+ finalPosition.setAutoPosition();
// Try to early detect the case of non existing named grid lines. This way we could assume later that
// GridResolvedPosition::resolveGrisPositionFromStyle() won't require the autoplacement to run, i.e., it'll always return a
// valid resolved position.
- if (m_initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide))
- m_initialPosition.setAutoPosition();
+ if (initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(initialPosition.namedGridLine(), gridContainerStyle, initialPositionSide(direction)))
+ initialPosition.setAutoPosition();
- if (m_finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide))
- m_finalPosition.setAutoPosition();
+ if (finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(finalPosition.namedGridLine(), gridContainerStyle, finalPositionSide(direction)))
+ finalPosition.setAutoPosition();
// If the grid item has an automatic position and a grid span for a named line in a given dimension, instead treat the grid span as one.
- if (m_initialPosition.isAuto() && m_finalPosition.isSpan() && !m_finalPosition.namedGridLine().isNull())
- m_finalPosition.setSpanPosition(1, String());
- if (m_finalPosition.isAuto() && m_initialPosition.isSpan() && !m_initialPosition.namedGridLine().isNull())
- m_initialPosition.setSpanPosition(1, String());
+ if (initialPosition.isAuto() && finalPosition.isSpan() && !finalPosition.namedGridLine().isNull())
+ finalPosition.setSpanPosition(1, String());
+ if (finalPosition.isAuto() && initialPosition.isSpan() && !initialPosition.namedGridLine().isNull())
+ initialPosition.setSpanPosition(1, String());
}
unsigned GridResolvedPosition::explicitGridColumnCount(const RenderStyle& gridContainerStyle)
@@ -133,7 +140,7 @@
static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
{
if (!resolvedOppositePosition.toInt())
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
unsigned firstLineBeforePositionIndex = 0;
auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
@@ -145,7 +152,7 @@
GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
if (resolvedGridLinePosition >= resolvedOppositePosition)
resolvedGridLinePosition = resolvedOppositePosition.prev();
- return GridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
}
static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
@@ -160,7 +167,7 @@
GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
if (resolvedGridLinePosition <= resolvedOppositePosition)
resolvedGridLinePosition = resolvedOppositePosition.next();
- return GridSpan(resolvedOppositePosition, resolvedGridLinePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
}
static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
@@ -177,8 +184,8 @@
// See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
if (it == gridLinesNames.end()) {
if (isStartSide(side) && resolvedOppositePosition.toInt())
- return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
}
if (side == RowStartSide || side == ColumnStartSide)
@@ -191,8 +198,8 @@
{
if (position.isAuto()) {
if (isStartSide(side) && resolvedOppositePosition.toInt())
- return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
}
ASSERT(position.isSpan());
@@ -208,30 +215,32 @@
unsigned positionOffset = position.spanPosition();
if (isStartSide(side)) {
if (!resolvedOppositePosition.toInt())
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
- return GridSpan(initialResolvedPosition, resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
}
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
}
GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
{
- GridUnresolvedSpan unresolvedSpan = unresolvedSpanFromStyle(gridContainerStyle, gridItem, direction);
+ GridPosition initialPosition, finalPosition;
+ adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
+ GridPositionSide finalSide = finalPositionSide(direction);
// This method will only be used when both positions need to be resolved against the opposite one.
- ASSERT(unresolvedSpan.requiresAutoPlacement());
+ ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
- if (unresolvedSpan.initialPosition().isSpan())
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.initialPosition(), unresolvedSpan.finalPositionSide());
- if (unresolvedSpan.finalPosition().isSpan())
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
+ if (initialPosition.isSpan())
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide);
+ if (finalPosition.isSpan())
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, finalPosition, finalSide);
- return GridSpan(resolvedInitialPosition, resolvedFinalPosition);
+ return GridSpan::definiteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
}
static GridResolvedPosition resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
@@ -291,47 +300,39 @@
return GridResolvedPosition(0);
}
-GridUnresolvedSpan GridResolvedPosition::unresolvedSpanFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
+GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
{
- GridPosition initialPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
- auto initialPositionSide = (direction == ForColumns) ? ColumnStartSide : RowStartSide;
- GridPosition finalPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
- auto finalPositionSide = (direction == ForColumns) ? ColumnEndSide : RowEndSide;
+ GridPosition initialPosition, finalPosition;
+ adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
- GridUnresolvedSpan unresolvedSpan(initialPosition, initialPositionSide, finalPosition, finalPositionSide);
- unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle);
+ GridPositionSide initialSide = initialPositionSide(direction);
+ GridPositionSide finalSide = finalPositionSide(direction);
- return unresolvedSpan;
-}
+ // We can't get our grid positions without running the auto placement algorithm.
+ if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition())
+ return GridSpan::indefiniteGridSpan();
-GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const GridUnresolvedSpan& unresolvedSpan, const RenderStyle& gridContainerStyle)
-{
- ASSERT(!unresolvedSpan.requiresAutoPlacement());
-
- // We must create the GridSpan using finalPosition.prev() because GridSpan stores cell indexes and
- // an item finishing on the N-th line belongs to the N-1-th cell.
-
- if (unresolvedSpan.initialPosition().shouldBeResolvedAgainstOppositePosition()) {
+ if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
- auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
+ auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
}
- if (unresolvedSpan.finalPosition().shouldBeResolvedAgainstOppositePosition()) {
+ if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
- auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
+ auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
}
- GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
- GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
+ GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
if (resolvedInitialPosition > resolvedFinalPosition)
std::swap(resolvedInitialPosition, resolvedFinalPosition);
else if (resolvedInitialPosition == resolvedFinalPosition)
resolvedFinalPosition = resolvedInitialPosition.next();
- return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
+ return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
}
} // namespace WebCore
Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.h (196690 => 196691)
--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-02-17 11:45:30 UTC (rev 196691)
@@ -46,31 +46,6 @@
ForRows
};
-class GridUnresolvedSpan {
-public:
- GridUnresolvedSpan(GridPosition initialPosition, GridPositionSide initialPositionSide, GridPosition finalPosition, GridPositionSide finalPositionSide)
- : m_initialPosition(initialPosition)
- , m_finalPosition(finalPosition)
- , m_initialPositionSide(initialPositionSide)
- , m_finalPositionSide(finalPositionSide)
- {
- }
-
- const GridPosition& initialPosition() const { return m_initialPosition; }
- const GridPosition& finalPosition() const { return m_finalPosition; }
- GridPositionSide initialPositionSide() const { return m_initialPositionSide; }
- GridPositionSide finalPositionSide() const { return m_finalPositionSide; }
-
- bool requiresAutoPlacement() const;
- void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle);
-
-private:
- GridPosition m_initialPosition;
- GridPosition m_finalPosition;
- GridPositionSide m_initialPositionSide;
- GridPositionSide m_finalPositionSide;
-};
-
// 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 GridResolvedPosition {
@@ -137,8 +112,7 @@
}
static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, const GridResolvedPosition&);
- static GridSpan resolveGridPositionsFromStyle(const GridUnresolvedSpan&, const RenderStyle&);
- static GridUnresolvedSpan unresolvedSpanFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
+ 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);
