<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[198399] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/198399">198399</a></dd>
<dt>Author</dt> <dd>rego@igalia.com</dd>
<dt>Date</dt> <dd>2016-03-18 06:56:40 -0700 (Fri, 18 Mar 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>[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):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssCSSGridTemplateAreasValuecpp">trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSParsercpp">trunk/Source/WebCore/css/CSSParser.cpp</a></li>
<li><a href="#trunkSourceWebCorecssStyleBuilderConverterh">trunk/Source/WebCore/css/StyleBuilderConverter.h</a></li>
<li><a href="#trunkSourceWebCorerenderingRenderGridcpp">trunk/Source/WebCore/rendering/RenderGrid.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleGridAreah">trunk/Source/WebCore/rendering/style/GridArea.h</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleGridPositionsResolvercpp">trunk/Source/WebCore/rendering/style/GridPositionsResolver.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/ChangeLog 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -1,3 +1,62 @@
</span><ins>+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):
+
</ins><span class="cx"> 2016-03-18 Csaba Osztrogonác <ossy@webkit.org>
</span><span class="cx">
</span><span class="cx"> [Mac][cmake] One more unreviewed speculative buildfix after r197633. Just for fun.
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGridTemplateAreasValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -55,13 +55,13 @@
</span><span class="cx">
</span><span class="cx"> for (const auto& it : gridAreaMap) {
</span><span class="cx"> const GridArea& area = it.value;
</span><del>- if (row >= area.rows.resolvedInitialPosition() && row < area.rows.resolvedFinalPosition())
</del><ins>+ if (row >= area.rows.startLine() && row < area.rows.endLine())
</ins><span class="cx"> candidates.append(it.key);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> for (const auto& it : gridAreaMap) {
</span><span class="cx"> const GridArea& area = it.value;
</span><del>- if (column >= area.columns.resolvedInitialPosition() && column < area.columns.resolvedFinalPosition() && candidates.contains(it.key))
</del><ins>+ if (column >= area.columns.startLine() && column < area.columns.endLine() && candidates.contains(it.key))
</ins><span class="cx"> return it.key;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.cpp (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -6255,18 +6255,18 @@
</span><span class="cx">
</span><span class="cx"> // The following checks test that the grid area is a single filled-in rectangle.
</span><span class="cx"> // 1. The new row is adjacent to the previously parsed row.
</span><del>- if (rowCount != gridArea.rows.resolvedFinalPosition())
</del><ins>+ if (rowCount != gridArea.rows.endLine())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // 2. The new area starts at the same position as the previously parsed area.
</span><del>- if (currentColumn != gridArea.columns.resolvedInitialPosition())
</del><ins>+ if (currentColumn != gridArea.columns.startLine())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // 3. The new area ends at the same position as the previously parsed area.
</span><del>- if (lookAheadColumn != gridArea.columns.resolvedFinalPosition())
</del><ins>+ if (lookAheadColumn != gridArea.columns.endLine())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.resolvedInitialPosition(), gridArea.rows.resolvedFinalPosition() + 1);
</del><ins>+ gridArea.rows = GridSpan::translatedDefiniteGridSpan(gridArea.rows.startLine(), gridArea.rows.endLine() + 1);
</ins><span class="cx"> }
</span><span class="cx"> currentColumn = lookAheadColumn - 1;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleBuilderConverterh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleBuilderConverter.h (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -939,12 +939,12 @@
</span><span class="cx"> GridSpan areaSpan = direction == ForRows ? area.value.rows : area.value.columns;
</span><span class="cx"> {
</span><span class="cx"> auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;
</span><del>- startVector.append(areaSpan.resolvedInitialPosition());
</del><ins>+ startVector.append(areaSpan.startLine());
</ins><span class="cx"> std::sort(startVector.begin(), startVector.end());
</span><span class="cx"> }
</span><span class="cx"> {
</span><span class="cx"> auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;
</span><del>- endVector.append(areaSpan.resolvedFinalPosition());
</del><ins>+ endVector.append(areaSpan.endLine());
</ins><span class="cx"> std::sort(endVector.begin(), endVector.end());
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderGridcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -578,7 +578,7 @@
</span><span class="cx"> const GridSpan span = cachedGridSpan(*gridItem, direction);
</span><span class="cx">
</span><span class="cx"> // Do not include already processed items.
</span><del>- if (i > 0 && span.resolvedInitialPosition() <= flexibleSizedTracksIndex[i - 1])
</del><ins>+ if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
</ins><span class="cx"> continue;
</span><span class="cx">
</span><span class="cx"> flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData.columnTracks)));
</span><span class="lines">@@ -868,7 +868,7 @@
</span><span class="cx">
</span><span class="cx"> void RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, RenderBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
</span><span class="cx"> {
</span><del>- unsigned trackPosition = span.resolvedInitialPosition();
</del><ins>+ unsigned trackPosition = span.startLine();
</ins><span class="cx"> GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
</span><span class="cx">
</span><span class="cx"> if (trackSize.hasMinContentMinTrackBreadth())
</span><span class="lines">@@ -1142,7 +1142,7 @@
</span><span class="cx"> void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridArea& area)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
</span><del>- ensureGridSize(area.rows.resolvedFinalPosition(), area.columns.resolvedFinalPosition());
</del><ins>+ ensureGridSize(area.rows.endLine(), area.columns.endLine());
</ins><span class="cx">
</span><span class="cx"> for (auto row : area.rows) {
</span><span class="cx"> for (auto column : area.columns)
</span><span class="lines">@@ -1214,8 +1214,8 @@
</span><span class="cx">
</span><span class="cx"> GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows);
</span><span class="cx"> if (!rowPositions.isIndefinite()) {
</span><del>- m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedResolvedInitialPosition());
- maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedResolvedFinalPosition());
</del><ins>+ m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untranslatedStartLine());
+ maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
</ins><span class="cx"> } else {
</span><span class="cx"> // Grow the grid for items with a definite row span, getting the largest such span.
</span><span class="cx"> unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *child, ForRows);
</span><span class="lines">@@ -1224,8 +1224,8 @@
</span><span class="cx">
</span><span class="cx"> GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns);
</span><span class="cx"> if (!columnPositions.isIndefinite()) {
</span><del>- m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedResolvedInitialPosition());
- maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedResolvedFinalPosition());
</del><ins>+ m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositions.untranslatedStartLine());
+ maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
</ins><span class="cx"> } else {
</span><span class="cx"> // Grow the grid for items with a definite column span, getting the largest such span.
</span><span class="cx"> unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *child, ForColumns);
</span><span class="lines">@@ -1264,9 +1264,9 @@
</span><span class="cx"> ASSERT(majorAxisPositions.isTranslatedDefinite());
</span><span class="cx"> ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
</span><span class="cx"> unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
</span><del>- unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition();
</del><ins>+ unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
</ins><span class="cx">
</span><del>- GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
</del><ins>+ GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
</ins><span class="cx"> std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
</span><span class="cx"> if (!emptyGridArea)
</span><span class="cx"> emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
</span><span class="lines">@@ -1275,7 +1275,7 @@
</span><span class="cx"> insertItemIntoGrid(*autoGridItem, *emptyGridArea);
</span><span class="cx">
</span><span class="cx"> if (!isGridAutoFlowDense)
</span><del>- minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitialPosition());
</del><ins>+ minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.startLine() : emptyGridArea->columns.startLine());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1307,11 +1307,11 @@
</span><span class="cx"> GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
</span><span class="cx"> if (minorAxisPositions.isTranslatedDefinite()) {
</span><span class="cx"> // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
</span><del>- if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacementCursor)
</del><ins>+ if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
</ins><span class="cx"> majorAxisAutoPlacementCursor++;
</span><span class="cx">
</span><span class="cx"> if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
</span><del>- GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor);
</del><ins>+ GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.startLine(), majorAxisAutoPlacementCursor);
</ins><span class="cx"> emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisSpanSize);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1326,7 +1326,7 @@
</span><span class="cx">
</span><span class="cx"> if (emptyGridArea) {
</span><span class="cx"> // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
</span><del>- unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
</del><ins>+ unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
</ins><span class="cx"> const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
</span><span class="cx"> if (minorAxisFinalPositionIndex <= endOfMinorAxis)
</span><span class="cx"> break;
</span><span class="lines">@@ -1346,8 +1346,8 @@
</span><span class="cx">
</span><span class="cx"> m_gridItemArea.set(&gridItem, *emptyGridArea);
</span><span class="cx"> insertItemIntoGrid(gridItem, *emptyGridArea);
</span><del>- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition();
</del><ins>+ autoPlacementCursor.first = emptyGridArea->rows.startLine();
+ autoPlacementCursor.second = emptyGridArea->columns.startLine();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
</span><span class="lines">@@ -1495,8 +1495,8 @@
</span><span class="cx">
</span><span class="cx"> // 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.
</span><span class="cx"> int smallestStart = std::abs(isRowAxis ? m_smallestColumnStart : m_smallestRowStart);
</span><del>- int resolvedInitialPosition = positions.untranslatedResolvedInitialPosition() + smallestStart;
- int resolvedFinalPosition = positions.untranslatedResolvedFinalPosition() + smallestStart;
</del><ins>+ int startLine = positions.untranslatedStartLine() + smallestStart;
+ int endLine = positions.untranslatedEndLine() + smallestStart;
</ins><span class="cx">
</span><span class="cx"> GridPosition startPosition = isRowAxis ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
</span><span class="cx"> GridPosition endPosition = isRowAxis ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
</span><span class="lines">@@ -1505,15 +1505,15 @@
</span><span class="cx">
</span><span class="cx"> bool startIsAuto = startPosition.isAuto()
</span><span class="cx"> || (startPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
</span><del>- || (resolvedInitialPosition < firstExplicitLine)
- || (resolvedInitialPosition > lastExplicitLine);
</del><ins>+ || (startLine < firstExplicitLine)
+ || (startLine > lastExplicitLine);
</ins><span class="cx"> bool endIsAuto = endPosition.isAuto()
</span><span class="cx"> || (endPosition.isNamedGridArea() && GridPositionsResolver::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
</span><del>- || (resolvedFinalPosition < firstExplicitLine)
- || (resolvedFinalPosition > lastExplicitLine);
</del><ins>+ || (endLine < firstExplicitLine)
+ || (endLine > lastExplicitLine);
</ins><span class="cx">
</span><del>- unsigned initialPosition = startIsAuto ? 0 : resolvedInitialPosition;
- unsigned finalPosition = endIsAuto ? lastExplicitLine : resolvedFinalPosition;
</del><ins>+ unsigned initialPosition = startIsAuto ? 0 : startLine;
+ unsigned finalPosition = endIsAuto ? lastExplicitLine : endLine;
</ins><span class="cx">
</span><span class="cx"> LayoutUnit start = startIsAuto ? LayoutUnit() : isRowAxis ? m_columnPositions[initialPosition] : m_rowPositions[initialPosition];
</span><span class="cx"> LayoutUnit end = endIsAuto ? (isRowAxis ? logicalWidth() : logicalHeight()) : (isRowAxis ? m_columnPositions[finalPosition] : m_rowPositions[finalPosition]);
</span><span class="lines">@@ -1574,11 +1574,11 @@
</span><span class="cx"> const auto& span = cachedGridSpan(child, direction);
</span><span class="cx"> const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
</span><span class="cx">
</span><del>- LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition()];
- LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition() - 1];
</del><ins>+ LayoutUnit initialTrackPosition = linePositions[span.startLine()];
+ LayoutUnit finalTrackPosition = linePositions[span.endLine() - 1];
</ins><span class="cx">
</span><span class="cx"> // Track Positions vector stores the 'start' grid line of each track, so we have to add last track's baseSize.
</span><del>- return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition() - 1].baseSize();
</del><ins>+ return finalTrackPosition - initialTrackPosition + tracks[span.endLine() - 1].baseSize();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderGrid::populateGridPositions(GridSizingData& sizingData)
</span><span class="lines">@@ -1857,7 +1857,7 @@
</span><span class="cx"> LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
</span><span class="cx"> {
</span><span class="cx"> const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
</span><del>- unsigned childStartLine = rowsSpan.resolvedInitialPosition();
</del><ins>+ unsigned childStartLine = rowsSpan.startLine();
</ins><span class="cx"> LayoutUnit startOfRow = m_rowPositions[childStartLine];
</span><span class="cx"> LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
</span><span class="cx"> if (hasAutoMarginsInColumnAxis(child))
</span><span class="lines">@@ -1868,7 +1868,7 @@
</span><span class="cx"> return startPosition;
</span><span class="cx"> case GridAxisEnd:
</span><span class="cx"> case GridAxisCenter: {
</span><del>- unsigned childEndLine = rowsSpan.resolvedFinalPosition();
</del><ins>+ unsigned childEndLine = rowsSpan.endLine();
</ins><span class="cx"> LayoutUnit endOfRow = m_rowPositions[childEndLine];
</span><span class="cx"> // m_rowPositions include gutters so we need to substract them to get the actual end position for a given
</span><span class="cx"> // row (this does not have to be done for the last track as there are no more m_rowPositions after it)
</span><span class="lines">@@ -1891,7 +1891,7 @@
</span><span class="cx"> LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
</span><span class="cx"> {
</span><span class="cx"> const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
</span><del>- unsigned childStartLine = columnsSpan.resolvedInitialPosition();
</del><ins>+ unsigned childStartLine = columnsSpan.startLine();
</ins><span class="cx"> LayoutUnit startOfColumn = m_columnPositions[childStartLine];
</span><span class="cx"> LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
</span><span class="cx"> if (hasAutoMarginsInRowAxis(child))
</span><span class="lines">@@ -1902,7 +1902,7 @@
</span><span class="cx"> return startPosition;
</span><span class="cx"> case GridAxisEnd:
</span><span class="cx"> case GridAxisCenter: {
</span><del>- unsigned childEndLine = columnsSpan.resolvedFinalPosition();
</del><ins>+ unsigned childEndLine = columnsSpan.endLine();
</ins><span class="cx"> LayoutUnit endOfColumn = m_columnPositions[childEndLine];
</span><span class="cx"> // m_columnPositions include gutters so we need to substract them to get the actual end position for a given
</span><span class="cx"> // column (this does not have to be done for the last track as there are no more m_columnPositions after it)
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleGridAreah"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridArea.h (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridArea.h 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/rendering/style/GridArea.h 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -43,20 +43,20 @@
</span><span class="cx"> // Recommended maximum size for both explicit and implicit grids.
</span><span class="cx"> const int kGridMaxTracks = 1000000;
</span><span class="cx">
</span><del>-// 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.
</del><ins>+// 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".
</ins><span class="cx"> class GridSpan {
</span><span class="cx"> public:
</span><span class="cx">
</span><del>- static GridSpan untranslatedDefiniteGridSpan(int resolvedInitialPosition, int resolvedFinalPosition)
</del><ins>+ static GridSpan untranslatedDefiniteGridSpan(int startLine, int endLine)
</ins><span class="cx"> {
</span><del>- return GridSpan(resolvedInitialPosition, resolvedFinalPosition, UntranslatedDefinite);
</del><ins>+ return GridSpan(startLine, endLine, UntranslatedDefinite);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- static GridSpan translatedDefiniteGridSpan(unsigned resolvedInitialPosition, unsigned resolvedFinalPosition)
</del><ins>+ static GridSpan translatedDefiniteGridSpan(unsigned startLine, unsigned endLine)
</ins><span class="cx"> {
</span><del>- return GridSpan(resolvedInitialPosition, resolvedFinalPosition, TranslatedDefinite);
</del><ins>+ return GridSpan(startLine, endLine, TranslatedDefinite);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static GridSpan indefiniteGridSpan()
</span><span class="lines">@@ -66,39 +66,39 @@
</span><span class="cx">
</span><span class="cx"> bool operator==(const GridSpan& o) const
</span><span class="cx"> {
</span><del>- return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
</del><ins>+ return m_type == o.m_type && m_startLine == o.m_startLine && m_endLine == o.m_endLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> unsigned integerSpan() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isTranslatedDefinite());
</span><del>- return m_resolvedFinalPosition - m_resolvedInitialPosition;
</del><ins>+ return m_endLine - m_startLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- int untranslatedResolvedInitialPosition() const
</del><ins>+ int untranslatedStartLine() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(m_type == UntranslatedDefinite);
</span><del>- return m_resolvedInitialPosition;
</del><ins>+ return m_startLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- int untranslatedResolvedFinalPosition() const
</del><ins>+ int untranslatedEndLine() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(m_type == UntranslatedDefinite);
</span><del>- return m_resolvedFinalPosition;
</del><ins>+ return m_endLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- unsigned resolvedInitialPosition() const
</del><ins>+ unsigned startLine() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(isTranslatedDefinite());
</span><del>- ASSERT(m_resolvedFinalPosition >= 0);
- return m_resolvedInitialPosition;
</del><ins>+ ASSERT(m_endLine >= 0);
+ return m_startLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- unsigned resolvedFinalPosition() const
</del><ins>+ unsigned endLine() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(isTranslatedDefinite());
</span><del>- ASSERT(m_resolvedFinalPosition > 0);
- return m_resolvedFinalPosition;
</del><ins>+ ASSERT(m_endLine > 0);
+ return m_endLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> struct GridSpanIterator {
</span><span class="lines">@@ -116,13 +116,13 @@
</span><span class="cx"> GridSpanIterator begin() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isTranslatedDefinite());
</span><del>- return m_resolvedInitialPosition;
</del><ins>+ return m_startLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GridSpanIterator end() const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isTranslatedDefinite());
</span><del>- return m_resolvedFinalPosition;
</del><ins>+ return m_endLine;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool isTranslatedDefinite() const
</span><span class="lines">@@ -140,34 +140,34 @@
</span><span class="cx"> ASSERT(m_type == UntranslatedDefinite);
</span><span class="cx">
</span><span class="cx"> m_type = TranslatedDefinite;
</span><del>- m_resolvedInitialPosition += offset;
- m_resolvedFinalPosition += offset;
</del><ins>+ m_startLine += offset;
+ m_endLine += offset;
</ins><span class="cx">
</span><del>- ASSERT(m_resolvedInitialPosition >= 0);
- ASSERT(m_resolvedFinalPosition > 0);
</del><ins>+ ASSERT(m_startLine >= 0);
+ ASSERT(m_endLine > 0);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><span class="cx">
</span><span class="cx"> enum GridSpanType {UntranslatedDefinite, TranslatedDefinite, Indefinite};
</span><span class="cx">
</span><del>- GridSpan(int resolvedInitialPosition, int resolvedFinalPosition, GridSpanType type)
</del><ins>+ GridSpan(int startLine, int endLine, GridSpanType type)
</ins><span class="cx"> : m_type(type)
</span><span class="cx"> {
</span><span class="cx"> #if ENABLE(ASSERT)
</span><del>- ASSERT(resolvedInitialPosition < resolvedFinalPosition);
</del><ins>+ ASSERT(startLine < endLine);
</ins><span class="cx"> if (type == TranslatedDefinite) {
</span><del>- ASSERT(resolvedInitialPosition >= 0);
- ASSERT(resolvedFinalPosition > 0);
</del><ins>+ ASSERT(startLine >= 0);
+ ASSERT(endLine > 0);
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- m_resolvedInitialPosition = std::max(-kGridMaxTracks, std::min(resolvedInitialPosition, kGridMaxTracks - 1));
- m_resolvedFinalPosition = std::max(-kGridMaxTracks + 1, std::min(resolvedFinalPosition, kGridMaxTracks));
</del><ins>+ m_startLine = std::max(-kGridMaxTracks, std::min(startLine, kGridMaxTracks - 1));
+ m_endLine = std::max(-kGridMaxTracks + 1, std::min(endLine, kGridMaxTracks));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- int m_resolvedInitialPosition;
- int m_resolvedFinalPosition;
</del><ins>+ int m_startLine;
+ int m_endLine;
</ins><span class="cx"> GridSpanType m_type;
</span><span class="cx">
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleGridPositionsResolvercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridPositionsResolver.cpp (198398 => 198399)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridPositionsResolver.cpp 2016-03-18 13:56:01 UTC (rev 198398)
+++ trunk/Source/WebCore/rendering/style/GridPositionsResolver.cpp 2016-03-18 13:56:40 UTC (rev 198399)
</span><span class="lines">@@ -169,22 +169,22 @@
</span><span class="cx"> return lookBackForNamedGridLine(lastLine, std::abs(position.integerPosition()), gridLines, lastLine);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int resolvedOppositePosition, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
</del><ins>+static GridSpan definiteGridSpanWithNamedLineSpanAgainstOpposite(int oppositeLine, const GridPosition& position, GridPositionSide side, const Vector<unsigned>* gridLines, unsigned lastLine)
</ins><span class="cx"> {
</span><span class="cx"> int start, end;
</span><span class="cx">
</span><span class="cx"> if (side == RowStartSide || side == ColumnStartSide) {
</span><del>- start = lookBackForNamedGridLine(resolvedOppositePosition - 1, position.spanPosition(), gridLines, lastLine);
- end = resolvedOppositePosition;
</del><ins>+ start = lookBackForNamedGridLine(oppositeLine - 1, position.spanPosition(), gridLines, lastLine);
+ end = oppositeLine;
</ins><span class="cx"> } else {
</span><del>- start = resolvedOppositePosition;
- end = lookAheadForNamedGridLine(resolvedOppositePosition + 1, position.spanPosition(), gridLines, lastLine);
</del><ins>+ start = oppositeLine;
+ end = lookAheadForNamedGridLine(oppositeLine + 1, position.spanPosition(), gridLines, lastLine);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return GridSpan::untranslatedDefiniteGridSpan(start, end);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
</del><ins>+static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(position.isSpan());
</span><span class="cx"> ASSERT(!position.namedGridLine().isNull());
</span><span class="lines">@@ -196,15 +196,15 @@
</span><span class="cx"> const Vector<unsigned>* gridLines = iterator == gridLinesNames.end() ? nullptr : &iterator->value;
</span><span class="cx"> unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side);
</span><span class="cx">
</span><del>- return definiteGridSpanWithNamedLineSpanAgainstOpposite(resolvedOppositePosition, position, side, gridLines, lastLine);
</del><ins>+ return definiteGridSpanWithNamedLineSpanAgainstOpposite(oppositeLine, position, side, gridLines, lastLine);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
</del><ins>+static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side)
</ins><span class="cx"> {
</span><span class="cx"> if (position.isAuto()) {
</span><span class="cx"> if (isStartSide(side))
</span><del>- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - 1, resolvedOppositePosition);
- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + 1);
</del><ins>+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - 1, oppositeLine);
+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + 1);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT(position.isSpan());
</span><span class="lines">@@ -212,16 +212,16 @@
</span><span class="cx">
</span><span class="cx"> if (!position.namedGridLine().isNull()) {
</span><span class="cx"> // span 2 'c' -> we need to find the appropriate grid line before / after our opposite position.
</span><del>- return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, resolvedOppositePosition, position, side);
</del><ins>+ return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, oppositeLine, position, side);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // 'span 1' is contained inside a single grid track regardless of the direction.
</span><span class="cx"> // That's why the CSS span value is one more than the offset we apply.
</span><span class="cx"> unsigned positionOffset = position.spanPosition();
</span><span class="cx"> if (isStartSide(side))
</span><del>- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition - positionOffset, resolvedOppositePosition);
</del><ins>+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine - positionOffset, oppositeLine);
</ins><span class="cx">
</span><del>- return GridSpan::untranslatedDefiniteGridSpan(resolvedOppositePosition, resolvedOppositePosition + positionOffset);
</del><ins>+ return GridSpan::untranslatedDefiniteGridSpan(oppositeLine, oppositeLine + positionOffset);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> unsigned GridPositionsResolver::spanSizeForAutoPlacedItem(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
</span><span class="lines">@@ -308,25 +308,25 @@
</span><span class="cx">
</span><span class="cx"> if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
</span><span class="cx"> // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
</span><del>- auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
</del><ins>+ auto endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, endLine, initialPosition, initialSide);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
</span><span class="cx"> // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
</span><del>- auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
</del><ins>+ auto startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, startLine, finalPosition, finalSide);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- int resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
- int resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
</del><ins>+ int startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ int endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
</ins><span class="cx">
</span><del>- if (resolvedInitialPosition > resolvedFinalPosition)
- std::swap(resolvedInitialPosition, resolvedFinalPosition);
- else if (resolvedInitialPosition == resolvedFinalPosition)
- resolvedFinalPosition = resolvedInitialPosition + 1;
</del><ins>+ if (startLine > endLine)
+ std::swap(startLine, endLine);
+ else if (startLine == endLine)
+ endLine = startLine + 1;
</ins><span class="cx">
</span><del>- return GridSpan::untranslatedDefiniteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
</del><ins>+ return GridSpan::untranslatedDefiniteGridSpan(startLine, std::max(startLine, endLine));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre>
</div>
</div>
</body>
</html>