Index: third_party/WebKit/Source/core/style/GridResolvedPosition.cpp |
diff --git a/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp b/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp |
index 9108080d1938e5567f7cb7f4771944b607776203..22b8fce5c0f99ce0c637e7309a8dc71b88d7da19 100644 |
--- a/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp |
+++ b/third_party/WebKit/Source/core/style/GridResolvedPosition.cpp |
@@ -10,9 +10,16 @@ |
namespace blink { |
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition&, GridPositionSide); |
+ |
+static bool isColumnSide(GridPositionSide side) |
+{ |
+ return side == ColumnStartSide || side == ColumnEndSide; |
+} |
+ |
static const NamedGridLinesMap& gridLinesForSide(const ComputedStyle& style, GridPositionSide side) |
{ |
- return (side == ColumnStartSide || side == ColumnEndSide) ? style.namedGridColumnLines() : style.namedGridRowLines(); |
+ return isColumnSide(side) ? style.namedGridColumnLines() : style.namedGridRowLines(); |
} |
static inline String implicitNamedGridLineForSide(const String& lineName, GridPositionSide side) |
@@ -20,21 +27,80 @@ static inline String implicitNamedGridLineForSide(const String& lineName, GridPo |
return lineName + ((side == ColumnStartSide || side == RowStartSide) ? "-start" : "-end"); |
} |
-bool GridResolvedPosition::isValidNamedLineOrArea(const String& lineName, const ComputedStyle& style, GridPositionSide side) |
+static GridPositionSide initialPositionSide(GridTrackSizingDirection direction) |
{ |
- const NamedGridLinesMap& gridLineNames = gridLinesForSide(style, side); |
+ return direction == ForColumns ? ColumnStartSide : RowStartSide; |
+} |
- return gridLineNames.contains(implicitNamedGridLineForSide(lineName, side)) || gridLineNames.contains(lineName); |
+static GridPositionSide finalPositionSide(GridTrackSizingDirection direction) |
+{ |
+ return direction == ForColumns ? ColumnEndSide : RowEndSide; |
} |
-GridPositionSide GridResolvedPosition::initialPositionSide(GridTrackSizingDirection direction) |
+static size_t explicitGridSizeForSide(const ComputedStyle& gridContainerStyle, GridPositionSide side) |
{ |
- return (direction == ForColumns) ? ColumnStartSide : RowStartSide; |
+ return isColumnSide(side) ? GridResolvedPosition::explicitGridColumnCount(gridContainerStyle) : GridResolvedPosition::explicitGridRowCount(gridContainerStyle); |
} |
-GridPositionSide GridResolvedPosition::finalPositionSide(GridTrackSizingDirection direction) |
+bool GridUnresolvedSpan::requiresAutoPlacement() const |
{ |
- return (direction == ForColumns) ? ColumnEndSide : RowEndSide; |
+ return m_initialPosition.shouldBeResolvedAgainstOppositePosition() && m_finalPosition.shouldBeResolvedAgainstOppositePosition(); |
+} |
+ |
+GridUnresolvedSpan& GridUnresolvedSpan::adjustGridPositionsFromStyle(const ComputedStyle& 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(); |
+ |
+ // 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::isValidNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide)) |
+ m_initialPosition.setAutoPosition(); |
+ |
+ if (m_finalPosition.isNamedGridArea() && !GridResolvedPosition::isValidNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide)) |
+ m_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()); |
+ |
+ return *this; |
+} |
+ |
+static GridResolvedPosition adjustGridPositionForRowEndColumnEndSide(size_t resolvedPosition) |
+{ |
+ return resolvedPosition ? GridResolvedPosition(resolvedPosition - 1) : GridResolvedPosition(0); |
+} |
+ |
+static GridResolvedPosition adjustGridPositionForSide(size_t resolvedPosition, GridPositionSide side) |
+{ |
+ // An item finishing on the N-th line belongs to the N-1-th cell. |
+ if (side == ColumnEndSide || side == RowEndSide) |
+ return adjustGridPositionForRowEndColumnEndSide(resolvedPosition); |
+ |
+ return GridResolvedPosition(resolvedPosition); |
+} |
+ |
+GridResolvedPosition::GridResolvedPosition(const GridPosition& position, GridPositionSide side) |
+{ |
+ ASSERT(position.integerPosition()); |
+ size_t integerPosition = position.integerPosition() - 1; |
+ |
+ m_integerPosition = adjustGridPositionForSide(integerPosition, side).toInt(); |
+} |
+ |
+bool GridResolvedPosition::isValidNamedLineOrArea(const String& lineName, const ComputedStyle& style, GridPositionSide side) |
+{ |
+ const NamedGridLinesMap& gridLineNames = gridLinesForSide(style, side); |
+ |
+ return gridLineNames.contains(implicitNamedGridLineForSide(lineName, side)) || gridLineNames.contains(lineName); |
} |
void GridResolvedPosition::initialAndFinalPositionsFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition) |
@@ -62,77 +128,51 @@ void GridResolvedPosition::initialAndFinalPositionsFromStyle(const ComputedStyle |
initialPosition.setSpanPosition(1, String()); |
} |
-GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition) |
+static GridSpan resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) |
{ |
- GridPosition initialPosition, finalPosition; |
- initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition); |
- |
- GridPositionSide finalSide = finalPositionSide(direction); |
+ if (position.isAuto()) |
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition); |
- // This method will only be used when both positions need to be resolved against the opposite one. |
- ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()); |
+ ASSERT(position.isSpan()); |
+ ASSERT(position.spanPosition() > 0); |
- GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition; |
+ 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); |
+ } |
- if (initialPosition.isSpan()) |
- return *resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide); |
- if (finalPosition.isSpan()) |
- return *resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, finalPosition, finalSide); |
+ // '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. |
+ size_t positionOffset = position.spanPosition() - 1; |
+ if (side == ColumnStartSide || side == RowStartSide) { |
+ size_t initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset); |
+ return GridSpan(initialResolvedPosition, resolvedOppositePosition); |
+ } |
- return GridSpan(resolvedInitialPosition, resolvedFinalPosition); |
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset); |
} |
-PassOwnPtr<GridSpan> GridResolvedPosition::resolveGridPositionsFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction) |
+GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition) |
{ |
GridPosition initialPosition, finalPosition; |
initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition); |
- GridPositionSide initialSide = initialPositionSide(direction); |
GridPositionSide finalSide = finalPositionSide(direction); |
- if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()) { |
- // We can't get our grid positions without running the auto placement algorithm. |
- return nullptr; |
- } |
- |
- if (initialPosition.shouldBeResolvedAgainstOppositePosition()) { |
- // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case). |
- GridResolvedPosition finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide); |
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide); |
- } |
- |
- if (finalPosition.shouldBeResolvedAgainstOppositePosition()) { |
- // Infer our position from the initial position ('1 / auto' or '3 / span 2' case). |
- GridResolvedPosition initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide); |
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide); |
- } |
- |
- GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide); |
- GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide); |
- |
- // If 'grid-after' specifies a line at or before that specified by 'grid-before', it computes to 'span 1'. |
- if (resolvedFinalPosition < resolvedInitialPosition) |
- resolvedFinalPosition = resolvedInitialPosition; |
- |
- return adoptPtr(new GridSpan(resolvedInitialPosition, resolvedFinalPosition)); |
-} |
+ // This method will only be used when both positions need to be resolved against the opposite one. |
+ ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition()); |
-size_t GridResolvedPosition::explicitGridColumnCount(const ComputedStyle& gridContainerStyle) |
-{ |
- return std::min(gridContainerStyle.gridTemplateColumns().size(), kGridMaxTracks); |
-} |
+ GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition; |
-size_t GridResolvedPosition::explicitGridRowCount(const ComputedStyle& gridContainerStyle) |
-{ |
- return std::min(gridContainerStyle.gridTemplateRows().size(), kGridMaxTracks); |
-} |
+ if (initialPosition.isSpan()) |
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide); |
+ if (finalPosition.isSpan()) |
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, finalPosition, finalSide); |
-size_t GridResolvedPosition::explicitGridSizeForSide(const ComputedStyle& gridContainerStyle, GridPositionSide side) |
-{ |
- return (side == ColumnStartSide || side == ColumnEndSide) ? explicitGridColumnCount(gridContainerStyle) : explicitGridRowCount(gridContainerStyle); |
+ return GridSpan(resolvedInitialPosition, resolvedFinalPosition); |
} |
-GridResolvedPosition GridResolvedPosition::resolveNamedGridLinePositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side) |
+static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side) |
{ |
ASSERT(!position.namedGridLine().isNull()); |
@@ -153,7 +193,7 @@ GridResolvedPosition GridResolvedPosition::resolveNamedGridLinePositionFromStyle |
return adjustGridPositionForSide(it->value[namedGridLineIndex], side); |
} |
-GridResolvedPosition GridResolvedPosition::resolveGridPositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side) |
+static GridResolvedPosition resolveGridPositionFromStyle(const ComputedStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side) |
{ |
switch (position.type()) { |
case ExplicitPosition: { |
@@ -181,7 +221,7 @@ GridResolvedPosition GridResolvedPosition::resolveGridPositionFromStyle(const Co |
// ''<custom-ident>-start (for grid-*-start) / <custom-ident>-end'' (for grid-*-end), contributes the first such |
// line to the grid item's placement. |
String namedGridLine = position.namedGridLine(); |
- ASSERT(isValidNamedLineOrArea(namedGridLine, gridContainerStyle, side)); |
+ ASSERT(GridResolvedPosition::isValidNamedLineOrArea(namedGridLine, gridContainerStyle, side)); |
const NamedGridLinesMap& gridLineNames = gridLinesForSide(gridContainerStyle, side); |
NamedGridLinesMap::const_iterator implicitLineIter = gridLineNames.find(implicitNamedGridLineForSide(namedGridLine, side)); |
@@ -210,23 +250,78 @@ GridResolvedPosition GridResolvedPosition::resolveGridPositionFromStyle(const Co |
return GridResolvedPosition(0); |
} |
-PassOwnPtr<GridSpan> GridResolvedPosition::resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) |
+GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const GridUnresolvedSpan& unresolvedSpan, const ComputedStyle& gridContainerStyle) |
{ |
- if (position.isAuto()) |
- return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition); |
+ ASSERT(!unresolvedSpan.requiresAutoPlacement()); |
- ASSERT(position.isSpan()); |
- ASSERT(position.spanPosition() > 0); |
+ if (unresolvedSpan.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()); |
+ } |
- 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); |
+ if (unresolvedSpan.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 resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide()); |
+ auto resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide()); |
+ |
+ // If 'grid-row-end' specifies a line at or before that specified by 'grid-row-start', it computes to 'span 1'. |
+ return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition)); |
+} |
+ |
+size_t GridResolvedPosition::explicitGridColumnCount(const ComputedStyle& gridContainerStyle) |
+{ |
+ return std::min(gridContainerStyle.gridTemplateColumns().size(), kGridMaxTracks); |
+} |
+ |
+size_t GridResolvedPosition::explicitGridRowCount(const ComputedStyle& gridContainerStyle) |
+{ |
+ return std::min(gridContainerStyle.gridTemplateRows().size(), kGridMaxTracks); |
+} |
+ |
+static inline size_t firstNamedGridLineBeforePosition(size_t position, const Vector<size_t>& gridLines) |
+{ |
+ // The grid line inequality needs to be strict (which doesn't match the after / end case) because |position| is |
+ // already converted to an index in our grid representation (ie one was removed from the grid line to account for |
+ // the side). |
+ size_t firstLineBeforePositionIndex = 0; |
+ auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), position); |
+ if (firstLineBeforePosition != gridLines.end()) { |
+ if (*firstLineBeforePosition > position && firstLineBeforePosition != gridLines.begin()) |
+ --firstLineBeforePosition; |
+ |
+ firstLineBeforePositionIndex = firstLineBeforePosition - gridLines.begin(); |
} |
+ return firstLineBeforePositionIndex; |
+} |
- return GridSpan::createWithSpanAgainstOpposite(resolvedOppositePosition, position, side); |
+static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) |
+{ |
+ size_t gridLineIndex = std::max<int>(0, firstNamedGridLineBeforePosition(resolvedOppositePosition.toInt(), gridLines) - position.spanPosition() + 1); |
+ GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]); |
+ return GridSpan(std::min(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition); |
} |
-PassOwnPtr<GridSpan> GridResolvedPosition::resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) |
+static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<size_t>& gridLines) |
+{ |
+ ASSERT(gridLines.size()); |
+ size_t firstLineAfterOppositePositionIndex = gridLines.size() - 1; |
+ const auto firstLineAfterOppositePosition = std::upper_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition); |
+ if (firstLineAfterOppositePosition != gridLines.end()) |
+ firstLineAfterOppositePositionIndex = firstLineAfterOppositePosition - gridLines.begin(); |
+ |
+ size_t gridLineIndex = std::min<size_t>(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1); |
+ GridResolvedPosition resolvedGridLinePosition = adjustGridPositionForRowEndColumnEndSide(gridLines[gridLineIndex]); |
+ if (resolvedGridLinePosition < resolvedOppositePosition) |
+ resolvedGridLinePosition = resolvedOppositePosition; |
+ return GridSpan(resolvedOppositePosition, resolvedGridLinePosition); |
+} |
+ |
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side) |
{ |
ASSERT(position.isSpan()); |
ASSERT(!position.namedGridLine().isNull()); |
@@ -239,9 +334,24 @@ PassOwnPtr<GridSpan> GridResolvedPosition::resolveNamedGridLinePositionAgainstOp |
// 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()) |
- return GridSpan::create(resolvedOppositePosition, resolvedOppositePosition); |
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition); |
+ |
+ if (side == RowStartSide || side == ColumnStartSide) |
+ return resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(resolvedOppositePosition, position, it->value); |
+ |
+ return resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(resolvedOppositePosition, position, it->value); |
+} |
+ |
+GridUnresolvedSpan GridResolvedPosition::unresolvedSpanFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction) |
+{ |
+ const ComputedStyle& itemStyle = gridItem.styleRef(); |
+ if (direction == ForColumns) { |
+ GridUnresolvedSpan unresolvedSpan(itemStyle.gridColumnStart(), ColumnStartSide, itemStyle.gridColumnEnd(), ColumnEndSide); |
+ return unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle); |
+ } |
- return GridSpan::createWithNamedSpanAgainstOpposite(resolvedOppositePosition, position, side, it->value); |
+ GridUnresolvedSpan unresolvedSpan(itemStyle.gridRowStart(), RowStartSide, itemStyle.gridRowEnd(), RowEndSide); |
+ return unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle); |
} |
} // namespace blink |