[css-grid] Allow percentage values for column and row gutters

third_party/WebKit/Source/core/layout/LayoutGrid.cpp

Index: third_party/WebKit/Source/core/layout/LayoutGrid.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
index 6d8864e4a0d6d97a786ebe9bb66b5cfebf6bd4b9..fcc7b1ee9ad30d1df1942d68c2b6c6631661a555 100644
--- a/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutGrid.cpp
@@ -251,6 +251,15 @@ public:
     Vector<GridTrack*> growBeyondGrowthLimitsTracks;
 
     LayoutUnit& freeSpaceForDirection(GridTrackSizingDirection direction) { return direction == ForColumns ? freeSpaceForColumns : freeSpaceForRows; }
+    void setTrackGapsForDirection(GridTrackSizingDirection direction, LayoutUnit gap)
+    {
+        if (direction == ForColumns)
+            gapsForColumns = gap;
+        else
+            gapsForRows = gap;
+    }
+    LayoutUnit trackGapsForDirection(GridTrackSizingDirection direction) const { return direction == ForColumns ? gapsForColumns : gapsForRows; }
+    LayoutUnit guttersSize(GridTrackSizingDirection direction, size_t span) const { return span <= 1 ? LayoutUnit() : trackGapsForDirection(direction) * (span - 1); }
 
     SizingOperation sizingOperation { TrackSizing };
     enum SizingState { ColumnSizingFirstIteration, RowSizingFirstIteration, ColumnSizingSecondIteration, RowSizingSecondIteration};
@@ -294,6 +303,8 @@ public:
 private:
     LayoutUnit freeSpaceForColumns { };
     LayoutUnit freeSpaceForRows { };
+    LayoutUnit gapsForColumns { };
+    LayoutUnit gapsForRows { };
 };
 
 struct GridItemsSpanGroupRange {
@@ -387,7 +398,7 @@ LayoutUnit LayoutGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizi
     for (const auto& row : sizingData.rowTracks)
         logicalHeight += row.baseSize();
 
-    logicalHeight += guttersSize(ForRows, sizingData.rowTracks.size());
+    logicalHeight += sizingData.guttersSize(ForRows, sizingData.rowTracks.size());
 
     return logicalHeight;
 }
@@ -395,7 +406,7 @@ LayoutUnit LayoutGrid::computeTrackBasedLogicalHeight(const GridSizingData& sizi
 void LayoutGrid::computeTrackSizesForDirection(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit freeSpace)
 {
     DCHECK(sizingData.isValidTransitionForDirection(direction));
-    sizingData.freeSpaceForDirection(direction) = freeSpace - guttersSize(direction, direction == ForRows ? gridRowCount() : gridColumnCount());
+    sizingData.freeSpaceForDirection(direction) = freeSpace - sizingData.guttersSize(direction, direction == ForRows ? gridRowCount() : gridColumnCount());
     sizingData.sizingOperation = TrackSizing;
 
     LayoutUnit baseSizes, growthLimits;
@@ -453,14 +464,19 @@ void LayoutGrid::layoutBlock(bool relayoutChildren)
         // paths inside updateLogicalHeight() require a previous call to setLogicalHeight() to resolve
         // heights properly (like for positioned items for example).
         LayoutUnit availableSpaceForColumns = availableLogicalWidth();
+        sizingData.setTrackGapsForDirection(ForColumns, guttersSize(ForColumns, 2, availableSpaceForColumns));
         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 (logicalHeightWasIndefinite) {
+            sizingData.setTrackGapsForDirection(ForRows, guttersSize(ForRows, 2, LayoutUnit()));
             computeIntrinsicLogicalHeight(sizingData);
-        else
-            computeTrackSizesForDirection(ForRows, sizingData, availableLogicalHeight(ExcludeMarginBorderPadding));
+        } else {
+            LayoutUnit availableHeight = availableLogicalHeight(ExcludeMarginBorderPadding);
+            sizingData.setTrackGapsForDirection(ForRows, guttersSize(ForRows, 2, availableHeight));
+            computeTrackSizesForDirection(ForRows, sizingData, availableHeight);
+        }
         setLogicalHeight(computeTrackBasedLogicalHeight(sizingData) + borderAndPaddingLogicalHeight() + scrollbarLogicalHeight());
 
         LayoutUnit oldClientAfterEdge = clientLogicalBottom();
@@ -500,13 +516,13 @@ void LayoutGrid::layoutBlock(bool relayoutChildren)
     clearNeedsLayout();
 }
 
-LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction, size_t span) const
+LayoutUnit LayoutGrid::guttersSize(GridTrackSizingDirection direction, size_t span, LayoutUnit availableSize) const
 {
     if (span <= 1)
         return LayoutUnit();
 
     const Length& trackGap = direction == ForColumns ? styleRef().gridColumnGap() : styleRef().gridRowGap();
-    return valueForLength(trackGap, LayoutUnit()) * (span - 1);
+    return valueForLength(trackGap, availableSize) * (span - 1);
 }
 
 void LayoutGrid::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
@@ -516,9 +532,10 @@ void LayoutGrid::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, Layo
     GridSizingData sizingData(gridColumnCount(), gridRowCount());
     sizingData.freeSpaceForDirection(ForColumns) = LayoutUnit();
     sizingData.sizingOperation = IntrinsicSizeComputation;
+    sizingData.setTrackGapsForDirection(ForColumns, guttersSize(ForColumns, 2, LayoutUnit()));
     const_cast<LayoutGrid*>(this)->computeUsedBreadthOfGridTracks(ForColumns, sizingData, minLogicalWidth, maxLogicalWidth);
 
-    LayoutUnit totalGuttersSize = guttersSize(ForColumns, sizingData.columnTracks.size());
+    LayoutUnit totalGuttersSize = sizingData.guttersSize(ForColumns, sizingData.columnTracks.size());

[Manuel Rego, 2016/07/01 06:45:57]

I think you've just calculated the gap size a few lines above,
we can reuse it here.

     minLogicalWidth += totalGuttersSize;
     maxLogicalWidth += totalGuttersSize;
 
@@ -532,9 +549,10 @@ void LayoutGrid::computeIntrinsicLogicalHeight(GridSizingData& sizingData)
     ASSERT(tracksAreWiderThanMinTrackBreadth(ForColumns, sizingData));
     sizingData.freeSpaceForDirection(ForRows) = LayoutUnit();
     sizingData.sizingOperation = IntrinsicSizeComputation;
+    sizingData.setTrackGapsForDirection(ForRows, guttersSize(ForRows, 2, LayoutUnit()));
     computeUsedBreadthOfGridTracks(ForRows, sizingData, m_minContentHeight, m_maxContentHeight);
 
-    LayoutUnit totalGuttersSize = guttersSize(ForRows, gridRowCount());
+    LayoutUnit totalGuttersSize = sizingData.guttersSize(ForRows, gridRowCount());

[Manuel Rego, 2016/07/01 06:45:57]

Ditto.

     m_minContentHeight += totalGuttersSize;
     m_maxContentHeight += totalGuttersSize;
 
@@ -571,7 +589,8 @@ void LayoutGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection directi
 {
     LayoutUnit& freeSpace = sizingData.freeSpaceForDirection(direction);
     const LayoutUnit initialFreeSpace = freeSpace;
-    Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
+    bool isRowAxis = direction == ForColumns;
+    Vector<GridTrack>& tracks = isRowAxis ? sizingData.columnTracks : sizingData.rowTracks;
     Vector<size_t> flexibleSizedTracksIndex;
     sizingData.contentSizedTracksIndex.shrink(0);
 
@@ -579,7 +598,7 @@ void LayoutGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection directi
     // Grid gutters were removed from freeSpace by the caller, but we must use them to compute relative (i.e. percentages) sizes.
     bool hasDefiniteFreeSpace = sizingData.sizingOperation == TrackSizing;
     if (hasDefiniteFreeSpace)
-        maxSize += guttersSize(direction, direction == ForRows ? gridRowCount() : gridColumnCount());
+        maxSize += sizingData.guttersSize(direction, isRowAxis ? gridColumnCount() : gridRowCount());
 
     // 1. Initialize per Grid track variables.
     for (size_t i = 0; i < tracks.size(); ++i) {
@@ -1173,7 +1192,8 @@ LayoutUnit LayoutGrid::currentItemSizeForTrackSizeComputationPhase(TrackSizeComp
 template <TrackSizeComputationPhase phase>
 void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizingDirection direction, GridSizingData& sizingData, const GridItemsSpanGroupRange& gridItemsWithSpan)
 {
-    Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
+    bool isRowAxis = direction == ForColumns;
+    Vector<GridTrack>& tracks = isRowAxis ? sizingData.columnTracks : sizingData.rowTracks;
     for (const auto& trackIndex : sizingData.contentSizedTracksIndex) {
         GridTrack& track = tracks[trackIndex];
         track.setPlannedSize(trackSizeForTrackSizeComputationPhase(phase, track, AllowInfinity));
@@ -1189,7 +1209,7 @@ void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizing
         LayoutUnit spanningTracksSize;
         for (const auto& trackPosition : itemSpan) {
             GridTrackSize trackSize = gridTrackSize(direction, trackPosition);
-            GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
+            GridTrack& track = isRowAxis ? sizingData.columnTracks[trackPosition] : sizingData.rowTracks[trackPosition];
             spanningTracksSize += trackSizeForTrackSizeComputationPhase(phase, track, ForbidInfinity);
             if (!shouldProcessTrackForTrackSizeComputationPhase(phase, trackSize))
                 continue;
@@ -1203,7 +1223,7 @@ void LayoutGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizing
         if (sizingData.filteredTracks.isEmpty())
             continue;
 
-        spanningTracksSize += guttersSize(direction, itemSpan.integerSpan());
+        spanningTracksSize += sizingData.guttersSize(direction, itemSpan.integerSpan());
 
         LayoutUnit extraSpace = currentItemSizeForTrackSizeComputationPhase(phase, gridItemWithSpan.gridItem(), direction, sizingData) - spanningTracksSize;
         extraSpace = extraSpace.clampNegativeToZero();
@@ -1366,7 +1386,7 @@ size_t LayoutGrid::computeAutoRepeatTracksCount(GridTrackSizingDirection directi
 
     // Add gutters as if there where only 1 auto repeat track. Gaps between auto repeat tracks will be added later when
     // computing the repetitions.
-    LayoutUnit gapSize = guttersSize(direction, 2);
+    LayoutUnit gapSize = guttersSize(direction, 2, availableSize);
     tracksSize += gapSize * trackSizes.size();
 
     LayoutUnit freeSpace = availableSize - tracksSize;
@@ -1809,6 +1829,7 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
         }
     }
 
+    bool logicalHeightWasIndefinite = computeContentLogicalHeight(MainOrPreferredSize, style()->logicalHeight(), LayoutUnit(-1)) == LayoutUnit(-1);

[Manuel Rego, 2016/07/01 06:45:57]

We know this check is wrong, but it's part of bug #624301 to get it fixed.

Anyway we're now using this check (with your patch) in 3 places:
1) LayoutGrid::layoutBlock()
2) LayoutGrid::computeAutoRepeatTracksCount()
3) Here :-)

Maybe it's worth to move it to a boolean that we can reuse.
Despite it being wrong.

     LayoutUnit end = isForColumns ? clientLogicalWidth() : clientLogicalHeight();
     if (!endIsAuto) {
         if (isForColumns) {
@@ -1822,7 +1843,7 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
 
         // These vectors store line positions including gaps, but we shouldn't consider them for the edges of the grid.
         if (endLine > 0 && endLine < lastLine) {
-            end -= guttersSize(direction, 2);
+            end -= guttersSize(direction, 2, isForColumns ? logicalWidth() : logicalHeightWasIndefinite ? LayoutUnit() : contentLogicalHeight());

[Manuel Rego, 2016/07/01 06:45:57]

This is weird, you're using here logicalWidth() and contentLogicalHeight(),
in other parts you're using availableLogicalWidth() and
availableLogicalHeight().

             end -= isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
         }
     }
@@ -1839,7 +1860,7 @@ void LayoutGrid::offsetAndBreadthForPositionedChild(const LayoutBox& child, Grid
             offset = translateRTLCoordinate(m_columnPositions[endLine]) - borderLogicalLeft();
 
             if (endLine > 0 && endLine < lastLine) {
-                offset += guttersSize(direction, 2);
+                offset += guttersSize(direction, 2, isForColumns ? logicalWidth() : logicalHeightWasIndefinite ? LayoutUnit() : contentLogicalHeight());

[Manuel Rego, 2016/07/01 06:45:57]

Ditto.

                 offset += isForColumns ? m_offsetBetweenColumns : m_offsetBetweenRows;
             }
         }
@@ -1874,7 +1895,7 @@ LayoutUnit LayoutGrid::assumedRowsSizeForOrthogonalChild(const LayoutBox& child,
             gridAreaSize += valueForLength(maxTrackSize.length(), containingBlockAvailableSize);
     }
 
-    gridAreaSize += guttersSize(ForRows, span.integerSpan());
+    gridAreaSize += guttersSize(ForRows, span.integerSpan(), LayoutUnit());

[Manuel Rego, 2016/07/01 06:45:57]

I'm not sure if this call is right, if the sizingOperation is "TrackSizing"
we might need to use the availableLogicalHeight() instead of 0.

Didn't debug or test it so I don't know if it's possible to call this
with that sizingOperation or not.

 
     return gridAreaIsIndefinite ? std::max(child.maxPreferredLogicalWidth(), gridAreaSize) : gridAreaSize;
 }
@@ -1893,7 +1914,7 @@ LayoutUnit LayoutGrid::gridAreaBreadthForChild(const LayoutBox& child, GridTrack
     for (const auto& trackPosition : span)
         gridAreaBreadth += tracks[trackPosition].baseSize();
 
-    gridAreaBreadth += guttersSize(direction, span.integerSpan());
+    gridAreaBreadth += sizingData.guttersSize(direction, span.integerSpan());
 
     return gridAreaBreadth;
 }
@@ -1926,7 +1947,7 @@ void LayoutGrid::populateGridPositionsForDirection(GridSizingData& sizingData, G
     size_t numberOfLines = numberOfTracks + 1;
     size_t lastLine = numberOfLines - 1;
     ContentAlignmentData offset = computeContentPositionAndDistributionOffset(direction, sizingData.freeSpaceForDirection(direction), numberOfTracks);
-    LayoutUnit trackGap = guttersSize(direction, 2);
+    LayoutUnit trackGap = sizingData.trackGapsForDirection(direction);
     auto& positions = isRowAxis ? m_columnPositions : m_rowPositions;
     positions.resize(numberOfLines);
     auto borderAndPadding = isRowAxis ? borderAndPaddingLogicalLeft() : borderAndPaddingBefore();
@@ -2186,7 +2207,7 @@ LayoutUnit LayoutGrid::columnAxisOffsetForChild(const LayoutBox& child, GridSizi
         // m_rowPositions include distribution offset (because of content alignment) and gutters
         // so we need to subtract them to get the actual end position for a given row
         // (this does not have to be done for the last track as there are no more m_columnPositions after it).
-        LayoutUnit trackGap = guttersSize(ForRows, 2);
+        LayoutUnit trackGap = sizingData.trackGapsForDirection(ForRows);
         if (childEndLine < m_rowPositions.size() - 1) {
             endOfRow -= trackGap;
             endOfRow -= m_offsetBetweenRows;
@@ -2221,7 +2242,7 @@ LayoutUnit LayoutGrid::rowAxisOffsetForChild(const LayoutBox& child, GridSizingD
         // m_columnPositions include distribution offset (because of content alignment) and gutters
         // so we need to subtract them to get the actual end position for a given column
         // (this does not have to be done for the last track as there are no more m_columnPositions after it).
-        LayoutUnit trackGap = guttersSize(ForColumns, 2);
+        LayoutUnit trackGap = sizingData.trackGapsForDirection(ForColumns);
         if (childEndLine < m_columnPositions.size() - 1) {
             endOfColumn -= trackGap;
             endOfColumn -= m_offsetBetweenColumns;