[CSS Grid Layout] Support marking tracks as infinitely growable

Source/core/layout/LayoutGrid.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 23 matching lines @@
 #include "core/paint/GridPainter.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 static const int infinity = -1;
 
 class GridTrack {
 public:
     GridTrack()
-        : m_plannedIncrease(0)
-        , m_increaseDuringDistribution(0)
-        , m_baseSize(0)
+        : m_baseSize(0)
         , m_growthLimit(0)
+        , m_plannedSize(0)
+        , m_sizeDuringDistribution(0)
+        , m_infinitelyGrowable(false)
     {
     }
 
     const LayoutUnit& baseSize() const
     {
         ASSERT(isGrowthLimitBiggerThanBaseSize());
         return m_baseSize;
     }
 
     const LayoutUnit& growthLimit() const
     {
         ASSERT(isGrowthLimitBiggerThanBaseSize());
         return m_growthLimit;
     }
 
     void setBaseSize(LayoutUnit baseSize)
     {
         m_baseSize = baseSize;
         ensureGrowthLimitIsBiggerThanBaseSize();
     }
 
     void setGrowthLimit(LayoutUnit growthLimit)
     {
         m_growthLimit = growthLimit;
         ensureGrowthLimitIsBiggerThanBaseSize();
     }
 
-    void growBaseSize(LayoutUnit growth)
-    {
-        ASSERT(growth >= 0);
-        m_baseSize += growth;
-        ensureGrowthLimitIsBiggerThanBaseSize();
-    }
-
-    void growGrowthLimit(LayoutUnit growth)
-    {
-        ASSERT(growth >= 0);
-        if (m_growthLimit == infinity)
-            m_growthLimit = m_baseSize + growth;
-        else
-            m_growthLimit += growth;
-
-        ASSERT(m_growthLimit >= m_baseSize);
-    }
-
     bool growthLimitIsInfinite() const
     {
         return m_growthLimit == infinity;
     }
 
+    bool growthLimitIsInfiniteOrTrackIsInfinitelyGrowable() const
+    {
+        return growthLimitIsInfinite() || m_infinitelyGrowable;
+    }
+
     const LayoutUnit& growthLimitIfNotInfinite() const
     {
         ASSERT(isGrowthLimitBiggerThanBaseSize());
         return (m_growthLimit == infinity) ? m_baseSize : m_growthLimit;
     }
 
-    LayoutUnit m_plannedIncrease;
-    LayoutUnit m_increaseDuringDistribution;
+    const LayoutUnit& plannedSize() const { return m_plannedSize; }
+
+    void setPlannedSize(const LayoutUnit& plannedSize)
+    {
+        ASSERT(plannedSize >= 0 || plannedSize == infinity);
+        m_plannedSize = plannedSize;

[Julien - ping for review, 2015/04/08 18:58:56]

It seems weird to allow the plannedSize to be infinite. We don't allow that for
the baseSize and we may copy plannedSize into baseSize.

[svillar, 2015/04/10 09:43:09]

In theory that's true, although not possible with the current code I agree that
we're somehow not enforcing the restriction you mention.

+    }
+
+    const LayoutUnit& sizeDuringDistribution() { return m_sizeDuringDistribution; }
+
+    void setSizeDuringDistribution(const LayoutUnit& sizeDuringDistribution)
+    {
+        ASSERT(sizeDuringDistribution >= 0);
+        m_sizeDuringDistribution = sizeDuringDistribution;
+    }
+
+    void growSizeDuringDistribution(const LayoutUnit& sizeDuringDistribution)
+    {
+        ASSERT(sizeDuringDistribution >= 0);
+        m_sizeDuringDistribution += sizeDuringDistribution;
+    }
+
+    bool infinitelyGrowable() const { return m_infinitelyGrowable; }
+    void setInfinitelyGrowable(bool infinitelyGrowable) { m_infinitelyGrowable = infinitelyGrowable; }
 
 private:
     bool isGrowthLimitBiggerThanBaseSize() const { return growthLimitIsInfinite() || m_growthLimit >= m_baseSize; }
 
     void ensureGrowthLimitIsBiggerThanBaseSize()
     {
         if (m_growthLimit != infinity && m_growthLimit < m_baseSize)
             m_growthLimit = m_baseSize;
     }
 
     LayoutUnit m_baseSize;
     LayoutUnit m_growthLimit;
+    LayoutUnit m_plannedSize;
+    LayoutUnit m_sizeDuringDistribution;
+    bool m_infinitelyGrowable;

[Julien - ping for review, 2015/04/08 18:58:56]

We are storing one extra member compared to the specification
(m_sizeDuringDistribution doesn't exist), which will add differences in the
algorithm.

Also related is the fact that 'infinitely growable' is either plannedSize or
growthLimit being infinite.

[svillar, 2015/04/10 09:43:09]

It does exist in the original algorithm, it's called TempBreadth. I changed that
to m_sizeDuringDistribution because you requested it.

In the new algorithm there is no mention to that but it's just because the new
version is descriptive while the previous one it was pseudocode. In any case it
mentions that we need to "Mark any tracks whose growth limit changed from
infinite to finite in this step" which means that we have to store the previous
size in order to compare to the new one. I don't mind if we call it plannedSize
or whatever but we need to store that information anyway.

 };
 
 struct GridTrackForNormalization {
     GridTrackForNormalization(const GridTrack& track, double flex)
         : m_track(&track)
         , m_flex(flex)
         , m_normalizedFlexValue(track.baseSize() / flex)
     {
     }
 
@@ skipping 278 matching lines @@
 
     // 1. Initialize per Grid track variables.
     for (size_t i = 0; i < tracks.size(); ++i) {
         GridTrack& track = tracks[i];
         GridTrackSize trackSize = gridTrackSize(direction, i);
         const GridLength& minTrackBreadth = trackSize.minTrackBreadth();
         const GridLength& maxTrackBreadth = trackSize.maxTrackBreadth();
 
         track.setBaseSize(computeUsedBreadthOfMinLength(direction, minTrackBreadth));
         track.setGrowthLimit(computeUsedBreadthOfMaxLength(direction, maxTrackBreadth, track.baseSize()));
+        track.setInfinitelyGrowable(false);
 
         if (trackSize.isContentSized())
             sizingData.contentSizedTracksIndex.append(i);
         if (trackSize.maxTrackBreadth().isFlex())
             flexibleSizedTracksIndex.append(i);
     }
 
     // 2. Resolve content-based TrackSizingFunctions.
     if (!sizingData.contentSizedTracksIndex.isEmpty())
         resolveContentBasedTrackSizingFunctions(direction, sizingData);
 
     for (const auto& track: tracks) {
-        ASSERT(!track.growthLimitIsInfinite());
+        ASSERT(!track.growthLimitIsInfinite() && !track.infinitelyGrowable());

[Julien - ping for review, 2015/04/08 18:58:56]

This should be split in 2. Logical AND in ASSERT make it less clear which
predicate failed.

[svillar, 2015/04/10 09:43:09]

Acknowledged.

         freeSpace -= track.baseSize();
     }
 
     const bool hasUndefinedRemainingSpace = (direction == ForRows) ? style()->logicalHeight().isAuto() : gridElementIsShrinkToFit();
 
     if (!hasUndefinedRemainingSpace && freeSpace <= 0)
         return;
 
     // 3. Grow all Grid tracks in GridTracks from their baseSize up to their growthLimit value until freeSpace is exhausted.
     const size_t tracksSize = tracks.size();
     if (!hasUndefinedRemainingSpace) {
         Vector<GridTrack*> tracksForDistribution(tracksSize);
         for (size_t i = 0; i < tracksSize; ++i) {
             tracksForDistribution[i] = tracks.data() + i;
-            tracksForDistribution[i]->m_plannedIncrease = 0;
+            tracksForDistribution[i]->setPlannedSize(tracksForDistribution[i]->baseSize());
         }
 
         distributeSpaceToTracks(tracksForDistribution, nullptr, &GridTrack::baseSize, sizingData, freeSpace);
 
         for (auto* track : tracksForDistribution)
-            track->growBaseSize(track->m_plannedIncrease);
+            track->setBaseSize(track->plannedSize());
     } else {
         for (auto& track : tracks)
             track.setBaseSize(track.growthLimit());
     }
 
     if (flexibleSizedTracksIndex.isEmpty())
         return;
 
     // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
     double normalizedFractionBreadth = 0;
@@ skipping 276 matching lines @@
                 }
             }
         }
     }
     std::sort(sizingData.itemsSortedByIncreasingSpan.begin(), sizingData.itemsSortedByIncreasingSpan.end());
 
     auto it = sizingData.itemsSortedByIncreasingSpan.begin();
     auto end = sizingData.itemsSortedByIncreasingSpan.end();
     while (it != end) {
         GridItemsSpanGroupRange spanGroupRange = { it, std::upper_bound(it, end, *it) };
-        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &LayoutGrid::minContentForChild, &GridTrack::baseSize, &GridTrack::growBaseSize, &GridTrackSize::hasMinContentMinTrackBreadthAndMinOrMaxContentMaxTrackBreadth);
-        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMaxContentMinTrackBreadth, &LayoutGrid::maxContentForChild, &GridTrack::baseSize, &GridTrack::growBaseSize, &GridTrackSize::hasMaxContentMinTrackBreadthAndMaxContentMaxTrackBreadth);
-        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &LayoutGrid::minContentForChild, &GridTrack::growthLimitIfNotInfinite, &GridTrack::growGrowthLimit);
-        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMaxContentMaxTrackBreadth, &LayoutGrid::maxContentForChild, &GridTrack::growthLimitIfNotInfinite, &GridTrack::growGrowthLimit);
+        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMinOrMaxContentMinTrackBreadth, &LayoutGrid::minContentForChild, &GridTrack::baseSize, &GridTrack::baseSize, &GridTrack::setBaseSize, &GridTrackSize::hasMinContentMinTrackBreadthAndMinOrMaxContentMaxTrackBreadth);
+        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMaxContentMinTrackBreadth, &LayoutGrid::maxContentForChild, &GridTrack::baseSize, &GridTrack::baseSize, &GridTrack::setBaseSize, &GridTrackSize::hasMaxContentMinTrackBreadthAndMaxContentMaxTrackBreadth);
+        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMinOrMaxContentMaxTrackBreadth, &LayoutGrid::minContentForChild, &GridTrack::growthLimit, &GridTrack::growthLimitIfNotInfinite, &GridTrack::setGrowthLimit);
+        resolveContentBasedTrackSizingFunctionsForItems(direction, sizingData, spanGroupRange, &GridTrackSize::hasMaxContentMaxTrackBreadth, &LayoutGrid::maxContentForChild, &GridTrack::growthLimit, &GridTrack::growthLimitIfNotInfinite, &GridTrack::setGrowthLimit);
         it = spanGroupRange.rangeEnd;
     }
 
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
         GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
         if (track.growthLimitIsInfinite())
             track.setGrowthLimit(track.baseSize());
     }
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridCoordinate& coordinate, LayoutBox& gridItem, GridTrack& track, Vector<GridTrack>& columnTracks)
 {
     const GridResolvedPosition trackPosition = (direction == ForColumns) ? coordinate.columns.resolvedInitialPosition : coordinate.rows.resolvedInitialPosition;
     GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
 
     if (trackSize.hasMinContentMinTrackBreadth())
         track.setBaseSize(std::max(track.baseSize(), minContentForChild(gridItem, direction, columnTracks)));
     else if (trackSize.hasMaxContentMinTrackBreadth())
         track.setBaseSize(std::max(track.baseSize(), maxContentForChild(gridItem, direction, columnTracks)));
 
     if (trackSize.hasMinContentMaxTrackBreadth())
         track.setGrowthLimit(std::max(track.growthLimit(), minContentForChild(gridItem, direction, columnTracks)));
     else if (trackSize.hasMaxContentMaxTrackBreadth())
         track.setGrowthLimit(std::max(track.growthLimit(), maxContentForChild(gridItem, direction, columnTracks)));
 }
 
-void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, const GridItemsSpanGroupRange& gridItemsWithSpan, FilterFunction filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGetter, AccumulatorGrowFunction trackGrowthFunction, FilterFunction growAboveMaxBreadthFilterFunction)
+void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, const GridItemsSpanGroupRange& gridItemsWithSpan, FilterFunction filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGetter, AccumulatorGetter trackGetterIfNotInfinite, AccumulatorSetterFunction trackSetterFunction, FilterFunction growAboveMaxBreadthFilterFunction)
 {
     Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
-    for (const auto& trackIndex : sizingData.contentSizedTracksIndex)
-        tracks[trackIndex].m_plannedIncrease = 0;
+    for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
+        GridTrack& track = tracks[trackIndex];
+        track.setPlannedSize((track.*trackGetter)());
+    }
 
     for (auto it = gridItemsWithSpan.rangeStart; it != gridItemsWithSpan.rangeEnd; ++it) {
         GridItemWithSpan& gridItemWithSpan = *it;
         ASSERT(gridItemWithSpan.span() > 1);
         const GridCoordinate coordinate = gridItemWithSpan.coordinate();
         const GridSpan& itemSpan = (direction == ForColumns) ? coordinate.columns : coordinate.rows;
 
         sizingData.growBeyondGrowthLimitsTracks.shrink(0);
         sizingData.filteredTracks.shrink(0);
         LayoutUnit spanningTracksSize;
         for (const auto& trackPosition : itemSpan) {
             GridTrackSize trackSize = gridTrackSize(direction, trackPosition.toInt());
             GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition.toInt()] : sizingData.rowTracks[trackPosition.toInt()];
-            spanningTracksSize += (track.*trackGetter)();
+            spanningTracksSize += (track.*trackGetterIfNotInfinite)();
             if (!(trackSize.*filterFunction)())
                 continue;
 
             sizingData.filteredTracks.append(&track);
 
             if (!growAboveMaxBreadthFilterFunction || (trackSize.*growAboveMaxBreadthFilterFunction)())
                 sizingData.growBeyondGrowthLimitsTracks.append(&track);
         }
 
         if (sizingData.filteredTracks.isEmpty())
             continue;
 
-        // Specs mandate to floor extraSpace to 0. Instead we directly avoid the function call in those cases as it will be
-        // a noop in terms of track sizing.
         LayoutUnit extraSpace = (this->*sizingFunction)(gridItemWithSpan.gridItem(), direction, sizingData.columnTracks) - spanningTracksSize;
-        if (extraSpace > 0) {
-            Vector<GridTrack*>* tracksToGrowBeyondGrowthLimits = sizingData.growBeyondGrowthLimitsTracks.isEmpty() ? &sizingData.filteredTracks : &sizingData.growBeyondGrowthLimitsTracks;
-            distributeSpaceToTracks(sizingData.filteredTracks, tracksToGrowBeyondGrowthLimits, trackGetter, sizingData, extraSpace);
-        }
+        Vector<GridTrack*>* tracksToGrowBeyondGrowthLimits = sizingData.growBeyondGrowthLimitsTracks.isEmpty() ? &sizingData.filteredTracks : &sizingData.growBeyondGrowthLimitsTracks;
+        extraSpace = std::max<LayoutUnit>(extraSpace, 0);
+        distributeSpaceToTracks(sizingData.filteredTracks, tracksToGrowBeyondGrowthLimits, trackGetterIfNotInfinite, sizingData, extraSpace);
     }
 
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
         GridTrack& track = tracks[trackIndex];
-        if (track.m_plannedIncrease)
-            (track.*trackGrowthFunction)(track.m_plannedIncrease);
+        if ((track.*trackGetter)() == infinity && track.plannedSize() != infinity)
+            track.setInfinitelyGrowable(true);
+        else if (track.infinitelyGrowable())
+            track.setInfinitelyGrowable(false);
+        (track.*trackSetterFunction)(track.plannedSize());
     }
 }
 
 static bool sortByGridTrackGrowthPotential(const GridTrack* track1, const GridTrack* track2)
 {
     // This check ensures that we respect the irreflexivity property of the strict weak ordering required by std::sort
     // (forall x: NOT x < x).
-    if (track1->growthLimitIsInfinite() && track2->growthLimitIsInfinite())
+    if (track1->growthLimitIsInfiniteOrTrackIsInfinitelyGrowable() && track2->growthLimitIsInfiniteOrTrackIsInfinitelyGrowable())
         return false;
 
-    if (track1->growthLimitIsInfinite() || track2->growthLimitIsInfinite())
-        return track2->growthLimitIsInfinite();
+    if (track1->growthLimitIsInfiniteOrTrackIsInfinitelyGrowable() || track2->growthLimitIsInfiniteOrTrackIsInfinitelyGrowable())
+        return track2->growthLimitIsInfiniteOrTrackIsInfinitelyGrowable();
 
     return (track1->growthLimit() - track1->baseSize()) < (track2->growthLimit() - track2->baseSize());
 }
 
-void LayoutGrid::distributeSpaceToTracks(Vector<GridTrack*>& tracks, const Vector<GridTrack*>* growBeyondGrowthLimitsTracks, AccumulatorGetter trackGetter, GridSizingData& sizingData, LayoutUnit& availableLogicalSpace)
+void LayoutGrid::distributeSpaceToTracks(Vector<GridTrack*>& tracks, const Vector<GridTrack*>* growBeyondGrowthLimitsTracks, AccumulatorGetter trackGetterIfNotInfinite, GridSizingData& sizingData, LayoutUnit& availableLogicalSpace)
 {
-    ASSERT(availableLogicalSpace > 0);
-    std::sort(tracks.begin(), tracks.end(), sortByGridTrackGrowthPotential);
+    ASSERT(availableLogicalSpace >= 0);
+    if (availableLogicalSpace > 0) {
+        std::sort(tracks.begin(), tracks.end(), sortByGridTrackGrowthPotential);
 
-    size_t tracksSize = tracks.size();
-    for (size_t i = 0; i < tracksSize; ++i) {
-        GridTrack& track = *tracks[i];
-        LayoutUnit availableLogicalSpaceShare = availableLogicalSpace / (tracksSize - i);
-        const LayoutUnit& trackBreadth = (track.*trackGetter)();
-        LayoutUnit growthShare = track.growthLimitIsInfinite() ? availableLogicalSpaceShare : std::min(availableLogicalSpaceShare, track.growthLimit() - trackBreadth);
-        ASSERT_WITH_MESSAGE(growthShare >= 0, "We must never shrink any grid track or else we can't guarantee we abide by our min-sizing function.");
-        track.m_increaseDuringDistribution = growthShare;
-        availableLogicalSpace -= growthShare;
+        size_t tracksSize = tracks.size();
+        for (size_t i = 0; i < tracksSize; ++i) {
+            GridTrack& track = *tracks[i];
+            LayoutUnit availableLogicalSpaceShare = availableLogicalSpace / (tracksSize - i);
+            const LayoutUnit& trackBreadth = (track.*trackGetterIfNotInfinite)();
+            LayoutUnit growthShare = track.growthLimitIsInfiniteOrTrackIsInfinitelyGrowable() ? availableLogicalSpaceShare : std::min(availableLogicalSpaceShare, track.growthLimit() - trackBreadth);
+            ASSERT_WITH_MESSAGE(growthShare >= 0, "We must never shrink any grid track or else we can't guarantee we abide by our min-sizing function.");
+            track.setSizeDuringDistribution(trackBreadth + growthShare);
+            availableLogicalSpace -= growthShare;
+        }
+    } else {
+        for (auto* track : tracks)
+            track->setSizeDuringDistribution((track->*trackGetterIfNotInfinite)());
     }
 
     if (availableLogicalSpace > 0 && growBeyondGrowthLimitsTracks) {
         size_t tracksGrowingAboveMaxBreadthSize = growBeyondGrowthLimitsTracks->size();
         for (size_t i = 0; i < tracksGrowingAboveMaxBreadthSize; ++i) {
             GridTrack* track = growBeyondGrowthLimitsTracks->at(i);
             LayoutUnit growthShare = availableLogicalSpace / (tracksGrowingAboveMaxBreadthSize - i);
-            track->m_increaseDuringDistribution += growthShare;
+            track->growSizeDuringDistribution(growthShare);
             availableLogicalSpace -= growthShare;
         }
     }
 
     for (auto* track : tracks)
-        track->m_plannedIncrease = std::max(track->m_plannedIncrease, track->m_increaseDuringDistribution);
+        track->setPlannedSize(track->plannedSize() == infinity ? track->sizeDuringDistribution() : std::max(track->plannedSize(), track->sizeDuringDistribution()));
 }
 
 #if ENABLE(ASSERT)
 bool LayoutGrid::tracksAreWiderThanMinTrackBreadth(GridTrackSizingDirection direction, const Vector<GridTrack>& tracks)
 {
     for (size_t i = 0; i < tracks.size(); ++i) {
         GridTrackSize trackSize = gridTrackSize(direction, i);
         const GridLength& minTrackBreadth = trackSize.minTrackBreadth();
         if (computeUsedBreadthOfMinLength(direction, minTrackBreadth) > tracks[i].baseSize())
             return false;
@@ skipping 891 matching lines @@
     if (isFloating())
         return "LayoutGrid (floating)";
     if (isAnonymous())
         return "LayoutGrid (anonymous)";
     if (isRelPositioned())
         return "LayoutGrid (relative positioned)";
     return "LayoutGrid";
 }
 
 } // namespace blink