Modified: trunk/Source/WebCore/rendering/RenderGrid.cpp (209179 => 209180)
--- 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)
@@ -46,10 +46,17 @@
ForbidInfinity,
};
+unsigned RenderGrid::Grid::numTracks(GridTrackSizingDirection direction) const
+{
+ if (direction == ForRows)
+ return m_grid.size();
+ return m_grid.size() ? m_grid[0].size() : 0;
+}
+
void RenderGrid::Grid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize)
{
- const size_t oldColumnSize = numColumns();
- const size_t oldRowSize = numRows();
+ const size_t oldColumnSize = numTracks(ForColumns);
+ const size_t oldRowSize = numTracks(ForRows);
if (maximumRowSize > oldRowSize) {
m_grid.grow(maximumRowSize);
for (size_t row = oldRowSize; row < maximumRowSize; ++row)
@@ -57,7 +64,7 @@
}
if (maximumColumnSize > oldColumnSize) {
- for (size_t row = 0; row < numRows(); ++row)
+ for (size_t row = 0; row < numTracks(ForRows); ++row)
m_grid[row].grow(maximumColumnSize);
}
}
@@ -97,6 +104,50 @@
m_gridItemArea.set(&item, area);
}
+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;
+}
+
void RenderGrid::Grid::clear()
{
m_grid.resize(0);
@@ -104,6 +155,12 @@
m_hasAnyOrthogonalGridItem = false;
m_smallestRowStart = 0;
m_smallestColumnStart = 0;
+ // 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;
}
class GridTrack {
@@ -373,7 +430,7 @@
RenderGrid::RenderGrid(Element& element, RenderStyle&& style)
: RenderBlock(element, WTFMove(style), 0)
- , m_orderIterator(*this)
+ , m_grid(*this)
{
// All of our children must be block level.
setChildrenInline(false);
@@ -444,18 +501,6 @@
}
}
-unsigned RenderGrid::gridColumnCount() const
-{
- ASSERT(!m_gridIsDirty);
- return m_grid.numColumns();
-}
-
-unsigned RenderGrid::gridRowCount() const
-{
- ASSERT(!m_gridIsDirty);
- return m_grid.numRows();
-}
-
LayoutUnit RenderGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizingData) const
{
LayoutUnit logicalHeight;
@@ -471,7 +516,7 @@
void RenderGrid::computeTrackSizesForDirection(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit availableSpace)
{
ASSERT(sizingData.isValidTransition(direction));
- LayoutUnit totalGuttersSize = guttersSize(direction, 0, direction == ForRows ? gridRowCount() : gridColumnCount());
+ LayoutUnit totalGuttersSize = guttersSize(direction, 0, m_grid.numTracks(direction));
sizingData.setAvailableSpace(availableSpace);
sizingData.setFreeSpace(direction, availableSpace - totalGuttersSize);
sizingData.sizingOperation = TrackSizing;
@@ -609,17 +654,6 @@
clearNeedsLayout();
}
-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);
-}
-
LayoutUnit RenderGrid::gridGapForDirection(GridTrackSizingDirection direction) const
{
return valueForLength(direction == ForColumns ? style().gridColumnGap() : style().gridRowGap(), LayoutUnit());
@@ -630,11 +664,10 @@
if (span <= 1)
return { };
- bool isRowAxis = direction == ForColumns;
LayoutUnit gap = gridGapForDirection(direction);
// Fast path, no collapsing tracks.
- if (!hasAutoRepeatEmptyTracks(direction))
+ if (!m_grid.hasAutoRepeatEmptyTracks(direction))
return gap * (span - 1);
// If there are collapsing tracks we need to be sure that gutters are properly collapsed. Apart
@@ -646,12 +679,12 @@
unsigned endLine = startLine + span;
for (unsigned line = startLine; line < endLine - 1; ++line) {
- if (!isEmptyAutoRepeatTrack(direction, line))
+ if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
gapAccumulator += gap;
}
// The above loop adds one extra gap for trailing collapsed tracks.
- if (gapAccumulator && isEmptyAutoRepeatTrack(direction, endLine - 1)) {
+ if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
ASSERT(gapAccumulator >= gap);
gapAccumulator -= gap;
}
@@ -658,9 +691,9 @@
// If the startLine is the start line of a collapsed track we need to go backwards till we reach
// a non collapsed track. If we find a non collapsed track we need to add that gap.
- if (startLine && isEmptyAutoRepeatTrack(direction, startLine)) {
+ if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
unsigned nonEmptyTracksBeforeStartLine = startLine;
- auto begin = isRowAxis ? m_autoRepeatEmptyColumns->begin() : m_autoRepeatEmptyRows->begin();
+ auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
for (auto it = begin; *it != startLine; ++it) {
ASSERT(nonEmptyTracksBeforeStartLine);
--nonEmptyTracksBeforeStartLine;
@@ -671,10 +704,10 @@
// If the endLine is the end line of a collapsed track we need to go forward till we reach a non
// collapsed track. If we find a non collapsed track we need to add that gap.
- 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();
+ 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();
// HashSet iterators do not implement operator- so we have to manually iterate to know the number of remaining empty tracks.
for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) {
ASSERT(nonEmptyTracksAfterEndLine >= 1);
@@ -726,7 +759,7 @@
minHeight += scrollbarHeight;
maxHeight += scrollbarHeight;
- LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, gridRowCount());
+ LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
minHeight += totalGuttersSize;
maxHeight += totalGuttersSize;
@@ -853,7 +886,7 @@
for (unsigned i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
while (auto* gridItem = iterator.nextGridItem()) {
- GridSpan span = cachedGridSpan(*gridItem, direction);
+ const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
// Do not include already processed items.
if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
@@ -883,7 +916,7 @@
bool checkMaxSize = maxSize && rowsSize > maxSize.value();
if (checkMinSize || checkMaxSize) {
LayoutUnit constrainedFreeSpace = checkMaxSize ? maxSize.value() : LayoutUnit(-1);
- constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, gridRowCount());
+ constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, sizingData.sizingOperation, constrainedFreeSpace);
totalGrowth = LayoutUnit(0);
@@ -1028,7 +1061,7 @@
auto& autoRepeatTrackStyles = isRowAxis ? style().gridAutoRepeatColumns() : style().gridAutoRepeatRows();
auto& autoTrackStyles = isRowAxis ? style().gridAutoColumns() : style().gridAutoRows();
unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
- unsigned autoRepeatTracksCount = autoRepeatCountForDirection(direction);
+ unsigned autoRepeatTracksCount = m_grid.autoRepeatTracks(direction);
// We should not use GridPositionsResolver::explicitGridXXXCount() for this because the
// explicit grid might be larger than the number of tracks in grid-template-rows|columns (if
@@ -1062,7 +1095,7 @@
GridTrackSize RenderGrid::gridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex, SizingOperation sizingOperation) const
{
// Collapse empty auto repeat tracks if auto-fit.
- if (hasAutoRepeatEmptyTracks(direction) && isEmptyAutoRepeatTrack(direction, translatedIndex))
+ if (m_grid.hasAutoRepeatEmptyTracks(direction) && m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
return { Length(Fixed), LengthTrackSizing };
auto& trackSize = rawGridTrackSize(direction, translatedIndex);
@@ -1255,7 +1288,7 @@
while (auto* gridItem = iterator.nextGridItem()) {
if (itemsSet.add(gridItem).isNewEntry) {
- GridSpan span = cachedGridSpan(*gridItem, direction);
+ const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
if (span.integerSpan() == 1)
resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData);
else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData.sizingOperation))
@@ -1658,7 +1691,7 @@
std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
unsigned firstAutoRepeatTrack = insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
- unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + autoRepeatCountForDirection(direction);
+ unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + m_grid.autoRepeatTracks(direction);
if (!m_grid.hasGridItems()) {
emptyTrackIndexes = std::make_unique<OrderedTrackIndexSet>();
@@ -1682,8 +1715,9 @@
ASSERT(m_gridIsDirty);
ASSERT(!m_grid.hasGridItems());
- m_autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
- m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
+ unsigned autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
+ unsigned autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
+ m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
populateExplicitGridAndOrderIterator();
m_gridIsDirty = false;
@@ -1691,7 +1725,7 @@
Vector<RenderBox*> autoMajorAxisAutoGridItems;
Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
if (child->isOutOfFlowPositioned())
continue;
@@ -1719,8 +1753,8 @@
#if ENABLE(ASSERT)
if (m_grid.hasGridItems()) {
- ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows));
- ASSERT(gridColumnCount() >= GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns));
+ ASSERT(m_grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(style(), m_grid.autoRepeatTracks(ForRows)));
+ ASSERT(m_grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(style(), m_grid.autoRepeatTracks(ForColumns)));
}
#endif
@@ -1728,11 +1762,11 @@
placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
// Compute collapsible tracks for auto-fit.
- m_autoRepeatEmptyColumns = computeEmptyTracksForAutoRepeat(ForColumns);
- m_autoRepeatEmptyRows = computeEmptyTracksForAutoRepeat(ForRows);
+ m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
+ m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
#if ENABLE(ASSERT)
- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
if (child->isOutOfFlowPositioned())
continue;
@@ -1744,11 +1778,13 @@
void RenderGrid::populateExplicitGridAndOrderIterator()
{
- OrderIteratorPopulator populator(m_orderIterator);
+ OrderIteratorPopulator populator(m_grid.orderIterator());
int smallestRowStart = 0;
int smallestColumnStart = 0;
- unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows);
- unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
+ unsigned autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
+ unsigned autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
+ unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), autoRepeatRows);
+ unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), autoRepeatColumns);
for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
if (child->isOutOfFlowPositioned())
@@ -1756,7 +1792,7 @@
populator.collectChild(*child);
- GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, m_autoRepeatRows);
+ GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, autoRepeatRows);
if (!rowPositions.isIndefinite()) {
smallestRowStart = std::min(smallestRowStart, rowPositions.untranslatedStartLine());
maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
@@ -1766,7 +1802,7 @@
maximumRowIndex = std::max(maximumRowIndex, spanSize);
}
- GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, m_autoRepeatColumns);
+ GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, autoRepeatColumns);
if (!columnPositions.isIndefinite()) {
smallestColumnStart = std::min(smallestColumnStart, columnPositions.untranslatedStartLine());
maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
@@ -1786,7 +1822,7 @@
std::unique_ptr<GridArea> RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const RenderBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
{
GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
- const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
+ const unsigned endOfCrossDirection = m_grid.numTracks(crossDirection);
unsigned crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection);
GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
return std::make_unique<GridArea>(specifiedDirection == ForColumns ? crossDirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPositions : crossDirectionPositions);
@@ -1803,9 +1839,9 @@
HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> minorAxisCursors;
for (auto& autoGridItem : autoGridItems) {
- GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
+ GridSpan majorAxisPositions = m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
ASSERT(majorAxisPositions.isTranslatedDefinite());
- ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
+ ASSERT(m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
@@ -1838,15 +1874,15 @@
void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
{
- ASSERT(cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
+ ASSERT(m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
unsigned majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection());
- const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
+ const unsigned endOfMajorAxis = m_grid.numTracks(autoPlacementMajorAxisDirection());
unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
std::unique_ptr<GridArea> emptyGridArea;
- GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
+ GridSpan minorAxisPositions = m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
if (minorAxisPositions.isTranslatedDefinite()) {
// Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
if (minorAxisPositions.startLine() < minorAxisAutoPlacementCursor)
@@ -1869,7 +1905,7 @@
if (emptyGridArea) {
// Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
- const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
+ const unsigned endOfMinorAxis = m_grid.numTracks(autoPlacementMinorAxisDirection());
if (minorAxisFinalPositionIndex <= endOfMinorAxis)
break;
@@ -1918,7 +1954,7 @@
if (numPositions < 2)
return tracks;
- bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
+ bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
tracks.reserveCapacity(numPositions - 1);
for (size_t i = 0; i < numPositions - 2; ++i)
@@ -1928,17 +1964,17 @@
if (!hasCollapsedTracks)
return tracks;
- size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
+ size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
size_t lastLine = tracks.size();
gap = gridGapForDirection(direction);
for (size_t i = 1; i < lastLine; ++i) {
- if (isEmptyAutoRepeatTrack(direction, i - 1))
+ if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
--remainingEmptyTracks;
else {
// Remove the gap between consecutive non empty tracks. Remove it also just once for an
// arbitrary number of empty tracks between two non empty ones.
bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
- if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
+ if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
tracks[i - 1] -= gap;
}
}
@@ -2073,7 +2109,7 @@
ASSERT(!isOrthogonalChild(child));
bool isRowAxis = direction == ForColumns;
- unsigned autoRepeatCount = autoRepeatCountForDirection(direction);
+ unsigned autoRepeatCount = m_grid.autoRepeatTracks(direction);
GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), child, direction, autoRepeatCount);
if (positions.isIndefinite()) {
offset = LayoutUnit();
@@ -2147,16 +2183,10 @@
}
}
-GridSpan RenderGrid::cachedGridSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const
-{
- GridArea area = m_grid.gridItemArea(gridItem);
- return direction == ForColumns ? area.columns : area.rows;
-}
-
LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, SizingOperation sizingOperation) const
{
ASSERT(isOrthogonalChild(child));
- const GridSpan& span = cachedGridSpan(child, ForRows);
+ const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
LayoutUnit gridAreaSize;
bool gridAreaIsIndefinite = false;
LayoutUnit containingBlockAvailableSize = containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
@@ -2182,7 +2212,7 @@
return assumedRowsSizeForOrthogonalChild(child, sizingData.sizingOperation);
const Vector<GridTrack>& tracks = direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
- const GridSpan& span = cachedGridSpan(child, direction);
+ const GridSpan& span = m_grid.gridItemSpan(child, direction);
LayoutUnit gridAreaBreadth = 0;
for (auto trackPosition : span)
gridAreaBreadth += tracks[trackPosition].baseSize();
@@ -2197,7 +2227,7 @@
// We need the cached value when available because Content Distribution alignment properties
// may have some influence in the final grid area breadth.
const auto& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
- const auto& span = cachedGridSpan(child, direction);
+ const auto& span = m_grid.gridItemSpan(child, direction);
const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
LayoutUnit initialTrackPosition = linePositions[span.startLine()];
@@ -2230,7 +2260,7 @@
if (numberOfLines > 1) {
// If we have collapsed tracks we just ignore gaps here and add them later as we might not
// compute the gap between two consecutive tracks without examining the surrounding ones.
- bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
+ bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
unsigned nextToLastLine = numberOfLines - 2;
for (unsigned i = 0; i < nextToLastLine; ++i)
@@ -2241,16 +2271,16 @@
// coincide exactly) except on the edges of the grid where they become 0.
if (hasCollapsedTracks) {
gap = gridGapForDirection(direction);
- unsigned remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
+ unsigned remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
LayoutUnit gapAccumulator;
for (unsigned i = 1; i < lastLine; ++i) {
- if (isEmptyAutoRepeatTrack(direction, i - 1))
+ if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
--remainingEmptyTracks;
else {
// Add gap between consecutive non empty tracks. Add it also just once for an
// arbitrary number of empty tracks between two non empty ones.
bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
- if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
+ if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
gapAccumulator += gap;
}
positions[i] += gapAccumulator;
@@ -2546,7 +2576,7 @@
LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
{
- const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
+ const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
unsigned childStartLine = rowsSpan.startLine();
LayoutUnit startOfRow = m_rowPositions[childStartLine];
LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
@@ -2579,7 +2609,7 @@
LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
{
- const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
+ const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
unsigned childStartLine = columnsSpan.startLine();
LayoutUnit startOfColumn = m_columnPositions[childStartLine];
LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
@@ -2744,14 +2774,15 @@
// because not having rows implies that there are no "normal" children (out-of-flow children are
// not stored in m_grid).
if (direction == ForRows)
- return m_grid.numRows();
+ return m_grid.numTracks(ForRows);
- return m_grid.numRows() ? m_grid.numColumns() : GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
+ // 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));
}
void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect)
{
- for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next())
+ for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next())
paintChild(*child, paintInfo, paintOffset, forChild, usePrintRect, PaintAsInlineBlock);
}
