Changeset 209601 in webkit


Ignore:
Timestamp:
Dec 9, 2016 2:32:22 AM (7 years ago)
Author:
svillar@igalia.com
Message:

[css-grid] Pass Grid as argument to items' placement methods
​https://bugs.webkit.org/show_bug.cgi?id=165250

Reviewed by Darin Adler.

In order to constify computeIntrinsicLogicalWidths() it is required to constify
placeItemsOnGrid() first, which is the base method of the grid items' positioning logic. The
first step is to constify all the methods invoked by the latter, which basically means to
pass the Grid as argument to all of them instead of directly using the m_grid attribute from
RenderGrid. As this is an intermediate step, a new const_cast<> was required in the
intrinsic size computation. However it will be promptly removed after the const-ification of
placeItemsOnGrid().

After this, only the methods used by the track sizing algorithm will directly access
m_grid. All those would get a reference to the Grid via GridSizingData, but that's a matter
of a follow up patch.

Apart from that, m_gridIsDirty was removed because it was always too confusing. It was
replaced by Grid's m_needsItemsPlacement which is much more concise. The clearGrid() call
was indeed only forcing a new placement of the grid items.

No new tests as this is a refactoring.

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::Grid::setNeedsItemsPlacement): New method to flag the Grid whenever
grid items' placement algorithm needs to be run.
(WebCore::RenderGrid::canPerformSimplifiedLayout):
(WebCore::RenderGrid::layoutBlock):
(WebCore::RenderGrid::computeIntrinsicLogicalWidths):
(WebCore::RenderGrid::computeEmptyTracksForAutoRepeat):
(WebCore::RenderGrid::placeItemsOnGrid):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator): Constified. Got Grid as
argument.
(WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid): Ditto.
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid): Ditto.
(WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Ditto.
(WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid): Ditto.
(WebCore::RenderGrid::clearGrid):
(WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
(WebCore::RenderGrid::numTracks):

  • rendering/RenderGrid.h:
Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r209599 r209601  
     12016-12-01  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [css-grid] Pass Grid as argument to items' placement methods
     4        https://bugs.webkit.org/show_bug.cgi?id=165250
     5
     6        Reviewed by Darin Adler.
     7
     8        In order to constify computeIntrinsicLogicalWidths() it is required to constify
     9        placeItemsOnGrid() first, which is the base method of the grid items' positioning logic. The
     10        first step is to constify all the methods invoked by the latter, which basically means to
     11        pass the Grid as argument to all of them instead of directly using the m_grid attribute from
     12        RenderGrid. As this is an intermediate step, a new const_cast<> was required in the
     13        intrinsic size computation. However it will be promptly removed after the const-ification of
     14        placeItemsOnGrid().
     15
     16        After this, only the methods used by the track sizing algorithm will directly access
     17        m_grid. All those would get a reference to the Grid via GridSizingData, but that's a matter
     18        of a follow up patch.
     19
     20        Apart from that, m_gridIsDirty was removed because it was always too confusing. It was
     21        replaced by Grid's m_needsItemsPlacement which is much more concise. The clearGrid() call
     22        was indeed only forcing a new placement of the grid items.
     23
     24        No new tests as this is a refactoring.
     25
     26        * rendering/RenderGrid.cpp:
     27        (WebCore::RenderGrid::Grid::setNeedsItemsPlacement): New method to flag the Grid whenever
     28        grid items' placement algorithm needs to be run.
     29        (WebCore::RenderGrid::canPerformSimplifiedLayout):
     30        (WebCore::RenderGrid::layoutBlock):
     31        (WebCore::RenderGrid::computeIntrinsicLogicalWidths):
     32        (WebCore::RenderGrid::computeEmptyTracksForAutoRepeat):
     33        (WebCore::RenderGrid::placeItemsOnGrid):
     34        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator): Constified. Got Grid as
     35        argument.
     36        (WebCore::RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid): Ditto.
     37        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid): Ditto.
     38        (WebCore::RenderGrid::placeAutoMajorAxisItemsOnGrid): Ditto.
     39        (WebCore::RenderGrid::placeAutoMajorAxisItemOnGrid): Ditto.
     40        (WebCore::RenderGrid::clearGrid):
     41        (WebCore::RenderGrid::offsetAndBreadthForPositionedChild):
     42        (WebCore::RenderGrid::numTracks):
     43        * rendering/RenderGrid.h:
     44
    1452016-12-09  Gavin Barraclough  <barraclough@apple.com>
    246

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

    r209180 r209601  
    149149}
    150150
     151void RenderGrid::Grid::setNeedsItemsPlacement(bool needsItemsPlacement)
     152{
     153    m_needsItemsPlacement = needsItemsPlacement;
     154
     155    if (needsItemsPlacement)
     156        clear();
     157}
     158
    151159void RenderGrid::Grid::clear()
    152160{
    … …  
    530538void RenderGrid::repeatTracksSizingIfNeeded(GridSizingData& sizingData, LayoutUnit availableSpaceForColumns, LayoutUnit availableSpaceForRows)
    531539{
    532     ASSERT(!m_gridIsDirty);
     540    ASSERT(!m_grid.needsItemsPlacement());
    533541    ASSERT(sizingData.sizingState > GridSizingData::RowSizingFirstIteration);
    534542
    … …  
    549557bool RenderGrid::canPerformSimplifiedLayout() const
    550558{
    551     // We cannot perform a simplified layout if the grid is dirty and we have
    552     // some positioned items to be laid out.
    553     if (m_gridIsDirty && posChildNeedsLayout())
     559    // We cannot perform a simplified layout if we need to position the items and we have some
     560    // positioned items to be laid out.
     561    if (m_grid.needsItemsPlacement() && posChildNeedsLayout())
    554562        return false;
    555563
    … …  
    587595    updateLogicalWidth();
    588596
    589     placeItemsOnGrid(TrackSizing);
    590 
    591     GridSizingData sizingData(numTracks(ForColumns), numTracks(ForRows));
     597    placeItemsOnGrid(m_grid, TrackSizing);
     598
     599    GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid));
    592600
    593601    // At this point the logical width is always definite as the above call to updateLogicalWidth()
    … …  
    723731void RenderGrid::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
    724732{
    725     bool wasPopulated = !m_gridIsDirty;
     733    bool wasPopulated = !m_grid.needsItemsPlacement();
    726734    if (!wasPopulated)
    727         const_cast<RenderGrid*>(this)->placeItemsOnGrid(IntrinsicSizeComputation);
    728 
    729     GridSizingData sizingData(numTracks(ForColumns), numTracks(ForRows));
     735        const_cast<RenderGrid*>(this)->placeItemsOnGrid(const_cast<Grid&>(m_grid), IntrinsicSizeComputation);
     736
     737    GridSizingData sizingData(numTracks(ForColumns, m_grid), numTracks(ForRows, m_grid));
    730738    sizingData.setAvailableSpace(std::nullopt);
    731739    sizingData.setFreeSpace(ForColumns, std::nullopt);
    … …  
    16821690
    16831691
    1684 std::unique_ptr<RenderGrid::OrderedTrackIndexSet> RenderGrid::computeEmptyTracksForAutoRepeat(GridTrackSizingDirection direction) const
     1692std::unique_ptr<RenderGrid::OrderedTrackIndexSet> RenderGrid::computeEmptyTracksForAutoRepeat(Grid& grid, GridTrackSizingDirection direction) const
    16851693{
    16861694    bool isRowAxis = direction == ForColumns;
    … …  
    16911699    std::unique_ptr<OrderedTrackIndexSet> emptyTrackIndexes;
    16921700    unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint();
    1693     unsigned firstAutoRepeatTrack = insertionPoint + std::abs(m_grid.smallestTrackStart(direction));
    1694     unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + m_grid.autoRepeatTracks(direction);
     1701    unsigned firstAutoRepeatTrack = insertionPoint + std::abs(grid.smallestTrackStart(direction));
     1702    unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + grid.autoRepeatTracks(direction);
    16951703
    16961704    if (!m_grid.hasGridItems()) {
    … …  
    17001708    } else {
    17011709        for (unsigned trackIndex = firstAutoRepeatTrack; trackIndex < lastAutoRepeatTrack; ++trackIndex) {
    1702             GridIterator iterator(m_grid, direction, trackIndex);
     1710            GridIterator iterator(grid, direction, trackIndex);
    17031711            if (!iterator.nextGridItem()) {
    17041712                if (!emptyTrackIndexes)
    … …  
    17111719}
    17121720
    1713 void RenderGrid::placeItemsOnGrid(SizingOperation sizingOperation)
    1714 {
    1715     ASSERT(m_gridIsDirty);
    1716     ASSERT(!m_grid.hasGridItems());
     1721void RenderGrid::placeItemsOnGrid(Grid& grid, SizingOperation sizingOperation)
     1722{
     1723    ASSERT(grid.needsItemsPlacement());
     1724    ASSERT(!grid.hasGridItems());
    17171725
    17181726    unsigned autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, sizingOperation);
    17191727    unsigned autoRepeatRows = computeAutoRepeatTracksCount(ForRows, sizingOperation);
    1720     m_grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
    1721 
    1722     populateExplicitGridAndOrderIterator();
    1723     m_gridIsDirty = false;
    1724     bool hasAnyOrthogonalGridItem = false;
     1728    grid.setAutoRepeatTracks(autoRepeatRows, autoRepeatColumns);
     1729
     1730    populateExplicitGridAndOrderIterator(grid);
    17251731
    17261732    Vector<RenderBox*> autoMajorAxisAutoGridItems;
    17271733    Vector<RenderBox*> specifiedMajorAxisAutoGridItems;
    1728     for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
     1734    bool hasAnyOrthogonalGridItem = false;
     1735    for (auto* child = grid.orderIterator().first(); child; child = grid.orderIterator().next()) {
    17291736        if (child->isOutOfFlowPositioned())
    17301737            continue;
    … …  
    17321739        hasAnyOrthogonalGridItem = hasAnyOrthogonalGridItem || isOrthogonalChild(*child);
    17331740
    1734         GridArea area = m_grid.gridItemArea(*child);
     1741        GridArea area = grid.gridItemArea(*child);
    17351742        if (!area.rows.isIndefinite())
    1736             area.rows.translate(std::abs(m_grid.smallestTrackStart(ForRows)));
     1743            area.rows.translate(std::abs(grid.smallestTrackStart(ForRows)));
    17371744        if (!area.columns.isIndefinite())
    1738             area.columns.translate(std::abs(m_grid.smallestTrackStart(ForColumns)));
     1745            area.columns.translate(std::abs(grid.smallestTrackStart(ForColumns)));
    17391746
    17401747        if (area.rows.isIndefinite() || area.columns.isIndefinite()) {
    1741             m_grid.setGridItemArea(*child, area);
     1748            grid.setGridItemArea(*child, area);
    17421749            bool majorAxisDirectionIsForColumns = autoPlacementMajorAxisDirection() == ForColumns;
    17431750            if ((majorAxisDirectionIsForColumns && area.columns.isIndefinite())
    … …  
    17481755            continue;
    17491756        }
    1750         m_grid.insert(*child, { area.rows, area.columns });
    1751     }
    1752     m_grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
     1757        grid.insert(*child, { area.rows, area.columns });
     1758    }
     1759    grid.setHasAnyOrthogonalGridItem(hasAnyOrthogonalGridItem);
    17531760
    17541761#if ENABLE(ASSERT)
    1755     if (m_grid.hasGridItems()) {
    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)));
     1762    if (grid.hasGridItems()) {
     1763        ASSERT(grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(style(), grid.autoRepeatTracks(ForRows)));
     1764        ASSERT(grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(style(), grid.autoRepeatTracks(ForColumns)));
    17581765    }
    17591766#endif
    17601767
    1761     placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems);
    1762     placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems);
     1768    placeSpecifiedMajorAxisItemsOnGrid(grid, specifiedMajorAxisAutoGridItems);
     1769    placeAutoMajorAxisItemsOnGrid(grid, autoMajorAxisAutoGridItems);
    17631770
    17641771    // Compute collapsible tracks for auto-fit.
    1765     m_grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(ForColumns));
    1766     m_grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(ForRows));
     1772    grid.setAutoRepeatEmptyColumns(computeEmptyTracksForAutoRepeat(grid, ForColumns));
     1773    grid.setAutoRepeatEmptyRows(computeEmptyTracksForAutoRepeat(grid, ForRows));
     1774
     1775    grid.setNeedsItemsPlacement(false);
    17671776
    17681777#if ENABLE(ASSERT)
    1769     for (RenderBox* child = m_grid.orderIterator().first(); child; child = m_grid.orderIterator().next()) {
     1778    for (auto* child = grid.orderIterator().first(); child; child = grid.orderIterator().next()) {
    17701779        if (child->isOutOfFlowPositioned())
    17711780            continue;
    17721781
    1773         GridArea area = m_grid.gridItemArea(*child);
     1782        GridArea area = grid.gridItemArea(*child);
    17741783        ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
    17751784    }
    … …  
    17771786}
    17781787
    1779 void RenderGrid::populateExplicitGridAndOrderIterator()
    1780 {
    1781     OrderIteratorPopulator populator(m_grid.orderIterator());
     1788void RenderGrid::populateExplicitGridAndOrderIterator(Grid& grid) const
     1789{
     1790    OrderIteratorPopulator populator(grid.orderIterator());
    17821791    int smallestRowStart = 0;
    17831792    int smallestColumnStart = 0;
    1784     unsigned autoRepeatRows = m_grid.autoRepeatTracks(ForRows);
    1785     unsigned autoRepeatColumns = m_grid.autoRepeatTracks(ForColumns);
     1793    unsigned autoRepeatRows = grid.autoRepeatTracks(ForRows);
     1794    unsigned autoRepeatColumns = grid.autoRepeatTracks(ForColumns);
    17861795    unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), autoRepeatRows);
    17871796    unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), autoRepeatColumns);
    … …  
    18131822        }
    18141823
    1815         m_grid.setGridItemArea(*child, { rowPositions, columnPositions });
    1816     }
    1817 
    1818     m_grid.setSmallestTracksStart(smallestRowStart, smallestColumnStart);
    1819     m_grid.ensureGridSize(maximumRowIndex + std::abs(smallestRowStart), maximumColumnIndex + std::abs(smallestColumnStart));
    1820 }
    1821 
    1822 std::unique_ptr<GridArea> RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const RenderBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
     1824        grid.setGridItemArea(*child, { rowPositions, columnPositions });
     1825    }
     1826
     1827    grid.setSmallestTracksStart(smallestRowStart, smallestColumnStart);
     1828    grid.ensureGridSize(maximumRowIndex + std::abs(smallestRowStart), maximumColumnIndex + std::abs(smallestColumnStart));
     1829}
     1830
     1831std::unique_ptr<GridArea> RenderGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(Grid& grid, const RenderBox& gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& specifiedPositions) const
    18231832{
    18241833    GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns;
    1825     const unsigned endOfCrossDirection = m_grid.numTracks(crossDirection);
     1834    const unsigned endOfCrossDirection = grid.numTracks(crossDirection);
    18261835    unsigned crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection);
    18271836    GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize);
    … …  
    18291838}
    18301839
    1831 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGridItems)
     1840void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(Grid& grid, const Vector<RenderBox*>& autoGridItems) const
    18321841{
    18331842    bool isForColumns = autoPlacementMajorAxisDirection() == ForColumns;
    … …  
    18401849
    18411850    for (auto& autoGridItem : autoGridItems) {
    1842         GridSpan majorAxisPositions = m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
     1851        GridSpan majorAxisPositions = grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection());
    18431852        ASSERT(majorAxisPositions.isTranslatedDefinite());
    1844         ASSERT(m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
     1853        ASSERT(grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());
    18451854        unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection());
    18461855        unsigned majorAxisInitialPosition = majorAxisPositions.startLine();
    18471856
    1848         GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
     1857        GridIterator iterator(grid, autoPlacementMajorAxisDirection(), majorAxisPositions.startLine(), isGridAutoFlowDense ? 0 : minorAxisCursors.get(majorAxisInitialPosition));
    18491858        std::unique_ptr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPositions.integerSpan(), minorAxisSpanSize);
    18501859        if (!emptyGridArea)
    1851             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
    1852 
    1853         m_grid.insert(*autoGridItem, *emptyGridArea);
     1860            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(grid, *autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
     1861
     1862        grid.insert(*autoGridItem, *emptyGridArea);
    18541863
    18551864        if (!isGridAutoFlowDense)
    … …  
    18581867}
    18591868
    1860 void RenderGrid::placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGridItems)
     1869void RenderGrid::placeAutoMajorAxisItemsOnGrid(Grid& grid, const Vector<RenderBox*>& autoGridItems) const
    18611870{
    18621871    AutoPlacementCursor autoPlacementCursor = {0, 0};
    … …  
    18641873
    18651874    for (auto& autoGridItem : autoGridItems) {
    1866         placeAutoMajorAxisItemOnGrid(*autoGridItem, autoPlacementCursor);
     1875        placeAutoMajorAxisItemOnGrid(grid, *autoGridItem, autoPlacementCursor);
    18671876
    18681877        if (isGridAutoFlowDense) {
    … …  
    18731882}
    18741883
    1875 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor)
    1876 {
    1877     ASSERT(m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
     1884void RenderGrid::placeAutoMajorAxisItemOnGrid(Grid& grid, RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor) const
     1885{
     1886    ASSERT(grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());
    18781887    unsigned majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection());
    18791888
    1880     const unsigned endOfMajorAxis = m_grid.numTracks(autoPlacementMajorAxisDirection());
     1889    const unsigned endOfMajorAxis = grid.numTracks(autoPlacementMajorAxisDirection());
    18811890    unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first;
    18821891    unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second;
    18831892
    18841893    std::unique_ptr<GridArea> emptyGridArea;
    1885     GridSpan minorAxisPositions = m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
     1894    GridSpan minorAxisPositions = grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection());
    18861895    if (minorAxisPositions.isTranslatedDefinite()) {
    18871896        // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor.
    … …  
    18901899
    18911900        if (majorAxisAutoPlacementCursor < endOfMajorAxis) {
    1892             GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAxisPositions.startLine(), majorAxisAutoPlacementCursor);
     1901            GridIterator iterator(grid, autoPlacementMinorAxisDirection(), minorAxisPositions.startLine(), majorAxisAutoPlacementCursor);
    18931902            emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.integerSpan(), majorAxisSpanSize);
    18941903        }
    18951904
    18961905        if (!emptyGridArea)
    1897             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), minorAxisPositions);
     1906            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(grid, gridItem, autoPlacementMinorAxisDirection(), minorAxisPositions);
    18981907    } else {
    18991908        unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMinorAxisDirection());
    19001909
    19011910        for (unsigned majorAxisIndex = majorAxisAutoPlacementCursor; majorAxisIndex < endOfMajorAxis; ++majorAxisIndex) {
    1902             GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAxisIndex, minorAxisAutoPlacementCursor);
     1911            GridIterator iterator(grid, autoPlacementMajorAxisDirection(), majorAxisIndex, minorAxisAutoPlacementCursor);
    19031912            emptyGridArea = iterator.nextEmptyGridArea(majorAxisSpanSize, minorAxisSpanSize);
    19041913
    … …  
    19061915                // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()).
    19071916                unsigned minorAxisFinalPositionIndex = autoPlacementMinorAxisDirection() == ForColumns ? emptyGridArea->columns.endLine() : emptyGridArea->rows.endLine();
    1908                 const unsigned endOfMinorAxis = m_grid.numTracks(autoPlacementMinorAxisDirection());
     1917                const unsigned endOfMinorAxis = grid.numTracks(autoPlacementMinorAxisDirection());
    19091918                if (minorAxisFinalPositionIndex <= endOfMinorAxis)
    19101919                    break;
    … …  
    19201929
    19211930        if (!emptyGridArea)
    1922             emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(gridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
    1923     }
    1924 
    1925     m_grid.insert(gridItem, *emptyGridArea);
     1931            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(grid, gridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan(0, minorAxisSpanSize));
     1932    }
     1933
     1934    grid.insert(gridItem, *emptyGridArea);
    19261935    autoPlacementCursor.first = emptyGridArea->rows.startLine();
    19271936    autoPlacementCursor.second = emptyGridArea->columns.startLine();
    … …  
    19401949void RenderGrid::clearGrid()
    19411950{
    1942     m_grid.clear();
    1943     m_gridIsDirty = true;
     1951    m_grid.setNeedsItemsPlacement(true);
    19441952}
    19451953
    … …  
    21252133    GridPosition startPosition = isRowAxis ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
    21262134    GridPosition endPosition = isRowAxis ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
    2127     int lastLine = numTracks(direction);
     2135    int lastLine = numTracks(direction, m_grid);
    21282136
    21292137    bool startIsAuto = startPosition.isAuto()
    … …  
    27672775}
    27682776
    2769 unsigned RenderGrid::numTracks(GridTrackSizingDirection direction) const
     2777unsigned RenderGrid::numTracks(GridTrackSizingDirection direction, const Grid& grid) const
    27702778{
    27712779    // Due to limitations in our internal representation, we cannot know the number of columns from
    … …  
    27752783    // not stored in m_grid).
    27762784    if (direction == ForRows)
    2777         return m_grid.numTracks(ForRows);
     2785        return grid.numTracks(ForRows);
    27782786
    27792787    // 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));
     2788    return grid.numTracks(ForRows) ? grid.numTracks(ForColumns) : GridPositionsResolver::explicitGridColumnCount(style(), grid.autoRepeatTracks(ForColumns));
    27812789}
    27822790

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

    r209180 r209601  
    8080    std::optional<LayoutUnit> computeIntrinsicLogicalContentHeightUsing(Length logicalHeightLength, std::optional<LayoutUnit> intrinsicContentHeight, LayoutUnit borderAndPadding) const override;
    8181
     82    class Grid;
    8283    class GridIterator;
    8384    class GridSizingData;
    … …  
    9293
    9394    typedef ListHashSet<size_t> OrderedTrackIndexSet;
    94     std::unique_ptr<OrderedTrackIndexSet> computeEmptyTracksForAutoRepeat(GridTrackSizingDirection) const;
    95 
    96     void placeItemsOnGrid(SizingOperation);
    97     void populateExplicitGridAndOrderIterator();
    98     std::unique_ptr<GridArea> createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(const RenderBox&, GridTrackSizingDirection, const GridSpan&) const;
    99     void placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>&);
    100     void placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>&);
     95    std::unique_ptr<OrderedTrackIndexSet> computeEmptyTracksForAutoRepeat(Grid&, GridTrackSizingDirection) const;
     96
     97    void placeItemsOnGrid(Grid&, SizingOperation);
     98    void populateExplicitGridAndOrderIterator(Grid&) const;
     99    std::unique_ptr<GridArea> createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(Grid&, const RenderBox&, GridTrackSizingDirection, const GridSpan&) const;
     100    void placeSpecifiedMajorAxisItemsOnGrid(Grid&, const Vector<RenderBox*>&) const;
     101    void placeAutoMajorAxisItemsOnGrid(Grid&, const Vector<RenderBox*>&) const;
    101102    typedef std::pair<unsigned, unsigned> AutoPlacementCursor;
    102     void placeAutoMajorAxisItemOnGrid(RenderBox&, AutoPlacementCursor&);
     103    void placeAutoMajorAxisItemOnGrid(Grid&, RenderBox&, AutoPlacementCursor&) const;
    103104    GridTrackSizingDirection autoPlacementMajorAxisDirection() const;
    104105    GridTrackSizingDirection autoPlacementMinorAxisDirection() const;
    … …  
    185186    bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, SizingOperation) const;
    186187
    187     unsigned numTracks(GridTrackSizingDirection) const;
     188    unsigned numTracks(GridTrackSizingDirection, const Grid&) const;
    188189
    189190    LayoutUnit translateRTLCoordinate(LayoutUnit) const;
    … …  
    235236        OrderIterator& orderIterator() { return m_orderIterator; }
    236237
    237         void shrinkToFit() { m_grid.shrinkToFit(); }
    238 
    239         void clear();
     238        void setNeedsItemsPlacement(bool);
     239        bool needsItemsPlacement() const { return m_needsItemsPlacement; };
    240240
    241241    private:
    242242        friend class GridIterator;
    243243
     244        void clear();
     245
    244246        OrderIterator m_orderIterator;
    245247
    … …  
    251253
    252254        bool m_hasAnyOrthogonalGridItem { false };
     255        bool m_needsItemsPlacement { true };
    253256
    254257        GridAsMatrix m_grid;
    … …  
    269272    std::optional<LayoutUnit> m_minContentHeight;
    270273    std::optional<LayoutUnit> m_maxContentHeight;
    271 
    272     bool m_gridIsDirty { true };
    273274};
    274275
Note: See TracChangeset for help on using the changeset viewer.