<!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>[196691] 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/196691">196691</a></dd>
<dt>Author</dt> <dd>rego@igalia.com</dd>
<dt>Date</dt> <dd>2016-02-17 03:45:30 -0800 (Wed, 17 Feb 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>[css-grid] GridSpan refactoring
https://bugs.webkit.org/show_bug.cgi?id=153868
Reviewed by Sergio Villar Senin.
Add new enum to know if a GridSpan is definite or indefinite.
That way we don't need GridUnresolvedSpan class (which is removed).
We can always have two GridSpans in GridCoordinate,
if the position is "auto" the GridSpan will be marked as indefinite.
This will allow in a follow-up patch to avoid repeated calls
to methods that resolve positions.
Most operations in GridSpan are restricted to definite GridSpans (access
to positions, iterator, etc.). For indefinite GridSpans we only need to
know that they're indefinite, we shouldn't use the rest of the data.
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::GridIterator::nextEmptyGridArea):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
(WebCore::RenderGrid::insertItemIntoGrid):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):
(WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
(WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
(WebCore::RenderGrid::populateGridPositions): Deleted.
* rendering/style/GridCoordinate.h:
(WebCore::GridSpan::definiteGridSpan):
(WebCore::GridSpan::indefiniteGridSpan):
(WebCore::GridSpan::operator==):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::resolvedInitialPosition):
(WebCore::GridSpan::resolvedFinalPosition):
(WebCore::GridSpan::begin):
(WebCore::GridSpan::end):
(WebCore::GridSpan::isDefinite):
(WebCore::GridSpan::GridSpan):
(WebCore::GridCoordinate::GridCoordinate):
* rendering/style/GridResolvedPosition.cpp:
(WebCore::initialPositionSide):
(WebCore::finalPositionSide):
(WebCore::adjustGridPositionsFromStyle):
(WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
(WebCore::implicitNamedGridLineForSide): Deleted.
(WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Deleted.
(WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
(WebCore::resolveGridPositionFromStyle): Deleted.
* rendering/style/GridResolvedPosition.h:
(WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
(WebCore::GridResolvedPosition::operator*): Deleted.
(WebCore::GridResolvedPosition::operator++): Deleted.
(WebCore::GridResolvedPosition::operator==): Deleted.</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="#trunkSourceWebCorerenderingstyleGridCoordinateh">trunk/Source/WebCore/rendering/style/GridCoordinate.h</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleGridResolvedPositioncpp">trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp</a></li>
<li><a href="#trunkSourceWebCorerenderingstyleGridResolvedPositionh">trunk/Source/WebCore/rendering/style/GridResolvedPosition.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/ChangeLog 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -1,3 +1,77 @@
</span><ins>+2016-02-17 Manuel Rego Casasnovas <rego@igalia.com>
+
+ [css-grid] GridSpan refactoring
+ https://bugs.webkit.org/show_bug.cgi?id=153868
+
+ Reviewed by Sergio Villar Senin.
+
+ Add new enum to know if a GridSpan is definite or indefinite.
+ That way we don't need GridUnresolvedSpan class (which is removed).
+ We can always have two GridSpans in GridCoordinate,
+ if the position is "auto" the GridSpan will be marked as indefinite.
+ This will allow in a follow-up patch to avoid repeated calls
+ to methods that resolve positions.
+
+ Most operations in GridSpan are restricted to definite GridSpans (access
+ to positions, iterator, etc.). For indefinite GridSpans we only need to
+ know that they're indefinite, we shouldn't use the rest of the data.
+
+ 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::GridIterator::nextEmptyGridArea):
+ (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
+ (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems):
+ (WebCore::RenderGrid::insertItemIntoGrid):
+ (WebCore::RenderGrid::placeItemsOnGrid):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Deleted.
+ (WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
+ (WebCore::RenderGrid::populateGridPositions): Deleted.
+ * rendering/style/GridCoordinate.h:
+ (WebCore::GridSpan::definiteGridSpan):
+ (WebCore::GridSpan::indefiniteGridSpan):
+ (WebCore::GridSpan::operator==):
+ (WebCore::GridSpan::integerSpan):
+ (WebCore::GridSpan::resolvedInitialPosition):
+ (WebCore::GridSpan::resolvedFinalPosition):
+ (WebCore::GridSpan::begin):
+ (WebCore::GridSpan::end):
+ (WebCore::GridSpan::isDefinite):
+ (WebCore::GridSpan::GridSpan):
+ (WebCore::GridCoordinate::GridCoordinate):
+ * rendering/style/GridResolvedPosition.cpp:
+ (WebCore::initialPositionSide):
+ (WebCore::finalPositionSide):
+ (WebCore::adjustGridPositionsFromStyle):
+ (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveGridPositionAgainstOppositePosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
+ (WebCore::implicitNamedGridLineForSide): Deleted.
+ (WebCore::GridResolvedPosition::isNonExistentNamedLineOrArea): Deleted.
+ (WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
+ (WebCore::resolveGridPositionFromStyle): Deleted.
+ * rendering/style/GridResolvedPosition.h:
+ (WebCore::GridResolvedPosition::GridResolvedPosition): Deleted.
+ (WebCore::GridResolvedPosition::operator*): Deleted.
+ (WebCore::GridResolvedPosition::operator++): Deleted.
+ (WebCore::GridResolvedPosition::operator==): Deleted.
+
</ins><span class="cx"> 2016-02-17 Chris Dumez <cdumez@apple.com>
</span><span class="cx">
</span><span class="cx"> Window should have its 'constructor' property on the prototype
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGridTemplateAreasValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-02-17 11:45:30 UTC (rev 196691)
</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 GridCoordinate& coordinate = it.value;
</span><del>- if (row >= coordinate.rows.resolvedInitialPosition.toInt() && row < coordinate.rows.resolvedFinalPosition.toInt())
</del><ins>+ if (row >= coordinate.rows.resolvedInitialPosition().toInt() && row < coordinate.rows.resolvedFinalPosition().toInt())
</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 GridCoordinate& coordinate = it.value;
</span><del>- if (column >= coordinate.columns.resolvedInitialPosition.toInt() && column < coordinate.columns.resolvedFinalPosition.toInt() && candidates.contains(it.key))
</del><ins>+ if (column >= coordinate.columns.resolvedInitialPosition().toInt() && column < coordinate.columns.resolvedFinalPosition().toInt() && 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 (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -6217,24 +6217,24 @@
</span><span class="cx">
</span><span class="cx"> auto gridAreaIterator = gridAreaMap.find(gridAreaName);
</span><span class="cx"> if (gridAreaIterator == gridAreaMap.end())
</span><del>- gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount + 1), GridSpan(currentColumn, lookAheadColumn)));
</del><ins>+ gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan::definiteGridSpan(rowCount, rowCount + 1), GridSpan::definiteGridSpan(currentColumn, lookAheadColumn)));
</ins><span class="cx"> else {
</span><span class="cx"> GridCoordinate& gridCoordinate = gridAreaIterator->value;
</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 != gridCoordinate.rows.resolvedFinalPosition.toInt())
</del><ins>+ if (rowCount != gridCoordinate.rows.resolvedFinalPosition().toInt())
</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 != gridCoordinate.columns.resolvedInitialPosition.toInt())
</del><ins>+ if (currentColumn != gridCoordinate.columns.resolvedInitialPosition().toInt())
</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 != gridCoordinate.columns.resolvedFinalPosition.toInt())
</del><ins>+ if (lookAheadColumn != gridCoordinate.columns.resolvedFinalPosition().toInt())
</ins><span class="cx"> return false;
</span><span class="cx">
</span><del>- ++gridCoordinate.rows.resolvedFinalPosition;
</del><ins>+ gridCoordinate.rows = GridSpan::definiteGridSpan(gridCoordinate.rows.resolvedInitialPosition(), gridCoordinate.rows.resolvedFinalPosition().next());
</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 (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -886,12 +886,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.toInt());
</del><ins>+ startVector.append(areaSpan.resolvedInitialPosition().toInt());
</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.toInt());
</del><ins>+ endVector.append(areaSpan.resolvedFinalPosition().toInt());
</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 (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -190,7 +190,7 @@
</span><span class="cx"> const unsigned endOfVaryingTrackIndex = (m_direction == ForColumns) ? m_grid.size() : m_grid[0].size();
</span><span class="cx"> for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex) {
</span><span class="cx"> if (isEmptyAreaEnough(rowSpan, columnSpan)) {
</span><del>- std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan(m_columnIndex, m_columnIndex + columnSpan));
</del><ins>+ std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan::definiteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::definiteGridSpan(m_columnIndex, m_columnIndex + columnSpan));
</ins><span class="cx"> // Advance the iterator to avoid an infinite loop where we would return the same grid area over and over.
</span><span class="cx"> ++varyingTrackIndex;
</span><span class="cx"> return result;
</span><span class="lines">@@ -566,7 +566,7 @@
</span><span class="cx"> // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
</span><span class="cx"> double flexFraction = 0;
</span><span class="cx"> if (hasDefiniteFreeSpace)
</span><del>- flexFraction = findFlexFactorUnitSize(tracks, GridSpan(0, tracks.size()), direction, initialFreeSpace.value());
</del><ins>+ flexFraction = findFlexFactorUnitSize(tracks, GridSpan::definiteGridSpan(0, tracks.size()), direction, initialFreeSpace.value());
</ins><span class="cx"> else {
</span><span class="cx"> for (const auto& trackIndex : flexibleSizedTracksIndex)
</span><span class="cx"> flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
</span><span class="lines">@@ -577,7 +577,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.toInt() <= flexibleSizedTracksIndex[i - 1])
</del><ins>+ if (i > 0 && span.resolvedInitialPosition().toInt() <= 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">@@ -865,7 +865,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>- const GridResolvedPosition trackPosition = span.resolvedInitialPosition;
</del><ins>+ const GridResolvedPosition trackPosition = span.resolvedInitialPosition();
</ins><span class="cx"> GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
</span><span class="cx">
</span><span class="cx"> if (trackSize.hasMinContentMinTrackBreadth())
</span><span class="lines">@@ -1138,7 +1138,7 @@
</span><span class="cx">
</span><span class="cx"> void RenderGrid::insertItemIntoGrid(RenderBox& child, const GridCoordinate& coordinate)
</span><span class="cx"> {
</span><del>- ensureGridSize(coordinate.rows.resolvedFinalPosition.toInt(), coordinate.columns.resolvedFinalPosition.toInt());
</del><ins>+ ensureGridSize(coordinate.rows.resolvedFinalPosition().toInt(), coordinate.columns.resolvedFinalPosition().toInt());
</ins><span class="cx">
</span><span class="cx"> for (auto& row : coordinate.rows) {
</span><span class="cx"> for (auto& column : coordinate.columns)
</span><span class="lines">@@ -1160,21 +1160,18 @@
</span><span class="cx"> if (child->isOutOfFlowPositioned())
</span><span class="cx"> continue;
</span><span class="cx">
</span><del>- auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
- auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
</del><ins>+ GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
+ GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
</ins><span class="cx">
</span><del>- if (unresolvedRowPositions.requiresAutoPlacement() || unresolvedColumnPositions.requiresAutoPlacement()) {
-
</del><ins>+ if (!rowPositions.isDefinite() || !columnPositions.isDefinite()) {
</ins><span class="cx"> bool majorAxisDirectionIsForColumns = autoPlacementMajorAxisDirection() == ForColumns;
</span><del>- if ((majorAxisDirectionIsForColumns && unresolvedColumnPositions.requiresAutoPlacement())
- || (!majorAxisDirectionIsForColumns && unresolvedRowPositions.requiresAutoPlacement()))
</del><ins>+ if ((majorAxisDirectionIsForColumns && !columnPositions.isDefinite())
+ || (!majorAxisDirectionIsForColumns && !rowPositions.isDefinite()))
</ins><span class="cx"> autoMajorAxisAutoGridItems.append(child);
</span><span class="cx"> else
</span><span class="cx"> specifiedMajorAxisAutoGridItems.append(child);
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><del>- GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
- GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
</del><span class="cx"> insertItemIntoGrid(*child, GridCoordinate(rowPositions, columnPositions));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1197,24 +1194,22 @@
</span><span class="cx">
</span><span class="cx"> populator.collectChild(*child);
</span><span class="cx">
</span><del>- auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
- if (!unresolvedRowPositions.requiresAutoPlacement()) {
- GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
- maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.toInt());
</del><ins>+ GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForRows);
+ if (rowPositions.isDefinite()) {
+ maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition().toInt());
</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"> GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForRows, GridResolvedPosition(0));
</span><del>- maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition.toInt());
</del><ins>+ maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition().toInt());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
- if (!unresolvedColumnPositions.requiresAutoPlacement()) {
- GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
- maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.toInt());
</del><ins>+ GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *child, ForColumns);
+ if (columnPositions.isDefinite()) {
+ maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition().toInt());
</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"> GridSpan positions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *child, ForColumns, GridResolvedPosition(0));
</span><del>- maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition.toInt());
</del><ins>+ maximumColumnIndex = std::max(maximumColumnIndex, positions.resolvedFinalPosition().toInt());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1242,20 +1237,19 @@
</span><span class="cx"> HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> minorAxisCursors;
</span><span class="cx">
</span><span class="cx"> for (auto& autoGridItem : autoGridItems) {
</span><del>- auto unresolvedMajorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
- ASSERT(!unresolvedMajorAxisPositions.requiresAutoPlacement());
- GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMajorAxisPositions, style());
</del><ins>+ GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), *autoGridItem, autoPlacementMajorAxisDirection());
+ ASSERT(majorAxisPositions.isDefinite());
</ins><span class="cx"> GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), *autoGridItem, autoPlacementMinorAxisDirection(), GridResolvedPosition(0));
</span><del>- unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition.toInt();
</del><ins>+ unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPosition().toInt();
</ins><span class="cx">
</span><del>- GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition.toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
</del><ins>+ GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.resolvedInitialPosition().toInt(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
</ins><span class="cx"> std::unique_ptr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisPositions.integerSpan());
</span><span class="cx"> if (!emptyGridArea)
</span><span class="cx"> emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
</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.toInt() : emptyGridArea->columns.resolvedInitialPosition.toInt());
</del><ins>+ minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyGridArea->rows.resolvedInitialPosition().toInt() : emptyGridArea->columns.resolvedInitialPosition().toInt());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1276,7 +1270,7 @@
</span><span class="cx">
</span><span class="cx"> void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
</span><span class="cx"> {
</span><del>- ASSERT(GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).requiresAutoPlacement());
</del><ins>+ ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(style(), gridItem, autoPlacementMajorAxisDirection()).isDefinite());
</ins><span class="cx"> GridSpan majorAxisPositions = GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(style(), gridItem, autoPlacementMajorAxisDirection(), GridResolvedPosition(0));
</span><span class="cx">
</span><span class="cx"> const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
</span><span class="lines">@@ -1284,16 +1278,14 @@
</span><span class="cx"> unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
</span><span class="cx">
</span><span class="cx"> std::unique_ptr<GridCoordinate> emptyGridArea;
</span><del>- auto unresolvedMinorAxisPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), gridItem, autoPlacementMinorAxisDirection());
- if (!unresolvedMinorAxisPositions.requiresAutoPlacement()) {
- GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedMinorAxisPositions, style());
-
</del><ins>+ GridSpan minorAxisPositions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), gridItem, autoPlacementMinorAxisDirection());
+ if (minorAxisPositions.isDefinite()) {
</ins><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.toInt() < minorAxisAutoPlacementCursor)
</del><ins>+ if (minorAxisPositions.resolvedInitialPosition().toInt() < 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.toInt(), majorAxisAutoPlacementCursor);
</del><ins>+ GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.resolvedInitialPosition().toInt(), majorAxisAutoPlacementCursor);
</ins><span class="cx"> emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisPositions.integerSpan());
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1308,7 +1300,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>- GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition : emptyGridArea->rows.resolvedFinalPosition;
</del><ins>+ GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition() : emptyGridArea->rows.resolvedFinalPosition();
</ins><span class="cx"> const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
</span><span class="cx"> if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
</span><span class="cx"> break;
</span><span class="lines">@@ -1327,8 +1319,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> insertItemIntoGrid(gridItem, *emptyGridArea);
</span><del>- autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition.toInt();
- autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition.toInt();
</del><ins>+ autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition().toInt();
+ autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition().toInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const
</span><span class="lines">@@ -1460,8 +1452,8 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(child.isHorizontalWritingMode() == isHorizontalWritingMode());
</span><span class="cx">
</span><del>- auto unresolvedPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), child, direction);
- if (unresolvedPositions.requiresAutoPlacement()) {
</del><ins>+ GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(style(), child, direction);
+ if (!positions.isDefinite()) {
</ins><span class="cx"> offset = LayoutUnit();
</span><span class="cx"> breadth = (direction == ForColumns) ? clientLogicalWidth() : clientLogicalHeight();
</span><span class="cx"> return;
</span><span class="lines">@@ -1471,18 +1463,17 @@
</span><span class="cx"> GridPosition endPosition = (direction == ForColumns) ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
</span><span class="cx"> size_t lastTrackIndex = (direction == ForColumns ? gridColumnCount() : gridRowCount()) - 1;
</span><span class="cx">
</span><del>- GridSpan positions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedPositions, style());
</del><span class="cx"> bool startIsAuto = startPosition.isAuto()
</span><span class="cx"> || (startPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(startPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnStartSide : RowStartSide))
</span><del>- || (positions.resolvedInitialPosition.toInt() > lastTrackIndex);
</del><ins>+ || (positions.resolvedInitialPosition().toInt() > lastTrackIndex);
</ins><span class="cx"> bool endIsAuto = endPosition.isAuto()
</span><span class="cx"> || (endPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(endPosition.namedGridLine(), style(), (direction == ForColumns) ? ColumnEndSide : RowEndSide))
</span><del>- || (positions.resolvedFinalPosition.prev().toInt() > lastTrackIndex);
</del><ins>+ || (positions.resolvedFinalPosition().prev().toInt() > lastTrackIndex);
</ins><span class="cx">
</span><span class="cx"> GridResolvedPosition firstPosition = GridResolvedPosition(0);
</span><del>- GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
</del><ins>+ GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition();
</ins><span class="cx"> GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
</span><del>- GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition.prev();
</del><ins>+ GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition().prev();
</ins><span class="cx">
</span><span class="cx"> // Positioned children do not grow the grid, so we need to clamp the positions to avoid ending up outside of it.
</span><span class="cx"> initialPosition = std::min<GridResolvedPosition>(initialPosition, lastPosition);
</span><span class="lines">@@ -1542,11 +1533,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.toInt()];
- LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.prev().toInt()];
</del><ins>+ LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition().toInt()];
+ LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition().prev().toInt()];
</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.prev().toInt()].baseSize();
</del><ins>+ return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition().prev().toInt()].baseSize();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderGrid::populateGridPositions(GridSizingData& sizingData)
</span><span class="lines">@@ -1825,7 +1816,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.toInt();
</del><ins>+ unsigned childStartLine = rowsSpan.resolvedInitialPosition().toInt();
</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">@@ -1836,7 +1827,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.toInt();
</del><ins>+ unsigned childEndLine = rowsSpan.resolvedFinalPosition().toInt();
</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">@@ -1859,7 +1850,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.toInt();
</del><ins>+ unsigned childStartLine = columnsSpan.resolvedInitialPosition().toInt();
</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">@@ -1870,7 +1861,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.toInt();
</del><ins>+ unsigned childEndLine = columnsSpan.resolvedFinalPosition().toInt();
</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="trunkSourceWebCorerenderingstyleGridCoordinateh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridCoordinate.h (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -48,37 +48,76 @@
</span><span class="cx"> // Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
</span><span class="cx"> class GridSpan {
</span><span class="cx"> public:
</span><del>- GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
- : resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
- , resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
</del><ins>+
+ static GridSpan definiteGridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
</ins><span class="cx"> {
</span><del>- ASSERT(resolvedInitialPosition < resolvedFinalPosition);
</del><ins>+ return GridSpan(resolvedInitialPosition, resolvedFinalPosition, Definite);
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+ static GridSpan indefiniteGridSpan()
+ {
+ return GridSpan(0, 1, Indefinite);
+ }
+
</ins><span class="cx"> bool operator==(const GridSpan& o) const
</span><span class="cx"> {
</span><del>- return resolvedInitialPosition == o.resolvedInitialPosition && resolvedFinalPosition == o.resolvedFinalPosition;
</del><ins>+ return m_type == o.m_type && m_resolvedInitialPosition == o.m_resolvedInitialPosition && m_resolvedFinalPosition == o.m_resolvedFinalPosition;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> unsigned integerSpan() const
</span><span class="cx"> {
</span><del>- return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt();
</del><ins>+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition.toInt() - m_resolvedInitialPosition.toInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- GridResolvedPosition resolvedInitialPosition;
- GridResolvedPosition resolvedFinalPosition;
</del><ins>+ const GridResolvedPosition& resolvedInitialPosition() const
+ {
+ ASSERT(isDefinite());
+ return m_resolvedInitialPosition;
+ }
</ins><span class="cx">
</span><ins>+ const GridResolvedPosition& resolvedFinalPosition() const
+ {
+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition;
+ }
+
</ins><span class="cx"> typedef GridResolvedPosition iterator;
</span><span class="cx">
</span><span class="cx"> iterator begin() const
</span><span class="cx"> {
</span><del>- return resolvedInitialPosition;
</del><ins>+ ASSERT(isDefinite());
+ return m_resolvedInitialPosition;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> iterator end() const
</span><span class="cx"> {
</span><del>- return resolvedFinalPosition;
</del><ins>+ ASSERT(isDefinite());
+ return m_resolvedFinalPosition;
</ins><span class="cx"> }
</span><ins>+
+ bool isDefinite() const
+ {
+ return m_type == Definite;
+ }
+
+private:
+
+ enum GridSpanType {Definite, Indefinite};
+
+ GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition, GridSpanType type)
+ : m_resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
+ , m_resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
+ , m_type(type)
+ {
+ ASSERT(resolvedInitialPosition < resolvedFinalPosition);
+ }
+
+ GridResolvedPosition m_resolvedInitialPosition;
+ GridResolvedPosition m_resolvedFinalPosition;
+ GridSpanType m_type;
+
+
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> // This represents a grid area that spans in both rows' and columns' direction.
</span><span class="lines">@@ -86,8 +125,8 @@
</span><span class="cx"> public:
</span><span class="cx"> // HashMap requires a default constuctor.
</span><span class="cx"> GridCoordinate()
</span><del>- : columns(0, 1)
- , rows(0, 1)
</del><ins>+ : columns(GridSpan::indefiniteGridSpan())
+ , rows(GridSpan::indefiniteGridSpan())
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleGridResolvedPositioncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -48,6 +48,16 @@
</span><span class="cx"> return side == ColumnStartSide || side == RowStartSide;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+static inline GridPositionSide initialPositionSide(GridTrackSizingDirection direction)
+{
+ return direction == ForColumns ? ColumnStartSide : RowStartSide;
+}
+
+static inline GridPositionSide finalPositionSide(GridTrackSizingDirection direction)
+{
+ return direction == ForColumns ? ColumnEndSide : RowEndSide;
+}
+
</ins><span class="cx"> static const NamedGridLinesMap& gridLinesForSide(const RenderStyle& style, GridPositionSide side)
</span><span class="cx"> {
</span><span class="cx"> return isColumnSide(side) ? style.namedGridColumnLines() : style.namedGridRowLines();
</span><span class="lines">@@ -64,34 +74,31 @@
</span><span class="cx"> return !gridLineNames.contains(implicitNamedGridLineForSide(lineName, side)) && !gridLineNames.contains(lineName);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool GridUnresolvedSpan::requiresAutoPlacement() const
</del><ins>+static void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
</ins><span class="cx"> {
</span><del>- return m_initialPosition.shouldBeResolvedAgainstOppositePosition() && m_finalPosition.shouldBeResolvedAgainstOppositePosition();
-}
</del><ins>+ bool isForColumns = direction == ForColumns;
+ initialPosition = isForColumns ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
+ finalPosition = isForColumns ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
</ins><span class="cx">
</span><del>-void GridUnresolvedSpan::adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle)
-{
- ASSERT(isColumnSide(m_initialPositionSide) == isColumnSide(m_finalPositionSide));
-
</del><span class="cx"> // We must handle the placement error handling code here instead of in the StyleAdjuster because we don't want to
</span><span class="cx"> // overwrite the specified values.
</span><del>- if (m_initialPosition.isSpan() && m_finalPosition.isSpan())
- m_finalPosition.setAutoPosition();
</del><ins>+ if (initialPosition.isSpan() && finalPosition.isSpan())
+ finalPosition.setAutoPosition();
</ins><span class="cx">
</span><span class="cx"> // Try to early detect the case of non existing named grid lines. This way we could assume later that
</span><span class="cx"> // GridResolvedPosition::resolveGrisPositionFromStyle() won't require the autoplacement to run, i.e., it'll always return a
</span><span class="cx"> // valid resolved position.
</span><del>- if (m_initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_initialPosition.namedGridLine(), gridContainerStyle, m_initialPositionSide))
- m_initialPosition.setAutoPosition();
</del><ins>+ if (initialPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(initialPosition.namedGridLine(), gridContainerStyle, initialPositionSide(direction)))
+ initialPosition.setAutoPosition();
</ins><span class="cx">
</span><del>- if (m_finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(m_finalPosition.namedGridLine(), gridContainerStyle, m_finalPositionSide))
- m_finalPosition.setAutoPosition();
</del><ins>+ if (finalPosition.isNamedGridArea() && GridResolvedPosition::isNonExistentNamedLineOrArea(finalPosition.namedGridLine(), gridContainerStyle, finalPositionSide(direction)))
+ finalPosition.setAutoPosition();
</ins><span class="cx">
</span><span class="cx"> // 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.
</span><del>- 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());
</del><ins>+ if (initialPosition.isAuto() && finalPosition.isSpan() && !finalPosition.namedGridLine().isNull())
+ finalPosition.setSpanPosition(1, String());
+ if (finalPosition.isAuto() && initialPosition.isSpan() && !initialPosition.namedGridLine().isNull())
+ initialPosition.setSpanPosition(1, String());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> unsigned GridResolvedPosition::explicitGridColumnCount(const RenderStyle& gridContainerStyle)
</span><span class="lines">@@ -133,7 +140,7 @@
</span><span class="cx"> static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
</span><span class="cx"> {
</span><span class="cx"> if (!resolvedOppositePosition.toInt())
</span><del>- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</ins><span class="cx">
</span><span class="cx"> unsigned firstLineBeforePositionIndex = 0;
</span><span class="cx"> auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
</span><span class="lines">@@ -145,7 +152,7 @@
</span><span class="cx"> GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
</span><span class="cx"> if (resolvedGridLinePosition >= resolvedOppositePosition)
</span><span class="cx"> resolvedGridLinePosition = resolvedOppositePosition.prev();
</span><del>- return GridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
</del><ins>+ return GridSpan::definiteGridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static GridSpan resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
</span><span class="lines">@@ -160,7 +167,7 @@
</span><span class="cx"> GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
</span><span class="cx"> if (resolvedGridLinePosition <= resolvedOppositePosition)
</span><span class="cx"> resolvedGridLinePosition = resolvedOppositePosition.next();
</span><del>- return GridSpan(resolvedOppositePosition, resolvedGridLinePosition);
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedGridLinePosition);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
</span><span class="lines">@@ -177,8 +184,8 @@
</span><span class="cx"> // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
</span><span class="cx"> if (it == gridLinesNames.end()) {
</span><span class="cx"> if (isStartSide(side) && resolvedOppositePosition.toInt())
</span><del>- return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (side == RowStartSide || side == ColumnStartSide)
</span><span class="lines">@@ -191,8 +198,8 @@
</span><span class="cx"> {
</span><span class="cx"> if (position.isAuto()) {
</span><span class="cx"> if (isStartSide(side) && resolvedOppositePosition.toInt())
</span><del>- return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> ASSERT(position.isSpan());
</span><span class="lines">@@ -208,30 +215,32 @@
</span><span class="cx"> unsigned positionOffset = position.spanPosition();
</span><span class="cx"> if (isStartSide(side)) {
</span><span class="cx"> if (!resolvedOppositePosition.toInt())
</span><del>- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
</ins><span class="cx">
</span><span class="cx"> unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
</span><del>- return GridSpan(initialResolvedPosition, resolvedOppositePosition);
</del><ins>+ return GridSpan::definiteGridSpan(initialResolvedPosition, resolvedOppositePosition);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- return GridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
</del><ins>+ return GridSpan::definiteGridSpan(resolvedOppositePosition, resolvedOppositePosition.toInt() + positionOffset);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GridSpan GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, const GridResolvedPosition& resolvedInitialPosition)
</span><span class="cx"> {
</span><del>- GridUnresolvedSpan unresolvedSpan = unresolvedSpanFromStyle(gridContainerStyle, gridItem, direction);
</del><ins>+ GridPosition initialPosition, finalPosition;
+ adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
</ins><span class="cx">
</span><ins>+ GridPositionSide finalSide = finalPositionSide(direction);
</ins><span class="cx"> // This method will only be used when both positions need to be resolved against the opposite one.
</span><del>- ASSERT(unresolvedSpan.requiresAutoPlacement());
</del><ins>+ ASSERT(initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition());
</ins><span class="cx">
</span><span class="cx"> GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
</span><span class="cx">
</span><del>- if (unresolvedSpan.initialPosition().isSpan())
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.initialPosition(), unresolvedSpan.finalPositionSide());
- if (unresolvedSpan.finalPosition().isSpan())
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
</del><ins>+ if (initialPosition.isSpan())
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, initialPosition, finalSide);
+ if (finalPosition.isSpan())
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, finalPosition, finalSide);
</ins><span class="cx">
</span><del>- return GridSpan(resolvedInitialPosition, resolvedFinalPosition);
</del><ins>+ return GridSpan::definiteGridSpan(resolvedInitialPosition, resolvedFinalPosition);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static GridResolvedPosition resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
</span><span class="lines">@@ -291,47 +300,39 @@
</span><span class="cx"> return GridResolvedPosition(0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-GridUnresolvedSpan GridResolvedPosition::unresolvedSpanFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
</del><ins>+GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction)
</ins><span class="cx"> {
</span><del>- GridPosition initialPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnStart() : gridItem.style().gridItemRowStart();
- auto initialPositionSide = (direction == ForColumns) ? ColumnStartSide : RowStartSide;
- GridPosition finalPosition = (direction == ForColumns) ? gridItem.style().gridItemColumnEnd() : gridItem.style().gridItemRowEnd();
- auto finalPositionSide = (direction == ForColumns) ? ColumnEndSide : RowEndSide;
</del><ins>+ GridPosition initialPosition, finalPosition;
+ adjustGridPositionsFromStyle(gridContainerStyle, gridItem, direction, initialPosition, finalPosition);
</ins><span class="cx">
</span><del>- GridUnresolvedSpan unresolvedSpan(initialPosition, initialPositionSide, finalPosition, finalPositionSide);
- unresolvedSpan.adjustGridPositionsFromStyle(gridContainerStyle);
</del><ins>+ GridPositionSide initialSide = initialPositionSide(direction);
+ GridPositionSide finalSide = finalPositionSide(direction);
</ins><span class="cx">
</span><del>- return unresolvedSpan;
-}
</del><ins>+ // We can't get our grid positions without running the auto placement algorithm.
+ if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPosition.shouldBeResolvedAgainstOppositePosition())
+ return GridSpan::indefiniteGridSpan();
</ins><span class="cx">
</span><del>-GridSpan GridResolvedPosition::resolveGridPositionsFromStyle(const GridUnresolvedSpan& unresolvedSpan, const RenderStyle& gridContainerStyle)
-{
- ASSERT(!unresolvedSpan.requiresAutoPlacement());
-
- // We must create the GridSpan using finalPosition.prev() because GridSpan stores cell indexes and
- // an item finishing on the N-th line belongs to the N-1-th cell.
-
- if (unresolvedSpan.initialPosition().shouldBeResolvedAgainstOppositePosition()) {
</del><ins>+ if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
</ins><span class="cx"> // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
</span><del>- auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
</del><ins>+ auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, initialPosition, initialSide);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- if (unresolvedSpan.finalPosition().shouldBeResolvedAgainstOppositePosition()) {
</del><ins>+ if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
</ins><span class="cx"> // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
</span><del>- auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
</del><ins>+ auto initialResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, initialResolvedPosition, finalPosition, finalSide);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
- GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
</del><ins>+ GridResolvedPosition resolvedInitialPosition = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide);
+ GridResolvedPosition resolvedFinalPosition = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide);
</ins><span class="cx">
</span><span class="cx"> if (resolvedInitialPosition > resolvedFinalPosition)
</span><span class="cx"> std::swap(resolvedInitialPosition, resolvedFinalPosition);
</span><span class="cx"> else if (resolvedInitialPosition == resolvedFinalPosition)
</span><span class="cx"> resolvedFinalPosition = resolvedInitialPosition.next();
</span><span class="cx">
</span><del>- return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
</del><ins>+ return GridSpan::definiteGridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleGridResolvedPositionh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridResolvedPosition.h (196690 => 196691)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-02-17 08:38:27 UTC (rev 196690)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-02-17 11:45:30 UTC (rev 196691)
</span><span class="lines">@@ -46,31 +46,6 @@
</span><span class="cx"> ForRows
</span><span class="cx"> };
</span><span class="cx">
</span><del>-class GridUnresolvedSpan {
-public:
- GridUnresolvedSpan(GridPosition initialPosition, GridPositionSide initialPositionSide, GridPosition finalPosition, GridPositionSide finalPositionSide)
- : m_initialPosition(initialPosition)
- , m_finalPosition(finalPosition)
- , m_initialPositionSide(initialPositionSide)
- , m_finalPositionSide(finalPositionSide)
- {
- }
-
- const GridPosition& initialPosition() const { return m_initialPosition; }
- const GridPosition& finalPosition() const { return m_finalPosition; }
- GridPositionSide initialPositionSide() const { return m_initialPositionSide; }
- GridPositionSide finalPositionSide() const { return m_finalPositionSide; }
-
- bool requiresAutoPlacement() const;
- void adjustGridPositionsFromStyle(const RenderStyle& gridContainerStyle);
-
-private:
- GridPosition m_initialPosition;
- GridPosition m_finalPosition;
- GridPositionSide m_initialPositionSide;
- GridPositionSide m_finalPositionSide;
-};
-
</del><span class="cx"> // This class represents a line index into one of the dimensions of the grid array.
</span><span class="cx"> // Wraps an unsigned integer just for the purpose of knowing what we manipulate in the grid code.
</span><span class="cx"> class GridResolvedPosition {
</span><span class="lines">@@ -137,8 +112,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static GridSpan resolveGridPositionsFromAutoPlacementPosition(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, const GridResolvedPosition&);
</span><del>- static GridSpan resolveGridPositionsFromStyle(const GridUnresolvedSpan&, const RenderStyle&);
- static GridUnresolvedSpan unresolvedSpanFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
</del><ins>+ static GridSpan resolveGridPositionsFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection);
</ins><span class="cx"> static unsigned explicitGridColumnCount(const RenderStyle&);
</span><span class="cx"> static unsigned explicitGridRowCount(const RenderStyle&);
</span><span class="cx"> static bool isNonExistentNamedLineOrArea(const String& lineName, const RenderStyle&, GridPositionSide);
</span></span></pre>
</div>
</div>
</body>
</html>