[css-grid] Simplify the interface of GridResolvedPosition

third_party/WebKit/Source/core/style/GridResolvedPosition.cpp

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..d23911a7235c09d69561274655c6ec31c0424575 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);

[rune, 2015/11/11 18:16:51]

Why did you need to declare this? Couldn't you just move the implementation
above where it is used?

+
+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,24 +27,75 @@ 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;
+}
+
+static size_t explicitGridSizeForSide(const ComputedStyle& gridContainerStyle, GridPositionSide side)
+{
+    return isColumnSide(side) ? GridResolvedPosition::explicitGridColumnCount(gridContainerStyle) : GridResolvedPosition::explicitGridRowCount(gridContainerStyle);
+}
+
+bool GridUnresolvedSpan::requiresAutoPlacement() const
+{
+    return m_initialPosition.shouldBeResolvedAgainstOppositePosition() && m_finalPosition.shouldBeResolvedAgainstOppositePosition();
 }
 
-GridPositionSide GridResolvedPosition::initialPositionSide(GridTrackSizingDirection direction)
+GridUnresolvedSpan& GridUnresolvedSpan::adjustGridPositionsFromStyle(const ComputedStyle& gridContainerStyle)
 {
-    return (direction == ForColumns) ? ColumnStartSide : RowStartSide;
+    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;
 }
 
-GridPositionSide GridResolvedPosition::finalPositionSide(GridTrackSizingDirection direction)
+static GridResolvedPosition adjustGridPositionForRowEndColumnEndSide(size_t resolvedPosition)
 {
-    return (direction == ForColumns) ? ColumnEndSide : RowEndSide;
+    return resolvedPosition ? GridResolvedPosition(resolvedPosition - 1) : GridResolvedPosition(0);
 }
 
-void GridResolvedPosition::initialAndFinalPositionsFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
+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);
+}
+
+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);
+}
+
+static void initialAndFinalPositionsFromStyle(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
 {
     initialPosition = (direction == ForColumns) ? gridItem.style()->gridColumnStart() : gridItem.style()->gridRowStart();
     finalPosition = (direction == ForColumns) ? gridItem.style()->gridColumnEnd() : gridItem.style()->gridRowEnd();
@@ -49,10 +107,10 @@ void GridResolvedPosition::initialAndFinalPositionsFromStyle(const ComputedStyle
 
     // Try to early detect the case of non existing named grid lines. This way we could assume later that
     // GridResolvedPosition::resolveGrisPositionFromStyle() always return a valid resolved position.
-    if (initialPosition.isNamedGridArea() && !isValidNamedLineOrArea(initialPosition.namedGridLine(), gridContainerStyle, initialPositionSide(direction)))
+    if (initialPosition.isNamedGridArea() && !GridResolvedPosition::isValidNamedLineOrArea(initialPosition.namedGridLine(), gridContainerStyle, initialPositionSide(direction)))
         initialPosition.setAutoPosition();
 
-    if (finalPosition.isNamedGridArea() && !isValidNamedLineOrArea(finalPosition.namedGridLine(), gridContainerStyle, finalPositionSide(direction)))
+    if (finalPosition.isNamedGridArea() && !GridResolvedPosition::isValidNamedLineOrArea(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.
@@ -62,77 +120,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 +185,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 +213,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 +242,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());
     }
 
-    return GridSpan::createWithSpanAgainstOpposite(resolvedOppositePosition, position, side);
+    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));
 }
 
-PassOwnPtr<GridSpan> GridResolvedPosition::resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+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;
+}
+
+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);
+}
+
+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 +326,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);

[rune, 2015/11/11 18:16:51]

I would make adjustGridPositionsFromStyle return void and return unresolvedSpan
below to make it clear that it modifies the object and don't return a new value
based on the callee. Returning a non-const *this reference from
adjustGridPositionsFromStyle which in this case is a stack-allocated object
looks unnecessarily scary.

+    }
 
-    return GridSpan::createWithNamedSpanAgainstOpposite(resolvedOppositePosition, position, side, it->value);
+    GridUnresolvedSpan unresolvedSpan(itemStyle.gridRowStart(), RowStartSide, itemStyle.gridRowEnd(), RowEndSide);
+    return unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle);
 }
 
 } // namespace blink