[css-grid] Use min|max-sizes to compute flex fraction

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 855 matching lines @@
           flexFraction = std::max(
               flexFraction,
               findFlexFactorUnitSize(
                   tracks, span, direction,
                   maxContentForChild(*gridItem, direction, sizingData)));
         }
       }
     }
   }
 
+  // We don't need to redo the fr computation for widths ever because at layout
+  // time we always have the right available space (with min|max-width
+  // constraints already considered). That's why we can skip this step for
+  // indefinite widths (which only appear during intrinsic size computation).
+  if (direction == ForRows) {

[jfernandez, 2016/11/04 11:30:43]

We will compute the flex tracks' base size twice, even in the case that rowsSize
end up between the min/max constraints. 

[svillar, 2016/11/04 11:42:06]

Right. I thought about caching the results but I don't think it will cause
performance penalties unless we have tons of fr tracks in a huge grid, something
I consider unlikely.

+    LayoutUnit rowsSize = computeTrackBasedLogicalHeight(sizingData);
+    for (const auto& trackIndex : flexibleSizedTracksIndex) {
+      GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
+      LayoutUnit oldBaseSize = tracks[trackIndex].baseSize();
+      LayoutUnit baseSize = std::max(
+          oldBaseSize,
+          LayoutUnit(flexFraction * trackSize.maxTrackBreadth().flex()));
+      rowsSize += baseSize - oldBaseSize;
+    }
+
+    auto minSize = computeContentLogicalHeight(
+        MinSize, styleRef().logicalMinHeight(), LayoutUnit(-1));
+    auto maxSize = computeContentLogicalHeight(
+        MaxSize, styleRef().logicalMaxHeight(), LayoutUnit(-1));
+
+    // Redo the flex fraction computation using min|max-height as definite
+    // available space in case the total height is smaller than min-height
+    // or larger than max-height.
+    bool checkMinSize = minSize && rowsSize < minSize;
+    bool checkMaxSize = maxSize != -1 && rowsSize > maxSize;
+    if (checkMinSize || checkMaxSize) {
+      LayoutUnit freeSpace(-1);

[jfernandez, 2016/11/04 11:30:43]

freeSpace = checkMaxSize ? maxSize : -1;

[svillar, 2016/11/04 11:42:06]

Acknowledged.

+      if (checkMaxSize)
+        freeSpace = maxSize;
+      freeSpace =
+          std::max(freeSpace, minSize) -

[jfernandez, 2016/11/04 11:30:43]

What we should do if maxSize < minSize ? 

[svillar, 2016/11/04 11:42:06]

min-size always trumps max-size.

+          guttersSize(ForRows, 0, gridRowCount(), sizingData.sizingOperation);
+
+      flexFraction = findFlexFactorUnitSize(
+          tracks, GridSpan::translatedDefiniteGridSpan(0, tracks.size()),
+          direction, freeSpace);

[jfernandez, 2016/11/04 11:30:43]

Perhaps using here ForRows, instead of direction, to be more explicit.

[svillar, 2016/11/04 11:42:06]

Acknowledged.

+    }
+  }
+
   for (const auto& trackIndex : flexibleSizedTracksIndex) {
     GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
 
     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;
@@ skipping 2550 matching lines @@
   if (!m_gridItemArea.isEmpty())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
 }  // namespace blink