Changeset 173620 in webkit


Ignore:
Timestamp:
Sep 15, 2014 7:20:46 AM (10 years ago)
Author:
svillar@igalia.com
Message:

[CSS Grid Layout] Sort items by span when resolving content-based track sizing functions
https://bugs.webkit.org/show_bug.cgi?id=135701

Reviewed by Darin Adler.

Source/WebCore:

Section 10.4 of the specs mentions that we should first treat non
spanning items and then incrementally proceed with items with
greater spans when resolving the track breaths in the Track Sizing
Algorithm.

As a nice side effect we're removing the multiple processing of
spanning grid items caused by GridIterator (it returns the same
item as many times as the number of cells it spans). This adds a
~4% performance penalty in auto-grid-lots-of-data.html mainly due
to the use of a hash to remove duplicates.

Test: fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution.html

  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::gridItemSpan):
(WebCore::gridItemWithSpanSorter):
(WebCore::uniquePointerInPair):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):

  • rendering/RenderGrid.h:

LayoutTests:

Tests that check that items are sorted by span to resolve content
based track sizing functions instead of directly using DOM order.

  • fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution-expected.txt: Added.
  • fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution.html: Added.
Location:
trunk
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r173615 r173620  
     12014-08-07  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [CSS Grid Layout] Sort items by span when resolving content-based track sizing functions
     4        https://bugs.webkit.org/show_bug.cgi?id=135701
     5
     6        Reviewed by Darin Adler.
     7
     8        Tests that check that items are sorted by span to resolve content
     9        based track sizing functions instead of directly using DOM order.
     10
     11        * fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution-expected.txt: Added.
     12        * fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution.html: Added.
     13
    1142014-09-12  Sergio Villar Senin  <svillar@igalia.com>
    215
  • trunk/Source/WebCore/ChangeLog

    r173619 r173620  
     12014-08-07  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [CSS Grid Layout] Sort items by span when resolving content-based track sizing functions
     4        https://bugs.webkit.org/show_bug.cgi?id=135701
     5
     6        Reviewed by Darin Adler.
     7
     8        Section 10.4 of the specs mentions that we should first treat non
     9        spanning items and then incrementally proceed with items with
     10        greater spans when resolving the track breaths in the Track Sizing
     11        Algorithm.
     12
     13        As a nice side effect we're removing the multiple processing of
     14        spanning grid items caused by GridIterator (it returns the same
     15        item as many times as the number of cells it spans). This adds a
     16        ~4% performance penalty in auto-grid-lots-of-data.html mainly due
     17        to the use of a hash to remove duplicates.
     18
     19        Test: fast/css-grid-layout/grid-item-order-in-content-sized-columns-resolution.html
     20
     21        * rendering/RenderGrid.cpp:
     22        (WebCore::RenderGrid::gridItemSpan):
     23        (WebCore::gridItemWithSpanSorter):
     24        (WebCore::uniquePointerInPair):
     25        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
     26        * rendering/RenderGrid.h:
     27
    1282014-09-15  Zan Dobersek  <zdobersek@igalia.com>
    229
  • trunk/Source/WebCore/rendering/RenderGrid.cpp

    r173427 r173620  
    532532}
    533533
     534class GridItemWithSpan {
     535public:
     536    GridItemWithSpan(RenderBox& gridItem, GridCoordinate coordinate, GridTrackSizingDirection direction)
     537        : m_gridItem(gridItem)
     538        , m_coordinate(coordinate)
     539    {
     540        const GridSpan& span = (direction == ForRows) ? coordinate.rows : coordinate.columns;
     541        m_span = span.resolvedFinalPosition.toInt() - span.resolvedInitialPosition.toInt() + 1;
     542    }
     543
     544    RenderBox& gridItem() const { return m_gridItem; }
     545    GridCoordinate coordinate() const { return m_coordinate; }
     546
     547    bool operator<(const GridItemWithSpan other) const
     548    {
     549        return m_span < other.m_span;
     550    }
     551
     552private:
     553    std::reference_wrapper<RenderBox> m_gridItem;
     554    GridCoordinate m_coordinate;
     555    size_t m_span;
     556};
     557
    534558void RenderGrid::resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection direction, GridSizingData& sizingData)
    535559{
     
    538562    for (size_t i = 0; i < sizingData.contentSizedTracksIndex.size(); ++i) {
    539563        GridIterator iterator(m_grid, direction, sizingData.contentSizedTracksIndex[i]);
     564        HashSet<RenderBox*> itemsSet;
     565        Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
     566
    540567        while (RenderBox* gridItem = iterator.nextGridItem()) {
    541             resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, *gridItem, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
    542             resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, *gridItem, &GridTrackSize::hasMaxContentMinTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
    543             resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, *gridItem, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
    544             resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, *gridItem, &GridTrackSize::hasMaxContentMaxTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
     568            if (itemsSet.add(gridItem).isNewEntry)
     569                itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, cachedGridCoordinate(*gridItem), direction));
     570        }
     571        std::stable_sort(itemsSortedByIncreasingSpan.begin(), itemsSortedByIncreasingSpan.end());
     572
     573        for (auto& itemWithSpan : itemsSortedByIncreasingSpan) {
     574            resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
     575            resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMinTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth);
     576            resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
     577            resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMaxTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
    545578        }
    546579
     
    551584}
    552585
    553 void RenderGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, RenderBox& gridItem, FilterFunction filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGetter, AccumulatorGrowFunction trackGrowthFunction)
    554 {
    555     const GridCoordinate coordinate = cachedGridCoordinate(gridItem);
     586void RenderGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, GridItemWithSpan& gridItemWithSpan, FilterFunction filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGetter, AccumulatorGrowFunction trackGrowthFunction)
     587{
     588    const GridCoordinate& coordinate = gridItemWithSpan.coordinate();
    556589    const GridResolvedPosition initialTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedInitialPosition : coordinate.rows.resolvedInitialPosition;
    557590    const GridResolvedPosition finalTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedFinalPosition : coordinate.rows.resolvedFinalPosition;
     
    570603        return;
    571604
    572     LayoutUnit additionalBreadthSpace = (this->*sizingFunction)(gridItem, direction, sizingData.columnTracks);
     605    LayoutUnit additionalBreadthSpace = (this->*sizingFunction)(gridItemWithSpan.gridItem(), direction, sizingData.columnTracks);
    573606    for (GridResolvedPosition trackPositionForSpace = initialTrackPosition; trackPositionForSpace <= finalTrackPosition; ++trackPositionForSpace) {
    574607        GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPositionForSpace.toInt()] : sizingData.rowTracks[trackPositionForSpace.toInt()];
  • trunk/Source/WebCore/rendering/RenderGrid.h

    r173427 r173620  
    3939class GridSpan;
    4040class GridTrack;
     41class GridItemWithSpan;
    4142
    4243class RenderGrid final : public RenderBlock {
     
    9192    typedef void (GridTrack::* AccumulatorGrowFunction)(LayoutUnit);
    9293    typedef bool (GridTrackSize::* FilterFunction)() const;
    93     void resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection, GridSizingData&, RenderBox&, FilterFunction, SizingFunction, AccumulatorGetter, AccumulatorGrowFunction);
     94    void resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection, GridSizingData&, GridItemWithSpan&, FilterFunction, SizingFunction, AccumulatorGetter, AccumulatorGrowFunction);
    9495    void distributeSpaceToTracks(Vector<GridTrack*>&, Vector<GridTrack*>* tracksForGrowthAboveMaxBreadth, AccumulatorGetter, AccumulatorGrowFunction, GridSizingData&, LayoutUnit& availableLogicalSpace);
    9596
Note: See TracChangeset for help on using the changeset viewer.