[css-grid] Cache definite height detection

third_party/WebKit/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 221 matching lines @@
     GridTrackSizingDirection m_direction;
     size_t m_rowIndex;
     size_t m_columnIndex;
     size_t m_childIndex;
 };
 
 struct LayoutGrid::GridSizingData {
     WTF_MAKE_NONCOPYABLE(GridSizingData);
     STACK_ALLOCATED();
 public:
-    GridSizingData(size_t gridColumnCount, size_t gridRowCount)
+    GridSizingData(size_t gridColumnCount, size_t gridRowCount, bool definiteLogicalHeight)

[jfernandez, 2016/09/14 10:29:37]

better use 'hasDefiniteLogicalHeigth" as variable name.

         : columnTracks(gridColumnCount)
         , rowTracks(gridRowCount)
+        , m_definiteLogicalHeight(definiteLogicalHeight)

[jfernandez, 2016/09/14 10:29:37]

Again, better use the 'has' prefix in the attribute name.

     {
     }
 
     Vector<GridTrack> columnTracks;
     Vector<GridTrack> rowTracks;
     Vector<size_t> contentSizedTracksIndex;
 
     // Performance optimization: hold onto these Vectors until the end of Layout to avoid repeated malloc / free.
     Vector<GridTrack*> filteredTracks;
     Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
     Vector<GridTrack*> growBeyondGrowthLimitsTracks;
 
     LayoutUnit& freeSpace(GridTrackSizingDirection direction) { return direction == ForColumns ? freeSpaceForColumns : freeSpaceForRows; }
 
     LayoutUnit availableSpace() const { return m_availableSpace; }
     void setAvailableSpace(LayoutUnit availableSpace) { m_availableSpace = availableSpace; }
+    bool hasDefiniteLogicalHeight() const { return m_definiteLogicalHeight; }
 
     SizingOperation sizingOperation { TrackSizing };
     enum SizingState { ColumnSizingFirstIteration, RowSizingFirstIteration, ColumnSizingSecondIteration, RowSizingSecondIteration};
     SizingState sizingState { ColumnSizingFirstIteration };
     void nextState()
     {
         switch (sizingState) {
         case ColumnSizingFirstIteration:
             sizingState = RowSizingFirstIteration;
             return;
@@ skipping 22 matching lines @@
         }
         NOTREACHED();
         return false;
     }
 private:
     LayoutUnit freeSpaceForColumns { };
     LayoutUnit freeSpaceForRows { };
     // No need to store one per direction as it will be only used for computations during each axis
     // track sizing. It's cached here because we need it to compute relative sizes.
     LayoutUnit m_availableSpace;
+
+    bool m_definiteLogicalHeight;
 };
 
 struct GridItemsSpanGroupRange {
     Vector<GridItemWithSpan>::iterator rangeStart;
     Vector<GridItemWithSpan>::iterator rangeEnd;
 };
 
 LayoutGrid::LayoutGrid(Element* element)
     : LayoutBlock(element)
     , m_gridIsDirty(true)
@@ skipping 133 matching lines @@
     SubtreeLayoutScope layoutScope(*this);
 
     {
         // LayoutState needs this deliberate scope to pop before updating scroll information (which
         // may trigger relayout).
         LayoutState state(*this, locationOffset());
 
         LayoutSize previousSize = size();
 
         updateLogicalWidth();
-        bool logicalHeightWasIndefinite = !hasDefiniteLogicalHeight();
-
         TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
         // TODO(svillar): we won't need to do this once the intrinsic width computation is isolated
         // from the LayoutGrid object state (it should not touch any attribute) (see crbug.com/627812)
         if (m_autoRepeatColumns && m_autoRepeatColumns != computeAutoRepeatTracksCount(ForColumns, TrackSizing))
             dirtyGrid();
         placeItemsOnGrid(TrackSizing);
 
-        GridSizingData sizingData(gridColumnCount(), gridRowCount());
+        GridSizingData sizingData(gridColumnCount(), gridRowCount(), hasDefiniteLogicalHeight());

[jfernandez, 2016/09/14 10:29:37]

Are we suer we want to store this information in the GridSizingData structure ?
it seems something that depends more on the grid container box than the
temporary sizing structure data. 

My point is that passing the info as a boolean variable it's a bit strange. Why
not just defining a new class attribute so we can access to it independently of
the sizingData structure ?

[Manuel Rego, 2016/09/15 06:35:28]

Ok, I've moved it to an attribute called m_hasDefiniteLogicalHeight.

 
         // 1- First, the track sizing algorithm is used to resolve the sizes of the grid columns.
         // At this point the logical width is always definite as the above call to updateLogicalWidth()
         // properly resolves intrinsic sizes. We cannot do the same for heights though because many code
         // paths inside updateLogicalHeight() require a previous call to setLogicalHeight() to resolve
         // heights properly (like for positioned items for example).
         LayoutUnit availableSpaceForColumns = availableLogicalWidth();
         computeTrackSizesForDirection(ForColumns, sizingData, availableSpaceForColumns);
 
         // 2- Next, the track sizing algorithm resolves the sizes of the grid rows, using the
         // grid column sizes calculated in the previous step.
-        if (logicalHeightWasIndefinite)
+        if (sizingData.hasDefiniteLogicalHeight())
+            computeTrackSizesForDirection(ForRows, sizingData, availableLogicalHeight(ExcludeMarginBorderPadding));
+        else
             computeIntrinsicLogicalHeight(sizingData);
-        else
-            computeTrackSizesForDirection(ForRows, sizingData, availableLogicalHeight(ExcludeMarginBorderPadding));
         setLogicalHeight(computeTrackBasedLogicalHeight(sizingData) + borderAndPaddingLogicalHeight() + scrollbarLogicalHeight());
 
         LayoutUnit oldClientAfterEdge = clientLogicalBottom();
         updateLogicalHeight();
 
         // The above call might have changed the grid's logical height depending on min|max height restrictions.
         // Update the sizes of the rows whose size depends on the logical height (also on definite|indefinite sizes).
         LayoutUnit availableSpaceForRows = contentLogicalHeight();
-        if (logicalHeightWasIndefinite)
+        if (!sizingData.hasDefiniteLogicalHeight())
             computeTrackSizesForDirection(ForRows, sizingData, availableSpaceForRows);
 
         // 3- If the min-content contribution of any grid items have changed based on the row
         // sizes calculated in step 2, steps 1 and 2 are repeated with the new min-content
         // contribution (once only).
         repeatTracksSizingIfNeeded(sizingData, availableSpaceForColumns, availableSpaceForRows);
 
         // Grid container should have the minimum height of a line if it's editable. That doesn't affect track sizing though.
         if (hasLineIfEmpty())
             setLogicalHeight(std::max(logicalHeight(), minimumLogicalHeightForEmptyLine()));
@@ skipping 91 matching lines @@
             gapAccumulator += gap;
     }
 
     return gapAccumulator;
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     const_cast<LayoutGrid*>(this)->placeItemsOnGrid(IntrinsicSizeComputation);
 
-    GridSizingData sizingData(gridColumnCount(), gridRowCount());
+    GridSizingData sizingData(gridColumnCount(), gridRowCount(), false);
     sizingData.setAvailableSpace(LayoutUnit());
     sizingData.freeSpace(ForColumns) = LayoutUnit();
     sizingData.sizingOperation = IntrinsicSizeComputation;
     computeUsedBreadthOfGridTracks(ForColumns, sizingData, minLogicalWidth, maxLogicalWidth);
 
     LayoutUnit totalGuttersSize = guttersSize(ForColumns, 0, sizingData.columnTracks.size(), sizingData.sizingOperation);
     minLogicalWidth += totalGuttersSize;
     maxLogicalWidth += totalGuttersSize;
 
     LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
