Reimplement min-width: auto

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 401 matching lines @@
 {
     // If we have a horizontal flow, that means the main size is the width.
     // 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.
         if (size.isIntrinsic())
             child.layoutIfNeeded();
-        return child.computeContentLogicalHeight(size, child.logicalHeight() - child.borderAndPaddingLogicalHeight()) + child.scrollbarLogicalHeight();
+        return child.computeContentLogicalHeight(sizeType, size, child.logicalHeight() - child.borderAndPaddingLogicalHeight()) + child.scrollbarLogicalHeight();
     }
     return child.computeLogicalWidthUsing(sizeType, size, contentLogicalWidth(), this) - child.borderAndPaddingLogicalWidth();
 }
 
 WritingMode LayoutFlexibleBox::transformedWritingMode() const
 {
     WritingMode mode = style()->writingMode();
     if (!isColumnFlow())
         return mode;
 
@@ skipping 397 matching lines @@
         } else {
             child->setMarginTop(computeChildMarginValue(child->style()->marginTop()));
             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom()));
         }
     }
 }
 
 LayoutUnit LayoutFlexibleBox::adjustChildSizeForMinAndMax(LayoutBox& child, LayoutUnit childSize)
 {
     Length max = isHorizontalFlow() ? child.style()->maxWidth() : child.style()->maxHeight();
+    LayoutUnit maxExtent = -1;
     if (max.isSpecifiedOrIntrinsic()) {
-        LayoutUnit maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
+        maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
         if (maxExtent != -1 && childSize > maxExtent)
             childSize = maxExtent;
     }
 
     Length min = isHorizontalFlow() ? child.style()->minWidth() : child.style()->minHeight();
     LayoutUnit minExtent = 0;
-    if (min.isSpecifiedOrIntrinsic())
+    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(0), minExtent);
+    } 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;
+
+        bool hasClampedSize = !childPreferredMainAxisContentExtentRequiresLayout(child);
+        if (hasClampedSize) {
+            Length flexBasis = flexBasisForChild(child);

[Julien - ping for review, 2015/04/06 17:06:47]

const Length&?

[cbiesinger, 2015/04/06 21:34:16]

Done.

+            bool flexBasisIsDefinite = flexBasis.isFixed() || (flexBasis.isPercent() && mainAxisExtentIsDefinite());
+            if (flexBasisIsDefinite) {
+                LayoutUnit resolvedFlexBasis = computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis);
+                ASSERT(resolvedFlexBasis >= 0);
+                LayoutUnit clampedSize = resolvedFlexBasis;

[Julien - ping for review, 2015/04/06 17:06:47]

We don't seem to need |resolvedFlexBasis| as we directly copy its value into
|clampedSize|.

[cbiesinger, 2015/04/06 21:34:16]

clampedSize is basically std::min(resolvedFlexBasis, maxExtent) -- the if below
modified it. Do you think it's too unclear?

[Julien - ping for review, 2015/04/13 21:25:59]

I think this would be clearer:

LayoutUnit clampedSize = maxExtent != -1 ? min(resolvedFlexBasis, maxExtent) :
resolvedFlexBasis;

[cbiesinger, 2015/04/13 23:23:12]

Done.

+                if (maxExtent != -1 && clampedSize > maxExtent)
+                    clampedSize = maxExtent;
+
+                minExtent = std::min(clampedSize, contentSize);
+            } else {
+                minExtent = contentSize;
+            }
+        } else {
+            minExtent = contentSize;
+        }
+        // TODO(cbiesinger): Implement aspect ratio handling (here, transferred size) - crbug.com/249112
+    }
+    ASSERT(minExtent >= 0);
     return std::max(childSize, minExtent);
 }
 
 bool LayoutFlexibleBox::computeNextFlexLine(OrderedFlexItemList& orderedChildren, LayoutUnit& sumFlexBaseSize, double& totalFlexGrow, double& totalWeightedFlexShrink, LayoutUnit& sumHypotheticalMainSize, bool relayoutChildren)
 {
     orderedChildren.clear();
     sumFlexBaseSize = 0;
     totalFlexGrow = totalWeightedFlexShrink = 0;
     sumHypotheticalMainSize = 0;
 
@@ skipping 191 matching lines @@
 }
 
 bool LayoutFlexibleBox::needToStretchChildLogicalHeight(LayoutBox& child) const
 {
     if (alignmentForChild(child) != ItemPositionStretch)
         return false;
 
     return isHorizontalFlow() && child.style()->height().isAuto();
 }
 
+EOverflow LayoutFlexibleBox::mainAxisOverflowForChild(LayoutBox& child) const
+{
+    if (isHorizontalFlow())
+        return child.styleRef().overflowX();
+    return child.styleRef().overflowY();
+}
+
 void LayoutFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const Vector<LayoutUnit, 16>& childSizes, LayoutUnit availableFreeSpace, bool relayoutChildren, Vector<LineContext>& lineContexts)
 {
     ASSERT(childSizes.size() == children.size());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), style()->justifyContentDistribution(), numberOfChildrenForJustifyContent);
     if (style()->flexDirection() == FlowRowReverse)
         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
@@ skipping 330 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 }