[CSS Grid Layout] Do not stretch always grid items with auto width

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 1257 matching lines @@
         SubtreeLayoutScope layoutScope(*child);
         if (oldOverrideContainingBlockContentLogicalWidth != overrideContainingBlockContentLogicalWidth || (oldOverrideContainingBlockContentLogicalHeight != overrideContainingBlockContentLogicalHeight && child->hasRelativeLogicalHeight()))
             layoutScope.setNeedsLayout(child, LayoutInvalidationReason::GridChanged);
 
         child->setOverrideContainingBlockContentLogicalWidth(overrideContainingBlockContentLogicalWidth);
         child->setOverrideContainingBlockContentLogicalHeight(overrideContainingBlockContentLogicalHeight);
 
         // Stretching logic might force a child layout, so we need to run it before the layoutIfNeeded
         // call to avoid unnecessary relayouts. This might imply that child margins, needed to correctly
         // determine the available space before stretching, are not set yet.
-        applyStretchAlignmentToChildIfNeeded(*child, overrideContainingBlockContentLogicalHeight);
+        applyStretchAlignmentToChildIfNeeded(*child);
 
         child->layoutIfNeeded();
 
 #if ENABLE(ASSERT)
         const GridCoordinate& coordinate = cachedGridCoordinate(*child);
         ASSERT(coordinate.columns.resolvedInitialPosition.toInt() < sizingData.columnTracks.size());
         ASSERT(coordinate.rows.resolvedInitialPosition.toInt() < sizingData.rowTracks.size());
 #endif
         child->setLogicalLocation(findChildLogicalPosition(*child, sizingData));
 
@@ skipping 157 matching lines @@
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 static inline LayoutUnit constrainedChildIntrinsicContentLogicalHeight(const LayoutBox& child)
 {
     LayoutUnit childIntrinsicContentLogicalHeight = child.intrinsicContentLogicalHeight();
     return child.constrainLogicalHeightByMinMax(childIntrinsicContentLogicalHeight + child.borderAndPaddingLogicalHeight(), childIntrinsicContentLogicalHeight);
 }
 
-bool LayoutGrid::allowedToStretchLogicalHeightForChild(const LayoutBox& child) const
+bool LayoutGrid::canShrinkToFitInRowAxisForChild(const LayoutBox& child) const
 {
-    return child.style()->logicalHeight().isAuto() && !child.style()->marginBeforeUsing(style()).isAuto() && !child.style()->marginAfterUsing(style()).isAuto();
+    return !hasAutoMinSizeInRowAxis(child) || child.minPreferredLogicalWidth() <= child.overrideContainingBlockContentLogicalWidth();
+}
+
+bool LayoutGrid::hasAutoMinSizeInRowAxis(const LayoutBox& child) const
+{
+    return isHorizontalWritingMode() ? style()->minWidth().isAuto() : child.style()->minHeight().isAuto();

[Manuel Rego, 2015/07/23 09:41:26]

Hey, missing child.style() in the first call!

[jfernandez, 2015/07/23 11:01:04]

Done.

+}
+
+bool LayoutGrid::hasAutoSizeInColumnAxisForChild(const LayoutBox& child) const
+{
+    return isHorizontalWritingMode() ? child.style()->height().isAuto() : child.style()->width().isAuto();
+}
+
+bool LayoutGrid::hasAutoSizeInRowAxisForChild(const LayoutBox& child) const
+{
+    return isHorizontalWritingMode() ? child.style()->width().isAuto() : child.style()->height().isAuto();
+}
+
+bool LayoutGrid::allowedToStretchChildAlongColumnAxis(const LayoutBox& child) const
+{
+    return hasAutoSizeInColumnAxisForChild(child) && !child.style()->marginBeforeUsing(style()).isAuto() && !child.style()->marginAfterUsing(style()).isAuto();
+}
+
+bool LayoutGrid::allowedToStretchChildAlongRowAxis(const LayoutBox& child) const
+{
+    return hasAutoSizeInRowAxisForChild(child) && !child.style()->marginStartUsing(style()).isAuto() && !child.style()->marginEndUsing(style()).isAuto();
 }
 
 // FIXME: This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
 bool LayoutGrid::needToStretchChildLogicalHeight(const LayoutBox& child) const
 {
     if (ComputedStyle::resolveAlignment(styleRef(), child.styleRef(), ItemPositionStretch) != ItemPositionStretch)
         return false;
 
     return isHorizontalWritingMode() && child.style()->height().isAuto();
 }
@@ skipping 47 matching lines @@
     // Because we want to avoid multiple layouts, stretching logic might be performed before
     // children are laid out, so we can't use the child cached values. Hence, we need to
     // compute margins in order to determine the available height before stretching.
     if (childMarginLogicalHeight == 0)
         childMarginLogicalHeight = computeMarginLogicalHeightForChild(child);
 
     return gridAreaBreadthForChild - childMarginLogicalHeight;
 }
 
 // FIXME: This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
