Changeset 179824 in webkit


Ignore:
Timestamp:
Feb 9, 2015 3:34:11 AM (9 years ago)
Author:
svillar@igalia.com
Message:

[CSS Grid Layout] Tracks' growth limits must be >= base sizes
​https://bugs.webkit.org/show_bug.cgi?id=140540

Reviewed by Antti Koivisto.

Source/WebCore:

The track sizing algorithm is supposed to avoid those situations
but they easily (specially when we mix absolute lengths and
intrinsic lengths in min and max track sizing functions) and
frequently appear. In those cases the outcome from the algorithm
is wrong, tracks are not correctly sized.

In order to fulfill the restriction, m_usedBreadth and
m_maxBreadth are now private members of GridTrack and the class
now provides a couple of methods to modify them respecting the
growthLimit >= baseSize precondition.

Apart from that, the members and methods of GridTrack were also
renamed to match the ones used in the recent algorithm rewrite:
usedBreadth became baseSize and maxBreadth is now growthLimit.

Although the algorithm was not modified at all, this change
detected and fixed several invalid results (tracks and/or grids
bigger than expected).

  • rendering/RenderGrid.cpp:

(WebCore::GridTrack::GridTrack): Renamed fields and methods. Added
assertions.
(WebCore::GridTrack::baseSize): Renamed from usedBreadth.
(WebCore::GridTrack::growthLimit): Renamed from maxBreadth.
(WebCore::GridTrack::setBaseSize):
(WebCore::GridTrack::setGrowthLimit):
(WebCore::GridTrack::growBaseSize): Renamed from growUsedBreadth.
(WebCore::GridTrack::growGrowthLimit): Renamed from growMaxBreadth.
(WebCore::GridTrack::growthLimitIsInfinite): New helper method.
(WebCore::GridTrack::growthLimitIfNotInfinite): Renamed from
maxBreadthIfNotInfinite.
(WebCore::GridTrack::isGrowthLimitBiggerThanBaseSize): New helper
method to verify ASSERTs are true.
(WebCore::GridTrack::ensureGrowthLimitIsBiggerThanBaseSize): Ditto.
(WebCore::GridTrackForNormalization::GridTrackForNormalization):
(WebCore::RenderGrid::computeIntrinsicLogicalWidths):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::computeNormalizedFractionBreadth):
(WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
(WebCore::sortByGridTrackGrowthPotential):
(WebCore::RenderGrid::distributeSpaceToTracks):
(WebCore::RenderGrid::tracksAreWiderThanMinTrackBreadth):
(WebCore::RenderGrid::layoutGridItems):
(WebCore::RenderGrid::gridAreaBreadthForChild):
(WebCore::RenderGrid::populateGridPositions):
(WebCore::GridTrack::growUsedBreadth): Renamed to growBaseSize.
(WebCore::GridTrack::usedBreadth): Renamed to baseSize.
(WebCore::GridTrack::growMaxBreadth): Renamed to growGrowthLimit.
(WebCore::GridTrack::maxBreadthIfNotInfinite): Renamed to
growthLimitIfNotInfinite.

  • rendering/RenderGrid.h:

LayoutTests:

  • fast/css-grid-layout/grid-content-sized-columns-resolution-expected.txt:
  • fast/css-grid-layout/grid-content-sized-columns-resolution.html:
Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r179822 r179824  
     12015-01-22  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [CSS Grid Layout] Tracks' growth limits must be >= base sizes
     4        https://bugs.webkit.org/show_bug.cgi?id=140540
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * fast/css-grid-layout/grid-content-sized-columns-resolution-expected.txt:
     9        * fast/css-grid-layout/grid-content-sized-columns-resolution.html:
     10
    1112015-02-09  Gyuyoung Kim  <gyuyoung.kim@samsung.com>
    212

  • trunk/LayoutTests/fast/css-grid-layout/grid-content-sized-columns-resolution-expected.txt

    r178893 r179824  
    2929PASS window.getComputedStyle(gridMinContentFixedAndAutoUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "15px 90px"
    3030PASS window.getComputedStyle(gridAutoAndAutoUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "30px 60px"
    31 PASS window.getComputedStyle(gridMinContentAndMinContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "10px 40px"
     31PASS window.getComputedStyle(gridMinContentAndMinContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "0px 40px"
    3232PASS window.getComputedStyle(gridMaxContentAndMinContentUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "0px 70px"
    3333PASS window.getComputedStyle(gridFixedMinContentAndMaxContentUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "10px 70px"
    3434PASS window.getComputedStyle(gridFixedMaxContentAndMinContentUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "50px 40px"
    35 PASS window.getComputedStyle(gridMinContentAndMaxContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "10px 90px"
     35PASS window.getComputedStyle(gridMinContentAndMaxContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "0px 90px"
    3636PASS window.getComputedStyle(gridMaxContentFixedAndAutoUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "15px 70px"
    3737PASS window.getComputedStyle(gridAutoMinContentUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "50px 60px"
    3838PASS window.getComputedStyle(gridAutoMaxContentUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "0px 90px"
    39 PASS window.getComputedStyle(gridMaxContentAndMinContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "55px 40px"
    40 PASS window.getComputedStyle(gridMaxContentAndMaxContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "75px 70px"
     39PASS window.getComputedStyle(gridMaxContentAndMinContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "50px 40px"
     40PASS window.getComputedStyle(gridMaxContentAndMaxContentFixedUnsorted, '').getPropertyValue('-webkit-grid-template-columns') is "40px 70px"
    4141PASS window.getComputedStyle(gridMinContentFixedAndAutoAboveLimits, '').getPropertyValue('-webkit-grid-template-columns') is "15px 95px"
    4242PASS window.getComputedStyle(gridMaxContentFixedAndAutoAboveLimits, '').getPropertyValue('-webkit-grid-template-columns') is "65px 85px"
    4343PASS window.getComputedStyle(gridMinContentFixedAndFixedFixedAndAuto, '').getPropertyValue('-webkit-grid-template-columns') is "20px 20px 60px"
    44 PASS window.getComputedStyle(gridAutoAndFixedFixedAndMaxContentFixed, '').getPropertyValue('-webkit-grid-template-columns') is "40px 20px 90px"
     44PASS window.getComputedStyle(gridAutoAndFixedFixedAndMaxContentFixed, '').getPropertyValue('-webkit-grid-template-columns') is "70px 20px 60px"
    4545PASS successfullyParsed is true
    4646

  • trunk/LayoutTests/fast/css-grid-layout/grid-content-sized-columns-resolution.html

    r178893 r179824  
    333333testGridColumnsValues("gridMinContentFixedAndAutoUnsorted", "15px 90px");
    334334testGridColumnsValues("gridAutoAndAutoUnsorted", "30px 60px");
    335 testGridColumnsValues("gridMinContentAndMinContentFixedUnsorted", "10px 40px");
     335testGridColumnsValues("gridMinContentAndMinContentFixedUnsorted", "0px 40px");
    336336testGridColumnsValues("gridMaxContentAndMinContentUnsorted", "0px 70px");
    337337testGridColumnsValues("gridFixedMinContentAndMaxContentUnsorted", "10px 70px");
    338338testGridColumnsValues("gridFixedMaxContentAndMinContentUnsorted", "50px 40px");
    339 testGridColumnsValues("gridMinContentAndMaxContentFixedUnsorted", "10px 90px");
     339testGridColumnsValues("gridMinContentAndMaxContentFixedUnsorted", "0px 90px");
    340340testGridColumnsValues("gridMaxContentFixedAndAutoUnsorted", "15px 70px");
    341341testGridColumnsValues("gridAutoMinContentUnsorted", "50px 60px");
    342342testGridColumnsValues("gridAutoMaxContentUnsorted", "0px 90px");
    343 testGridColumnsValues("gridMaxContentAndMinContentFixedUnsorted", "55px 40px");
    344 testGridColumnsValues("gridMaxContentAndMaxContentFixedUnsorted", "75px 70px");
     343testGridColumnsValues("gridMaxContentAndMinContentFixedUnsorted", "50px 40px");
     344testGridColumnsValues("gridMaxContentAndMaxContentFixedUnsorted", "40px 70px");
    345345
    346346testGridColumnsValues("gridMinContentFixedAndAutoAboveLimits", "15px 95px");
    347347testGridColumnsValues("gridMaxContentFixedAndAutoAboveLimits", "65px 85px");
    348348testGridColumnsValues("gridMinContentFixedAndFixedFixedAndAuto", "20px 20px 60px");
    349 testGridColumnsValues("gridAutoAndFixedFixedAndMaxContentFixed", "40px 20px 90px");
     349testGridColumnsValues("gridAutoAndFixedFixedAndMaxContentFixed", "70px 20px 60px");
    350350</script>
    351351</body>

  • trunk/Source/WebCore/ChangeLog

    r179820 r179824  
     12015-01-22  Sergio Villar Senin  <svillar@igalia.com>
     2
     3        [CSS Grid Layout] Tracks' growth limits must be >= base sizes
     4        https://bugs.webkit.org/show_bug.cgi?id=140540
     5
     6        Reviewed by Antti Koivisto.
     7
     8        The track sizing algorithm is supposed to avoid those situations
     9        but they easily (specially when we mix absolute lengths and
     10        intrinsic lengths in min and max track sizing functions) and
     11        frequently appear. In those cases the outcome from the algorithm
     12        is wrong, tracks are not correctly sized.
     13
     14        In order to fulfill the restriction, m_usedBreadth and
     15        m_maxBreadth are now private members of GridTrack and the class
     16        now provides a couple of methods to modify them respecting the
     17        growthLimit >= baseSize precondition.
     18
     19        Apart from that, the members and methods of GridTrack were also
     20        renamed to match the ones used in the recent algorithm rewrite:
     21        usedBreadth became baseSize and maxBreadth is now growthLimit.
     22
     23        Although the algorithm was not modified at all, this change
     24        detected and fixed several invalid results (tracks and/or grids
     25        bigger than expected).
     26
     27        * rendering/RenderGrid.cpp:
     28        (WebCore::GridTrack::GridTrack): Renamed fields and methods. Added
     29        assertions.
     30        (WebCore::GridTrack::baseSize): Renamed from usedBreadth.
     31        (WebCore::GridTrack::growthLimit): Renamed from maxBreadth.
     32        (WebCore::GridTrack::setBaseSize):
     33        (WebCore::GridTrack::setGrowthLimit):
     34        (WebCore::GridTrack::growBaseSize): Renamed from growUsedBreadth.
     35        (WebCore::GridTrack::growGrowthLimit): Renamed from growMaxBreadth.
     36        (WebCore::GridTrack::growthLimitIsInfinite): New helper method.
     37        (WebCore::GridTrack::growthLimitIfNotInfinite): Renamed from
     38        maxBreadthIfNotInfinite.
     39        (WebCore::GridTrack::isGrowthLimitBiggerThanBaseSize): New helper
     40        method to verify ASSERTs are true.
     41        (WebCore::GridTrack::ensureGrowthLimitIsBiggerThanBaseSize): Ditto.
     42        (WebCore::GridTrackForNormalization::GridTrackForNormalization):
     43        (WebCore::RenderGrid::computeIntrinsicLogicalWidths):
     44        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     45        (WebCore::RenderGrid::computeNormalizedFractionBreadth):
     46        (WebCore::RenderGrid::resolveContentBasedTrackSizingFunctions):
     47        (WebCore::sortByGridTrackGrowthPotential):
     48        (WebCore::RenderGrid::distributeSpaceToTracks):
     49        (WebCore::RenderGrid::tracksAreWiderThanMinTrackBreadth):
     50        (WebCore::RenderGrid::layoutGridItems):
     51        (WebCore::RenderGrid::gridAreaBreadthForChild):
     52        (WebCore::RenderGrid::populateGridPositions):
     53        (WebCore::GridTrack::growUsedBreadth): Renamed to growBaseSize.
     54        (WebCore::GridTrack::usedBreadth): Renamed to baseSize.
     55        (WebCore::GridTrack::growMaxBreadth): Renamed to growGrowthLimit.
     56        (WebCore::GridTrack::maxBreadthIfNotInfinite): Renamed to
     57        growthLimitIfNotInfinite.
     58        * rendering/RenderGrid.h:
     59
    1602015-02-08  Chris Fleizach  <cfleizach@apple.com>
    261

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

    r178895 r179824  
    4343class GridTrack {
    4444public:
    45     GridTrack()
    46         : m_usedBreadth(0)
    47         , m_maxBreadth(0)
    48     {
    49     }
    50 
    51     void growUsedBreadth(LayoutUnit growth)
     45    GridTrack() {}
     46
     47    const LayoutUnit& baseSize() const
     48    {
     49        ASSERT(isGrowthLimitBiggerThanBaseSize());
     50        return m_baseSize;
     51    }
     52
     53    const LayoutUnit& growthLimit() const
     54    {
     55        ASSERT(isGrowthLimitBiggerThanBaseSize());
     56        return m_growthLimit;
     57    }
     58
     59    void setBaseSize(LayoutUnit baseSize)
     60    {
     61        m_baseSize = baseSize;
     62        ensureGrowthLimitIsBiggerThanBaseSize();
     63    }
     64
     65    void setGrowthLimit(LayoutUnit growthLimit)
     66    {
     67        m_growthLimit = growthLimit;
     68        ensureGrowthLimitIsBiggerThanBaseSize();
     69    }
     70
     71    void growBaseSize(LayoutUnit growth)
    5272    {
    5373        ASSERT(growth >= 0);
    54         m_usedBreadth += growth;
    55     }
    56     LayoutUnit usedBreadth() const { return m_usedBreadth; }
    57 
    58     void growMaxBreadth(LayoutUnit growth)
    59     {
    60         if (m_maxBreadth == infinity)
    61             m_maxBreadth = m_usedBreadth + growth;
     74        m_baseSize += growth;
     75        ensureGrowthLimitIsBiggerThanBaseSize();
     76    }
     77
     78    void growGrowthLimit(LayoutUnit growth)
     79    {
     80        ASSERT(growth >= 0);
     81        if (m_growthLimit == infinity)
     82            m_growthLimit = m_baseSize + growth;
    6283        else
    63             m_maxBreadth += growth;
    64     }
    65     LayoutUnit maxBreadthIfNotInfinite() const
    66     {
    67         return (m_maxBreadth == infinity) ? m_usedBreadth : m_maxBreadth;
    68     }
    69 
    70     LayoutUnit m_usedBreadth;
    71     LayoutUnit m_maxBreadth;
     84            m_growthLimit += growth;
     85
     86        ASSERT(m_growthLimit >= m_baseSize);
     87    }
     88
     89    bool growthLimitIsInfinite() const
     90    {
     91        return m_growthLimit == infinity;
     92    }
     93
     94    const LayoutUnit& growthLimitIfNotInfinite() const
     95    {
     96        ASSERT(isGrowthLimitBiggerThanBaseSize());
     97        return (m_growthLimit == infinity) ? m_baseSize : m_growthLimit;
     98    }
     99
     100private:
     101    bool isGrowthLimitBiggerThanBaseSize() const { return growthLimitIsInfinite() || m_growthLimit >= m_baseSize; }
     102
     103    void ensureGrowthLimitIsBiggerThanBaseSize()
     104    {
     105        if (m_growthLimit != infinity && m_growthLimit < m_baseSize)
     106            m_growthLimit = m_baseSize;
     107    }
     108
     109    LayoutUnit m_baseSize { 0 };
     110    LayoutUnit m_growthLimit { 0 };
    72111};
    73112
    … …  
    76115        : m_track(&track)
    77116        , m_flex(flex)
    78         , m_normalizedFlexValue(track.m_usedBreadth / flex)
     117        , m_normalizedFlexValue(track.baseSize() / flex)
    79118    {
    80119    }
    … …  
    253292
    254293    for (auto& column : sizingData.columnTracks) {
    255         LayoutUnit minTrackBreadth = column.m_usedBreadth;
    256         LayoutUnit maxTrackBreadth = column.m_maxBreadth;
    257         maxTrackBreadth = std::max(maxTrackBreadth, minTrackBreadth);
     294        LayoutUnit minTrackBreadth = column.baseSize();
     295        LayoutUnit maxTrackBreadth = column.growthLimit();
    258296
    259297        minLogicalWidth += minTrackBreadth;
    … …  
    311349        const GridLength& maxTrackBreadth = trackSize.maxTrackBreadth();
    312350
    313         track.m_usedBreadth = computeUsedBreadthOfMinLength(direction, minTrackBreadth);
    314         track.m_maxBreadth = computeUsedBreadthOfMaxLength(direction, maxTrackBreadth, track.m_usedBreadth);
    315 
    316         if (track.m_maxBreadth != infinity)
    317             track.m_maxBreadth = std::max(track.m_maxBreadth, track.m_usedBreadth);
     351        track.setBaseSize(computeUsedBreadthOfMinLength(direction, minTrackBreadth));
     352        track.setGrowthLimit(computeUsedBreadthOfMaxLength(direction, maxTrackBreadth, track.baseSize()));
    318353
    319354        if (trackSize.isContentSized())
    … …  
    328363
    329364    for (auto& track : tracks) {
    330         ASSERT(track.m_maxBreadth != infinity);
    331         availableLogicalSpace -= track.m_usedBreadth;
     365        ASSERT(!track.growthLimitIsInfinite());
     366        availableLogicalSpace -= track.baseSize();
    332367    }
    333368
    … …  
    344379            tracksForDistribution[i] = tracks.data() + i;
    345380
    346         distributeSpaceToTracks(tracksForDistribution, 0, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth, sizingData, availableLogicalSpace);
     381        distributeSpaceToTracks(tracksForDistribution, nullptr, &GridTrack::baseSize, &GridTrack::growBaseSize, sizingData, availableLogicalSpace);
    347382    } else {
    348383        for (auto& track : tracks)
    349             track.m_usedBreadth = std::max(track.m_usedBreadth, track.m_maxBreadth);
     384            track.setBaseSize(track.growthLimit());
    350385    }
    351386
    … …  
    360395        for (auto trackIndex : flexibleSizedTracksIndex) {
    361396            const GridTrackSize& trackSize = gridTrackSize(direction, trackIndex);
    362             normalizedFractionBreadth = std::max(normalizedFractionBreadth, tracks[trackIndex].m_usedBreadth / trackSize.maxTrackBreadth().flex());
     397            normalizedFractionBreadth = std::max(normalizedFractionBreadth, tracks[trackIndex].baseSize() / trackSize.maxTrackBreadth().flex());
    363398        }
    364399
    … …  
    382417        const GridTrackSize& trackSize = gridTrackSize(direction, trackIndex);
    383418        GridTrack& track = tracks[trackIndex];
    384         track.m_usedBreadth = std::max<LayoutUnit>(track.m_usedBreadth, normalizedFractionBreadth * trackSize.maxTrackBreadth().flex());
     419        LayoutUnit baseSize = std::max<LayoutUnit>(track.baseSize(), normalizedFractionBreadth * trackSize.maxTrackBreadth().flex());
     420        track.setBaseSize(baseSize);
     421        availableLogicalSpace -= baseSize;
    385422    }
    386423}
    … …  
    429466    for (auto& position : tracksSpan) {
    430467        GridTrack& track = tracks[position.toInt()];
    431         allocatedSpace += track.m_usedBreadth;
     468        allocatedSpace += track.baseSize();
    432469
    433470        const GridTrackSize& trackSize = gridTrackSize(direction, position.toInt());
    … …  
    465502        accumulatedFractions += track.m_flex;
    466503        // This item was processed so we re-add its used breadth to the available space to accurately count the remaining space.
    467         availableLogicalSpaceIgnoringFractionTracks += track.m_track->m_usedBreadth;
     504        availableLogicalSpaceIgnoringFractionTracks += track.m_track->baseSize();
    468505    }
    469506
    … …  
    596633
    597634    for (auto& itemWithSpan : sizingData.itemsSortedByIncreasingSpan) {
    598         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth, &GridTrackSize::hasMinContentMinTrackBreadthAndMinOrMaxContentMaxTrackBreadth);
    599         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMinTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::usedBreadth, &GridTrack::growUsedBreadth, &GridTrackSize::hasMaxContentMinTrackBreadthAndMaxContentMaxTrackBreadth);
    600         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
    601         resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMaxTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::maxBreadthIfNotInfinite, &GridTrack::growMaxBreadth);
     635        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::baseSize, &GridTrack::growBaseSize, &GridTrackSize::hasMinContentMinTrackBreadthAndMinOrMaxContentMaxTrackBreadth);
     636        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMinTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::baseSize, &GridTrack::growBaseSize, &GridTrackSize::hasMaxContentMinTrackBreadthAndMaxContentMaxTrackBreadth);
     637        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &RenderGrid::minContentForChild, &GridTrack::growthLimitIfNotInfinite, &GridTrack::growGrowthLimit);
     638        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, itemWithSpan, &GridTrackSize::hasMaxContentMaxTrackBreadth, &RenderGrid::maxContentForChild, &GridTrack::growthLimitIfNotInfinite, &GridTrack::growGrowthLimit);
    602639    }
    603640
    604641    for (auto trackIndex : sizingData.contentSizedTracksIndex) {
    605642        GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
    606         if (track.m_maxBreadth == infinity)
    607             track.m_maxBreadth = track.m_usedBreadth;
     643        if (track.growthLimitIsInfinite())
     644            track.setGrowthLimit(track.baseSize());
    608645    }
    609646}
    … …  
    648685    // This check ensures that we respect the irreflexivity property of the strict weak ordering required by std::sort
    649686    // (forall x: NOT x < x).
    650     if (track1->m_maxBreadth == infinity && track2->m_maxBreadth == infinity)
     687    if (track1->growthLimitIsInfinite() && track2->growthLimitIsInfinite())
    651688        return false;
    652689
    653     if (track1->m_maxBreadth == infinity || track2->m_maxBreadth == infinity)
    654         return track2->m_maxBreadth == infinity;
    655 
    656     return (track1->m_maxBreadth - track1->m_usedBreadth) < (track2->m_maxBreadth - track2->m_usedBreadth);
     690    if (track1->growthLimitIsInfinite() || track2->growthLimitIsInfinite())
     691        return track2->growthLimitIsInfinite();
     692
     693    return (track1->growthLimit() - track1->baseSize()) < (track2->growthLimit() - track2->baseSize());
    657694}
    658695
    … …  
    667704    for (unsigned i = 0; i < tracksSize; ++i) {
    668705        GridTrack& track = *tracks[i];
    669         LayoutUnit trackBreadth = (tracks[i]->*trackGetter)();
    670         bool infiniteGrowthPotential = track.m_maxBreadth == infinity;
    671         LayoutUnit trackGrowthPotential = infiniteGrowthPotential ? track.m_maxBreadth : track.m_maxBreadth - trackBreadth;
     706        const LayoutUnit& trackBreadth = (tracks[i]->*trackGetter)();
     707        bool infiniteGrowthPotential = track.growthLimitIsInfinite();
     708        LayoutUnit trackGrowthPotential = infiniteGrowthPotential ? track.growthLimit() : track.growthLimit() - trackBreadth;
    672709        sizingData.distributeTrackVector[i] = trackBreadth;
    673710        // Let's avoid computing availableLogicalSpaceShare as much as possible as it's a hot spot in performance tests.
    … …  
    707744        const GridTrackSize& trackSize = gridTrackSize(direction, i);
    708745        const GridLength& minTrackBreadth = trackSize.minTrackBreadth();
    709         if (computeUsedBreadthOfMinLength(direction, minTrackBreadth) > tracks[i].m_usedBreadth)
     746        if (computeUsedBreadthOfMinLength(direction, minTrackBreadth) > tracks[i].baseSize())
    710747            return false;
    711748    }
    … …  
    959996
    960997    for (auto& row : sizingData.rowTracks)
    961         setLogicalHeight(logicalHeight() + row.m_usedBreadth);
     998        setLogicalHeight(logicalHeight() + row.baseSize());
    962999
    9631000    // min / max logical height is handled in updateLogicalHeight().
    … …  
    9781015    LayoutUnit gridAreaBreadth = 0;
    9791016    for (auto& trackPosition : span)
    980         gridAreaBreadth += tracks[trackPosition.toInt()].m_usedBreadth;
     1017        gridAreaBreadth += tracks[trackPosition.toInt()].baseSize();
    9811018    return gridAreaBreadth;
    9821019}
    … …  
    9871024    m_columnPositions[0] = borderAndPaddingStart();
    9881025    for (unsigned i = 0; i < m_columnPositions.size() - 1; ++i)
    989         m_columnPositions[i + 1] = m_columnPositions[i] + sizingData.columnTracks[i].m_usedBreadth;
     1026        m_columnPositions[i + 1] = m_columnPositions[i] + sizingData.columnTracks[i].baseSize();
    9901027
    9911028    m_rowPositions.resizeToFit(sizingData.rowTracks.size() + 1);
    9921029    m_rowPositions[0] = borderAndPaddingBefore();
    9931030    for (unsigned i = 0; i < m_rowPositions.size() - 1; ++i)
    994         m_rowPositions[i + 1] = m_rowPositions[i] + sizingData.rowTracks[i].m_usedBreadth;
     1031        m_rowPositions[i + 1] = m_rowPositions[i] + sizingData.rowTracks[i].baseSize();
    9951032}
    9961033

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

    r178895 r179824  
    8989
    9090    typedef LayoutUnit (RenderGrid::* SizingFunction)(RenderBox&, GridTrackSizingDirection, Vector<GridTrack>&);
    91     typedef LayoutUnit (GridTrack::* AccumulatorGetter)() const;
     91    typedef const LayoutUnit& (GridTrack::* AccumulatorGetter)() const;
    9292    typedef void (GridTrack::* AccumulatorGrowFunction)(LayoutUnit);
    9393    typedef bool (GridTrackSize::* FilterFunction)() const;
Note: See TracChangeset for help on using the changeset viewer.