<!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>[209180] 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/209180">209180</a></dd>
<dt>Author</dt> <dd>svillar@igalia.com</dd>
<dt>Date</dt> <dd>2016-12-01 03:05:22 -0800 (Thu, 01 Dec 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>[css-grid] Move more attributes from RenderGrid to the new Grid class
https://bugs.webkit.org/show_bug.cgi?id=165094
Reviewed by Darin Adler.
Moved more attributes from RenderGrid to Grid as they are not really part of the state of
the RenderGrid object. In particular m_autoRepeat{Columns|Rows},
m_autoRepeatEmpty{Columns|Rows} and m_orderIterator. All of them are now private attributes
of the Grid class so clients should use the getters/setters provided by this patch.
This change allows to definitely remove the grid{Column|Row}Count() methods from
RenderGrid. These two became Grid::numTracks() which returns the number of tracks in the
data structure used to represent the grid (currently a matrix). Contrary to that,
RenderGrid::numTracks() returns the actual size of the grid.
No new tests as this is a refactoring.
* rendering/RenderGrid.cpp:
(WebCore::RenderGrid::Grid::numTracks):
(WebCore::RenderGrid::Grid::ensureGridSize):
(WebCore::RenderGrid::Grid::setAutoRepeatTracks):
(WebCore::RenderGrid::Grid::autoRepeatTracks):
(WebCore::RenderGrid::Grid::setAutoRepeatEmptyColumns):
(WebCore::RenderGrid::Grid::setAutoRepeatEmptyRows):
(WebCore::RenderGrid::Grid::hasAutoRepeatEmptyTracks):
(WebCore::RenderGrid::Grid::isEmptyAutoRepeatTrack):
(WebCore::RenderGrid::Grid::autoRepeatEmptyTracks):
(WebCore::RenderGrid::Grid::gridItemSpan):
(WebCore::RenderGrid::Grid::clear):
(WebCore::RenderGrid::RenderGrid):
(WebCore::RenderGrid::computeTrackSizesForDirection):
(WebCore::RenderGrid::guttersSize):
(WebCore::RenderGrid::computeIntrinsicLogicalHeight):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::rawGridTrackSize):
(WebCore::RenderGrid::gridTrackSize):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
(WebCore::RenderGrid::computeEmptyTracksForAutoRepeat):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
(WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
(WebCore::RenderGrid::trackSizesForComputedStyle):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::assumedRowsSizeForOrthogonalChild):
(WebCore::RenderGrid::gridAreaBreadthForChild):
(WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
(WebCore::RenderGrid::populateGridPositionsForDirection):
(WebCore::RenderGrid::columnAxisOffsetForChild):
(WebCore::RenderGrid::rowAxisOffsetForChild):
(WebCore::RenderGrid::numTracks):
(WebCore::RenderGrid::paintChildren):
(WebCore::RenderGrid::gridColumnCount): Deleted.
(WebCore::RenderGrid::gridRowCount): Deleted.
(WebCore::RenderGrid::hasAutoRepeatEmptyTracks): Deleted.
(WebCore::RenderGrid::isEmptyAutoRepeatTrack): Deleted.
(WebCore::RenderGrid::cachedGridSpan): Deleted.
* rendering/RenderGrid.h:
(WebCore::RenderGrid::autoRepeatCountForDirection): Deleted.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</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>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (209179 => 209180)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-12-01 09:24:21 UTC (rev 209179)
+++ trunk/Source/WebCore/ChangeLog 2016-12-01 11:05:22 UTC (rev 209180)
</span><span class="lines">@@ -1,3 +1,66 @@
</span><ins>+2016-11-28 Sergio Villar Senin <svillar@igalia.com>
+
+ [css-grid] Move more attributes from RenderGrid to the new Grid class
+ https://bugs.webkit.org/show_bug.cgi?id=165094
+
+ Reviewed by Darin Adler.
+
+ Moved more attributes from RenderGrid to Grid as they are not really part of the state of
+ the RenderGrid object. In particular m_autoRepeat{Columns|Rows},
+ m_autoRepeatEmpty{Columns|Rows} and m_orderIterator. All of them are now private attributes
+ of the Grid class so clients should use the getters/setters provided by this patch.
+
+ This change allows to definitely remove the grid{Column|Row}Count() methods from
+ RenderGrid. These two became Grid::numTracks() which returns the number of tracks in the
+ data structure used to represent the grid (currently a matrix). Contrary to that,
+ RenderGrid::numTracks() returns the actual size of the grid.
+
+ No new tests as this is a refactoring.
+
+ * rendering/RenderGrid.cpp:
+ (WebCore::RenderGrid::Grid::numTracks):
+ (WebCore::RenderGrid::Grid::ensureGridSize):
+ (WebCore::RenderGrid::Grid::setAutoRepeatTracks):
+ (WebCore::RenderGrid::Grid::autoRepeatTracks):
+ (WebCore::RenderGrid::Grid::setAutoRepeatEmptyColumns):
+ (WebCore::RenderGrid::Grid::setAutoRepeatEmptyRows):
+ (WebCore::RenderGrid::Grid::hasAutoRepeatEmptyTracks):
+ (WebCore::RenderGrid::Grid::isEmptyAutoRepeatTrack):
+ (WebCore::RenderGrid::Grid::autoRepeatEmptyTracks):
+ (WebCore::RenderGrid::Grid::gridItemSpan):
+ (WebCore::RenderGrid::Grid::clear):
+ (WebCore::RenderGrid::RenderGrid):
+ (WebCore::RenderGrid::computeTrackSizesForDirection):
+ (WebCore::RenderGrid::guttersSize):
+ (WebCore::RenderGrid::computeIntrinsicLogicalHeight):
+ (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
+ (WebCore::RenderGrid::rawGridTrackSize):
+ (WebCore::RenderGrid::gridTrackSize):
+ (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
+ (WebCore::RenderGrid::computeEmptyTracksForAutoRepeat):
+ (WebCore::RenderGrid::placeItemsOnGrid):
+ (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
+ (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
+ (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
+ (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
+ (WebCore::RenderGrid::trackSizesForComputedStyle):
+ (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
+ (WebCore::RenderGrid::assumedRowsSizeForOrthogonalChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChild):
+ (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
+ (WebCore::RenderGrid::populateGridPositionsForDirection):
+ (WebCore::RenderGrid::columnAxisOffsetForChild):
+ (WebCore::RenderGrid::rowAxisOffsetForChild):
+ (WebCore::RenderGrid::numTracks):
+ (WebCore::RenderGrid::paintChildren):
+ (WebCore::RenderGrid::gridColumnCount): Deleted.
+ (WebCore::RenderGrid::gridRowCount): Deleted.
+ (WebCore::RenderGrid::hasAutoRepeatEmptyTracks): Deleted.
+ (WebCore::RenderGrid::isEmptyAutoRepeatTrack): Deleted.
+ (WebCore::RenderGrid::cachedGridSpan): Deleted.
+ * rendering/RenderGrid.h:
+ (WebCore::RenderGrid::autoRepeatCountForDirection): Deleted.
+
</ins><span class="cx"> 2016-11-30 Brady Eidson <beidson@apple.com>
</span><span class="cx">
</span><span class="cx"> Unreviewed, rolling out r209168.
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderGridcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (209179 => 209180)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-12-01 09:24:21 UTC (rev 209179)
+++ trunk/Source/WebCore/rendering/RenderGrid.cpp 2016-12-01 11:05:22 UTC (rev 209180)
</span><span class="lines">@@ -46,10 +46,17 @@
</span><span class="cx"> ForbidInfinity,
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+unsigned RenderGrid::Grid::numTracks(GridTrackSizingDirection direction) const
+{
+ if (direction == ForRows)
+ return m_grid.size();
+ return m_grid.size() ? m_grid[0].size() : 0;
+}
+
</ins><span class="cx"> void RenderGrid::Grid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize)
</span><span class="cx"> {
</span><del>- const size_t oldColumnSize = numColumns();
- const size_t oldRowSize = numRows();
</del><ins>+ const size_t oldColumnSize = numTracks(ForColumns);
+ const size_t oldRowSize = numTracks(ForRows);
</ins><span class="cx"> if (maximumRowSize > oldRowSize) {
</span><span class="cx"> m_grid.grow(maximumRowSize);
</span><span class="cx"> for (size_t row = oldRowSize; row < maximumRowSize; ++row)
</span><span class="lines">@@ -57,7 +64,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (maximumColumnSize > oldColumnSize) {
</span><del>- for (size_t row = 0; row < numRows(); ++row)
</del><ins>+ for (size_t row = 0; row < numTracks(ForRows); ++row)
</ins><span class="cx"> m_grid[row].grow(maximumColumnSize);
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -97,6 +104,50 @@
</span><span class="cx"> m_gridItemArea.set(&item, area);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void RenderGrid::Grid::setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns)
+{
+ m_autoRepeatRows = autoRepeatRows;
+ m_autoRepeatColumns = autoRepeatColumns;
+}
+
+unsigned RenderGrid::Grid::autoRepeatTracks(GridTrackSizingDirection direction) const
+{
+ return direction == ForRows ? m_autoRepeatRows : m_autoRepeatColumns;
+}
+
+void RenderGrid::Grid::setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyColumns)
+{
+ m_autoRepeatEmptyColumns = WTFMove(autoRepeatEmptyColumns);
+}
+
+void RenderGrid::Grid::setAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyRows)
+{
+ m_autoRepeatEmptyRows = WTFMove(autoRepeatEmptyRows);
+}
+
+bool RenderGrid::Grid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const
+{
+ return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows;
+}
+
+bool RenderGrid::Grid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const
+{
+ ASSERT(hasAutoRepeatEmptyTracks(direction));
+ return autoRepeatEmptyTracks(direction)->contains(line);
+}
+
+RenderGrid::OrderedTrackIndexSet* RenderGrid::Grid::autoRepeatEmptyTracks(GridTrackSizingDirection direction) const
+{
+ ASSERT(hasAutoRepeatEmptyTracks(direction));
+ return direction == ForColumns ? m_autoRepeatEmptyColumns.get() : m_autoRepeatEmptyRows.get();
+}
+
+GridSpan RenderGrid::Grid::gridItemSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const
+{
+ GridArea area = gridItemArea(gridItem);
+ return direction == ForColumns ? area.columns : area.rows;
+}
+
</ins><span class="cx"> void RenderGrid::Grid::clear()
</span><span class="cx"> {
</span><span class="cx"> m_grid.resize(0);
</span><span class="lines">@@ -104,6 +155,12 @@
</span><span class="cx"> m_hasAnyOrthogonalGridItem = false;
</span><span class="cx"> m_smallestRowStart = 0;
</span><span class="cx"> m_smallestColumnStart = 0;
</span><ins>+ // FIXME: clear these once m_grid survives layout. We cannot clear them now because they're
+ // needed after layout.
+ // m_autoRepeatEmptyColumns = nullptr;
+ // m_autoRepeatEmptyRows = nullptr;
+ // m_autoRepeatColumns = 0;
+ // m_autoRepeatRows = 0;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> class GridTrack {
</span><span class="lines">@@ -373,7 +430,7 @@
</span><span class="cx">
</span><span class="cx"> RenderGrid::RenderGrid(Element& element, RenderStyle&& style)
</span><span class="cx"> : RenderBlock(element, WTFMove(style), 0)
</span><del>- , m_orderIterator(*this)
</del><ins>+ , m_grid(*this)
</ins><span class="cx"> {
</span><span class="cx"> // All of our children must be block level.
</span><span class="cx"> setChildrenInline(false);
</span><span class="lines">@@ -444,18 +501,6 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-unsigned RenderGrid::gridColumnCount() const
-{
- ASSERT(!m_gridIsDirty);
- return m_grid.numColumns();
-}
-
-unsigned RenderGrid::gridRowCount() const
-{
- ASSERT(!m_gridIsDirty);
- return m_grid.numRows();
-}
-
</del><span class="cx"> LayoutUnit RenderGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizingData) const
</span><span class="cx"> {
</span><span class="cx"> LayoutUnit logicalHeight;
</span><span class="lines">@@ -471,7 +516,7 @@
</span><span class="cx"> void RenderGrid::computeTrackSizesForDirection(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit availableSpace)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(sizingData.isValidTransition(direction));
</span><del>- LayoutUnit totalGuttersSize = guttersSize(direction, 0, direction == ForRows ? gridRowCount() : gridColumnCount());
</del><ins>+ LayoutUnit totalGuttersSize = guttersSize(direction, 0, m_grid.numTracks(direction));
</ins><span class="cx"> sizingData.setAvailableSpace(availableSpace);
</span><span class="cx"> sizingData.setFreeSpace(direction, availableSpace - totalGuttersSize);
</span><span class="cx"> sizingData.sizingOperation = TrackSizing;
</span><span class="lines">@@ -609,17 +654,6 @@
</span><span class="cx"> clearNeedsLayout();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool RenderGrid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const
-{
- return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows;
-}
-
-bool RenderGrid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const
-{
- ASSERT(hasAutoRepeatEmptyTracks(direction));
- return direction == ForColumns ? m_autoRepeatEmptyColumns->contains(line) : m_autoRepeatEmptyRows->contains(line);
-}
-
</del><span class="cx"> LayoutUnit RenderGrid::gridGapForDirection(GridTrackSizingDirection direction) const
</span><span class="cx"> {
</span><span class="cx"> return valueForLength(direction == ForColumns ? style().gridColumnGap() : style().gridRowGap(), LayoutUnit());
</span><span class="lines">@@ -630,11 +664,10 @@
</span><span class="cx"> if (span <= 1)
</span><span class="cx"> return { };
</span><span class="cx">
</span><del>- bool isRowAxis = direction == ForColumns;
</del><span class="cx"> LayoutUnit gap = gridGapForDirection(direction);
</span><span class="cx">
</span><span class="cx"> // Fast path, no collapsing tracks.
</span><del>- if (!hasAutoRepeatEmptyTracks(direction))
</del><ins>+ if (!m_grid.hasAutoRepeatEmptyTracks(direction))
</ins><span class="cx"> return gap * (span - 1);
</span><span class="cx">
</span><span class="cx"> // If there are collapsing tracks we need to be sure that gutters are properly collapsed. Apart
</span><span class="lines">@@ -646,12 +679,12 @@
</span><span class="cx"> unsigned endLine = startLine + span;
</span><span class="cx">
</span><span class="cx"> for (unsigned line = startLine; line < endLine - 1; ++line) {
</span><del>- if (!isEmptyAutoRepeatTrack(direction, line))
</del><ins>+ if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
</ins><span class="cx"> gapAccumulator += gap;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // The above loop adds one extra gap for trailing collapsed tracks.
</span><del>- if (gapAccumulator && isEmptyAutoRepeatTrack(direction, endLine - 1)) {
</del><ins>+ if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
</ins><span class="cx"> ASSERT(gapAccumulator >= gap);
</span><span class="cx"> gapAccumulator -= gap;
</span><span class="cx"> }
</span><span class="lines">@@ -658,9 +691,9 @@
</span><span class="cx">
</span><span class="cx"> // If the startLine is the start line of a collapsed track we need to go backwards till we reach
</span><span class="cx"> // a non collapsed track. If we find a non collapsed track we need to add that gap.
</span><del>- if (startLine && isEmptyAutoRepeatTrack(direction, startLine)) {
</del><ins>+ if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
</ins><span class="cx"> unsigned nonEmptyTracksBeforeStartLine = startLine;
</span><del>- auto begin = isRowAxis ? m_autoRepeatEmptyColumns->begin() : m_autoRepeatEmptyRows->begin();
</del><ins>+ auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
</ins><span class="cx"> for (auto it = begin; *it != startLine; ++it) {
</span><span class="cx"> ASSERT(nonEmptyTracksBeforeStartLine);
</span><span class="cx"> --nonEmptyTracksBeforeStartLine;
</span><span class="lines">@@ -671,10 +704,10 @@
</span><span class="cx">
</span><span class="cx"> // If the endLine is the end line of a collapsed track we need to go forward till we reach a non
</span><span class="cx"> // collapsed track. If we find a non collapsed track we need to add that gap.
</span><del>- if (isEmptyAutoRepeatTrack(direction, endLine - 1)) {
- unsigned nonEmptyTracksAfterEndLine = (isRowAxis ? gridColumnCount() : gridRowCount()) - endLine;
- auto currentEmptyTrack = isRowAxis ? m_autoRepeatEmptyColumns->find(endLine - 1) : m_autoRepeatEmptyRows->find(endLine - 1);
- auto endEmptyTrack = isRowAxis ? m_autoRepeatEmptyColumns->end() : m_autoRepeatEmptyRows->end();
</del><ins>+ if (m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+ unsigned nonEmptyTracksAfterEndLine = m_grid.numTracks(direction) - endLine;
+ auto currentEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
+ auto endEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->end();
</ins><span class="cx"> // HashSet iterators do not implement operator- so we have to manually iterate to know the number of remaining empty tracks.
</span><span class="cx"> for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) {
</span><span class="cx"> ASSERT(nonEmptyTracksAfterEndLine >= 1);
</span><span class="lines">@@ -726,7 +759,7 @@
</span><span class="cx"> minHeight += scrollbarHeight;
</span><span class="cx"> maxHeight += scrollbarHeight;
</span><span class="cx">
</span><del>- LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, gridRowCount());
</del><ins>+ LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
</ins><span class="cx"> minHeight += totalGuttersSize;
</span><span class="cx"> maxHeight += totalGuttersSize;
</span><span class="cx">
</span><span class="lines">@@ -853,7 +886,7 @@
</span><span class="cx"> for (unsigned i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
</span><span class="cx"> GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
</span><span class="cx"> while (auto* gridItem = iterator.nextGridItem()) {
</span><del>- GridSpan span = cachedGridSpan(*gridItem, direction);
</del><ins>+ const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
</ins><span class="cx">
</span><span class="cx"> // Do not include already processed items.
</span><span class="cx"> if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
</span><span class="lines">@@ -883,7 +916,7 @@
</span><span class="cx"> bool checkMaxSize = maxSize && rowsSize > maxSize.value();
</span><span class="cx"> if (checkMinSize || checkMaxSize) {
</span><span class="cx"> LayoutUnit constrainedFreeSpace = checkMaxSize ? maxSize.value() : LayoutUnit(-1);
</span><del>- constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, gridRowCount());
</del><ins>+ constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
</ins><span class="cx"> flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, sizingData.sizingOperation, constrainedFreeSpace);
</span><span class="cx">
</span><span class="cx"> totalGrowth = LayoutUnit(0);
</span><span class="lines">@@ -1028,7 +1061,7 @@
</span><span class="cx"> auto& autoRepeatTrackStyles = isRowAxis ? style().gridAutoRepeatColumns() : style().gridAutoRepeatRows();
</span><span class="cx"> auto& autoTrackStyles = isRowAxis ? style().gridAutoColumns() : style().gridAutoRows();
</span><span class="cx"> unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
</span><del>- unsigned autoRepeatTracksCount = autoRepeatCountForDirection(direction);
</del><ins>+ unsigned autoRepeatTracksCount = m_grid.autoRepeatTracks(direction);
</ins><span class="cx">
</span><span class="cx"> // We should not use GridPositionsResolver::explicitGridXXXCount() for this because the
</span><span class="cx"> // explicit grid might be larger than the number of tracks in grid-template-rows|columns (if
</span><span class="lines">@@ -1062,7 +1095,7 @@
</span><span class="cx"> GridTrackSize RenderGrid::gridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex, SizingOperation sizingOperation) const
</span><span class="cx"> {
</span><span class="cx"> // Collapse empty auto repeat tracks if auto-fit.
</span><del>- if (hasAutoRepeatEmptyTracks(direction) && isEmptyAutoRepeatTrack(direction, translatedIndex))
</del><ins>+ if (m_grid.hasAutoRepeatEmptyTracks(direction) && m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
</ins><span class="cx"> return { Length(Fixed), LengthTrackSizing };
</span><span class="cx">
</span><span class="cx"> auto& trackSize = rawGridTrackSize(direction, translatedIndex);
</span><span class="lines">@@ -1255,7 +1288,7 @@
</span><span class="cx">
</span><span class="cx"> while (auto* gridItem = iterator.nextGridItem()) {
</span><span class="cx"> if (itemsSet.add(gridItem).isNewEntry) {
</span><del>- GridSpan span = cachedGridSpan(*gridItem, direction);
</del><ins>+ const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
</ins><span class="cx"> if (span.integerSpan() == 1)
</span><span class="cx"> resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData);
</span><span class="cx"> else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData.sizingOperation))
</span><span class="lines">@@ -1658,7 +1691,7 @@
</span><span class="cx"> std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
</span><span class="cx"> unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
</span><span class="cx"> unsigned firstAutoRepeatTrack = insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
</span><del>- unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + autoRepeatCountForDirection(direction);
</del><ins>+ unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + m_grid.autoRepeatTracks(direction);
</ins><span class="cx">
</span><span class="cx"> if (!m_grid.hasGridItems()) {
</span><span class="cx"> emptyTrackIndexes = std::make_unique<OrderedTrackIndexSet>();
</span><span class="lines">@@ -1682,8 +1715,9 @@
</span><span class="cx"> ASSERT(m_gridIsDirty);
</span><span class="cx"> ASSERT(!m_grid.hasGridItems());
</span><span class="cx">
</span><del>- m_autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
- m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
</del><ins>+ unsigned autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
+ unsigned autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
+ m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
</ins><span class="cx">
</span><span class="cx"> populateExplicitGridAndOrderIterator();
</span><span class="cx"> m_gridIsDirty = false;
</span><span class="lines">@@ -1691,7 +1725,7 @@
</span><span class="cx">
</span><span class="cx"> Vector<RenderBox*> autoMajorAxisAutoGridItems;
</span><span class="cx"> Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
</span><del>- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
</del><ins>+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
</ins><span class="cx"> if (child->isOutOfFlowPositioned())
</span><span class="cx"> continue;
</span><span class="cx">
</span><span class="lines">@@ -1719,8 +1753,8 @@
</span><span class="cx">
</span><span class="cx"> #if ENABLE(ASSERT)
</span><span class="cx"> if (m_grid.hasGridItems()) {
</span><del>- ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows));
- ASSERT(gridColumnCount() >= GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns));
</del><ins>+ ASSERT(m_grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(style(), m_grid.autoRepeatTracks(ForRows)));
+ ASSERT(m_grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(style(), m_grid.autoRepeatTracks(ForColumns)));
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -1728,11 +1762,11 @@
</span><span class="cx"> placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
</span><span class="cx">
</span><span class="cx"> // Compute collapsible tracks for auto-fit.
</span><del>- m_autoRepeatEmptyColumns = computeEmptyTracksForAutoRepeat(ForColumns);
- m_autoRepeatEmptyRows = computeEmptyTracksForAutoRepeat(ForRows);
</del><ins>+ m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
+ m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
</ins><span class="cx">
</span><span class="cx"> #if ENABLE(ASSERT)
</span><del>- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
</del><ins>+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
</ins><span class="cx"> if (child->isOutOfFlowPositioned())
</span><span class="cx"> continue;
</span><span class="cx">
</span><span class="lines">@@ -1744,11 +1778,13 @@
</span><span class="cx">
</span><span class="cx"> void RenderGrid::populateExplicitGridAndOrderIterator()
</span><span class="cx"> {
</span><del>- OrderIteratorPopulator populator(m_orderIterator);
</del><ins>+ OrderIteratorPopulator populator(m_grid.orderIterator());
</ins><span class="cx"> int smallestRowStart = 0;
</span><span class="cx"> int smallestColumnStart = 0;
</span><del>- unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows);
- unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
</del><ins>+ unsigned autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
+ unsigned autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
+ unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), autoRepeatRows);
+ unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), autoRepeatColumns);
</ins><span class="cx">
</span><span class="cx"> for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
</span><span class="cx"> if (child->isOutOfFlowPositioned())
</span><span class="lines">@@ -1756,7 +1792,7 @@
</span><span class="cx">
</span><span class="cx"> populator.collectChild(*child);
</span><span class="cx">
</span><del>- GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, m_autoRepeatRows);
</del><ins>+ GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, autoRepeatRows);
</ins><span class="cx"> if (!rowPositions.isIndefinite()) {
</span><span class="cx"> smallestRowStart = std::min(smallestRowStart, rowPositions.untranslatedStartLine());
</span><span class="cx"> maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
</span><span class="lines">@@ -1766,7 +1802,7 @@
</span><span class="cx"> maximumRowIndex = std::max(maximumRowIndex, spanSize);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, m_autoRepeatColumns);
</del><ins>+ GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, autoRepeatColumns);
</ins><span class="cx"> if (!columnPositions.isIndefinite()) {
</span><span class="cx"> smallestColumnStart = std::min(smallestColumnStart, columnPositions.untranslatedStartLine());
</span><span class="cx"> maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
</span><span class="lines">@@ -1786,7 +1822,7 @@
</span><span class="cx"> std::unique_ptr<GridArea> RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const RenderBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
</span><span class="cx"> {
</span><span class="cx"> GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
</span><del>- const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
</del><ins>+ const unsigned endOfCrossDirection = m_grid.numTracks(crossDirection);
</ins><span class="cx"> unsigned crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection);
</span><span class="cx"> GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
</span><span class="cx"> return std::make_unique<GridArea>(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions);
</span><span class="lines">@@ -1803,9 +1839,9 @@
</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>- GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
</del><ins>+ GridSpan majorAxisPositions = m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
</ins><span class="cx"> ASSERT(majorAxisPositions.isTranslatedDefinite());
</span><del>- ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
</del><ins>+ ASSERT(m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
</ins><span class="cx"> unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
</span><span class="cx"> unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
</span><span class="cx">
</span><span class="lines">@@ -1838,15 +1874,15 @@
</span><span class="cx">
</span><span class="cx"> void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
</span><span class="cx"> {
</span><del>- ASSERT(cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
</del><ins>+ ASSERT(m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
</ins><span class="cx"> unsigned majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection());
</span><span class="cx">
</span><del>- const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
</del><ins>+ const unsigned endOfMajorAxis = m_grid.numTracks(autoPlacementMajorAxisDirection());
</ins><span class="cx"> unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
</span><span class="cx"> unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
</span><span class="cx">
</span><span class="cx"> std::unique_ptr<GridArea> emptyGridArea;
</span><del>- GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
</del><ins>+ GridSpan minorAxisPositions = m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
</ins><span class="cx"> if (minorAxisPositions.isTranslatedDefinite()) {
</span><span class="cx"> // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
</span><span class="cx"> if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
</span><span class="lines">@@ -1869,7 +1905,7 @@
</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><span class="cx"> unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
</span><del>- const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
</del><ins>+ const unsigned endOfMinorAxis = m_grid.numTracks(autoPlacementMinorAxisDirection());
</ins><span class="cx"> if (minorAxisFinalPositionIndex <= endOfMinorAxis)
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="lines">@@ -1918,7 +1954,7 @@
</span><span class="cx"> if (numPositions < 2)
</span><span class="cx"> return tracks;
</span><span class="cx">
</span><del>- bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
</del><ins>+ bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
</ins><span class="cx"> LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
</span><span class="cx"> tracks.reserveCapacity(numPositions - 1);
</span><span class="cx"> for (size_t i = 0; i < numPositions - 2; ++i)
</span><span class="lines">@@ -1928,17 +1964,17 @@
</span><span class="cx"> if (!hasCollapsedTracks)
</span><span class="cx"> return tracks;
</span><span class="cx">
</span><del>- size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
</del><ins>+ size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
</ins><span class="cx"> size_t lastLine = tracks.size();
</span><span class="cx"> gap = gridGapForDirection(direction);
</span><span class="cx"> for (size_t i = 1; i < lastLine; ++i) {
</span><del>- if (isEmptyAutoRepeatTrack(direction, i - 1))
</del><ins>+ if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
</ins><span class="cx"> --remainingEmptyTracks;
</span><span class="cx"> else {
</span><span class="cx"> // Remove the gap between consecutive non empty tracks. Remove it also just once for an
</span><span class="cx"> // arbitrary number of empty tracks between two non empty ones.
</span><span class="cx"> bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
</span><del>- if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
</del><ins>+ if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
</ins><span class="cx"> tracks[i - 1] -= gap;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -2073,7 +2109,7 @@
</span><span class="cx"> ASSERT(!isOrthogonalChild(child));
</span><span class="cx"> bool isRowAxis = direction == ForColumns;
</span><span class="cx">
</span><del>- unsigned autoRepeatCount = autoRepeatCountForDirection(direction);
</del><ins>+ unsigned autoRepeatCount = m_grid.autoRepeatTracks(direction);
</ins><span class="cx"> GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), child, direction, autoRepeatCount);
</span><span class="cx"> if (positions.isIndefinite()) {
</span><span class="cx"> offset = LayoutUnit();
</span><span class="lines">@@ -2147,16 +2183,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-GridSpan RenderGrid::cachedGridSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const
-{
- GridArea area = m_grid.gridItemArea(gridItem);
- return direction == ForColumns ? area.columns : area.rows;
-}
-
</del><span class="cx"> LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, SizingOperation sizingOperation) const
</span><span class="cx"> {
</span><span class="cx"> ASSERT(isOrthogonalChild(child));
</span><del>- const GridSpan& span = cachedGridSpan(child, ForRows);
</del><ins>+ const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
</ins><span class="cx"> LayoutUnit gridAreaSize;
</span><span class="cx"> bool gridAreaIsIndefinite = false;
</span><span class="cx"> LayoutUnit containingBlockAvailableSize = containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
</span><span class="lines">@@ -2182,7 +2212,7 @@
</span><span class="cx"> return assumedRowsSizeForOrthogonalChild(child, sizingData.sizingOperation);
</span><span class="cx">
</span><span class="cx"> const Vector<GridTrack>& tracks = direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
</span><del>- const GridSpan& span = cachedGridSpan(child, direction);
</del><ins>+ const GridSpan& span = m_grid.gridItemSpan(child, direction);
</ins><span class="cx"> LayoutUnit gridAreaBreadth = 0;
</span><span class="cx"> for (auto trackPosition : span)
</span><span class="cx"> gridAreaBreadth += tracks[trackPosition].baseSize();
</span><span class="lines">@@ -2197,7 +2227,7 @@
</span><span class="cx"> // We need the cached value when available because Content Distribution alignment properties
</span><span class="cx"> // may have some influence in the final grid area breadth.
</span><span class="cx"> const auto& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
</span><del>- const auto& span = cachedGridSpan(child, direction);
</del><ins>+ const auto& span = m_grid.gridItemSpan(child, direction);
</ins><span class="cx"> const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
</span><span class="cx">
</span><span class="cx"> LayoutUnit initialTrackPosition = linePositions[span.startLine()];
</span><span class="lines">@@ -2230,7 +2260,7 @@
</span><span class="cx"> if (numberOfLines > 1) {
</span><span class="cx"> // If we have collapsed tracks we just ignore gaps here and add them later as we might not
</span><span class="cx"> // compute the gap between two consecutive tracks without examining the surrounding ones.
</span><del>- bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
</del><ins>+ bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
</ins><span class="cx"> LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
</span><span class="cx"> unsigned nextToLastLine = numberOfLines - 2;
</span><span class="cx"> for (unsigned i = 0; i < nextToLastLine; ++i)
</span><span class="lines">@@ -2241,16 +2271,16 @@
</span><span class="cx"> // coincide exactly) except on the edges of the grid where they become 0.
</span><span class="cx"> if (hasCollapsedTracks) {
</span><span class="cx"> gap = gridGapForDirection(direction);
</span><del>- unsigned remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
</del><ins>+ unsigned remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
</ins><span class="cx"> LayoutUnit gapAccumulator;
</span><span class="cx"> for (unsigned i = 1; i < lastLine; ++i) {
</span><del>- if (isEmptyAutoRepeatTrack(direction, i - 1))
</del><ins>+ if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
</ins><span class="cx"> --remainingEmptyTracks;
</span><span class="cx"> else {
</span><span class="cx"> // Add gap between consecutive non empty tracks. Add it also just once for an
</span><span class="cx"> // arbitrary number of empty tracks between two non empty ones.
</span><span class="cx"> bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
</span><del>- if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
</del><ins>+ if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
</ins><span class="cx"> gapAccumulator += gap;
</span><span class="cx"> }
</span><span class="cx"> positions[i] += gapAccumulator;
</span><span class="lines">@@ -2546,7 +2576,7 @@
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
</span><span class="cx"> {
</span><del>- const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
</del><ins>+ const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
</ins><span class="cx"> unsigned childStartLine = rowsSpan.startLine();
</span><span class="cx"> LayoutUnit startOfRow = m_rowPositions[childStartLine];
</span><span class="cx"> LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
</span><span class="lines">@@ -2579,7 +2609,7 @@
</span><span class="cx">
</span><span class="cx"> LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
</span><span class="cx"> {
</span><del>- const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
</del><ins>+ const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
</ins><span class="cx"> unsigned childStartLine = columnsSpan.startLine();
</span><span class="cx"> LayoutUnit startOfColumn = m_columnPositions[childStartLine];
</span><span class="cx"> LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
</span><span class="lines">@@ -2744,14 +2774,15 @@
</span><span class="cx"> // because not having rows implies that there are no "normal" children (out-of-flow children are
</span><span class="cx"> // not stored in m_grid).
</span><span class="cx"> if (direction == ForRows)
</span><del>- return m_grid.numRows();
</del><ins>+ return m_grid.numTracks(ForRows);
</ins><span class="cx">
</span><del>- return m_grid.numRows() ? m_grid.numColumns() : GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
</del><ins>+ // FIXME: This still requires knowledge about m_grid internals.
+ return m_grid.numTracks(ForRows) ? m_grid.numTracks(ForColumns) : GridPositionsResolver::explicitGridColumnCount(style(), m_grid.autoRepeatTracks(ForColumns));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect)
</span><span class="cx"> {
</span><del>- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next())
</del><ins>+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next())
</ins><span class="cx"> paintChild(*child, paintInfo, paintOffset, forChild, usePrintRect, PaintAsInlineBlock);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorerenderingRenderGridh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/rendering/RenderGrid.h (209179 => 209180)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/rendering/RenderGrid.h 2016-12-01 09:24:21 UTC (rev 209179)
+++ trunk/Source/WebCore/rendering/RenderGrid.h 2016-12-01 11:05:22 UTC (rev 209180)
</span><span class="lines">@@ -70,7 +70,7 @@
</span><span class="cx"> const Vector<LayoutUnit>& columnPositions() const { return m_columnPositions; }
</span><span class="cx"> const Vector<LayoutUnit>& rowPositions() const { return m_rowPositions; }
</span><span class="cx">
</span><del>- size_t autoRepeatCountForDirection(GridTrackSizingDirection) const;
</del><ins>+ unsigned autoRepeatCountForDirection(GridTrackSizingDirection direction) const { return m_grid.autoRepeatTracks(direction); }
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> const char* renderName() const override;
</span><span class="lines">@@ -93,9 +93,6 @@
</span><span class="cx"> typedef ListHashSet<size_t> OrderedTrackIndexSet;
</span><span class="cx"> std::unique_ptr<OrderedTrackIndexSet> computeEmptyTracksForAutoRepeat(GridTrackSizingDirection) const;
</span><span class="cx">
</span><del>- bool hasAutoRepeatEmptyTracks(GridTrackSizingDirection) const;
- bool isEmptyAutoRepeatTrack(GridTrackSizingDirection, unsigned track) const;
-
</del><span class="cx"> void placeItemsOnGrid(SizingOperation);
</span><span class="cx"> void populateExplicitGridAndOrderIterator();
</span><span class="cx"> std::unique_ptr<GridArea> createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const RenderBox&, GridTrackSizingDirection, const GridSpan&) const;
</span><span class="lines">@@ -187,9 +184,6 @@
</span><span class="cx">
</span><span class="cx"> bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, SizingOperation) const;
</span><span class="cx">
</span><del>- // FIXME: Look for better names once the refactoring is complete.
- unsigned gridColumnCount() const;
- unsigned gridRowCount() const;
</del><span class="cx"> unsigned numTracks(GridTrackSizingDirection) const;
</span><span class="cx">
</span><span class="cx"> LayoutUnit translateRTLCoordinate(LayoutUnit) const;
</span><span class="lines">@@ -201,10 +195,9 @@
</span><span class="cx"> typedef Vector<Vector<GridCell>> GridAsMatrix;
</span><span class="cx"> class Grid final {
</span><span class="cx"> public:
</span><del>- Grid() { }
</del><ins>+ Grid(RenderGrid& grid) : m_orderIterator(grid) { }
</ins><span class="cx">
</span><del>- unsigned numColumns() const { return m_grid.size() ? m_grid[0].size() : 0; }
- unsigned numRows() const { return m_grid.size(); }
</del><ins>+ unsigned numTracks(GridTrackSizingDirection) const;
</ins><span class="cx">
</span><span class="cx"> void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize);
</span><span class="cx"> void insert(RenderBox&, const GridArea&);
</span><span class="lines">@@ -220,10 +213,27 @@
</span><span class="cx"> GridArea gridItemArea(const RenderBox& item) const;
</span><span class="cx"> void setGridItemArea(const RenderBox& item, GridArea);
</span><span class="cx">
</span><ins>+ GridSpan gridItemSpan(const RenderBox&, GridTrackSizingDirection) const;
+
</ins><span class="cx"> const GridCell& cell(unsigned row, unsigned column) const { return m_grid[row][column]; }
</span><span class="cx">
</span><span class="cx"> int smallestTrackStart(GridTrackSizingDirection) const;
</span><span class="cx"> void setSmallestTracksStart(int rowStart, int columnStart);
</span><ins>+
+ unsigned autoRepeatTracks(GridTrackSizingDirection) const;
+ void setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns);
+
+ void setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet>);
+ void setAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet>);
+
+ unsigned autoRepeatEmptyTracksCount(GridTrackSizingDirection) const;
+ bool hasAutoRepeatEmptyTracks(GridTrackSizingDirection) const;
+ bool isEmptyAutoRepeatTrack(GridTrackSizingDirection, unsigned) const;
+
+ OrderedTrackIndexSet* autoRepeatEmptyTracks(GridTrackSizingDirection) const;
+
+ OrderIterator& orderIterator() { return m_orderIterator; }
+
</ins><span class="cx"> void shrinkToFit() { m_grid.shrinkToFit(); }
</span><span class="cx">
</span><span class="cx"> void clear();
</span><span class="lines">@@ -231,9 +241,14 @@
</span><span class="cx"> private:
</span><span class="cx"> friend class GridIterator;
</span><span class="cx">
</span><ins>+ OrderIterator m_orderIterator;
+
</ins><span class="cx"> int m_smallestColumnStart { 0 };
</span><span class="cx"> int m_smallestRowStart { 0 };
</span><span class="cx">
</span><ins>+ unsigned m_autoRepeatColumns { 0 };
+ unsigned m_autoRepeatRows { 0 };
+
</ins><span class="cx"> bool m_hasAnyOrthogonalGridItem { false };
</span><span class="cx">
</span><span class="cx"> GridAsMatrix m_grid;
</span><span class="lines">@@ -240,6 +255,9 @@
</span><span class="cx">
</span><span class="cx"> HashMap<const RenderBox*, GridArea> m_gridItemArea;
</span><span class="cx"> HashMap<const RenderBox*, size_t> m_gridItemsIndexesMap;
</span><ins>+
+ std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns;
+ std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows;
</ins><span class="cx"> };
</span><span class="cx"> Grid m_grid;
</span><span class="cx">
</span><span class="lines">@@ -247,25 +265,13 @@
</span><span class="cx"> Vector<LayoutUnit> m_rowPositions;
</span><span class="cx"> LayoutUnit m_offsetBetweenColumns;
</span><span class="cx"> LayoutUnit m_offsetBetweenRows;
</span><del>- OrderIterator m_orderIterator;
</del><span class="cx">
</span><span class="cx"> std::optional<LayoutUnit> m_minContentHeight;
</span><span class="cx"> std::optional<LayoutUnit> m_maxContentHeight;
</span><span class="cx">
</span><del>- unsigned m_autoRepeatColumns { 0 };
- unsigned m_autoRepeatRows { 0 };
-
</del><span class="cx"> bool m_gridIsDirty { true };
</span><del>-
- std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns { nullptr };
- std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows { nullptr };
</del><span class="cx"> };
</span><span class="cx">
</span><del>-size_t inline RenderGrid::autoRepeatCountForDirection(GridTrackSizingDirection direction) const
-{
- return direction == ForColumns ? m_autoRepeatColumns : m_autoRepeatRows;
-}
-
</del><span class="cx"> } // namespace WebCore
</span><span class="cx">
</span><span class="cx"> SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderGrid, isRenderGrid())
</span></span></pre>
</div>
</div>
</body>
</html>