@@ skipping 50 matching lines @@
     Vector<size_t> flexibleSizedTracksIndex;
     sizingData.contentSizedTracksIndex.shrink(0);
 
     // Grid gutters were removed from freeSpace by the caller, but we must use them to compute relative (i.e. percentages) sizes.
     LayoutUnit maxSize = sizingData.availableSpace().clampNegativeToZero();
     bool hasDefiniteFreeSpace = sizingData.sizingOperation == TrackSizing;
 
     // 1. Initialize per Grid track variables.
     for (size_t i = 0; i < tracks.size(); ++i) {
         GridTrack& track = tracks[i];
-        GridTrackSize trackSize = gridTrackSize(direction, i, sizingData.sizingOperation);
+        GridTrackSize trackSize = gridTrackSize(direction, i, sizingData);
 
         track.setBaseSize(computeUsedBreadthOfMinLength(trackSize, maxSize));
         track.setGrowthLimit(computeUsedBreadthOfMaxLength(trackSize, track.baseSize(), maxSize));
         track.setInfinitelyGrowable(false);
 
         if (trackSize.isFitContent()) {
             GridLength gridLength = trackSize.fitContentTrackBreadth();
             if (!gridLength.hasPercentage() || hasDefiniteFreeSpace)
                 track.setGrowthLimitCap(valueForLength(gridLength.length(), maxSize));
         }
@@ skipping 40 matching lines @@
         for (auto& track : tracks)
             track.setBaseSize(track.growthLimit());
     }
 
     if (flexibleSizedTracksIndex.isEmpty())
         return;
 
     // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
     double flexFraction = 0;
     if (hasDefiniteFreeSpace) {
-        flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), direction, initialFreeSpace);
+        flexFraction = findFlexFactorUnitSize(tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()), direction, sizingData, initialFreeSpace);
     } else {
         for (const auto& trackIndex : flexibleSizedTracksIndex)
-            flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex).maxTrackBreadth().flex()));
+            flexFraction = std::max(flexFraction, normalizedFlexFraction(tracks[trackIndex], gridTrackSize(direction, trackIndex, sizingData).maxTrackBreadth().flex()));
 
         if (!m_gridItemArea.isEmpty()) {
             for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
                 GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
                 while (LayoutBox* gridItem = iterator.nextGridItem()) {
                     const GridSpan span = cachedGridSpan(*gridItem, direction);
 
                     // Do not include already processed items.
                     if (i > 0 && span.startLine() <= flexibleSizedTracksIndex[i - 1])
                         continue;
 
-                    flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, maxContentForChild(*gridItem, direction, sizingData)));
+                    flexFraction = std::max(flexFraction, findFlexFactorUnitSize(tracks, span, direction, sizingData, maxContentForChild(*gridItem, direction, sizingData)));
                 }
             }
         }
     }
 
     for (const auto& trackIndex : flexibleSizedTracksIndex) {
-        GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
+        GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingData);
 
         LayoutUnit oldBaseSize = tracks[trackIndex].baseSize();
         LayoutUnit baseSize = std::max(oldBaseSize, LayoutUnit(flexFraction * trackSize.maxTrackBreadth().flex()));
         if (LayoutUnit increment = baseSize - oldBaseSize) {
             tracks[trackIndex].setBaseSize(baseSize);
             freeSpace -= increment;
 
             baseSizesWithoutMaximization += increment;
             growthLimitsWithoutMaximization += increment;
         }
@@ skipping 21 matching lines @@
         return usedBreadth;
 
     const Length& trackLength = gridLength.length();
     if (trackLength.isSpecified())
         return valueForLength(trackLength, maxSize);
 
     ASSERT(trackLength.isMinContent() || trackLength.isAuto() || trackLength.isMaxContent());
     return LayoutUnit(infinity);
 }
 
-double LayoutGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, double flexFactorSum, LayoutUnit& leftOverSpace, const Vector<size_t, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
+double LayoutGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, const GridSizingData& sizingData, double flexFactorSum, LayoutUnit& leftOverSpace, const Vector<size_t, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
 {
     // We want to avoid the effect of flex factors sum below 1 making the factor unit size to grow exponentially.
     double hypotheticalFactorUnitSize = leftOverSpace / std::max<double>(1, flexFactorSum);
 
     // product of the hypothetical "flex factor unit" and any flexible track's "flex factor" must be grater than such track's "base size".
     std::unique_ptr<TrackIndexSet> additionalTracksToTreatAsInflexible = std::move(tracksToTreatAsInflexible);
     bool validFlexFactorUnit = true;
     for (auto index : flexibleTracksIndexes) {
         if (additionalTracksToTreatAsInflexible && additionalTracksToTreatAsInflexible->contains(index))
             continue;
         LayoutUnit baseSize = tracks[index].baseSize();
-        double flexFactor = gridTrackSize(direction, index).maxTrackBreadth().flex();
+        double flexFactor = gridTrackSize(direction, index, sizingData).maxTrackBreadth().flex();
         // treating all such tracks as inflexible.
         if (baseSize > hypotheticalFactorUnitSize * flexFactor) {
             leftOverSpace -= baseSize;
             flexFactorSum -= flexFactor;
             if (!additionalTracksToTreatAsInflexible)
                 additionalTracksToTreatAsInflexible = wrapUnique(new TrackIndexSet());
             additionalTracksToTreatAsInflexible->add(index);
             validFlexFactorUnit = false;
         }
     }
     if (!validFlexFactorUnit)
-        return computeFlexFactorUnitSize(tracks, direction, flexFactorSum, leftOverSpace, flexibleTracksIndexes, std::move(additionalTracksToTreatAsInflexible));
+        return computeFlexFactorUnitSize(tracks, direction, sizingData, flexFactorSum, leftOverSpace, flexibleTracksIndexes, std::move(additionalTracksToTreatAsInflexible));
     return hypotheticalFactorUnitSize;
 }
 
-double LayoutGrid::findFlexFactorUnitSize(const Vector<GridTrack>& tracks, const GridSpan& tracksSpan, GridTrackSizingDirection direction, LayoutUnit leftOverSpace) const
+double LayoutGrid::findFlexFactorUnitSize(const Vector<GridTrack>& tracks, const GridSpan& tracksSpan, GridTrackSizingDirection direction, const GridSizingData& sizingData, LayoutUnit leftOverSpace) const

[jfernandez, 2016/09/14 10:29:37]

an example of why I don't like a lot the approach you followed is that some
methods, like this one, receive the sizingData argument just to forward it to
the ones actually requiring to know whether the container has a definite logical
height or not.

 {
     if (leftOverSpace <= 0)
         return 0;
 
     double flexFactorSum = 0;
     Vector<size_t, 8> flexibleTracksIndexes;
     for (const auto& trackIndex : tracksSpan) {
-        GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
+        GridTrackSize trackSize = gridTrackSize(direction, trackIndex, sizingData);
         if (!trackSize.maxTrackBreadth().isFlex()) {
             leftOverSpace -= tracks[trackIndex].baseSize();
         } else {
             flexibleTracksIndexes.append(trackIndex);
             flexFactorSum += trackSize.maxTrackBreadth().flex();
         }
     }
 
     // The function is not called if we don't have <flex> grid tracks
     ASSERT(!flexibleTracksIndexes.isEmpty());
 
-    return computeFlexFactorUnitSize(tracks, direction, flexFactorSum, leftOverSpace, flexibleTracksIndexes);
+    return computeFlexFactorUnitSize(tracks, direction, sizingData, flexFactorSum, leftOverSpace, flexibleTracksIndexes);
 }
 
 static bool hasOverrideContainingBlockContentSizeForChild(const LayoutBox& child, GridTrackSizingDirection direction)
 {
     return direction == ForColumns ? child.hasOverrideContainingBlockLogicalWidth() : child.hasOverrideContainingBlockLogicalHeight();
 }
 
 static LayoutUnit overrideContainingBlockContentSizeForChild(const LayoutBox& child, GridTrackSizingDirection direction)
 {
     return direction == ForColumns ? child.overrideContainingBlockContentLogicalWidth() : child.overrideContainingBlockContentLogicalHeight();
@@ skipping 45 matching lines @@
         return trackStyles[untranslatedIndex];
 
     if (untranslatedIndex < (insertionPoint + autoRepeatTracksCount)) {
         size_t autoRepeatLocalIndex = untranslatedIndexAsInt - insertionPoint;
         return autoRepeatTrackStyles[autoRepeatLocalIndex % autoRepeatTrackStyles.size()];
     }
 
     return trackStyles[untranslatedIndex - autoRepeatTracksCount];
 }
 
-GridTrackSize LayoutGrid::gridTrackSize(GridTrackSizingDirection direction, size_t translatedIndex, SizingOperation sizingOperation) const
+GridTrackSize LayoutGrid::gridTrackSize(GridTrackSizingDirection direction, size_t translatedIndex, const GridSizingData& sizingData) const
 {
     // Collapse empty auto repeat tracks if auto-fit.
     if (hasAutoRepeatEmptyTracks(direction) && isEmptyAutoRepeatTrack(direction, translatedIndex))
         return { Length(Fixed), LengthTrackSizing };
 
     const GridTrackSize& trackSize = rawGridTrackSize(direction, translatedIndex);
     if (trackSize.isFitContent())
         return trackSize;
 
     GridLength minTrackBreadth = trackSize.minTrackBreadth();
     GridLength maxTrackBreadth = trackSize.maxTrackBreadth();
     // If the logical width/height of the grid container is indefinite, percentage values are treated as <auto>.
     if (minTrackBreadth.hasPercentage() || maxTrackBreadth.hasPercentage()) {
         // For the inline axis this only happens when we're computing the intrinsic sizes (AvailableSpaceIndefinite).
-        if ((sizingOperation == IntrinsicSizeComputation) || (direction == ForRows && !hasDefiniteLogicalHeight())) {
+        if ((sizingData.sizingOperation == IntrinsicSizeComputation) || (direction == ForRows && !sizingData.hasDefiniteLogicalHeight())) {

[jfernandez, 2016/09/14 10:29:37]

If I understood it correctly, you have passed 'false' as 'definiteLogicalHeight"
argument value when instantiating the SizingData structure for intrinsic size
computation. Since being under intrinsic size computation implies that height is
indefinite, wouldn't be better to just add an assertion here and avoid the
redundant condition ? 

[Manuel Rego, 2016/09/15 06:35:28]

The possibilities are:
* IntrinsicSizeComputation: Both width and height are considered indefinite (the
first condition of the if).
* TrackSizing: Width is always definite in that step. Height can be definite or
indefinite, so we need to check it.

So it's not redundant, if we're in IntrinsicSizeComputation phase, the first
part of the if is true and we consider the size as indefinite. But we need the
other part of the if for the TrackSizing phase.

             if (minTrackBreadth.hasPercentage())
                 minTrackBreadth = Length(Auto);
             if (maxTrackBreadth.hasPercentage())
                 maxTrackBreadth = Length(Auto);
         }
     }
 
     // Flex sizes are invalid as a min sizing function. However we still can have a flexible |minTrackBreadth|
     // if the track had a flex size directly (e.g. "1fr"), the spec says that in this case it implies an automatic minimum.
     if (minTrackBreadth.isFlex())
@@ skipping 135 matching lines @@
     LayoutBox& gridItem() const { return *m_gridItem; }
     GridSpan getGridSpan() const { return m_gridSpan; }
 
     bool operator<(const GridItemWithSpan other) const { return m_gridSpan.integerSpan() < other.m_gridSpan.integerSpan(); }
 
 private:
     LayoutBox* m_gridItem;
     GridSpan m_gridSpan;
 };
 
-bool LayoutGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& span, GridTrackSizingDirection direction, SizingOperation sizingOperation) const
+bool LayoutGrid::spanningItemCrossesFlexibleSizedTracks(const GridSpan& span, GridTrackSizingDirection direction, const GridSizingData& sizingData) const

[jfernandez, 2016/09/14 10:29:37]

isn't this another example of a method just forwarding the sizingData structure
?

 {
     for (const auto& trackPosition : span) {
-        const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingOperation);
+        const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition, sizingData);
         if (trackSize.minTrackBreadth().isFlex() || trackSize.maxTrackBreadth().isFlex())
             return true;
     }
 
     return false;
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctions(GridTrackSizingDirection direction, GridSizingData& sizingData) const
 {
     sizingData.itemsSortedByIncreasingSpan.shrink(0);
     if (!m_gridItemArea.isEmpty()) {
         HashSet<LayoutBox*> itemsSet;
         for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
             GridIterator iterator(m_grid, direction, trackIndex);
             GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
             while (LayoutBox* gridItem = iterator.nextGridItem()) {
                 if (itemsSet.add(gridItem).isNewEntry) {
                     const GridSpan& span = cachedGridSpan(*gridItem, direction);
                     if (span.integerSpan() == 1) {
                         resolveContentBasedTrackSizingFunctionsForNonSpanningItems(direction, span, *gridItem, track, sizingData);
-                    } else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData.sizingOperation)) {
+                    } else if (!spanningItemCrossesFlexibleSizedTracks(span, direction, sizingData)) {
                         sizingData.itemsSortedByIncreasingSpan.append(GridItemWithSpan(*gridItem, span));
                     }
                 }
             }
         }
         std::sort(sizingData.itemsSortedByIncreasingSpan.begin(), sizingData.itemsSortedByIncreasingSpan.end());
     }
 
     auto it = sizingData.itemsSortedByIncreasingSpan.begin();
     auto end = sizingData.itemsSortedByIncreasingSpan.end();
@@ skipping 10 matching lines @@
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
         GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackIndex] : sizingData.rowTracks[trackIndex];
         if (track.growthLimit() == infinity)
             track.setGrowthLimit(track.baseSize());
     }
 }
 
 void LayoutGrid::resolveContentBasedTrackSizingFunctionsForNonSpanningItems(GridTrackSizingDirection direction, const GridSpan& span, LayoutBox& gridItem, GridTrack& track, GridSizingData& sizingData) const
 {
     const size_t trackPosition = span.startLine();
-    GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData.sizingOperation);
+    GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData);
 
     if (trackSize.hasMinContentMinTrackBreadth())
         track.setBaseSize(std::max(track.baseSize(), minContentForChild(gridItem, direction, sizingData)));
     else if (trackSize.hasMaxContentMinTrackBreadth())
         track.setBaseSize(std::max(track.baseSize(), maxContentForChild(gridItem, direction, sizingData)));
     else if (trackSize.hasAutoMinTrackBreadth())
         track.setBaseSize(std::max(track.baseSize(), minSizeForChild(gridItem, direction, sizingData)));
 
     if (trackSize.hasMinContentMaxTrackBreadth()) {
         track.setGrowthLimit(std::max(track.growthLimit(), minContentForChild(gridItem, direction, sizingData)));
@@ skipping 141 matching lines @@
 
     for (auto it = gridItemsWithSpan.rangeStart; it != gridItemsWithSpan.rangeEnd; ++it) {
         GridItemWithSpan& gridItemWithSpan = *it;
         ASSERT(gridItemWithSpan.getGridSpan().integerSpan() > 1);
         const GridSpan& itemSpan = gridItemWithSpan.getGridSpan();
 
         sizingData.growBeyondGrowthLimitsTracks.shrink(0);
         sizingData.filteredTracks.shrink(0);
         LayoutUnit spanningTracksSize;
         for (const auto& trackPosition : itemSpan) {
-            GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
+            GridTrackSize trackSize = gridTrackSize(direction, trackPosition, sizingData);
             GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
             spanningTracksSize += trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
             if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
                 continue;
 
             sizingData.filteredTracks.append(&track);
 
             if (trackShouldGrowBeyondGrowthLimitsForTrackSizeComputationPhase(phase, trackSize))
                 sizingData.growBeyondGrowthLimitsTracks.append(&track);
         }
@@ skipping 90 matching lines @@
     for (auto* track : tracks)
         track->setPlannedSize(track->plannedSize() == infinity ? track->sizeDuringDistribution() : std::max(track->plannedSize(), track->sizeDuringDistribution()));
 }
 
 #if ENABLE(ASSERT)
 bool LayoutGrid::tracksAreWiderThanMinTrackBreadth(GridTrackSizingDirection direction, GridSizingData& sizingData)
 {
     const Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     LayoutUnit& maxSize = sizingData.freeSpace(direction);
     for (size_t i = 0; i < tracks.size(); ++i) {
-        GridTrackSize trackSize = gridTrackSize(direction, i, sizingData.sizingOperation);
+        GridTrackSize trackSize = gridTrackSize(direction, i, sizingData);
         if (computeUsedBreadthOfMinLength(trackSize, maxSize) > tracks[i].baseSize())
             return false;
     }
     return true;
 }
 #endif
 
 void LayoutGrid::ensureGridSize(size_t maximumRowSize, size_t maximumColumnSize)
 {
     const size_t oldRowSize = gridRowCount();
@@ skipping 439 matching lines @@
     LayoutUnit& availableSpace = sizingData.freeSpace(direction);
     if (availableSpace <= 0
         || (direction == ForColumns && styleRef().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior()) != ContentDistributionStretch)
         || (direction == ForRows && styleRef().resolvedAlignContentDistribution(contentAlignmentNormalBehavior()) != ContentDistributionStretch))
         return;
 
     // Spec defines auto-sized tracks as the ones with an 'auto' max-sizing function.
     Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     Vector<unsigned> autoSizedTracksIndex;
     for (unsigned i = 0; i < tracks.size(); ++i) {
-        const GridTrackSize& trackSize = gridTrackSize(direction, i);
+        const GridTrackSize& trackSize = gridTrackSize(direction, i, sizingData);
         if (trackSize.hasAutoMaxTrackBreadth())
             autoSizedTracksIndex.append(i);
     }
 
     unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
     if (numberOfAutoSizedTracks < 1)
         return;
 
     LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
     for (const auto& trackIndex : autoSizedTracksIndex) {
@@ skipping 188 matching lines @@
     ASSERT(m_gridItemArea.contains(&gridItem));
     return m_gridItemArea.get(&gridItem);
 }
 
 GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem, GridTrackSizingDirection direction) const
 {
     GridArea area = cachedGridArea(gridItem);
     return direction == ForColumns ? area.columns : area.rows;
 }
 
-LayoutUnit LayoutGrid::assumedRowsSizeForOrthogonalChild(const LayoutBox& child, SizingOperation sizingOperation) const
+LayoutUnit LayoutGrid::assumedRowsSizeForOrthogonalChild(const LayoutBox& child, const GridSizingData& sizingData) const
 {
     DCHECK(isOrthogonalChild(child));
     const GridSpan& span = cachedGridSpan(child, ForRows);
     LayoutUnit gridAreaSize;
     bool gridAreaIsIndefinite = false;
     LayoutUnit containingBlockAvailableSize = containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
     for (auto trackPosition : span) {
-        GridLength maxTrackSize = gridTrackSize(ForRows, trackPosition, sizingOperation).maxTrackBreadth();
+        GridLength maxTrackSize = gridTrackSize(ForRows, trackPosition, sizingData).maxTrackBreadth();
         if (maxTrackSize.isContentSized() || maxTrackSize.isFlex())
             gridAreaIsIndefinite = true;
         else
             gridAreaSize += valueForLength(maxTrackSize.length(), containingBlockAvailableSize);
     }
 
-    gridAreaSize += guttersSize(ForRows, span.startLine(), span.integerSpan(), sizingOperation);
+    gridAreaSize += guttersSize(ForRows, span.startLine(), span.integerSpan(), sizingData.sizingOperation);
 
     return gridAreaIsIndefinite ? std::max(child.maxPreferredLogicalWidth(), gridAreaSize) : gridAreaSize;
 }
 
 LayoutUnit LayoutGrid::gridAreaBreadthForChild(const LayoutBox& child, GridTrackSizingDirection direction, const GridSizingData& sizingData) const
 {
     // To determine the column track's size based on an orthogonal grid item we need it's logical height, which
     // may depend on the row track's size. It's possible that the row tracks sizing logic has not been performed yet,
     // so we will need to do an estimation.
     if (direction == ForRows && sizingData.sizingState == GridSizingData::ColumnSizingFirstIteration)
-        return assumedRowsSizeForOrthogonalChild(child, sizingData.sizingOperation);
+        return assumedRowsSizeForOrthogonalChild(child, sizingData);
 
     const Vector<GridTrack>& tracks = direction == ForColumns ? sizingData.columnTracks : sizingData.rowTracks;
     const GridSpan& span = cachedGridSpan(child, direction);
     LayoutUnit gridAreaBreadth;
     for (const auto& trackPosition : span)
         gridAreaBreadth += tracks[trackPosition].baseSize();
 
     gridAreaBreadth += guttersSize(direction, span.startLine(), span.integerSpan(), sizingData.sizingOperation);
 
     return gridAreaBreadth;
@@ skipping 544 matching lines @@
     return isOrthogonalChild(child) ? childLocation.transposedPoint() : childLocation;
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     if (!m_gridItemArea.isEmpty())
         GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink