[css-grid] Rename GridSpan properties

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "GridPositionsResolver.h"
 
 #include "core/layout/LayoutBox.h"
 #include "core/style/GridArea.h"
 #include <algorithm>
 
@@ skipping 88 matching lines @@
     }
 
     for (; numberOfLines; --start) {
         if (start < 0 || namedGridLinesIndexes->contains(static_cast<size_t>(start)))
             numberOfLines--;
     }
 
     return start + 1;
 }
 
-static GridSpan definiteGridSpanWithNamedSpanAgainstOpposite(int resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<size_t>* gridLines, int lastLine)
+static GridSpan definiteGridSpanWithNamedSpanAgainstOpposite(int opossiteLine, const GridPosition& position, GridPositionSide side, const Vector<size_t>* gridLines, int lastLine)
 {
     int start, end;
 
     if (side == RowStartSide || side == ColumnStartSide) {
-        start = lookBackForNamedGridLine(resolvedOppositePosition - 1, position.spanPosition(), gridLines, lastLine);
-        end = resolvedOppositePosition;
+        start = lookBackForNamedGridLine(opossiteLine - 1, position.spanPosition(), gridLines, lastLine);
+        end = opossiteLine;
     } else {
-        start = resolvedOppositePosition;
-        end = lookAheadForNamedGridLine(resolvedOppositePosition + 1, position.spanPosition(), gridLines, lastLine);
+        start = opossiteLine;
+        end = lookAheadForNamedGridLine(opossiteLine + 1, position.spanPosition(), gridLines, lastLine);
     }
 
     return GridSpan::untranslatedDefiniteGridSpan(start, end);
 }
 
 size_t GridPositionsResolver::explicitGridColumnCount(const ComputedStyle& gridContainerStyle)
 {
     return std::min<size_t>(gridContainerStyle.gridTemplateColumns().size(), kGridMaxTracks);
 }
 
 size_t GridPositionsResolver::explicitGridRowCount(const ComputedStyle& gridContainerStyle)
 {
     return std::min<size_t>(gridContainerStyle.gridTemplateRows().size(), kGridMaxTracks);
 }
 
 static size_t explicitGridSizeForSide(const ComputedStyle& gridContainerStyle, GridPositionSide side)
 {
     return (side == ColumnStartSide || side == ColumnEndSide) ? GridPositionsResolver::explicitGridColumnCount(gridContainerStyle) : GridPositionsResolver::explicitGridRowCount(gridContainerStyle);
 }
 
-static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, int opossiteLine, const GridPosition& position, GridPositionSide side)
 {
     ASSERT(position.isSpan());
     ASSERT(!position.namedGridLine().isNull());
     // Negative positions are not allowed per the specification and should have been handled during parsing.
     ASSERT(position.spanPosition() > 0);
 
     const NamedGridLinesMap& gridLinesNames = gridLinesForSide(gridContainerStyle, side);
     NamedGridLinesMap::const_iterator it = gridLinesNames.find(position.namedGridLine());
     const Vector<size_t>* gridLines = it == gridLinesNames.end() ? nullptr : &it->value;
     size_t lastLine = explicitGridSizeForSide(gridContainerStyle, side);
-    return definiteGridSpanWithNamedSpanAgainstOpposite(resolvedOppositePosition, position, side, gridLines, lastLine);
+    return definiteGridSpanWithNamedSpanAgainstOpposite(opossiteLine, position, side, gridLines, lastLine);
 }
 
-static GridSpan definiteGridSpanWithSpanAgainstOpposite(size_t resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan definiteGridSpanWithSpanAgainstOpposite(size_t opossiteLine, const GridPosition& position, GridPositionSide side)

[svillar, 2016/03/17 13:21:51]

Not directly related with the patch but why are we using size_t here? Couldn't
it be a negative line number?

[Manuel Rego, 2016/03/17 15:02:05]

Yep, you're right, this is wrong.
It's working fine just by chance because later it's used as an int.

I'll fix it in a different patch.

 {
     size_t positionOffset = position.spanPosition();
     if (side == ColumnStartSide || side == RowStartSide)
-        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - positionOffset, resolvedOppositePosition);
+        return GridSpan::untranslatedDefiniteGridSpan(opossiteLine - positionOffset, opossiteLine);
 
-    return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
+    return GridSpan::untranslatedDefiniteGridSpan(opossiteLine, opossiteLine + positionOffset);
 }
 
-static GridSpan resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
+static GridSpan resolveGridPositionAgainstOppositePosition(const ComputedStyle& gridContainerStyle, int opossiteLine, const GridPosition& position, GridPositionSide side)
 {
     if (position.isAuto()) {
         if (side == ColumnStartSide || side == RowStartSide)
-            return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
-        return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
+            return GridSpan::untranslatedDefiniteGridSpan(opossiteLine - 1, opossiteLine);
+        return GridSpan::untranslatedDefiniteGridSpan(opossiteLine, opossiteLine + 1);
     }
 
     ASSERT(position.isSpan());
     ASSERT(position.spanPosition() > 0);
 
     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, opossiteLine, position, side);
     }
 
-    return definiteGridSpanWithSpanAgainstOpposite(resolvedOppositePosition, position, side);
+    return definiteGridSpanWithSpanAgainstOpposite(opossiteLine, position, side);
 }
 
 size_t GridPositionsResolver::spanSizeForAutoPlacedItem(const ComputedStyle& gridContainerStyle, const LayoutBox& gridItem, GridTrackSizingDirection direction)
 {
     GridPosition initialPosition, finalPosition;
     initialAndFinalPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
 
     // This method will only be used when both positions need to be resolved against the opposite one.
     ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
 
@@ skipping 80 matching lines @@
     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 GridSpan::indefiniteGridSpan();
     }
 
     if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
         // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
-        int finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
-        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
+        int 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).
-        int initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
-        return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
+        int 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 (resolvedFinalPosition < resolvedInitialPosition)
-        std::swap(resolvedFinalPosition, resolvedInitialPosition);
-    else if (resolvedFinalPosition == resolvedInitialPosition)
-        resolvedFinalPosition = resolvedInitialPosition + 1;
+    if (endLine < startLine)
+        std::swap(endLine, startLine);
+    else if (endLine == startLine)
+        endLine = startLine + 1;
 
-    return GridSpan::untranslatedDefiniteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
+    return GridSpan::untranslatedDefiniteGridSpan(startLine, endLine);
 }
 
 } // namespace blink