[css-flexbox] Fix min-size: auto for a non-auto flex basis

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

 /*
  * Copyright (C) 2011 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 428 matching lines @@
     // That's the logical width for horizontal writing modes, and the logical height in vertical writing modes.
     // For a vertical flow, main size is the height, so it's the inverse.
     // So we need the logical width if we have a horizontal flow and horizontal writing mode, or vertical flow and vertical writing mode.
     // Otherwise we need the logical height.
     if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) {
         // We don't have to check for "auto" here - computeContentLogicalHeight will just return -1 for that case anyway.
         // It's safe to access scrollbarLogicalHeight here because computeNextFlexLine will have already
         // forced layout on the child.
         return child.computeContentLogicalHeight(sizeType, size, child.contentLogicalHeight()) + child.scrollbarLogicalHeight();
     }
-    return child.computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(), this) - child.borderAndPaddingLogicalWidth();
+    // computeLogicalWidth always re-computes the intrinsic widths. However, when our logical width is auto,
+    // we can just use our cached value. So let's do that here. (Compare code in LayoutBlock::computePreferredLogicalWidths)
+    LayoutUnit borderAndPadding = child.borderAndPaddingLogicalWidth();
+    if (styleRef().logicalWidth().isAuto()) {
+        if (size.type() == MinContent)
+            return child.minPreferredLogicalWidth() - borderAndPadding;
+        if (size.type() == MaxContent)
+            return child.maxPreferredLogicalWidth() - borderAndPadding;
+    }
+    return child.computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(), this) - borderAndPadding;
 }
 
 WritingMode LayoutFlexibleBox::transformedWritingMode() const
 {
     WritingMode mode = style()->writingMode();
     if (!isColumnFlow())
         return mode;
 
     switch (mode) {
     case TopToBottomWritingMode:
@@ skipping 403 matching lines @@
         if (isHorizontalFlow()) {
             child->setMarginLeft(computeChildMarginValue(child->style()->marginLeft()));
             child->setMarginRight(computeChildMarginValue(child->style()->marginRight()));
         } else {
             child->setMarginTop(computeChildMarginValue(child->style()->marginTop()));
             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom()));
         }
     }
 }
 
-LayoutUnit LayoutFlexibleBox::adjustChildSizeForMinAndMax(const LayoutBox& child, LayoutUnit childSize, bool childShrunk)
+LayoutUnit LayoutFlexibleBox::adjustChildSizeForMinAndMax(const LayoutBox& child, LayoutUnit childSize)
 {
     Length max = isHorizontalFlow() ? child.style()->maxWidth() : child.style()->maxHeight();
     LayoutUnit maxExtent = -1;
     if (max.isSpecifiedOrIntrinsic()) {
         maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
         ASSERT(maxExtent >= -1);
         if (maxExtent != -1 && childSize > maxExtent)
             childSize = maxExtent;
     }
 
     Length min = isHorizontalFlow() ? child.style()->minWidth() : child.style()->minHeight();
     LayoutUnit minExtent = 0;
     if (min.isSpecifiedOrIntrinsic()) {
         minExtent = computeMainAxisExtentForChild(child, MinSize, min);
         // computeMainAxisExtentForChild can return -1 when the child has a percentage
         // min size, but we have an indefinite size in that axis.
         minExtent = std::max(LayoutUnit(), minExtent);
-    } else if (childShrunk && min.isAuto() && mainAxisOverflowForChild(child) == OVISIBLE) {
+    } else if (min.isAuto() && mainAxisOverflowForChild(child) == OVISIBLE) {
         // css-flexbox section 4.5
         LayoutUnit contentSize = computeMainAxisExtentForChild(child, MinSize, Length(MinContent));
         ASSERT(contentSize >= 0);
         if (maxExtent != -1 && contentSize > maxExtent)
             contentSize = maxExtent;
 
         Length mainSize = isHorizontalFlow() ? child.styleRef().width() : child.styleRef().height();
         if (mainAxisLengthIsDefinite(child, mainSize)) {
             LayoutUnit resolvedMainSize = computeMainAxisExtentForChild(child, MainOrPreferredSize, mainSize);
             ASSERT(resolvedMainSize >= 0);
@@ skipping 85 matching lines @@
             childSizes.append(0);
             continue;
         }
 
         if (inflexibleItems.contains(child)) {
             childSizes.append(inflexibleItems.get(child));
         } else {
             LayoutUnit childInnerFlexBaseSize = computeInnerFlexBaseSizeForChild(*child);
             LayoutUnit childSize = childInnerFlexBaseSize;
             double extraSpace = 0;
-            bool childShrunk = false;
             if (availableFreeSpace > 0 && totalFlexGrow > 0 && flexSign == PositiveFlexibility && std::isfinite(totalFlexGrow)) {
                 if (totalFlexGrow < 1)
                     extraSpace = availableFreeSpace * child->style()->flexGrow();
                 else
                     extraSpace = availableFreeSpace * child->style()->flexGrow() / totalFlexGrow;
             } else if (availableFreeSpace < 0 && totalWeightedFlexShrink > 0 && flexSign == NegativeFlexibility && std::isfinite(totalWeightedFlexShrink) && child->style()->flexShrink()) {
                 extraSpace = availableFreeSpace * child->style()->flexShrink() * childInnerFlexBaseSize / totalWeightedFlexShrink;
-                childShrunk = true;
             }
             if (std::isfinite(extraSpace))
                 childSize += LayoutUnit::fromFloatRound(extraSpace);
 
-            LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize, childShrunk);
+            LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(*child, childSize);
             ASSERT(adjustedChildSize >= 0);
             childSizes.append(adjustedChildSize);
             usedFreeSpace += adjustedChildSize - childInnerFlexBaseSize;
 
             LayoutUnit violation = adjustedChildSize - childSize;
             if (violation > 0)
                 minViolations.append(Violation(child, adjustedChildSize, childInnerFlexBaseSize));
             else if (violation < 0)
                 maxViolations.append(Violation(child, adjustedChildSize, childInnerFlexBaseSize));
             totalViolation += violation;
@@ skipping 119 matching lines @@
     return isHorizontalFlow() && child.style()->height().isAuto();
 }
 
 bool LayoutFlexibleBox::childHasIntrinsicMainAxisSize(const LayoutBox& child) const
 {
     bool result = false;
     if (isHorizontalFlow() != child.styleRef().isHorizontalWritingMode()) {
         Length childFlexBasis = flexBasisForChild(child);
         Length childMinSize = isHorizontalFlow() ? child.style()->minWidth() : child.style()->minHeight();
         Length childMaxSize = isHorizontalFlow() ? child.style()->maxWidth() : child.style()->maxHeight();
-        if (childFlexBasis.isIntrinsic() || childMinSize.isIntrinsic() || childMaxSize.isIntrinsic())

[cbiesinger, 2015/10/28 18:27:59]

I had to make this change here. A min-size of auto in this condition does
require us to lay out the child just like a min-size of min-content would.

+        if (childFlexBasis.isIntrinsic() || childMinSize.isIntrinsicOrAuto() || childMaxSize.isIntrinsic())
             result = true;
     }
     return result;
 }
 
 EOverflow LayoutFlexibleBox::mainAxisOverflowForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return child.styleRef().overflowX();
     return child.styleRef().overflowY();
@@ skipping 350 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 }