[css-grid] Rename GridSpan properties
https://bugs.webkit.org/show_bug.cgi?id=155636
Reviewed by Sergio Villar Senin.
GridSpan was using old names initialResolvedPosition and
finalResolvedPosition.
This patch rename them to startLine and endLine.
Some reasons for this refactoring:
- "position" is a vague term not defined in the spec.
- GridSpan is currently storing grid lines. A grid "line" is defined
in the spec: https://drafts.csswg.org/css-grid/#grid-line-concept
- The spec uses the concepts "start" and "end" lines too.
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::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
(WebCore::RenderGrid::insertItemIntoGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):
* rendering/style/GridArea.h:
(WebCore::GridSpan::untranslatedDefiniteGridSpan):
(WebCore::GridSpan::translatedDefiniteGridSpan):
(WebCore::GridSpan::operator==):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::untranslatedStartLine):
(WebCore::GridSpan::untranslatedEndLine):
(WebCore::GridSpan::startLine):
(WebCore::GridSpan::endLine):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::translate):
(WebCore::GridSpan::GridSpan):
(WebCore::GridSpan::untranslatedResolvedInitialPosition): Deleted.
(WebCore::GridSpan::untranslatedResolvedFinalPosition): Deleted.
(WebCore::GridSpan::resolvedInitialPosition): Deleted.
(WebCore::GridSpan::resolvedFinalPosition): Deleted.
* rendering/style/GridPositionsResolver.cpp:
(WebCore::definiteGridSpanWithNamedLineSpanAgainstOpposite):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@198399 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 6500af9..2b76328 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,62 @@
+2016-03-18 Manuel Rego Casasnovas <rego@igalia.com>
+
+ [css-grid] Rename GridSpan properties
+ https://bugs.webkit.org/show_bug.cgi?id=155636
+
+ Reviewed by Sergio Villar Senin.
+
+ GridSpan was using old names initialResolvedPosition and
+ finalResolvedPosition.
+ This patch rename them to startLine and endLine.
+
+ Some reasons for this refactoring:
+ - "position" is a vague term not defined in the spec.
+ - GridSpan is currently storing grid lines. A grid "line" is defined
+ in the spec: https://drafts.csswg.org/css-grid/#grid-line-concept
+ - The spec uses the concepts "start" and "end" lines too.
+
+ 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::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
+ (WebCore::RenderGrid::insertItemIntoGrid):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ * rendering/style/GridArea.h:
+ (WebCore::GridSpan::untranslatedDefiniteGridSpan):
+ (WebCore::GridSpan::translatedDefiniteGridSpan):
+ (WebCore::GridSpan::operator==):
+ (WebCore::GridSpan::integerSpan):
+ (WebCore::GridSpan::untranslatedStartLine):
+ (WebCore::GridSpan::untranslatedEndLine):
+ (WebCore::GridSpan::startLine):
+ (WebCore::GridSpan::endLine):
+ (WebCore::GridSpan::begin):
+ (WebCore::GridSpan::end):
+ (WebCore::GridSpan::translate):
+ (WebCore::GridSpan::GridSpan):
+ (WebCore::GridSpan::untranslatedResolvedInitialPosition): Deleted.
+ (WebCore::GridSpan::untranslatedResolvedFinalPosition): Deleted.
+ (WebCore::GridSpan::resolvedInitialPosition): Deleted.
+ (WebCore::GridSpan::resolvedFinalPosition): Deleted.
+ * rendering/style/GridPositionsResolver.cpp:
+ (WebCore::definiteGridSpanWithNamedLineSpanAgainstOpposite):
+ (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveGridPositionAgainstOppositePosition):
+ (WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):
+
2016-03-18 Csaba Osztrogonác <ossy@webkit.org>
[Mac][cmake] One more unreviewed speculative buildfix after r197633. Just for fun.
diff --git a/Source/WebCore/css/CSSGridTemplateAreasValue.cpp b/Source/WebCore/css/CSSGridTemplateAreasValue.cpp
index 63f6697..909398e 100644
--- a/Source/WebCore/css/CSSGridTemplateAreasValue.cpp
+++ b/Source/WebCore/css/CSSGridTemplateAreasValue.cpp
@@ -55,13 +55,13 @@
for (const auto& it : gridAreaMap) {
const GridArea& area = it.value;
- if (row >= area.rows.resolvedInitialPosition() && row < area.rows.resolvedFinalPosition())
+ if (row >= area.rows.startLine() && row < area.rows.endLine())
candidates.append(it.key);
}
for (const auto& it : gridAreaMap) {
const GridArea& area = it.value;
- if (column >= area.columns.resolvedInitialPosition() && column < area.columns.resolvedFinalPosition() && candidates.contains(it.key))
+ if (column >= area.columns.startLine() && column < area.columns.endLine() && candidates.contains(it.key))
return it.key;
}
diff --git a/Source/WebCore/css/CSSParser.cpp b/Source/WebCore/css/CSSParser.cpp
index 27e6a39..496f4f9 100644
--- a/Source/WebCore/css/CSSParser.cpp
+++ b/Source/WebCore/css/CSSParser.cpp
@@ -6255,18 +6255,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 != gridArea.rows.resolvedFinalPosition())
+ if (rowCount != gridArea.rows.endLine())
return false;
// 2. The new area starts at the same position as the previously parsed area.
- if (currentColumn != gridArea.columns.resolvedInitialPosition())
+ if (currentColumn != gridArea.columns.startLine())
return false;
// 3. The new area ends at the same position as the previously parsed area.
- if (lookAheadColumn != gridArea.columns.resolvedFinalPosition())
+ if (lookAheadColumn != gridArea.columns.endLine())
return false;
- gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.resolvedInitialPosition(), gridArea.rows.resolvedFinalPosition() + 1);
+ gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
}
currentColumn = lookAheadColumn - 1;
}
diff --git a/Source/WebCore/css/StyleBuilderConverter.h b/Source/WebCore/css/StyleBuilderConverter.h
index b3d7839..ef6b19d 100644
--- a/Source/WebCore/css/StyleBuilderConverter.h
+++ b/Source/WebCore/css/StyleBuilderConverter.h
@@ -939,12 +939,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());
+ startVector.append(areaSpan.startLine());
std::sort(startVector.begin(), startVector.end());
}
{
auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
- endVector.append(areaSpan.resolvedFinalPosition());
+ endVector.append(areaSpan.endLine());
std::sort(endVector.begin(), endVector.end());
}
}
diff --git a/Source/WebCore/rendering/RenderGrid.cpp b/Source/WebCore/rendering/RenderGrid.cpp
index 5788a01..4ce9571 100644
--- a/Source/WebCore/rendering/RenderGrid.cpp
+++ b/Source/WebCore/rendering/RenderGrid.cpp
@@ -578,7 +578,7 @@
const GridSpan span = cachedGridSpan(*gridItem, direction);
// Do not include already processed items.
- if (i > 0 && span.resolvedInitialPosition() <= flexibleSizedTracksIndex[i - 1])
+ if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
continue;
flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData.columnTracks)));
@@ -868,7 +868,7 @@
void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
{
- unsigned trackPosition = span.resolvedInitialPosition();
+ unsigned trackPosition = span.startLine();
GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
if (trackSize.hasMinContentMinTrackBreadth())
@@ -1142,7 +1142,7 @@
void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridArea& area)
{
ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
- ensureGridSize(area.rows.resolvedFinalPosition(), area.columns.resolvedFinalPosition());
+ ensureGridSize(area.rows.endLine(), area.columns.endLine());
for (auto row : area.rows) {
for (auto column : area.columns)
@@ -1214,8 +1214,8 @@
GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows);
if (!rowPositions.isIndefinite()) {
- m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedResolvedInitialPosition());
- maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedResolvedFinalPosition());
+ m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedStartLine());
+ maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
} else {
// Grow the grid for items with a definite row span, getting the largest such span.
unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *child, ForRows);
@@ -1224,8 +1224,8 @@
GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns);
if (!columnPositions.isIndefinite()) {
- m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedResolvedInitialPosition());
- maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedResolvedFinalPosition());
+ m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedStartLine());
+ maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
} else {
// Grow the grid for items with a definite column span, getting the largest such span.
unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *child, ForColumns);
@@ -1264,9 +1264,9 @@
ASSERT(majorAxisPositions.isTranslatedDefinite());
ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
- unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
+ unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
- GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
+ GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
if (!emptyGridArea)
emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
@@ -1275,7 +1275,7 @@
insertItemIntoGrid(*autoGridItem, *emptyGridArea);
if (!isGridAutoFlowDense)
- minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitialPosition());
+ minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.startLine() : emptyGridArea->columns.startLine());
}
}
@@ -1307,11 +1307,11 @@
GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
if (minorAxisPositions.isTranslatedDefinite()) {
// Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
- if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
+ if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
majorAxisAutoPlacementCursor++;
if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
- GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor);
+ GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.startLine(), majorAxisAutoPlacementCursor);
emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisSpanSize);
}
@@ -1326,7 +1326,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()).
- unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
+ unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
if (minorAxisFinalPositionIndex <= endOfMinorAxis)
break;
@@ -1346,8 +1346,8 @@
m_gridItemArea.set(&gridItem, *emptyGridArea);
insertItemIntoGrid(gridItem, *emptyGridArea);
- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
+ autoPlacementCursor.first = emptyGridArea->rows.startLine();
+ autoPlacementCursor.second = emptyGridArea->columns.startLine();
}
GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
@@ -1495,8 +1495,8 @@
// For positioned items we cannot use GridSpan::translate() because we could end up with negative values, as the positioned items do not create implicit tracks per spec.
int smallestStart = std::abs(isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
- int resolvedInitialPosition = positions.untranslatedResolvedInitialPosition() + smallestStart;
- int resolvedFinalPosition = positions.untranslatedResolvedFinalPosition() + smallestStart;
+ int startLine = positions.untranslatedStartLine() + smallestStart;
+ int endLine = positions.untranslatedEndLine() + smallestStart;
GridPosition startPosition = isRowAxis ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
GridPosition endPosition = isRowAxis ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
@@ -1505,15 +1505,15 @@
bool startIsAuto = startPosition.isAuto()
|| (startPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
- || (resolvedInitialPosition < firstExplicitLine)
- || (resolvedInitialPosition > lastExplicitLine);
+ || (startLine < firstExplicitLine)
+ || (startLine > lastExplicitLine);
bool endIsAuto = endPosition.isAuto()
|| (endPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
- || (resolvedFinalPosition < firstExplicitLine)
- || (resolvedFinalPosition > lastExplicitLine);
+ || (endLine < firstExplicitLine)
+ || (endLine > lastExplicitLine);
- unsigned initialPosition = startIsAuto ? 0 : resolvedInitialPosition;
- unsigned finalPosition = endIsAuto ? lastExplicitLine : resolvedFinalPosition;
+ unsigned initialPosition = startIsAuto ? 0 : startLine;
+ unsigned finalPosition = endIsAuto ? lastExplicitLine : endLine;
LayoutUnit start = startIsAuto ? LayoutUnit() : isRowAxis ? m_columnPositions[initialPosition] : m_rowPositions[initialPosition];
LayoutUnit end = endIsAuto ? (isRowAxis ? logicalWidth() : logicalHeight()) : (isRowAxis ? m_columnPositions[finalPosition] : m_rowPositions[finalPosition]);
@@ -1574,11 +1574,11 @@
const auto& span = cachedGridSpan(child, direction);
const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
- LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition()];
- LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition() - 1];
+ LayoutUnit initialTrackPosition = linePositions[span.startLine()];
+ LayoutUnit finalTrackPosition = linePositions[span.endLine() - 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() - 1].baseSize();
+ return finalTrackPosition - initialTrackPosition + tracks[span.endLine() - 1].baseSize();
}
void RenderGrid::populateGridPositions(GridSizingData& sizingData)
@@ -1857,7 +1857,7 @@
LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
- unsigned childStartLine = rowsSpan.resolvedInitialPosition();
+ unsigned childStartLine = rowsSpan.startLine();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
if (hasAutoMarginsInColumnAxis(child))
@@ -1868,7 +1868,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = rowsSpan.resolvedFinalPosition();
+ unsigned childEndLine = rowsSpan.endLine();
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)
@@ -1891,7 +1891,7 @@
LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
{
const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
- unsigned childStartLine = columnsSpan.resolvedInitialPosition();
+ unsigned childStartLine = columnsSpan.startLine();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
if (hasAutoMarginsInRowAxis(child))
@@ -1902,7 +1902,7 @@
return startPosition;
case GridAxisEnd:
case GridAxisCenter: {
- unsigned childEndLine = columnsSpan.resolvedFinalPosition();
+ unsigned childEndLine = columnsSpan.endLine();
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/Source/WebCore/rendering/style/GridArea.h b/Source/WebCore/rendering/style/GridArea.h
index 898063e..c2ef253 100644
--- a/Source/WebCore/rendering/style/GridArea.h
+++ b/Source/WebCore/rendering/style/GridArea.h
@@ -43,20 +43,20 @@
// Recommended maximum size for both explicit and implicit grids.
const int kGridMaxTracks = 1000000;
-// A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
-// and |resolvedFinalPosition| are grid lines' indexes.
-// Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
+// A span in a single direction (either rows or columns). Note that |startLine|
+// and |endLine| are grid lines' indexes.
+// Despite line numbers in the spec start in "1", the indexes here start in "0".
class GridSpan {
public:
- static GridSpan untranslatedDefiniteGridSpan(int resolvedInitialPosition, int resolvedFinalPosition)
+ static GridSpan untranslatedDefiniteGridSpan(int startLine, int endLine)
{
- return GridSpan(resolvedInitialPosition, resolvedFinalPosition, UntranslatedDefinite);
+ return GridSpan(startLine, endLine, UntranslatedDefinite);
}
- static GridSpan translatedDefiniteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
+ static GridSpan translatedDefiniteGridSpan(unsigned startLine, unsigned endLine)
{
- return GridSpan(resolvedInitialPosition, resolvedFinalPosition, TranslatedDefinite);
+ return GridSpan(startLine, endLine, TranslatedDefinite);
}
static GridSpan indefiniteGridSpan()
@@ -66,39 +66,39 @@
bool operator==(const GridSpan& o) const
{
- return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
+ return m_type == o.m_type && m_startLine == o.m_startLine && m_endLine == o.m_endLine;
}
unsigned integerSpan() const
{
ASSERT(isTranslatedDefinite());
- return m_resolvedFinalPosition - m_resolvedInitialPosition;
+ return m_endLine - m_startLine;
}
- int untranslatedResolvedInitialPosition() const
+ int untranslatedStartLine() const
{
ASSERT(m_type == UntranslatedDefinite);
- return m_resolvedInitialPosition;
+ return m_startLine;
}
- int untranslatedResolvedFinalPosition() const
+ int untranslatedEndLine() const
{
ASSERT(m_type == UntranslatedDefinite);
- return m_resolvedFinalPosition;
+ return m_endLine;
}
- unsigned resolvedInitialPosition() const
+ unsigned startLine() const
{
ASSERT(isTranslatedDefinite());
- ASSERT(m_resolvedFinalPosition >= 0);
- return m_resolvedInitialPosition;
+ ASSERT(m_endLine >= 0);
+ return m_startLine;
}
- unsigned resolvedFinalPosition() const
+ unsigned endLine() const
{
ASSERT(isTranslatedDefinite());
- ASSERT(m_resolvedFinalPosition > 0);
- return m_resolvedFinalPosition;
+ ASSERT(m_endLine > 0);
+ return m_endLine;
}
struct GridSpanIterator {
@@ -116,13 +116,13 @@
GridSpanIterator begin() const
{
ASSERT(isTranslatedDefinite());
- return m_resolvedInitialPosition;
+ return m_startLine;
}
GridSpanIterator end() const
{
ASSERT(isTranslatedDefinite());
- return m_resolvedFinalPosition;
+ return m_endLine;
}
bool isTranslatedDefinite() const
@@ -140,34 +140,34 @@
ASSERT(m_type == UntranslatedDefinite);
m_type = TranslatedDefinite;
- m_resolvedInitialPosition += offset;
- m_resolvedFinalPosition += offset;
+ m_startLine += offset;
+ m_endLine += offset;
- ASSERT(m_resolvedInitialPosition >= 0);
- ASSERT(m_resolvedFinalPosition > 0);
+ ASSERT(m_startLine >= 0);
+ ASSERT(m_endLine > 0);
}
private:
enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
- GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
+ GridSpan(int startLine, int endLine, GridSpanType type)
: m_type(type)
{
#if ENABLE(ASSERT)
- ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+ ASSERT(startLine < endLine);
if (type == TranslatedDefinite) {
- ASSERT(resolvedInitialPosition >= 0);
- ASSERT(resolvedFinalPosition > 0);
+ ASSERT(startLine >= 0);
+ ASSERT(endLine > 0);
}
#endif
- m_resolvedInitialPosition = std::max(-kGridMaxTracks, std::min(resolvedInitialPosition, kGridMaxTracks - 1));
- m_resolvedFinalPosition = std::max(-kGridMaxTracks + 1, std::min(resolvedFinalPosition, kGridMaxTracks));
+ m_startLine = std::max(-kGridMaxTracks, std::min(startLine, kGridMaxTracks - 1));
+ m_endLine = std::max(-kGridMaxTracks + 1, std::min(endLine, kGridMaxTracks));
}
- int m_resolvedInitialPosition;
- int m_resolvedFinalPosition;
+ int m_startLine;
+ int m_endLine;
GridSpanType m_type;
diff --git a/Source/WebCore/rendering/style/GridPositionsResolver.cpp b/Source/WebCore/rendering/style/GridPositionsResolver.cpp
index 90c46ea..76eaeec 100644
--- a/Source/WebCore/rendering/style/GridPositionsResolver.cpp
+++ b/Source/WebCore/rendering/style/GridPositionsResolver.cpp
@@ -169,22 +169,22 @@
return lookBackForNamedGridLine(lastLine, std::abs(position.integerPosition()), gridLines, lastLine);
}
-static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
+static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int oppositeLine, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
{
int start, end;
if (side == RowStartSide || side == ColumnStartSide) {
- start = lookBackForNamedGridLine(resolvedOppositePosition - 1, position.spanPosition(), gridLines, lastLine);
- end = resolvedOppositePosition;
+ start = lookBackForNamedGridLine(oppositeLine - 1, position.spanPosition(), gridLines, lastLine);
+ end = oppositeLine;
} else {
- start = resolvedOppositePosition;
- end = lookAheadForNamedGridLine(resolvedOppositePosition + 1, position.spanPosition(), gridLines, lastLine);
+ start = oppositeLine;
+ end = lookAheadForNamedGridLine(oppositeLine + 1, position.spanPosition(), gridLines, lastLine);
}
return GridSpan::untranslatedDefiniteGridSpan(start, end);
}
-static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
{
ASSERT(position.isSpan());
ASSERT(!position.namedGridLine().isNull());
@@ -196,15 +196,15 @@
const Vector<unsigned>* gridLines = iterator == gridLinesNames.end() ? nullptr : &iterator->value;
unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side);
- return definiteGridSpanWithNamedLineSpanAgainstOpposite(resolvedOppositePosition, position, side, gridLines, lastLine);
+ return definiteGridSpanWithNamedLineSpanAgainstOpposite(oppositeLine, position, side, gridLines, lastLine);
}
-static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
{
if (position.isAuto()) {
if (isStartSide(side))
- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - 1, oppositeLine);
+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + 1);
}
ASSERT(position.isSpan());
@@ -212,16 +212,16 @@
if (!position.namedGridLine().isNull()) {
// span 2 'c' -> we need to find the appropriate grid line before / after our opposite position.
- return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, resolvedOppositePosition, position, side);
+ return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, oppositeLine, position, side);
}
// 'span 1' is contained inside a single grid track regardless of the direction.
// That's why the CSS span value is one more than the offset we apply.
unsigned positionOffset = position.spanPosition();
if (isStartSide(side))
- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - positionOffset, resolvedOppositePosition);
+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - positionOffset, oppositeLine);
- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + positionOffset);
}
unsigned GridPositionsResolver::spanSizeForAutoPlacedItem(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
@@ -308,25 +308,25 @@
if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
- auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
+ auto endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, endLine, initialPosition, initialSide);
}
if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
// Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
- auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
+ auto startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, startLine, finalPosition, finalSide);
}
- int resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- int resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ int startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ int endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
- if (resolvedInitialPosition > resolvedFinalPosition)
- std::swap(resolvedInitialPosition, resolvedFinalPosition);
- else if (resolvedInitialPosition == resolvedFinalPosition)
- resolvedFinalPosition = resolvedInitialPosition + 1;
+ if (startLine > endLine)
+ std::swap(startLine, endLine);
+ else if (startLine == endLine)
+ endLine = startLine + 1;
- return GridSpan::untranslatedDefiniteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
+ return GridSpan::untranslatedDefiniteGridSpan(startLine, std::max(startLine, endLine));
}
} // namespace WebCore
