Flexbox: Allow intrinsic aspect ratios to inform main-size calculation

Source/core/rendering/RenderFlexibleBox.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 592 matching lines @@
 static inline bool preferredMainAxisExtentDependsOnLayout(const Length& flexBasis, bool hasInfiniteLineLength)
 {
     return flexBasis.isAuto() || (flexBasis.isFixed() && !flexBasis.value() && hasInfiniteLineLength);
 }
 
 bool RenderFlexibleBox::childPreferredMainAxisContentExtentRequiresLayout(RenderBox* child, bool hasInfiniteLineLength) const
 {
     return preferredMainAxisExtentDependsOnLayout(flexBasisForChild(child), hasInfiniteLineLength) && hasOrthogonalFlow(child);
 }
 
+bool RenderFlexibleBox::childHasFiniteCrossSize(RenderBox* child) const
+{
+    Length crossAxisExtentForChild = isHorizontalFlow() ? child->style()->height() : child->style()->width();
+    Length crossAxisExtent = isHorizontalFlow() ? style()->height() : style()->width();
+
+    if (crossAxisExtentForChild.isFixed())
+        return true;
+
+    if (!crossAxisExtent.isFixed())
+        return false;
+
+    if (crossAxisExtentForChild.isPercent())
+        return true;
+
+    if (!isMultiline() && needToStretchChildLogicalHeight(child))
+        return true;
+
+    if (!isMultiline() && needToStretchChildLogicalWidth(child))
+        return true;
+
+    return false;
+}
+
+void RenderFlexibleBox::computeAspectRatioOfChild(RenderBox* child, double& aspectRatio)
+{
+    if (child->style()->hasAspectRatio())
+        aspectRatio = child->style()->aspectRatio();
+    else if (child->hasAspectRatio() && child->intrinsicLogicalHeight())
+        aspectRatio = child->intrinsicLogicalWidth().rawValue() / child->intrinsicLogicalHeight().rawValue();
+}
+
 LayoutUnit RenderFlexibleBox::preferredMainAxisContentExtentForChild(RenderBox* child, bool hasInfiniteLineLength, bool relayoutChildren)
 {
     child->clearOverrideSize();
 
-    if (child->style()->hasAspectRatio() || child->isImage() || child->isVideo() || child->isCanvas())
+    if (child->style()->hasAspectRatio() || child->hasAspectRatio())
         UseCounter::count(document(), UseCounter::AspectRatioFlexItem);
 
     Length flexBasis = flexBasisForChild(child);
+    double aspectRatio = -1.0;
+    computeAspectRatioOfChild(child, aspectRatio);
+
+    if (aspectRatio >= 0 && flexBasis.isAuto() && childHasFiniteCrossSize(child)) {
+        if (!isMultiline()) {
+            if (needToStretchChildLogicalHeight(child))
+                return aspectRatio * style()->height().value();
+            if (needToStretchChildLogicalWidth(child))
+                return style()->width().value() / aspectRatio;
+        }
+        return isHorizontalFlow() ? aspectRatio * crossAxisIntrinsicExtentForChild(child) : crossAxisIntrinsicExtentForChild(child) / aspectRatio;
+    }
+
     if (preferredMainAxisExtentDependsOnLayout(flexBasis, hasInfiniteLineLength)) {
         LayoutUnit mainAxisExtent;
         if (hasOrthogonalFlow(child)) {
             if (child->needsLayout() || relayoutChildren) {
                 m_intrinsicSizeAlongMainAxis.remove(child);
                 child->forceChildLayout();
                 m_intrinsicSizeAlongMainAxis.set(child, child->logicalHeight());
             }
             ASSERT(m_intrinsicSizeAlongMainAxis.contains(child));
             mainAxisExtent = m_intrinsicSizeAlongMainAxis.get(child);
@@ skipping 428 matching lines @@
 }
 
 bool RenderFlexibleBox::needToStretchChildLogicalHeight(RenderBox* child) const
 {
     if (alignmentForChild(child) != ItemPositionStretch)
         return false;
 
     return isHorizontalFlow() && child->style()->height().isAuto();
 }
 
+bool RenderFlexibleBox::needToStretchChildLogicalWidth(RenderBox* child) const
+{
+    if (alignmentForChild(child) != ItemPositionStretch)
+        return false;
+
+    return isColumnFlow() && child->style()->width().isAuto();
+}
+
 void RenderFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, const Vector<LayoutUnit, 16>& childSizes, LayoutUnit availableFreeSpace, bool relayoutChildren, Vector<LineContext>& lineContexts, bool hasInfiniteLineLength)
 {
     ASSERT(childSizes.size() == children.size());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, style()->justifyContent(), numberOfChildrenForJustifyContent);
     if (style()->flexDirection() == FlowRowReverse)
         mainAxisOffset += isHorizontalFlow() ? verticalScrollbarWidth() : horizontalScrollbarHeight();
@@ skipping 323 matching lines @@
             ASSERT(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(child, newOffset - originalOffset);
         }
     }
 }
 
 }