[css-grid] Fix track sizing algo w/ size restrictions and intrinsic sizes

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 373 matching lines @@
 
         minLogicalWidth += minTrackBreadth;
         maxLogicalWidth += maxTrackBreadth;
     }
 
     LayoutUnit scrollbarWidth = intrinsicScrollbarLogicalWidth();
     minLogicalWidth += scrollbarWidth;
     maxLogicalWidth += scrollbarWidth;
 }
 
-bool LayoutGrid::gridElementIsShrinkToFit()
+static bool heightSizedUnderMinContentConstraint(const ComputedStyle& style)

[cbiesinger, 2015/09/30 15:49:35]

I'm somewhat skeptical about this design -- does this mean it is not possible to
calculate a min-content and max-content width for a given grid? "sized under a
min-content constraint" is not so much a feature of a given element, it's an
aspect of what's being calculated right now, isn't it?

 {
-    return isFloatingOrOutOfFlowPositioned();
+    return style.logicalMinHeight().isMinContent() || style.logicalHeight().isMinContent() || style.logicalMaxHeight().isMinContent();
+}
+
+static bool heightSizedUnderMaxContentConstraint(const ComputedStyle& style)
+{
+    return style.logicalMinHeight().isMaxContent() || style.logicalHeight().isMaxContent() || style.logicalMaxHeight().isMaxContent();
+}
+
+LayoutUnit LayoutGrid::spaceToDistributeForMaximizeTracks(GridTrackSizingDirection direction, bool hasDefiniteAvailableSpace, const LayoutUnit &tracksBreadth, const LayoutUnit& freeSpace) const
+{
+    if (direction == ForColumns)
+        return freeSpace;
+
+    // Under max-content the freeSpace is infinity unless we have a max-height restriction.
+    if (heightSizedUnderMaxContentConstraint(styleRef())) {
+        if (!styleRef().logicalMaxHeight().isMaxSizeNone())
+            return std::max<LayoutUnit>(0, computeLogicalHeightUsing(MaxSize, styleRef().logicalMaxHeight(), contentLogicalHeight()) - tracksBreadth);
+
+        return infinity;
+    }
+
+    // Under min-content the freeSpace is 0 unless we have a min-height restriction.
+    if (heightSizedUnderMinContentConstraint(styleRef())) {
+        const Length& logicalMinSize = styleRef().logicalMinHeight();
+        if (!logicalMinSize.isZero() || logicalMinSize.isIntrinsic())
+            return std::max<LayoutUnit>(0, computeLogicalHeightUsing(MinSize, styleRef().logicalMinHeight(), contentLogicalHeight()) - tracksBreadth);
+
+        return 0;
+    }
+
+    if (!hasDefiniteAvailableSpace)
+        return infinity;
+
+    return freeSpace;
+}
+
+void LayoutGrid::maximizeTracks(Vector<GridTrack>& tracks, GridSizingData& sizingData, LayoutUnit& spaceToDistribute)
+{
+    if (spaceToDistribute == infinity) {
+        for (auto& track : tracks)
+            track.setBaseSize(track.growthLimit());
+        return;
+    }
+
+    ASSERT(spaceToDistribute >= 0);
+    if (spaceToDistribute == 0)
+        return;
+
+    size_t tracksSize = tracks.size();
+    Vector<GridTrack*> tracksForDistribution(tracksSize);
+    for (size_t i = 0; i < tracksSize; ++i) {
+        tracksForDistribution[i] = tracks.data() + i;
+        tracksForDistribution[i]->setPlannedSize(tracksForDistribution[i]->baseSize());
+    }
+
+    distributeSpaceToTracks<MaximizeTracks>(tracksForDistribution, nullptr, sizingData, spaceToDistribute);
+
+    for (auto* track : tracksForDistribution)
+        track->setBaseSize(track->plannedSize());
 }
 
 void LayoutGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit& freeSpace)
 {
     const LayoutUnit initialFreeSpace = freeSpace;
     Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     Vector<size_t> flexibleSizedTracksIndex;
     sizingData.contentSizedTracksIndex.shrink(0);
 
     // 1. Initialize per Grid track variables.
@@ skipping 15 matching lines @@
 
     // 2. Resolve content-based TrackSizingFunctions.
     if (!sizingData.contentSizedTracksIndex.isEmpty())
         resolveContentBasedTrackSizingFunctions(direction, sizingData);
 
     for (const auto& track: tracks) {
         ASSERT(!track.infiniteGrowthPotential());
         freeSpace -= track.baseSize();
     }
 
-    const bool hasUndefinedRemainingSpace = (direction == ForRows) ? style()->logicalHeight().isAuto() : gridElementIsShrinkToFit();
-
-    if (!hasUndefinedRemainingSpace && freeSpace <= 0)
+    // For columns we already have the right available space because the intrinsic sizes
+    // were previously computed by computeIntrinsicLogicalWidths().
+    const bool hasDefiniteAvailableSpace = (direction == ForRows) ? hasDefiniteLogicalHeight() : true;
+    if (hasDefiniteAvailableSpace && 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]->setPlannedSize(tracksForDistribution[i]->baseSize());
-        }
-
-        distributeSpaceToTracks<MaximizeTracks>(tracksForDistribution, nullptr, sizingData, freeSpace);
-
-        for (auto* track : tracksForDistribution)
-            track->setBaseSize(track->plannedSize());
-    } else {
-        for (auto& track : tracks)
-            track.setBaseSize(track.growthLimit());
-    }
+    LayoutUnit tracksBreadth = initialFreeSpace - freeSpace;
+    LayoutUnit spaceToDistribute = spaceToDistributeForMaximizeTracks(direction, hasDefiniteAvailableSpace, tracksBreadth, freeSpace);
+    maximizeTracks(tracks, sizingData, spaceToDistribute);
 
     if (flexibleSizedTracksIndex.isEmpty())
         return;
 
     // 4. Grow all Grid tracks having a fraction as the MaxTrackSizingFunction.
     double normalizedFractionBreadth = 0;
-    if (!hasUndefinedRemainingSpace) {
+    if (hasDefiniteAvailableSpace) {
         normalizedFractionBreadth = computeNormalizedFractionBreadth(tracks, GridSpan(0, tracks.size() - 1), direction, initialFreeSpace);
     } else {
         for (const auto& trackIndex : flexibleSizedTracksIndex) {
             GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
             normalizedFractionBreadth = std::max(normalizedFractionBreadth, tracks[trackIndex].baseSize() / trackSize.maxTrackBreadth().flex());
         }
 
         for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) {
             GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i]);
             while (LayoutBox* gridItem = iterator.nextGridItem()) {
@@ skipping 1449 matching lines @@
 
     return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child));
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink