<!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>[195808] 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/195808">195808</a></dd>
<dt>Author</dt> <dd>rego@igalia.com</dd>
<dt>Date</dt> <dd>2016-01-29 01:22:28 -0800 (Fri, 29 Jan 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>[css-grid] Store lines instead of tracks in GridResolvedPosition
https://bugs.webkit.org/show_bug.cgi?id=153592
Reviewed by Sergio Villar Senin.
Due to the new feature that allows to create implicit tracks before the
explicit ones, we will need to use lines instead of tracks in the
code to be able to implement it properly.
This is just a first simple patch using lines instead of tracks in
GridResolvedPosition. It modifies the code that was using it, as it was
considering that the resolvedFinalPosition was a track index and
not a line index.
So if we've an item positioned like:
grid-column: 2 / 5;
grid-row: 1 / span 2;
Before we were storing this information on the GridSpan:
* columns:
* resolvedInitialPosition: 1
* resolvedFinalPosition: 3
* rows:
* resolvedInitialPosition: 0
* resolvedFinalPosition: 1
And now we're storing:
* columns:
* resolvedInitialPosition: 1
* resolvedFinalPosition: 4
* rows:
* resolvedInitialPosition: 0
* resolvedFinalPosition: 2
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::ensureGridSize):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):
* rendering/RenderGrid.h:
* rendering/style/GridCoordinate.h:
(WebCore::GridSpan::GridSpan):
(WebCore::GridSpan::integerSpan):
(WebCore::GridSpan::end):
(WebCore::GridCoordinate::GridCoordinate):
* rendering/style/GridResolvedPosition.cpp:
(WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
(WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
(WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
* rendering/style/GridResolvedPosition.h:</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="#trunkSourceWebCorerenderingRenderGridh">trunk/Source/WebCore/rendering/RenderGrid.h</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 (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/ChangeLog 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -1,3 +1,73 @@
</span><ins>+2016-01-29 Manuel Rego Casasnovas <rego@igalia.com>
+
+ [css-grid] Store lines instead of tracks in GridResolvedPosition
+ https://bugs.webkit.org/show_bug.cgi?id=153592
+
+ Reviewed by Sergio Villar Senin.
+
+ Due to the new feature that allows to create implicit tracks before the
+ explicit ones, we will need to use lines instead of tracks in the
+ code to be able to implement it properly.
+
+ This is just a first simple patch using lines instead of tracks in
+ GridResolvedPosition. It modifies the code that was using it, as it was
+ considering that the resolvedFinalPosition was a track index and
+ not a line index.
+
+ So if we've an item positioned like:
+ grid-column: 2 / 5;
+ grid-row: 1 / span 2;
+
+ Before we were storing this information on the GridSpan:
+ * columns:
+ * resolvedInitialPosition: 1
+ * resolvedFinalPosition: 3
+ * rows:
+ * resolvedInitialPosition: 0
+ * resolvedFinalPosition: 1
+
+ And now we're storing:
+ * columns:
+ * resolvedInitialPosition: 1
+ * resolvedFinalPosition: 4
+ * rows:
+ * resolvedInitialPosition: 0
+ * resolvedFinalPosition: 2
+
+ 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::ensureGridSize):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ * rendering/RenderGrid.h:
+ * rendering/style/GridCoordinate.h:
+ (WebCore::GridSpan::GridSpan):
+ (WebCore::GridSpan::integerSpan):
+ (WebCore::GridSpan::end):
+ (WebCore::GridCoordinate::GridCoordinate):
+ * rendering/style/GridResolvedPosition.cpp:
+ (WebCore::resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveRowEndColumnEndNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
+ (WebCore::resolveGridPositionAgainstOppositePosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromAutoPlacementPosition):
+ (WebCore::GridResolvedPosition::resolveGridPositionsFromStyle):
+ (WebCore::resolveNamedGridLinePositionFromStyle): Deleted.
+ * rendering/style/GridResolvedPosition.h:
+
</ins><span class="cx"> 2016-01-28 Brady Eidson <beidson@apple.com>
</span><span class="cx">
</span><span class="cx"> Modern IDB: SQLite backend mismanages key generator values.
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGridTemplateAreasValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/css/CSSGridTemplateAreasValue.cpp 2016-01-29 09:22:28 UTC (rev 195808)
</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 (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -6195,20 +6195,20 @@
</span><span class="cx">
</span><span class="cx"> // We handle several grid areas with the same name at once to simplify the validation code.
</span><span class="cx"> unsigned lookAheadColumn;
</span><del>- for (lookAheadColumn = currentColumn; lookAheadColumn < columnCount - 1; ++lookAheadColumn) {
- if (columnNames[lookAheadColumn + 1] != gridAreaName)
</del><ins>+ for (lookAheadColumn = currentColumn + 1; lookAheadColumn < columnCount; ++lookAheadColumn) {
+ if (columnNames[lookAheadColumn] != gridAreaName)
</ins><span class="cx"> break;
</span><span class="cx"> }
</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), GridSpan(currentColumn, lookAheadColumn)));
</del><ins>+ gridAreaMap.add(gridAreaName, GridCoordinate(GridSpan(rowCount, rowCount + 1), GridSpan(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.next().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><span class="lines">@@ -6221,7 +6221,7 @@
</span><span class="cx">
</span><span class="cx"> ++gridCoordinate.rows.resolvedFinalPosition;
</span><span class="cx"> }
</span><del>- currentColumn = lookAheadColumn;
</del><ins>+ currentColumn = lookAheadColumn - 1;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_valueList->next();
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleBuilderConverterh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleBuilderConverter.h (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/css/StyleBuilderConverter.h 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -880,7 +880,7 @@
</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.next().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 (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-01-29 09:22:28 UTC (rev 195808)
</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 - 1), GridSpan(m_columnIndex, m_columnIndex + columnSpan - 1));
</del><ins>+ std::unique_ptr<GridCoordinate> result = std::make_unique<GridCoordinate>(GridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan(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() - 1), direction, initialFreeSpace.value());
</del><ins>+ flexFraction = findFlexFactorUnitSize(tracks, GridSpan(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">@@ -1121,18 +1121,18 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>-void RenderGrid::ensureGridSize(unsigned maximumRowIndex, unsigned maximumColumnIndex)
</del><ins>+void RenderGrid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize)
</ins><span class="cx"> {
</span><span class="cx"> const unsigned oldRowCount = gridRowCount();
</span><del>- if (maximumRowIndex >= oldRowCount) {
- m_grid.grow(maximumRowIndex + 1);
</del><ins>+ if (maximumRowSize > oldRowCount) {
+ m_grid.grow(maximumRowSize);
</ins><span class="cx"> for (unsigned row = oldRowCount; row < gridRowCount(); ++row)
</span><span class="cx"> m_grid[row].grow(gridColumnCount());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (maximumColumnIndex >= gridColumnCount()) {
</del><ins>+ if (maximumColumnSize > gridColumnCount()) {
</ins><span class="cx"> for (unsigned row = 0; row < gridRowCount(); ++row)
</span><del>- m_grid[row].grow(maximumColumnIndex + 1);
</del><ins>+ m_grid[row].grow(maximumColumnSize);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1200,21 +1200,21 @@
</span><span class="cx"> auto unresolvedRowPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForRows);
</span><span class="cx"> if (!unresolvedRowPositions.requiresAutoPlacement()) {
</span><span class="cx"> GridSpan rowPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedRowPositions, style());
</span><del>- maximumRowIndex = std::max(maximumRowIndex, rowPositions.resolvedFinalPosition.next().toInt());
</del><ins>+ 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.next().toInt());
</del><ins>+ maximumRowIndex = std::max(maximumRowIndex, positions.resolvedFinalPosition.toInt());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> auto unresolvedColumnPositions = GridResolvedPosition::unresolvedSpanFromStyle(style(), *child, ForColumns);
</span><span class="cx"> if (!unresolvedColumnPositions.requiresAutoPlacement()) {
</span><span class="cx"> GridSpan columnPositions = GridResolvedPosition::resolveGridPositionsFromStyle(unresolvedColumnPositions, style());
</span><del>- maximumColumnIndex = std::max(maximumColumnIndex, columnPositions.resolvedFinalPosition.next().toInt());
</del><ins>+ 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.next().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">@@ -1310,7 +1310,7 @@
</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><span class="cx"> GridResolvedPosition minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPosition : emptyGridArea->rows.resolvedFinalPosition;
</span><span class="cx"> const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
</span><del>- if (minorAxisFinalPositionIndex.toInt() < endOfMinorAxis)
</del><ins>+ if (minorAxisFinalPositionIndex.toInt() <= endOfMinorAxis)
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> // Discard empty grid area as it does not fit in the minor axis direction.
</span><span class="lines">@@ -1477,12 +1477,12 @@
</span><span class="cx"> || (positions.resolvedInitialPosition.toInt() > lastTrackIndex);
</span><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.toInt() > lastTrackIndex);
</del><ins>+ || (positions.resolvedFinalPosition.prev().toInt() > lastTrackIndex);
</ins><span class="cx">
</span><span class="cx"> GridResolvedPosition firstPosition = GridResolvedPosition(0);
</span><span class="cx"> GridResolvedPosition initialPosition = startIsAuto ? firstPosition : positions.resolvedInitialPosition;
</span><span class="cx"> GridResolvedPosition lastPosition = GridResolvedPosition(lastTrackIndex);
</span><del>- GridResolvedPosition finalPosition = endIsAuto ? lastPosition : positions.resolvedFinalPosition;
</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">@@ -1543,10 +1543,10 @@
</span><span class="cx"> const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
</span><span class="cx">
</span><span class="cx"> LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition.toInt()];
</span><del>- LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.toInt()];
</del><ins>+ 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.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">@@ -1836,7 +1836,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.next().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">@@ -1870,7 +1870,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.next().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="trunkSourceWebCorerenderingRenderGridh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderGrid.h (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.h 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/rendering/RenderGrid.h 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -76,7 +76,7 @@
</span><span class="cx"> LayoutUnit computeUsedBreadthOfMaxLength(const GridLength&, LayoutUnit usedBreadth, LayoutUnit maxSize) const;
</span><span class="cx"> void resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection, GridSizingData&);
</span><span class="cx">
</span><del>- void ensureGridSize(unsigned maximumRowIndex, unsigned maximumColumnIndex);
</del><ins>+ void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize);
</ins><span class="cx"> void insertItemIntoGrid(RenderBox&, const GridCoordinate&);
</span><span class="cx"> void placeItemsOnGrid();
</span><span class="cx"> void populateExplicitGridAndOrderIterator();
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingstyleGridCoordinateh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/style/GridCoordinate.h (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/rendering/style/GridCoordinate.h 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -44,15 +44,15 @@
</span><span class="cx"> const unsigned kGridMaxTracks = 1000000;
</span><span class="cx">
</span><span class="cx"> // A span in a single direction (either rows or columns). Note that |resolvedInitialPosition|
</span><del>-// and |resolvedFinalPosition| are grid areas' indexes, NOT grid lines'. Iterating over the
-// span should include both |resolvedInitialPosition| and |resolvedFinalPosition| to be correct.
</del><ins>+// and |resolvedFinalPosition| are grid lines' indexes.
+// Iterating over the span shouldn't include |resolvedFinalPosition| to be correct.
</ins><span class="cx"> class GridSpan {
</span><span class="cx"> public:
</span><span class="cx"> GridSpan(const GridResolvedPosition& resolvedInitialPosition, const GridResolvedPosition& resolvedFinalPosition)
</span><span class="cx"> : resolvedInitialPosition(std::min(resolvedInitialPosition.toInt(), kGridMaxTracks - 1))
</span><span class="cx"> , resolvedFinalPosition(std::min(resolvedFinalPosition.toInt(), kGridMaxTracks))
</span><span class="cx"> {
</span><del>- ASSERT(resolvedInitialPosition <= resolvedFinalPosition);
</del><ins>+ ASSERT(resolvedInitialPosition < resolvedFinalPosition);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool operator==(const GridSpan& o) const
</span><span class="lines">@@ -62,7 +62,7 @@
</span><span class="cx">
</span><span class="cx"> unsigned integerSpan() const
</span><span class="cx"> {
</span><del>- return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt() + 1;
</del><ins>+ return resolvedFinalPosition.toInt() - resolvedInitialPosition.toInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> GridResolvedPosition resolvedInitialPosition;
</span><span class="lines">@@ -77,7 +77,7 @@
</span><span class="cx">
</span><span class="cx"> iterator end() const
</span><span class="cx"> {
</span><del>- return resolvedFinalPosition.next();
</del><ins>+ return resolvedFinalPosition;
</ins><span class="cx"> }
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -86,8 +86,8 @@
</span><span class="cx"> public:
</span><span class="cx"> // HashMap requires a default constuctor.
</span><span class="cx"> GridCoordinate()
</span><del>- : columns(0, 0)
- , rows(0, 0)
</del><ins>+ : columns(0, 1)
+ , rows(0, 1)
</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 (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.cpp 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -109,11 +109,6 @@
</span><span class="cx"> return isColumnSide(side) ? GridResolvedPosition::explicitGridColumnCount(gridContainerStyle) : GridResolvedPosition::explicitGridRowCount(gridContainerStyle);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static GridResolvedPosition adjustGridPositionForRowEndColumnEndSide(unsigned resolvedPosition)
-{
- return resolvedPosition ? GridResolvedPosition(resolvedPosition - 1) : GridResolvedPosition(0);
-}
-
</del><span class="cx"> static GridResolvedPosition resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(!position.namedGridLine().isNull());
</span><span class="lines">@@ -135,26 +130,21 @@
</span><span class="cx"> return it->value[namedGridLineIndex];
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline unsigned firstNamedGridLineBeforePosition(unsigned position, const Vector<unsigned>& gridLines)
</del><ins>+static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
</ins><span class="cx"> {
</span><del>- // The grid line inequality needs to be strict (which doesn't match the after / end case) because |position| is
- // already converted to an index in our grid representation (ie one was removed from the grid line to account for
- // the side).
</del><ins>+ if (!resolvedOppositePosition.toInt())
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+
</ins><span class="cx"> unsigned firstLineBeforePositionIndex = 0;
</span><del>- auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), position);
- if (firstLineBeforePosition != gridLines.end()) {
- if (*firstLineBeforePosition > position && firstLineBeforePosition != gridLines.begin())
- --firstLineBeforePosition;
-
</del><ins>+ auto firstLineBeforePosition = std::lower_bound(gridLines.begin(), gridLines.end(), resolvedOppositePosition.toInt());
+ if (firstLineBeforePosition != gridLines.end())
</ins><span class="cx"> firstLineBeforePositionIndex = firstLineBeforePosition - gridLines.begin();
</span><del>- }
- return firstLineBeforePositionIndex;
-}
</del><span class="cx">
</span><del>-static GridSpan resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, const Vector<unsigned>& gridLines)
-{
- unsigned gridLineIndex = std::max<int>(0, firstNamedGridLineBeforePosition(resolvedOppositePosition.toInt(), gridLines) - position.spanPosition() + 1);
</del><ins>+ unsigned gridLineIndex = std::max<int>(0, firstLineBeforePositionIndex - position.spanPosition());
+
</ins><span class="cx"> GridResolvedPosition resolvedGridLinePosition = GridResolvedPosition(gridLines[gridLineIndex]);
</span><ins>+ if (resolvedGridLinePosition >= resolvedOppositePosition)
+ resolvedGridLinePosition = resolvedOppositePosition.prev();
</ins><span class="cx"> return GridSpan(std::min<GridResolvedPosition>(resolvedGridLinePosition, resolvedOppositePosition), resolvedOppositePosition);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -167,9 +157,9 @@
</span><span class="cx"> firstLineAfterOppositePositionIndex = firstLineAfterOppositePosition - gridLines.begin();
</span><span class="cx">
</span><span class="cx"> unsigned gridLineIndex = std::min<unsigned>(gridLines.size() - 1, firstLineAfterOppositePositionIndex + position.spanPosition() - 1);
</span><del>- GridResolvedPosition resolvedGridLinePosition = adjustGridPositionForRowEndColumnEndSide(gridLines[gridLineIndex]);
- if (resolvedGridLinePosition < resolvedOppositePosition)
- resolvedGridLinePosition = resolvedOppositePosition;
</del><ins>+ GridResolvedPosition resolvedGridLinePosition = gridLines[gridLineIndex];
+ if (resolvedGridLinePosition <= resolvedOppositePosition)
+ resolvedGridLinePosition = resolvedOppositePosition.next();
</ins><span class="cx"> return GridSpan(resolvedOppositePosition, resolvedGridLinePosition);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -185,8 +175,11 @@
</span><span class="cx">
</span><span class="cx"> // If there is no named grid line of that name, we resolve the position to 'auto' (which is equivalent to 'span 1' in this case).
</span><span class="cx"> // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html.
</span><del>- if (it == gridLinesNames.end())
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition);
</del><ins>+ if (it == gridLinesNames.end()) {
+ if (isStartSide(side) && resolvedOppositePosition.toInt())
+ return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ }
</ins><span class="cx">
</span><span class="cx"> if (side == RowStartSide || side == ColumnStartSide)
</span><span class="cx"> return resolveRowStartColumnStartNamedGridLinePositionAgainstOppositePosition(resolvedOppositePosition, position, it->value);
</span><span class="lines">@@ -196,8 +189,11 @@
</span><span class="cx">
</span><span class="cx"> static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, const GridResolvedPosition& resolvedOppositePosition, const GridPosition& position, GridPositionSide side)
</span><span class="cx"> {
</span><del>- if (position.isAuto())
- return GridSpan(resolvedOppositePosition, resolvedOppositePosition);
</del><ins>+ if (position.isAuto()) {
+ if (isStartSide(side) && resolvedOppositePosition.toInt())
+ return GridSpan(resolvedOppositePosition.prev(), resolvedOppositePosition);
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+ }
</ins><span class="cx">
</span><span class="cx"> ASSERT(position.isSpan());
</span><span class="cx"> ASSERT(position.spanPosition() > 0);
</span><span class="lines">@@ -209,8 +205,11 @@
</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><del>- unsigned positionOffset = position.spanPosition() - 1;
</del><ins>+ unsigned positionOffset = position.spanPosition();
</ins><span class="cx"> if (isStartSide(side)) {
</span><ins>+ if (!resolvedOppositePosition.toInt())
+ return GridSpan(resolvedOppositePosition, resolvedOppositePosition.next());
+
</ins><span class="cx"> unsigned initialResolvedPosition = std::max<int>(0, resolvedOppositePosition.toInt() - positionOffset);
</span><span class="cx"> return GridSpan(initialResolvedPosition, resolvedOppositePosition);
</span><span class="cx"> }
</span><span class="lines">@@ -225,7 +224,7 @@
</span><span class="cx"> // This method will only be used when both positions need to be resolved against the opposite one.
</span><span class="cx"> ASSERT(unresolvedSpan.requiresAutoPlacement());
</span><span class="cx">
</span><del>- GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition;
</del><ins>+ GridResolvedPosition resolvedFinalPosition = resolvedInitialPosition.next();
</ins><span class="cx">
</span><span class="cx"> if (unresolvedSpan.initialPosition().isSpan())
</span><span class="cx"> return resolveGridPositionAgainstOppositePosition(gridContainerStyle, resolvedInitialPosition, unresolvedSpan.initialPosition(), unresolvedSpan.finalPositionSide());
</span><span class="lines">@@ -315,7 +314,7 @@
</span><span class="cx"> if (unresolvedSpan.initialPosition().shouldBeResolvedAgainstOppositePosition()) {
</span><span class="cx"> // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
</span><span class="cx"> auto finalResolvedPosition = resolveGridPositionFromStyle(gridContainerStyle, unresolvedSpan.finalPosition(), unresolvedSpan.finalPositionSide());
</span><del>- return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition.prev(), unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
</del><ins>+ return resolveGridPositionAgainstOppositePosition(gridContainerStyle, finalResolvedPosition, unresolvedSpan.initialPosition(), unresolvedSpan.initialPositionSide());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (unresolvedSpan.finalPosition().shouldBeResolvedAgainstOppositePosition()) {
</span><span class="lines">@@ -329,8 +328,10 @@
</span><span class="cx">
</span><span class="cx"> if (resolvedInitialPosition > resolvedFinalPosition)
</span><span class="cx"> std::swap(resolvedInitialPosition, resolvedFinalPosition);
</span><ins>+ else if (resolvedInitialPosition == resolvedFinalPosition)
+ resolvedFinalPosition = resolvedInitialPosition.next();
</ins><span class="cx">
</span><del>- return GridSpan(resolvedInitialPosition, std::max(resolvedInitialPosition, resolvedFinalPosition.prev()));
</del><ins>+ return GridSpan(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 (195807 => 195808)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-01-29 08:38:25 UTC (rev 195807)
+++ trunk/Source/WebCore/rendering/style/GridResolvedPosition.h 2016-01-29 09:22:28 UTC (rev 195808)
</span><span class="lines">@@ -71,7 +71,7 @@
</span><span class="cx"> GridPositionSide m_finalPositionSide;
</span><span class="cx"> };
</span><span class="cx">
</span><del>-// This class represents an index into one of the dimensions of the grid array.
</del><ins>+// This class represents a line index into one of the dimensions of the grid array.
</ins><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="cx"> public:
</span></span></pre>
</div>
</div>
</body>
</html>