Move aspect-ratio calculation out of IntrinsicSize

Currently, IntrinsicSize() returns both the intrinsic size and the aspect
ratio. This patch splits the aspect ratio part out, in preparation for
implementing the CSS aspect-ratio property.

R=ikilpatrick@chromium.org

Bug: 1045668
Change-Id: I7d41ee4556a98122c2c4e6b4e875e20442ed7aa3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2130684
Commit-Queue: Christian Biesinger <cbiesinger@chromium.org>
Auto-Submit: Christian Biesinger <cbiesinger@chromium.org>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#756044}

third_party/blink/renderer/core/layout/ng/ng_block_node.cc

@@ -11,6 +11,7 @@
 #include "third_party/blink/renderer/core/html/html_marquee_element.h"
 #include "third_party/blink/renderer/core/input_type_names.h"
 #include "third_party/blink/renderer/core/layout/box_layout_extra_input.h"
+#include "third_party/blink/renderer/core/layout/intrinsic_sizing_info.h"
 #include "third_party/blink/renderer/core/layout/layout_block_flow.h"
 #include "third_party/blink/renderer/core/layout/layout_fieldset.h"
 #include "third_party/blink/renderer/core/layout/layout_inline.h"
@@ -1178,14 +1179,23 @@ bool NGBlockNode::HasAspectRatio() const {
   if (!layout_object->IsImage() && !IsA<LayoutVideo>(layout_object) &&
       !layout_object->IsCanvas())
     return false;
-  base::Optional<LayoutUnit> computed_inline_size;
-  base::Optional<LayoutUnit> computed_block_size;
-  LogicalSize aspect_ratio;
 
   // Retrieving this and throwing it away is wasteful. We could make this method
   // return Optional<LogicalSize> that returns the aspect_ratio if there is one.
-  IntrinsicSize(&computed_inline_size, &computed_block_size, &aspect_ratio);
-  return !aspect_ratio.IsEmpty();
+  return !GetAspectRatio().IsEmpty();
+}
+
+LogicalSize NGBlockNode::GetAspectRatio() const {
+  base::Optional<LayoutUnit> computed_inline_size;
+  base::Optional<LayoutUnit> computed_block_size;
+  GetOverrideIntrinsicSize(&computed_inline_size, &computed_block_size);
+  if (computed_inline_size && computed_block_size)
+    return LogicalSize(*computed_inline_size, *computed_block_size);
+
+  IntrinsicSizingInfo legacy_sizing_info;
+  ToLayoutReplaced(box_)->ComputeIntrinsicSizingInfo(legacy_sizing_info);
+  return LogicalSize(LayoutUnit(legacy_sizing_info.aspect_ratio.Width()),
+                     LayoutUnit(legacy_sizing_info.aspect_ratio.Height()));
 }
 
 bool NGBlockNode::UseLogicalBottomMarginEdgeForInlineBlockBaseline() const {

third_party/blink/renderer/core/layout/ng/ng_block_node.h

@@ -101,6 +101,9 @@ class CORE_EXPORT NGBlockNode final : public NGLayoutInputNode {
   bool IsAtomicInlineLevel() const;
   bool HasAspectRatio() const;
 
+  // Returns the aspect ratio of a replaced element.
+  LogicalSize GetAspectRatio() const;
+
   // Returns true if this node should fill the viewport.
   // This occurs when we are in quirks-mode and we are *not* OOF-positioned,
   // floating, or inline-level.

third_party/blink/renderer/core/layout/ng/ng_flex_layout_algorithm.cc

@@ -303,12 +303,7 @@ bool NGFlexLayoutAlgorithm::WillChildCrossSizeBeContainerCrossSize(
 double NGFlexLayoutAlgorithm::GetMainOverCrossAspectRatio(
     const NGBlockNode& child) const {
   DCHECK(child.HasAspectRatio());
-  base::Optional<LayoutUnit> computed_inline_size;
-  base::Optional<LayoutUnit> computed_block_size;
-  LogicalSize aspect_ratio;
-
-  child.IntrinsicSize(&computed_inline_size, &computed_block_size,
-                      &aspect_ratio);
+  LogicalSize aspect_ratio = child.GetAspectRatio();
 
   DCHECK_GT(aspect_ratio.inline_size, 0);
   DCHECK_GT(aspect_ratio.block_size, 0);
@@ -629,11 +624,8 @@ void NGFlexLayoutAlgorithm::ConstructAndAppendFlexItems() {
             if (child.HasAspectRatio()) {
               base::Optional<LayoutUnit> computed_inline_size;
               base::Optional<LayoutUnit> computed_block_size;
-              LogicalSize aspect_ratio;
-              child.IntrinsicSize(&computed_inline_size, &computed_block_size,
-                                  &aspect_ratio);
-              DCHECK_GT(aspect_ratio.inline_size, 0);
-              DCHECK_GT(aspect_ratio.block_size, 0);
+              child.IntrinsicSize(&computed_inline_size, &computed_block_size);
+
               // The 150 is for elements that have an aspect ratio but no size,
               // which SVG can have (maybe others?).
               intrinsic_block_size =

third_party/blink/renderer/core/layout/ng/ng_layout_input_node.cc

@@ -71,38 +71,12 @@ MinMaxSizes NGLayoutInputNode::ComputeMinMaxSizes(
 
 void NGLayoutInputNode::IntrinsicSize(
     base::Optional<LayoutUnit>* computed_inline_size,
-    base::Optional<LayoutUnit>* computed_block_size,
-    LogicalSize* aspect_ratio) const {
+    base::Optional<LayoutUnit>* computed_block_size) const {
   DCHECK(IsReplaced());
 
-  LayoutUnit override_inline_size = OverrideIntrinsicContentInlineSize();
-  if (override_inline_size != kIndefiniteSize) {
-    *computed_inline_size = override_inline_size;
-  } else {
-    LayoutUnit default_inline_size = DefaultIntrinsicContentInlineSize();
-    if (default_inline_size != kIndefiniteSize)
-      *computed_inline_size = default_inline_size;
-  }
-
-  LayoutUnit override_block_size = OverrideIntrinsicContentBlockSize();
-  if (override_block_size != kIndefiniteSize) {
-    *computed_block_size = override_block_size;
-  } else {
-    LayoutUnit default_block_size = DefaultIntrinsicContentBlockSize();
-    if (default_block_size != kIndefiniteSize)
-      *computed_block_size = default_block_size;
-  }
-
-  if (ShouldApplySizeContainment()) {
-    if (!*computed_inline_size)
-      *computed_inline_size = LayoutUnit();
-    if (!*computed_block_size)
-      *computed_block_size = LayoutUnit();
-  }
-  if (*computed_inline_size && *computed_block_size) {
-    *aspect_ratio = LogicalSize(**computed_inline_size, **computed_block_size);
+  GetOverrideIntrinsicSize(computed_inline_size, computed_block_size);
+  if (*computed_inline_size && *computed_block_size)
     return;
-  }
 
   IntrinsicSizingInfo legacy_sizing_info;
 
@@ -111,9 +85,6 @@ void NGLayoutInputNode::IntrinsicSize(
     *computed_inline_size = LayoutUnit(legacy_sizing_info.size.Width());
   if (!*computed_block_size && legacy_sizing_info.has_height)
     *computed_block_size = LayoutUnit(legacy_sizing_info.size.Height());
-  *aspect_ratio =
-      LogicalSize(LayoutUnit(legacy_sizing_info.aspect_ratio.Width()),
-                  LayoutUnit(legacy_sizing_info.aspect_ratio.Height()));
 }
 
 NGLayoutInputNode NGLayoutInputNode::NextSibling() {
@@ -147,4 +118,35 @@ void NGLayoutInputNode::ShowNodeTree() const {
 }
 #endif
 
+void NGLayoutInputNode::GetOverrideIntrinsicSize(
+    base::Optional<LayoutUnit>* computed_inline_size,
+    base::Optional<LayoutUnit>* computed_block_size) const {
+  DCHECK(IsReplaced());
+
+  LayoutUnit override_inline_size = OverrideIntrinsicContentInlineSize();
+  if (override_inline_size != kIndefiniteSize) {
+    *computed_inline_size = override_inline_size;
+  } else {
+    LayoutUnit default_inline_size = DefaultIntrinsicContentInlineSize();
+    if (default_inline_size != kIndefiniteSize)
+      *computed_inline_size = default_inline_size;
+  }
+
+  LayoutUnit override_block_size = OverrideIntrinsicContentBlockSize();
+  if (override_block_size != kIndefiniteSize) {
+    *computed_block_size = override_block_size;
+  } else {
+    LayoutUnit default_block_size = DefaultIntrinsicContentBlockSize();
+    if (default_block_size != kIndefiniteSize)
+      *computed_block_size = default_block_size;
+  }
+
+  if (ShouldApplySizeContainment()) {
+    if (!*computed_inline_size)
+      *computed_inline_size = LayoutUnit();
+    if (!*computed_block_size)
+      *computed_block_size = LayoutUnit();
+  }
+}
+
 }  // namespace blink

third_party/blink/renderer/core/layout/ng/ng_layout_input_node.h

@@ -25,7 +25,6 @@ class LayoutBox;
 class NGConstraintSpace;
 class NGPaintFragment;
 struct MinMaxSizes;
-struct LogicalSize;
 struct PhysicalSize;
 
 // Input to the min/max inline size calculation algorithm for child nodes. Child
@@ -164,9 +163,9 @@ class CORE_EXPORT NGLayoutInputNode {
   // Returns intrinsic sizing information for replaced elements.
   // ComputeReplacedSize can use it to compute actual replaced size.
   // Corresponds to Legacy's LayoutReplaced::IntrinsicSizingInfo.
+  // Use NGBlockNode::GetAspectRatio to get the aspect ratio.
   void IntrinsicSize(base::Optional<LayoutUnit>* computed_inline_size,
-                     base::Optional<LayoutUnit>* computed_block_size,
-                     LogicalSize* aspect_ratio) const;
+                     base::Optional<LayoutUnit>* computed_block_size) const;
 
   // Returns the next sibling.
   NGLayoutInputNode NextSibling();
@@ -245,6 +244,10 @@ class CORE_EXPORT NGLayoutInputNode {
   NGLayoutInputNode(LayoutBox* box, NGLayoutInputNodeType type)
       : box_(box), type_(type) {}
 
+  void GetOverrideIntrinsicSize(
+      base::Optional<LayoutUnit>* computed_inline_size,
+      base::Optional<LayoutUnit>* computed_block_size) const;
+
   LayoutBox* box_;
 
   unsigned type_ : 1;  // NGLayoutInputNodeType

third_party/blink/renderer/core/layout/ng/ng_length_utils.cc

@@ -472,7 +472,7 @@ LayoutUnit ComputeBlockSizeForFragment(
 }
 
 // Computes size for a replaced element.
-void ComputeReplacedSize(const NGLayoutInputNode& node,
+void ComputeReplacedSize(const NGBlockNode& node,
                          const NGConstraintSpace& space,
                          const base::Optional<MinMaxSizes>& child_min_max_sizes,
                          base::Optional<LogicalSize>* out_replaced_size,
@@ -521,9 +521,10 @@ void ComputeReplacedSize(const NGLayoutInputNode& node,
 
   base::Optional<LayoutUnit> intrinsic_inline;
   base::Optional<LayoutUnit> intrinsic_block;
-  LogicalSize aspect_ratio;
+  node.IntrinsicSize(&intrinsic_inline, &intrinsic_block);
+
+  LogicalSize aspect_ratio = node.GetAspectRatio();
 
-  node.IntrinsicSize(&intrinsic_inline, &intrinsic_block, &aspect_ratio);
   // Computing intrinsic size is complicated by the fact that
   // intrinsic_inline, intrinsic_block, and aspect_ratio can all
   // be empty independent of each other.

third_party/blink/renderer/core/layout/ng/ng_length_utils.h

@@ -326,7 +326,7 @@ ComputeBlockSizeForFragment(const NGConstraintSpace&,
 // - neither out_aspect_ratio, nor out_replaced_size
 // SVG elements can return any of the three options above.
 CORE_EXPORT void ComputeReplacedSize(
-    const NGLayoutInputNode&,
+    const NGBlockNode&,
     const NGConstraintSpace&,
     const base::Optional<MinMaxSizes>&,
     base::Optional<LogicalSize>* out_replaced_size,