Changeset 209180 in webkit


Ignore:
Timestamp:
Dec 1, 2016 3:05:22 AM (7 years ago)
Author:
svillar@igalia.com
Message:

[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.

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r209176 r209180  
     12016-11-28  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [css-grid] Move more attributes from RenderGrid to the new Grid class
     4        https://bugs.webkit.org/show_bug.cgi?id=165094
     5
     6        Reviewed by Darin Adler.
     7
     8        Moved more attributes from RenderGrid to Grid as they are not really part of the state of
     9        the RenderGrid object. In particular m_autoRepeat{Columns|Rows},
     10        m_autoRepeatEmpty{Columns|Rows} and m_orderIterator. All of them are now private attributes
     11        of the Grid class so clients should use the getters/setters provided by this patch.
     12
     13        This change allows to definitely remove the grid{Column|Row}Count() methods from
     14        RenderGrid. These two became Grid::numTracks() which returns the number of tracks in the
     15        data structure used to represent the grid (currently a matrix). Contrary to that,
     16        RenderGrid::numTracks() returns the actual size of the grid.
     17
     18        No new tests as this is a refactoring.
     19
     20        * rendering/RenderGrid.cpp:
     21        (WebCore::RenderGrid::Grid::numTracks):
     22        (WebCore::RenderGrid::Grid::ensureGridSize):
     23        (WebCore::RenderGrid::Grid::setAutoRepeatTracks):
     24        (WebCore::RenderGrid::Grid::autoRepeatTracks):
     25        (WebCore::RenderGrid::Grid::setAutoRepeatEmptyColumns):
     26        (WebCore::RenderGrid::Grid::setAutoRepeatEmptyRows):
     27        (WebCore::RenderGrid::Grid::hasAutoRepeatEmptyTracks):
     28        (WebCore::RenderGrid::Grid::isEmptyAutoRepeatTrack):
     29        (WebCore::RenderGrid::Grid::autoRepeatEmptyTracks):
     30        (WebCore::RenderGrid::Grid::gridItemSpan):
     31        (WebCore::RenderGrid::Grid::clear):
     32        (WebCore::RenderGrid::RenderGrid):
     33        (WebCore::RenderGrid::computeTrackSizesForDirection):
     34        (WebCore::RenderGrid::guttersSize):
     35        (WebCore::RenderGrid::computeIntrinsicLogicalHeight):
     36        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     37        (WebCore::RenderGrid::rawGridTrackSize):
     38        (WebCore::RenderGrid::gridTrackSize):
     39        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
     40        (WebCore::RenderGrid::computeEmptyTracksForAutoRepeat):
     41        (WebCore::RenderGrid::placeItemsOnGrid):
     42        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator):
     43        (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid):
     44        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid):
     45        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid):
     46        (WebCore::RenderGrid::trackSizesForComputedStyle):
     47        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     48        (WebCore::RenderGrid::assumedRowsSizeForOrthogonalChild):
     49        (WebCore::RenderGrid::gridAreaBreadthForChild):
     50        (WebCore::RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets):
     51        (WebCore::RenderGrid::populateGridPositionsForDirection):
     52        (WebCore::RenderGrid::columnAxisOffsetForChild):
     53        (WebCore::RenderGrid::rowAxisOffsetForChild):
     54        (WebCore::RenderGrid::numTracks):
     55        (WebCore::RenderGrid::paintChildren):
     56        (WebCore::RenderGrid::gridColumnCount): Deleted.
     57        (WebCore::RenderGrid::gridRowCount): Deleted.
     58        (WebCore::RenderGrid::hasAutoRepeatEmptyTracks): Deleted.
     59        (WebCore::RenderGrid::isEmptyAutoRepeatTrack): Deleted.
     60        (WebCore::RenderGrid::cachedGridSpan): Deleted.
     61        * rendering/RenderGrid.h:
     62        (WebCore::RenderGrid::autoRepeatCountForDirection): Deleted.
     63
    1642016-11-30  Brady Eidson  <beidson@apple.com>
    265

  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r208995 r209180  
    4747};
    4848
     49unsigned RenderGrid::Grid::numTracks(GridTrackSizingDirection direction) const
     50{
     51    if (direction == ForRows)
     52        return m_grid.size();
     53    return m_grid.size() ? m_grid[0].size() : 0;
     54}
     55
    4956void RenderGrid::Grid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize)
    5057{
    51     const size_t oldColumnSize = numColumns();
    52     const size_t oldRowSize = numRows();
     58    const size_t oldColumnSize = numTracks(ForColumns);
     59    const size_t oldRowSize = numTracks(ForRows);
    5360    if (maximumRowSize > oldRowSize) {
    5461        m_grid.grow(maximumRowSize);
    … …  
    5865
    5966    if (maximumColumnSize > oldColumnSize) {
    60         for (size_t row = 0; row < numRows(); ++row)
     67        for (size_t row = 0; row < numTracks(ForRows); ++row)
    6168            m_grid[row].grow(maximumColumnSize);
    6269    }
    … …  
    96103{
    97104    m_gridItemArea.set(&item, area);
     105}
     106
     107void RenderGrid::Grid::setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns)
     108{
     109    m_autoRepeatRows = autoRepeatRows;
     110    m_autoRepeatColumns =  autoRepeatColumns;
     111}
     112
     113unsigned RenderGrid::Grid::autoRepeatTracks(GridTrackSizingDirection direction) const
     114{
     115    return direction == ForRows ? m_autoRepeatRows : m_autoRepeatColumns;
     116}
     117
     118void RenderGrid::Grid::setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyColumns)
     119{
     120    m_autoRepeatEmptyColumns = WTFMove(autoRepeatEmptyColumns);
     121}
     122
     123void RenderGrid::Grid::setAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyRows)
     124{
     125    m_autoRepeatEmptyRows = WTFMove(autoRepeatEmptyRows);
     126}
     127
     128bool RenderGrid::Grid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const
     129{
     130    return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows;
     131}
     132
     133bool RenderGrid::Grid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const
     134{
     135    ASSERT(hasAutoRepeatEmptyTracks(direction));
     136    return autoRepeatEmptyTracks(direction)->contains(line);
     137}
     138
     139RenderGrid::OrderedTrackIndexSet* RenderGrid::Grid::autoRepeatEmptyTracks(GridTrackSizingDirection direction) const
     140{
     141    ASSERT(hasAutoRepeatEmptyTracks(direction));
     142    return direction == ForColumns ? m_autoRepeatEmptyColumns.get() : m_autoRepeatEmptyRows.get();
     143}
     144
     145GridSpan RenderGrid::Grid::gridItemSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const
     146{
     147    GridArea area = gridItemArea(gridItem);
     148    return direction == ForColumns ? area.columns : area.rows;
    98149}
    99150
    … …  
    105156    m_smallestRowStart = 0;
    106157    m_smallestColumnStart = 0;
     158    // FIXME: clear these once m_grid survives layout. We cannot clear them now because they're
     159    // needed after layout.
     160    // m_autoRepeatEmptyColumns = nullptr;
     161    // m_autoRepeatEmptyRows = nullptr;
     162    // m_autoRepeatColumns = 0;
     163    // m_autoRepeatRows = 0;
    107164}
    108165
    … …  
    374431RenderGrid::RenderGrid(Element& element, RenderStyle&& style)
    375432    : RenderBlock(element, WTFMove(style), 0)
    376     , m_orderIterator(*this)
     433    , m_grid(*this)
    377434{
    378435    // All of our children must be block level.
    … …  
    445502}
    446503
    447 unsigned RenderGrid::gridColumnCount() const
    448 {
    449     ASSERT(!m_gridIsDirty);
    450     return m_grid.numColumns();
    451 }
    452 
    453 unsigned RenderGrid::gridRowCount() const
    454 {
    455     ASSERT(!m_gridIsDirty);
    456     return m_grid.numRows();
    457 }
    458 
    459504LayoutUnit RenderGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizingData) const
    460505{
    … …  
    472517{
    473518    ASSERT(sizingData.isValidTransition(direction));
    474     LayoutUnit totalGuttersSize = guttersSize(direction, 0, direction == ForRows ? gridRowCount() : gridColumnCount());
     519    LayoutUnit totalGuttersSize = guttersSize(direction, 0, m_grid.numTracks(direction));
    475520    sizingData.setAvailableSpace(availableSpace);
    476521    sizingData.setFreeSpace(direction, availableSpace - totalGuttersSize);
    … …  
    610655}
    611656
    612 bool RenderGrid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const
    613 {
    614     return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows;
    615 }
    616 
    617 bool RenderGrid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const
    618 {
    619     ASSERT(hasAutoRepeatEmptyTracks(direction));
    620     return direction == ForColumns ? m_autoRepeatEmptyColumns->contains(line) : m_autoRepeatEmptyRows->contains(line);
    621 }
    622 
    623657LayoutUnit RenderGrid::gridGapForDirection(GridTrackSizingDirection direction) const
    624658{
    … …  
    631665        return { };
    632666
    633     bool isRowAxis = direction == ForColumns;
    634667    LayoutUnit gap = gridGapForDirection(direction);
    635668
    636669    // Fast path, no collapsing tracks.
    637     if (!hasAutoRepeatEmptyTracks(direction))
     670    if (!m_grid.hasAutoRepeatEmptyTracks(direction))
    638671        return gap * (span - 1);
    639672
    … …  
    647680
    648681    for (unsigned line = startLine; line < endLine - 1; ++line) {
    649         if (!isEmptyAutoRepeatTrack(direction, line))
     682        if (!m_grid.isEmptyAutoRepeatTrack(direction, line))
    650683            gapAccumulator += gap;
    651684    }
    652685
    653686    // The above loop adds one extra gap for trailing collapsed tracks.
    654     if (gapAccumulator && isEmptyAutoRepeatTrack(direction, endLine - 1)) {
     687    if (gapAccumulator && m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
    655688        ASSERT(gapAccumulator >= gap);
    656689        gapAccumulator -= gap;
    … …  
    659692    // If the startLine is the start line of a collapsed track we need to go backwards till we reach
    660693    // a non collapsed track. If we find a non collapsed track we need to add that gap.
    661     if (startLine && isEmptyAutoRepeatTrack(direction, startLine)) {
     694    if (startLine && m_grid.isEmptyAutoRepeatTrack(direction, startLine)) {
    662695        unsigned nonEmptyTracksBeforeStartLine = startLine;
    663         auto begin = isRowAxis ? m_autoRepeatEmptyColumns->begin() : m_autoRepeatEmptyRows->begin();
     696        auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin();
    664697        for (auto it = begin; *it != startLine; ++it) {
    665698            ASSERT(nonEmptyTracksBeforeStartLine);
    … …  
    672705    // If the endLine is the end line of a collapsed track we need to go forward till we reach a non
    673706    // collapsed track. If we find a non collapsed track we need to add that gap.
    674     if (isEmptyAutoRepeatTrack(direction, endLine - 1)) {
    675         unsigned nonEmptyTracksAfterEndLine = (isRowAxis ? gridColumnCount() : gridRowCount()) - endLine;
    676         auto currentEmptyTrack = isRowAxis ? m_autoRepeatEmptyColumns->find(endLine - 1) : m_autoRepeatEmptyRows->find(endLine - 1);
    677         auto endEmptyTrack = isRowAxis ? m_autoRepeatEmptyColumns->end() : m_autoRepeatEmptyRows->end();
     707    if (m_grid.isEmptyAutoRepeatTrack(direction, endLine - 1)) {
     708        unsigned nonEmptyTracksAfterEndLine = m_grid.numTracks(direction) - endLine;
     709        auto currentEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->find(endLine - 1);
     710        auto endEmptyTrack = m_grid.autoRepeatEmptyTracks(direction)->end();
    678711        // HashSet iterators do not implement operator- so we have to manually iterate to know the number of remaining empty tracks.
    679712        for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) {
    … …  
    727760    maxHeight += scrollbarHeight;
    728761
    729     LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, gridRowCount());
     762    LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
    730763    minHeight += totalGuttersSize;
    731764    maxHeight += totalGuttersSize;
    … …  
    854887                GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
    855888                while (auto* gridItem = iterator.nextGridItem()) {
    856                     GridSpan span = cachedGridSpan(*gridItem, direction);
     889                    const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
    857890
    858891                    // Do not include already processed items.
    … …  
    884917        if (checkMinSize || checkMaxSize) {
    885918            LayoutUnit constrainedFreeSpace = checkMaxSize ? maxSize.value() : LayoutUnit(-1);
    886             constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, gridRowCount());
     919            constrainedFreeSpace = std::max(constrainedFreeSpace, minSize.value()) - guttersSize(ForRows, 0, m_grid.numTracks(ForRows));
    887920            flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, sizingData.sizingOperation, constrainedFreeSpace);
    888921
    … …  
    10291062    auto& autoTrackStyles = isRowAxis ? style().gridAutoColumns() : style().gridAutoRows();
    10301063    unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
    1031     unsigned autoRepeatTracksCount = autoRepeatCountForDirection(direction);
     1064    unsigned autoRepeatTracksCount = m_grid.autoRepeatTracks(direction);
    10321065
    10331066    // We should not use GridPositionsResolver::explicitGridXXXCount() for this because the
    … …  
    10631096{
    10641097    // Collapse empty auto repeat tracks if auto-fit.
    1065     if (hasAutoRepeatEmptyTracks(direction) && isEmptyAutoRepeatTrack(direction, translatedIndex))
     1098    if (m_grid.hasAutoRepeatEmptyTracks(direction) && m_grid.isEmptyAutoRepeatTrack(direction, translatedIndex))
    10661099        return { Length(Fixed), LengthTrackSizing };
    10671100
    … …  
    12561289            while (auto* gridItem = iterator.nextGridItem()) {
    12571290                if (itemsSet.add(gridItem).isNewEntry) {
    1258                     GridSpan span = cachedGridSpan(*gridItem, direction);
     1291                    const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction);
    12591292                    if (span.integerSpan() == 1)
    12601293                        resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData);
    … …  
    16591692    unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
    16601693    unsigned firstAutoRepeatTrack = insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
    1661     unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + autoRepeatCountForDirection(direction);
     1694    unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + m_grid.autoRepeatTracks(direction);
    16621695
    16631696    if (!m_grid.hasGridItems()) {
    … …  
    16831716    ASSERT(!m_grid.hasGridItems());
    16841717
    1685     m_autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
    1686     m_autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
     1718    unsigned autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
     1719    unsigned autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
     1720    m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
    16871721
    16881722    populateExplicitGridAndOrderIterator();
    … …  
    16921726    Vector<RenderBox*> autoMajorAxisAutoGridItems;
    16931727    Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
    1694     for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
     1728    for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
    16951729        if (child->isOutOfFlowPositioned())
    16961730            continue;
    … …  
    17201754#if ENABLE(ASSERT)
    17211755    if (m_grid.hasGridItems()) {
    1722         ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows));
    1723         ASSERT(gridColumnCount() >= GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns));
     1756        ASSERT(m_grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(style(), m_grid.autoRepeatTracks(ForRows)));
     1757        ASSERT(m_grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(style(), m_grid.autoRepeatTracks(ForColumns)));
    17241758    }
    17251759#endif
    … …  
    17291763
    17301764    // Compute collapsible tracks for auto-fit.
    1731     m_autoRepeatEmptyColumns = computeEmptyTracksForAutoRepeat(ForColumns);
    1732     m_autoRepeatEmptyRows = computeEmptyTracksForAutoRepeat(ForRows);
     1765    m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
     1766    m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
    17331767
    17341768#if ENABLE(ASSERT)
    1735     for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next()) {
     1769    for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
    17361770        if (child->isOutOfFlowPositioned())
    17371771            continue;
    … …  
    17451779void RenderGrid::populateExplicitGridAndOrderIterator()
    17461780{
    1747     OrderIteratorPopulator populator(m_orderIterator);
     1781    OrderIteratorPopulator populator(m_grid.orderIterator());
    17481782    int smallestRowStart = 0;
    17491783    int smallestColumnStart = 0;
    1750     unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), m_autoRepeatRows);
    1751     unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
     1784    unsigned autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
     1785    unsigned autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
     1786    unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), autoRepeatRows);
     1787    unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), autoRepeatColumns);
    17521788
    17531789    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
    … …  
    17571793        populator.collectChild(*child);
    17581794
    1759         GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, m_autoRepeatRows);
     1795        GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, autoRepeatRows);
    17601796        if (!rowPositions.isIndefinite()) {
    17611797            smallestRowStart = std::min(smallestRowStart, rowPositions.untranslatedStartLine());
    … …  
    17671803        }
    17681804
    1769         GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, m_autoRepeatColumns);
     1805        GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, autoRepeatColumns);
    17701806        if (!columnPositions.isIndefinite()) {
    17711807            smallestColumnStart = std::min(smallestColumnStart, columnPositions.untranslatedStartLine());
    … …  
    17871823{
    17881824    GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
    1789     const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();
     1825    const unsigned endOfCrossDirection = m_grid.numTracks(crossDirection);
    17901826    unsigned crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection);
    17911827    GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
    … …  
    18041840
    18051841    for (auto& autoGridItem : autoGridItems) {
    1806         GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());
     1842        GridSpan majorAxisPositions = m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
    18071843        ASSERT(majorAxisPositions.isTranslatedDefinite());
    1808         ASSERT(cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
     1844        ASSERT(m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
    18091845        unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
    18101846        unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
    … …  
    18391875void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
    18401876{
    1841     ASSERT(cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
     1877    ASSERT(m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
    18421878    unsigned majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection());
    18431879
    1844     const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();
     1880    const unsigned endOfMajorAxis = m_grid.numTracks(autoPlacementMajorAxisDirection());
    18451881    unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
    18461882    unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
    18471883
    18481884    std::unique_ptr<GridArea> emptyGridArea;
    1849     GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());
     1885    GridSpan minorAxisPositions = m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
    18501886    if (minorAxisPositions.isTranslatedDefinite()) {
    18511887        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    … …  
    18701906                // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
    18711907                unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
    1872                 const unsigned endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount();
     1908                const unsigned endOfMinorAxis = m_grid.numTracks(autoPlacementMinorAxisDirection());
    18731909                if (minorAxisFinalPositionIndex <= endOfMinorAxis)
    18741910                    break;
    … …  
    19191955        return tracks;
    19201956
    1921     bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
     1957    bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
    19221958    LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
    19231959    tracks.reserveCapacity(numPositions - 1);
    … …  
    19291965        return tracks;
    19301966
    1931     size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
     1967    size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
    19321968    size_t lastLine = tracks.size();
    19331969    gap = gridGapForDirection(direction);
    19341970    for (size_t i = 1; i < lastLine; ++i) {
    1935         if (isEmptyAutoRepeatTrack(direction, i - 1))
     1971        if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
    19361972            --remainingEmptyTracks;
    19371973        else {
    … …  
    19391975            // arbitrary number of empty tracks between two non empty ones.
    19401976            bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
    1941             if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
     1977            if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
    19421978                tracks[i - 1] -= gap;
    19431979        }
    … …  
    20742110    bool isRowAxis = direction == ForColumns;
    20752111
    2076     unsigned autoRepeatCount = autoRepeatCountForDirection(direction);
     2112    unsigned autoRepeatCount = m_grid.autoRepeatTracks(direction);
    20772113    GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), child, direction, autoRepeatCount);
    20782114    if (positions.isIndefinite()) {
    … …  
    21482184}
    21492185
    2150 GridSpan RenderGrid::cachedGridSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const
    2151 {
    2152     GridArea area = m_grid.gridItemArea(gridItem);
    2153     return direction == ForColumns ? area.columns : area.rows;
    2154 }
    2155 
    21562186LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, SizingOperation sizingOperation) const
    21572187{
    21582188    ASSERT(isOrthogonalChild(child));
    2159     const GridSpan& span = cachedGridSpan(child, ForRows);
     2189    const GridSpan& span = m_grid.gridItemSpan(child, ForRows);
    21602190    LayoutUnit gridAreaSize;
    21612191    bool gridAreaIsIndefinite = false;
    … …  
    21832213
    21842214    const Vector<GridTrack>& tracks = direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
    2185     const GridSpan& span = cachedGridSpan(child, direction);
     2215    const GridSpan& span = m_grid.gridItemSpan(child, direction);
    21862216    LayoutUnit gridAreaBreadth = 0;
    21872217    for (auto trackPosition : span)
    … …  
    21982228    // may have some influence in the final grid area breadth.
    21992229    const auto& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
    2200     const auto& span = cachedGridSpan(child, direction);
     2230    const auto& span = m_grid.gridItemSpan(child, direction);
    22012231    const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
    22022232
    … …  
    22312261        // If we have collapsed tracks we just ignore gaps here and add them later as we might not
    22322262        // compute the gap between two consecutive tracks without examining the surrounding ones.
    2233         bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);
     2263        bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction);
    22342264        LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit();
    22352265        unsigned nextToLastLine = numberOfLines - 2;
    … …  
    22422272        if (hasCollapsedTracks) {
    22432273            gap = gridGapForDirection(direction);
    2244             unsigned remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();
     2274            unsigned remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size();
    22452275            LayoutUnit gapAccumulator;
    22462276            for (unsigned i = 1; i < lastLine; ++i) {
    2247                 if (isEmptyAutoRepeatTrack(direction, i - 1))
     2277                if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1))
    22482278                    --remainingEmptyTracks;
    22492279                else {
    … …  
    22512281                    // arbitrary number of empty tracks between two non empty ones.
    22522282                    bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i);
    2253                     if (!allRemainingTracksAreEmpty || !isEmptyAutoRepeatTrack(direction, i))
     2283                    if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i))
    22542284                        gapAccumulator += gap;
    22552285                }
    … …  
    25472577LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
    25482578{
    2549     const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);
     2579    const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows);
    25502580    unsigned childStartLine = rowsSpan.startLine();
    25512581    LayoutUnit startOfRow = m_rowPositions[childStartLine];
    … …  
    25802610LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const
    25812611{
    2582     const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);
     2612    const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns);
    25832613    unsigned childStartLine = columnsSpan.startLine();
    25842614    LayoutUnit startOfColumn = m_columnPositions[childStartLine];
    … …  
    27452775    // not stored in m_grid).
    27462776    if (direction == ForRows)
    2747         return m_grid.numRows();
    2748 
    2749     return m_grid.numRows() ? m_grid.numColumns() : GridPositionsResolver::explicitGridColumnCount(style(), m_autoRepeatColumns);
     2777        return m_grid.numTracks(ForRows);
     2778
     2779    // FIXME: This still requires knowledge about m_grid internals.
     2780    return m_grid.numTracks(ForRows) ? m_grid.numTracks(ForColumns) : GridPositionsResolver::explicitGridColumnCount(style(), m_grid.autoRepeatTracks(ForColumns));
    27502781}
    27512782
    27522783void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect)
    27532784{
    2754     for (RenderBox* child = m_orderIterator.first(); child; child = m_orderIterator.next())
     2785    for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next())
    27552786        paintChild(*child, paintInfo, paintOffset, forChild, usePrintRect, PaintAsInlineBlock);
    27562787}

  • trunk/Source/WebCore/rendering/RenderGrid.h

    r208995 r209180  
    7171    const Vector<LayoutUnit>& rowPositions() const { return m_rowPositions; }
    7272
    73     size_t autoRepeatCountForDirection(GridTrackSizingDirection) const;
     73    unsigned autoRepeatCountForDirection(GridTrackSizingDirection direction) const { return m_grid.autoRepeatTracks(direction); }
    7474
    7575private:
    … …  
    9393    typedef ListHashSet<size_t> OrderedTrackIndexSet;
    9494    std::unique_ptr<OrderedTrackIndexSet> computeEmptyTracksForAutoRepeat(GridTrackSizingDirection) const;
    95 
    96     bool hasAutoRepeatEmptyTracks(GridTrackSizingDirection) const;
    97     bool isEmptyAutoRepeatTrack(GridTrackSizingDirection, unsigned track) const;
    9895
    9996    void placeItemsOnGrid(SizingOperation);
    … …  
    188185    bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, SizingOperation) const;
    189186
    190     // FIXME: Look for better names once the refactoring is complete.
    191     unsigned gridColumnCount() const;
    192     unsigned gridRowCount() const;
    193187    unsigned numTracks(GridTrackSizingDirection) const;
    194188
    … …  
    202196    class Grid final {
    203197    public:
    204         Grid() { }
    205 
    206         unsigned numColumns() const { return m_grid.size() ? m_grid[0].size() : 0; }
    207         unsigned numRows() const { return m_grid.size(); }
     198        Grid(RenderGrid& grid) : m_orderIterator(grid) { }
     199
     200        unsigned numTracks(GridTrackSizingDirection) const;
    208201
    209202        void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize);
    … …  
    221214        void setGridItemArea(const RenderBox& item, GridArea);
    222215
     216        GridSpan gridItemSpan(const RenderBox&, GridTrackSizingDirection) const;
     217
    223218        const GridCell& cell(unsigned row, unsigned column) const { return m_grid[row][column]; }
    224219
    225220        int smallestTrackStart(GridTrackSizingDirection) const;
    226221        void setSmallestTracksStart(int rowStart, int columnStart);
     222
     223        unsigned autoRepeatTracks(GridTrackSizingDirection) const;
     224        void setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns);
     225
     226        void setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet>);
     227        void setAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet>);
     228
     229        unsigned autoRepeatEmptyTracksCount(GridTrackSizingDirection) const;
     230        bool hasAutoRepeatEmptyTracks(GridTrackSizingDirection) const;
     231        bool isEmptyAutoRepeatTrack(GridTrackSizingDirection, unsigned) const;
     232
     233        OrderedTrackIndexSet* autoRepeatEmptyTracks(GridTrackSizingDirection) const;
     234
     235        OrderIterator& orderIterator() { return m_orderIterator; }
     236
    227237        void shrinkToFit() { m_grid.shrinkToFit(); }
    228238
    … …  
    232242        friend class GridIterator;
    233243
     244        OrderIterator m_orderIterator;
     245
    234246        int m_smallestColumnStart { 0 };
    235247        int m_smallestRowStart { 0 };
    236248
     249        unsigned m_autoRepeatColumns { 0 };
     250        unsigned m_autoRepeatRows { 0 };
     251
    237252        bool m_hasAnyOrthogonalGridItem { false };
    238253
    … …  
    241256        HashMap<const RenderBox*, GridArea> m_gridItemArea;
    242257        HashMap<const RenderBox*, size_t> m_gridItemsIndexesMap;
     258
     259        std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns;
     260        std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows;
    243261    };
    244262    Grid m_grid;
    … …  
    248266    LayoutUnit m_offsetBetweenColumns;
    249267    LayoutUnit m_offsetBetweenRows;
    250     OrderIterator m_orderIterator;
    251268
    252269    std::optional<LayoutUnit> m_minContentHeight;
    253270    std::optional<LayoutUnit> m_maxContentHeight;
    254271
    255     unsigned m_autoRepeatColumns { 0 };
    256     unsigned m_autoRepeatRows { 0 };
    257 
    258272    bool m_gridIsDirty { true };
    259 
    260     std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns { nullptr };
    261     std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows { nullptr };
    262273};
    263274
    264 size_t inline RenderGrid::autoRepeatCountForDirection(GridTrackSizingDirection direction) const
    265 {
    266     return direction == ForColumns ? m_autoRepeatColumns : m_autoRepeatRows;
    267 }
    268 
    269275} // namespace WebCore
    270276
Note: See TracChangeset for help on using the changeset viewer.