-void LayoutGrid::applyStretchAlignmentToChildIfNeeded(LayoutBox& child, LayoutUnit gridAreaBreadthForChild)
+void LayoutGrid::applyStretchAlignmentToChildIfNeeded(LayoutBox& child)
 {
-    if (!allowedToStretchLogicalHeightForChild(child) || ComputedStyle::resolveAlignment(styleRef(), child.styleRef(), ItemPositionStretch) != ItemPositionStretch) {
-        child.clearOverrideLogicalContentHeight();
-        return;
+    child.clearOverrideSize();
+
+    if (!allowedToStretchChildAlongRowAxis(child) || ComputedStyle::resolveJustification(styleRef(), child.styleRef(), ItemPositionStretch) != ItemPositionStretch) {
+        // TODO(lajava): how to handle orthogonality in this case ?.
+        // TODO(lajava): grid track sizing and positioning do not support orthogonal modes yet.
+        if (hasAutoSizeInRowAxisForChild(child) && canShrinkToFitInRowAxisForChild(child)) {
+            LayoutUnit childWidthToFit = std::min(child.maxPreferredLogicalWidth(), child.overrideContainingBlockContentLogicalWidth()  - child.marginLogicalWidth());

[Manuel Rego, 2015/07/23 09:41:26]

Sorry but I've realized that the bug I reported for min-height,
was not actually a bug
(see https://code.google.com/p/chromium/issues/detail?id=510061#c4).

So, I think we're doing something wrong here, let me try to explain it
using a simple example:
  <div style="display: grid; grid: 5px / 5px;">
    <div style="min-width: 10px; font: 25px/1 Ahem;">XX X</div>
  </div>

Let's see what should happen depending on the value of justify-self
porperty of the item:
* "justify-self: stretch;" (default)
  As the item has "width: auto;" the width is resolved to
  the width of the cell 5px.
  We have to enforce "min-width: 10px;" so item's width is finally 10px.
* "justify-self: start;" (or any other value different from "stretch")
  In this case "width: auto;" resolves to the min-width of the content,
  50px in this example.
  As 50px is greater than "min-width: 10px;" we don't have nothing to do
  and we use 50px as item's height.

So, we've to change this line and be sure that we don't have a width
smaller than the min-content.

[jfernandez, 2015/07/23 11:01:04]

Acknowledged.

+            LayoutUnit desiredLogicalWidth = child.constrainLogicalHeightByMinMax(childWidthToFit, -1);
+            bool childNeedsRelayout = desiredLogicalWidth != child.logicalWidth();
+            child.setOverrideLogicalContentWidth(desiredLogicalWidth - child.borderAndPaddingLogicalWidth());
+            if (childNeedsRelayout) {
+                child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+            }
+        }
     }
 
-    bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
-    // FIXME: If the child has orthogonal flow, then it already has an override height set, so use it.
-    // FIXME: grid track sizing and positioning do not support orthogonal modes yet.
-    if (!hasOrthogonalWritingMode) {
-        LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(gridAreaBreadthForChild, child);
-        LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1);
+    if (allowedToStretchChildAlongColumnAxis(child) && ComputedStyle::resolveAlignment(styleRef(), child.styleRef(), ItemPositionStretch) == ItemPositionStretch) {
+        bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
+        // FIXME: If the child has orthogonal flow, then it already has an override height set, so use it.
+        // FIXME: grid track sizing and positioning do not support orthogonal modes yet.
+        if (!hasOrthogonalWritingMode) {
+            LayoutUnit stretchedLogicalHeight = availableAlignmentSpaceForChildBeforeStretching(child.overrideContainingBlockContentLogicalHeight(), child);
+            LayoutUnit desiredLogicalHeight = child.constrainLogicalHeightByMinMax(stretchedLogicalHeight, -1);
 
-        // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
-        bool childNeedsRelayout = desiredLogicalHeight != child.logicalHeight();
-        if (childNeedsRelayout || !child.hasOverrideLogicalContentHeight())
+            // FIXME: Can avoid laying out here in some cases. See https://webkit.org/b/87905.
+            bool childNeedsRelayout = desiredLogicalHeight != child.logicalHeight();
             child.setOverrideLogicalContentHeight(desiredLogicalHeight - child.borderAndPaddingLogicalHeight());
-        if (childNeedsRelayout) {
-            child.setLogicalHeight(0);
-            child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+            if (childNeedsRelayout) {
+                child.setLogicalHeight(0);
+                child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
+            }
         }
     }
 }
 
 GridAxisPosition LayoutGrid::columnAxisPositionForChild(const LayoutBox& child) const
 {
     bool hasOrthogonalWritingMode = child.isHorizontalWritingMode() != isHorizontalWritingMode();
     bool hasSameWritingMode = child.styleRef().writingMode() == styleRef().writingMode();
 
     switch (ComputedStyle::resolveAlignment(styleRef(), child.styleRef(), ItemPositionStretch)) {
@@ skipping 298 matching lines @@
 
     return LayoutPoint(columnPosition, rowPositionForChild(child));
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink