Changeset 209180 in webkit
- Timestamp:
- Dec 1, 2016 3:05:22 AM (7 years ago)
- Location:
- trunk/Source/WebCore
- Files:
-
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/WebCore/ChangeLog
r209176 r209180 1 2016-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 1 64 2016-11-30 Brady Eidson <beidson@apple.com> 2 65 -
trunk/Source/WebCore/rendering/RenderGrid.cpp
r208995 r209180 47 47 }; 48 48 49 unsigned 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 49 56 void RenderGrid::Grid::ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize) 50 57 { 51 const size_t oldColumnSize = num Columns();52 const size_t oldRowSize = num Rows();58 const size_t oldColumnSize = numTracks(ForColumns); 59 const size_t oldRowSize = numTracks(ForRows); 53 60 if (maximumRowSize > oldRowSize) { 54 61 m_grid.grow(maximumRowSize); … … 58 65 59 66 if (maximumColumnSize > oldColumnSize) { 60 for (size_t row = 0; row < num Rows(); ++row)67 for (size_t row = 0; row < numTracks(ForRows); ++row) 61 68 m_grid[row].grow(maximumColumnSize); 62 69 } … … 96 103 { 97 104 m_gridItemArea.set(&item, area); 105 } 106 107 void RenderGrid::Grid::setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns) 108 { 109 m_autoRepeatRows = autoRepeatRows; 110 m_autoRepeatColumns = autoRepeatColumns; 111 } 112 113 unsigned RenderGrid::Grid::autoRepeatTracks(GridTrackSizingDirection direction) const 114 { 115 return direction == ForRows ? m_autoRepeatRows : m_autoRepeatColumns; 116 } 117 118 void RenderGrid::Grid::setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyColumns) 119 { 120 m_autoRepeatEmptyColumns = WTFMove(autoRepeatEmptyColumns); 121 } 122 123 void RenderGrid::Grid::setAutoRepeatEmptyRows(std::unique_ptr<OrderedTrackIndexSet> autoRepeatEmptyRows) 124 { 125 m_autoRepeatEmptyRows = WTFMove(autoRepeatEmptyRows); 126 } 127 128 bool RenderGrid::Grid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const 129 { 130 return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows; 131 } 132 133 bool RenderGrid::Grid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const 134 { 135 ASSERT(hasAutoRepeatEmptyTracks(direction)); 136 return autoRepeatEmptyTracks(direction)->contains(line); 137 } 138 139 RenderGrid::OrderedTrackIndexSet* RenderGrid::Grid::autoRepeatEmptyTracks(GridTrackSizingDirection direction) const 140 { 141 ASSERT(hasAutoRepeatEmptyTracks(direction)); 142 return direction == ForColumns ? m_autoRepeatEmptyColumns.get() : m_autoRepeatEmptyRows.get(); 143 } 144 145 GridSpan RenderGrid::Grid::gridItemSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const 146 { 147 GridArea area = gridItemArea(gridItem); 148 return direction == ForColumns ? area.columns : area.rows; 98 149 } 99 150 … … 105 156 m_smallestRowStart = 0; 106 157 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; 107 164 } 108 165 … … 374 431 RenderGrid::RenderGrid(Element& element, RenderStyle&& style) 375 432 : RenderBlock(element, WTFMove(style), 0) 376 , m_ orderIterator(*this)433 , m_grid(*this) 377 434 { 378 435 // All of our children must be block level. … … 445 502 } 446 503 447 unsigned RenderGrid::gridColumnCount() const448 {449 ASSERT(!m_gridIsDirty);450 return m_grid.numColumns();451 }452 453 unsigned RenderGrid::gridRowCount() const454 {455 ASSERT(!m_gridIsDirty);456 return m_grid.numRows();457 }458 459 504 LayoutUnit RenderGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizingData) const 460 505 { … … 472 517 { 473 518 ASSERT(sizingData.isValidTransition(direction)); 474 LayoutUnit totalGuttersSize = guttersSize(direction, 0, direction == ForRows ? gridRowCount() : gridColumnCount());519 LayoutUnit totalGuttersSize = guttersSize(direction, 0, m_grid.numTracks(direction)); 475 520 sizingData.setAvailableSpace(availableSpace); 476 521 sizingData.setFreeSpace(direction, availableSpace - totalGuttersSize); … … 610 655 } 611 656 612 bool RenderGrid::hasAutoRepeatEmptyTracks(GridTrackSizingDirection direction) const613 {614 return direction == ForColumns ? !!m_autoRepeatEmptyColumns : !!m_autoRepeatEmptyRows;615 }616 617 bool RenderGrid::isEmptyAutoRepeatTrack(GridTrackSizingDirection direction, unsigned line) const618 {619 ASSERT(hasAutoRepeatEmptyTracks(direction));620 return direction == ForColumns ? m_autoRepeatEmptyColumns->contains(line) : m_autoRepeatEmptyRows->contains(line);621 }622 623 657 LayoutUnit RenderGrid::gridGapForDirection(GridTrackSizingDirection direction) const 624 658 { … … 631 665 return { }; 632 666 633 bool isRowAxis = direction == ForColumns;634 667 LayoutUnit gap = gridGapForDirection(direction); 635 668 636 669 // Fast path, no collapsing tracks. 637 if (! hasAutoRepeatEmptyTracks(direction))670 if (!m_grid.hasAutoRepeatEmptyTracks(direction)) 638 671 return gap * (span - 1); 639 672 … … 647 680 648 681 for (unsigned line = startLine; line < endLine - 1; ++line) { 649 if (! isEmptyAutoRepeatTrack(direction, line))682 if (!m_grid.isEmptyAutoRepeatTrack(direction, line)) 650 683 gapAccumulator += gap; 651 684 } 652 685 653 686 // 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)) { 655 688 ASSERT(gapAccumulator >= gap); 656 689 gapAccumulator -= gap; … … 659 692 // If the startLine is the start line of a collapsed track we need to go backwards till we reach 660 693 // 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)) { 662 695 unsigned nonEmptyTracksBeforeStartLine = startLine; 663 auto begin = isRowAxis ? m_autoRepeatEmptyColumns->begin() : m_autoRepeatEmptyRows->begin();696 auto begin = m_grid.autoRepeatEmptyTracks(direction)->begin(); 664 697 for (auto it = begin; *it != startLine; ++it) { 665 698 ASSERT(nonEmptyTracksBeforeStartLine); … … 672 705 // If the endLine is the end line of a collapsed track we need to go forward till we reach a non 673 706 // 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(); 678 711 // HashSet iterators do not implement operator- so we have to manually iterate to know the number of remaining empty tracks. 679 712 for (auto it = ++currentEmptyTrack; it != endEmptyTrack; ++it) { … … 727 760 maxHeight += scrollbarHeight; 728 761 729 LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, gridRowCount());762 LayoutUnit totalGuttersSize = guttersSize(ForRows, 0, m_grid.numTracks(ForRows)); 730 763 minHeight += totalGuttersSize; 731 764 maxHeight += totalGuttersSize; … … 854 887 GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]); 855 888 while (auto* gridItem = iterator.nextGridItem()) { 856 GridSpan span = cachedGridSpan(*gridItem, direction);889 const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction); 857 890 858 891 // Do not include already processed items. … … 884 917 if (checkMinSize || checkMaxSize) { 885 918 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)); 887 920 flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), ForRows, sizingData.sizingOperation, constrainedFreeSpace); 888 921 … … 1029 1062 auto& autoTrackStyles = isRowAxis ? style().gridAutoColumns() : style().gridAutoRows(); 1030 1063 unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint(); 1031 unsigned autoRepeatTracksCount = autoRepeatCountForDirection(direction);1064 unsigned autoRepeatTracksCount = m_grid.autoRepeatTracks(direction); 1032 1065 1033 1066 // We should not use GridPositionsResolver::explicitGridXXXCount() for this because the … … 1063 1096 { 1064 1097 // 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)) 1066 1099 return { Length(Fixed), LengthTrackSizing }; 1067 1100 … … 1256 1289 while (auto* gridItem = iterator.nextGridItem()) { 1257 1290 if (itemsSet.add(gridItem).isNewEntry) { 1258 GridSpan span = cachedGridSpan(*gridItem, direction);1291 const GridSpan& span = m_grid.gridItemSpan(*gridItem, direction); 1259 1292 if (span.integerSpan() == 1) 1260 1293 resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData); … … 1659 1692 unsigned insertionPoint = isRowAxis ? style().gridAutoRepeatColumnsInsertionPoint() : style().gridAutoRepeatRowsInsertionPoint(); 1660 1693 unsigned firstAutoRepeatTrack = insertionPoint + std::abs(m_grid.smallestTrackStart(direction)); 1661 unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + autoRepeatCountForDirection(direction);1694 unsigned lastAutoRepeatTrack = firstAutoRepeatTrack + m_grid.autoRepeatTracks(direction); 1662 1695 1663 1696 if (!m_grid.hasGridItems()) { … … 1683 1716 ASSERT(!m_grid.hasGridItems()); 1684 1717 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); 1687 1721 1688 1722 populateExplicitGridAndOrderIterator(); … … 1692 1726 Vector<RenderBox*> autoMajorAxisAutoGridItems; 1693 1727 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()) { 1695 1729 if (child->isOutOfFlowPositioned()) 1696 1730 continue; … … 1720 1754 #if ENABLE(ASSERT) 1721 1755 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))); 1724 1758 } 1725 1759 #endif … … 1729 1763 1730 1764 // 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)); 1733 1767 1734 1768 #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()) { 1736 1770 if (child->isOutOfFlowPositioned()) 1737 1771 continue; … … 1745 1779 void RenderGrid::populateExplicitGridAndOrderIterator() 1746 1780 { 1747 OrderIteratorPopulator populator(m_ orderIterator);1781 OrderIteratorPopulator populator(m_grid.orderIterator()); 1748 1782 int smallestRowStart = 0; 1749 1783 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); 1752 1788 1753 1789 for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) { … … 1757 1793 populator.collectChild(*child); 1758 1794 1759 GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, m_autoRepeatRows);1795 GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, autoRepeatRows); 1760 1796 if (!rowPositions.isIndefinite()) { 1761 1797 smallestRowStart = std::min(smallestRowStart, rowPositions.untranslatedStartLine()); … … 1767 1803 } 1768 1804 1769 GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, m_autoRepeatColumns);1805 GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, autoRepeatColumns); 1770 1806 if (!columnPositions.isIndefinite()) { 1771 1807 smallestColumnStart = std::min(smallestColumnStart, columnPositions.untranslatedStartLine()); … … 1787 1823 { 1788 1824 GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns; 1789 const unsigned endOfCrossDirection = crossDirection == ForColumns ? gridColumnCount() : gridRowCount();1825 const unsigned endOfCrossDirection = m_grid.numTracks(crossDirection); 1790 1826 unsigned crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, crossDirection); 1791 1827 GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endOfCrossDirection, endOfCrossDirection + crossDirectionSpanSize); … … 1804 1840 1805 1841 for (auto& autoGridItem : autoGridItems) { 1806 GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacementMajorAxisDirection());1842 GridSpan majorAxisPositions = m_grid.gridItemSpan(*autoGridItem, autoPlacementMajorAxisDirection()); 1807 1843 ASSERT(majorAxisPositions.isTranslatedDefinite()); 1808 ASSERT( cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite());1844 ASSERT(m_grid.gridItemSpan(*autoGridItem, autoPlacementMinorAxisDirection()).isIndefinite()); 1809 1845 unsigned minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), *autoGridItem, autoPlacementMinorAxisDirection()); 1810 1846 unsigned majorAxisInitialPosition = majorAxisPositions.startLine(); … … 1839 1875 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox& gridItem, AutoPlacementCursor& autoPlacementCursor) 1840 1876 { 1841 ASSERT( cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite());1877 ASSERT(m_grid.gridItemSpan(gridItem, autoPlacementMajorAxisDirection()).isIndefinite()); 1842 1878 unsigned majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(style(), gridItem, autoPlacementMajorAxisDirection()); 1843 1879 1844 const unsigned endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColumns) ? gridColumnCount() : gridRowCount();1880 const unsigned endOfMajorAxis = m_grid.numTracks(autoPlacementMajorAxisDirection()); 1845 1881 unsigned majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.second : autoPlacementCursor.first; 1846 1882 unsigned minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == ForColumns ? autoPlacementCursor.first : autoPlacementCursor.second; 1847 1883 1848 1884 std::unique_ptr<GridArea> emptyGridArea; 1849 GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxisDirection());1885 GridSpan minorAxisPositions = m_grid.gridItemSpan(gridItem, autoPlacementMinorAxisDirection()); 1850 1886 if (minorAxisPositions.isTranslatedDefinite()) { 1851 1887 // Move to the next track in major axis if initial position in minor axis is before auto-placement cursor. … … 1870 1906 // Check that it fits in the minor axis direction, as we shouldn't grow in that direction here (it was already managed in populateExplicitGridAndOrderIterator()). 1871 1907 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()); 1873 1909 if (minorAxisFinalPositionIndex <= endOfMinorAxis) 1874 1910 break; … … 1919 1955 return tracks; 1920 1956 1921 bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);1957 bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction); 1922 1958 LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit(); 1923 1959 tracks.reserveCapacity(numPositions - 1); … … 1929 1965 return tracks; 1930 1966 1931 size_t remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();1967 size_t remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size(); 1932 1968 size_t lastLine = tracks.size(); 1933 1969 gap = gridGapForDirection(direction); 1934 1970 for (size_t i = 1; i < lastLine; ++i) { 1935 if ( isEmptyAutoRepeatTrack(direction, i - 1))1971 if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) 1936 1972 --remainingEmptyTracks; 1937 1973 else { … … 1939 1975 // arbitrary number of empty tracks between two non empty ones. 1940 1976 bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i); 1941 if (!allRemainingTracksAreEmpty || ! isEmptyAutoRepeatTrack(direction, i))1977 if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i)) 1942 1978 tracks[i - 1] -= gap; 1943 1979 } … … 2074 2110 bool isRowAxis = direction == ForColumns; 2075 2111 2076 unsigned autoRepeatCount = autoRepeatCountForDirection(direction);2112 unsigned autoRepeatCount = m_grid.autoRepeatTracks(direction); 2077 2113 GridSpan positions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), child, direction, autoRepeatCount); 2078 2114 if (positions.isIndefinite()) { … … 2148 2184 } 2149 2185 2150 GridSpan RenderGrid::cachedGridSpan(const RenderBox& gridItem, GridTrackSizingDirection direction) const2151 {2152 GridArea area = m_grid.gridItemArea(gridItem);2153 return direction == ForColumns ? area.columns : area.rows;2154 }2155 2156 2186 LayoutUnit RenderGrid::assumedRowsSizeForOrthogonalChild(const RenderBox& child, SizingOperation sizingOperation) const 2157 2187 { 2158 2188 ASSERT(isOrthogonalChild(child)); 2159 const GridSpan& span = cachedGridSpan(child, ForRows);2189 const GridSpan& span = m_grid.gridItemSpan(child, ForRows); 2160 2190 LayoutUnit gridAreaSize; 2161 2191 bool gridAreaIsIndefinite = false; … … 2183 2213 2184 2214 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); 2186 2216 LayoutUnit gridAreaBreadth = 0; 2187 2217 for (auto trackPosition : span) … … 2198 2228 // may have some influence in the final grid area breadth. 2199 2229 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); 2201 2231 const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions; 2202 2232 … … 2231 2261 // If we have collapsed tracks we just ignore gaps here and add them later as we might not 2232 2262 // compute the gap between two consecutive tracks without examining the surrounding ones. 2233 bool hasCollapsedTracks = hasAutoRepeatEmptyTracks(direction);2263 bool hasCollapsedTracks = m_grid.hasAutoRepeatEmptyTracks(direction); 2234 2264 LayoutUnit gap = !hasCollapsedTracks ? gridGapForDirection(direction) : LayoutUnit(); 2235 2265 unsigned nextToLastLine = numberOfLines - 2; … … 2242 2272 if (hasCollapsedTracks) { 2243 2273 gap = gridGapForDirection(direction); 2244 unsigned remainingEmptyTracks = isRowAxis ? m_autoRepeatEmptyColumns->size() : m_autoRepeatEmptyRows->size();2274 unsigned remainingEmptyTracks = m_grid.autoRepeatEmptyTracks(direction)->size(); 2245 2275 LayoutUnit gapAccumulator; 2246 2276 for (unsigned i = 1; i < lastLine; ++i) { 2247 if ( isEmptyAutoRepeatTrack(direction, i - 1))2277 if (m_grid.isEmptyAutoRepeatTrack(direction, i - 1)) 2248 2278 --remainingEmptyTracks; 2249 2279 else { … … 2251 2281 // arbitrary number of empty tracks between two non empty ones. 2252 2282 bool allRemainingTracksAreEmpty = remainingEmptyTracks == (lastLine - i); 2253 if (!allRemainingTracksAreEmpty || ! isEmptyAutoRepeatTrack(direction, i))2283 if (!allRemainingTracksAreEmpty || !m_grid.isEmptyAutoRepeatTrack(direction, i)) 2254 2284 gapAccumulator += gap; 2255 2285 } … … 2547 2577 LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const 2548 2578 { 2549 const GridSpan& rowsSpan = cachedGridSpan(child, ForRows);2579 const GridSpan& rowsSpan = m_grid.gridItemSpan(child, ForRows); 2550 2580 unsigned childStartLine = rowsSpan.startLine(); 2551 2581 LayoutUnit startOfRow = m_rowPositions[childStartLine]; … … 2580 2610 LayoutUnit RenderGrid::rowAxisOffsetForChild(const RenderBox& child) const 2581 2611 { 2582 const GridSpan& columnsSpan = cachedGridSpan(child, ForColumns);2612 const GridSpan& columnsSpan = m_grid.gridItemSpan(child, ForColumns); 2583 2613 unsigned childStartLine = columnsSpan.startLine(); 2584 2614 LayoutUnit startOfColumn = m_columnPositions[childStartLine]; … … 2745 2775 // not stored in m_grid). 2746 2776 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)); 2750 2781 } 2751 2782 2752 2783 void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect) 2753 2784 { 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()) 2755 2786 paintChild(*child, paintInfo, paintOffset, forChild, usePrintRect, PaintAsInlineBlock); 2756 2787 } -
trunk/Source/WebCore/rendering/RenderGrid.h
r208995 r209180 71 71 const Vector<LayoutUnit>& rowPositions() const { return m_rowPositions; } 72 72 73 size_t autoRepeatCountForDirection(GridTrackSizingDirection) const;73 unsigned autoRepeatCountForDirection(GridTrackSizingDirection direction) const { return m_grid.autoRepeatTracks(direction); } 74 74 75 75 private: … … 93 93 typedef ListHashSet<size_t> OrderedTrackIndexSet; 94 94 std::unique_ptr<OrderedTrackIndexSet> computeEmptyTracksForAutoRepeat(GridTrackSizingDirection) const; 95 96 bool hasAutoRepeatEmptyTracks(GridTrackSizingDirection) const;97 bool isEmptyAutoRepeatTrack(GridTrackSizingDirection, unsigned track) const;98 95 99 96 void placeItemsOnGrid(SizingOperation); … … 188 185 bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&, GridTrackSizingDirection, SizingOperation) const; 189 186 190 // FIXME: Look for better names once the refactoring is complete.191 unsigned gridColumnCount() const;192 unsigned gridRowCount() const;193 187 unsigned numTracks(GridTrackSizingDirection) const; 194 188 … … 202 196 class Grid final { 203 197 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; 208 201 209 202 void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize); … … 221 214 void setGridItemArea(const RenderBox& item, GridArea); 222 215 216 GridSpan gridItemSpan(const RenderBox&, GridTrackSizingDirection) const; 217 223 218 const GridCell& cell(unsigned row, unsigned column) const { return m_grid[row][column]; } 224 219 225 220 int smallestTrackStart(GridTrackSizingDirection) const; 226 221 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 227 237 void shrinkToFit() { m_grid.shrinkToFit(); } 228 238 … … 232 242 friend class GridIterator; 233 243 244 OrderIterator m_orderIterator; 245 234 246 int m_smallestColumnStart { 0 }; 235 247 int m_smallestRowStart { 0 }; 236 248 249 unsigned m_autoRepeatColumns { 0 }; 250 unsigned m_autoRepeatRows { 0 }; 251 237 252 bool m_hasAnyOrthogonalGridItem { false }; 238 253 … … 241 256 HashMap<const RenderBox*, GridArea> m_gridItemArea; 242 257 HashMap<const RenderBox*, size_t> m_gridItemsIndexesMap; 258 259 std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns; 260 std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows; 243 261 }; 244 262 Grid m_grid; … … 248 266 LayoutUnit m_offsetBetweenColumns; 249 267 LayoutUnit m_offsetBetweenRows; 250 OrderIterator m_orderIterator;251 268 252 269 std::optional<LayoutUnit> m_minContentHeight; 253 270 std::optional<LayoutUnit> m_maxContentHeight; 254 271 255 unsigned m_autoRepeatColumns { 0 };256 unsigned m_autoRepeatRows { 0 };257 258 272 bool m_gridIsDirty { true }; 259 260 std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyColumns { nullptr };261 std::unique_ptr<OrderedTrackIndexSet> m_autoRepeatEmptyRows { nullptr };262 273 }; 263 274 264 size_t inline RenderGrid::autoRepeatCountForDirection(GridTrackSizingDirection direction) const265 {266 return direction == ForColumns ? m_autoRepeatColumns : m_autoRepeatRows;267 }268 269 275 } // namespace WebCore 270 276
Note: See TracChangeset
for help on using the changeset viewer.