[AspectRatio] Support min-inline-size: auto with abspos

Unfortunately this required adding *another* parameter to
ComputeOutOfFlowInlineDimensions because we now need two
different MinMaxSizes.

R=ikilpatrick@chromium.org, mstensho@chromium.org

Bug: 1098475
Change-Id: If2c05ce09292bc856e04c7a18950fbdd35579572
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2430828
Auto-Submit: Christian Biesinger <cbiesinger@chromium.org>
Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Reviewed-by: Morten Stenshorne <mstensho@chromium.org>
Commit-Queue: Christian Biesinger <cbiesinger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#811628}

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

@@ -425,19 +425,28 @@ void ComputeOutOfFlowInlineDimensions(
     const ComputedStyle& style,
     const NGBoxStrut& border_padding,
     const NGLogicalStaticPosition& static_position,
-    const base::Optional<MinMaxSizes>& min_max_sizes,
+    const base::Optional<MinMaxSizes>& minmax_content_sizes,
+    const base::Optional<MinMaxSizes>& minmax_intrinsic_sizes_for_ar,
     const base::Optional<LogicalSize>& replaced_size,
     const WritingMode container_writing_mode,
     const TextDirection container_direction,
     NGLogicalOutOfFlowDimensions* dimensions) {
   DCHECK(dimensions);
 
-  LayoutUnit min_inline_size = ResolveMinInlineLength(
-      space, style, border_padding, min_max_sizes, style.LogicalMinWidth(),
-      LengthResolvePhase::kLayout);
+  Length min_inline_length = style.LogicalMinWidth();
+  base::Optional<MinMaxSizes> min_size_minmax = minmax_content_sizes;
+  // We don't need to check for IsInlineSizeComputableFromBlockSize; this is
+  // done by the caller.
+  if (minmax_intrinsic_sizes_for_ar) {
+    min_inline_length = Length::MinIntrinsic();
+    min_size_minmax = minmax_intrinsic_sizes_for_ar;
+  }
+  LayoutUnit min_inline_size =
+      ResolveMinInlineLength(space, style, border_padding, min_size_minmax,
+                             min_inline_length, LengthResolvePhase::kLayout);
   LayoutUnit max_inline_size = ResolveMaxInlineLength(
-      space, style, border_padding, min_max_sizes, style.LogicalMaxWidth(),
-      LengthResolvePhase::kLayout);
+      space, style, border_padding, minmax_content_sizes,
+      style.LogicalMaxWidth(), LengthResolvePhase::kLayout);
 
   // This implements the transferred min/max sizes per
   // https://drafts.csswg.org/css-sizing-4/#aspect-ratio
@@ -451,8 +460,9 @@ void ComputeOutOfFlowInlineDimensions(
   bool is_table = style.IsDisplayTableBox();
   base::Optional<LayoutUnit> inline_size;
   if (!style.LogicalWidth().IsAuto()) {
-    LayoutUnit resolved_inline_size = ResolveMainInlineLength(
-        space, style, border_padding, min_max_sizes, style.LogicalWidth());
+    LayoutUnit resolved_inline_size =
+        ResolveMainInlineLength(space, style, border_padding,
+                                minmax_content_sizes, style.LogicalWidth());
 
     // Tables use the inline-size as a minimum.
     if (is_table)
@@ -462,8 +472,8 @@ void ComputeOutOfFlowInlineDimensions(
   } else if (replaced_size.has_value()) {
     inline_size = replaced_size->inline_size;
   } else if (IsInlineSizeComputableFromBlockSize(style)) {
-    DCHECK(min_max_sizes.has_value());
-    inline_size = min_max_sizes->min_size;
+    DCHECK(minmax_content_sizes.has_value());
+    inline_size = minmax_content_sizes->min_size;
   }
 
   bool is_start_dominant;
@@ -478,7 +488,7 @@ void ComputeOutOfFlowInlineDimensions(
   }
 
   ComputeAbsoluteSize(
-      border_padding.InlineSum(), min_max_sizes,
+      border_padding.InlineSum(), minmax_content_sizes,
       space.PercentageResolutionInlineSizeForParentWritingMode(),
       space.AvailableSize().inline_size, style.MarginStart(), style.MarginEnd(),
       style.LogicalInlineStart(), style.LogicalInlineEnd(), min_inline_size,

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

@@ -61,6 +61,8 @@ bool IsInlineSizeComputableFromBlockSize(const ComputedStyle& style);
 
 // Computes part of the absolute position which depends on the child's
 // inline-size.
+// |minmax_intrinsic_size_for_ar| is only used for min-inline-size: auto in
+// combination with aspect-ratio.
 // |replaced_size| should be set if and only if element is replaced element.
 // Returns the partially filled position.
 CORE_EXPORT void ComputeOutOfFlowInlineDimensions(
@@ -68,7 +70,8 @@ CORE_EXPORT void ComputeOutOfFlowInlineDimensions(
     const ComputedStyle&,
     const NGBoxStrut& border_padding,
     const NGLogicalStaticPosition&,
-    const base::Optional<MinMaxSizes>& child_minmax,
+    const base::Optional<MinMaxSizes>& minmax_content_sizes,
+    const base::Optional<MinMaxSizes>& minmax_intrinsic_sizes_for_ar,
     const base::Optional<LogicalSize>& replaced_size,
     const WritingMode container_writing_mode,
     const TextDirection container_direction,

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

@@ -161,10 +161,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(NGAuto, NGAuto, NGAuto, NGAuto, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), true);
   estimated_inline = min_max_60;
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min_max_60.min_size, dimensions.size.inline_size);
   EXPECT_EQ(LayoutUnit(0), dimensions.inset.inline_start);
 
@@ -172,18 +172,18 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(NGAuto, NGAuto, NGAuto, NGAuto, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), true);
   estimated_inline = min_max_60;
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position_inline_end, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position_inline_end,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min_max_60.min_size, dimensions.size.inline_size);
   EXPECT_EQ(container_size_.inline_size, dimensions.inset.inline_end);
 
   // All auto + RTL.
-  ComputeOutOfFlowInlineDimensions(rtl_space_, *style_, rtl_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      rtl_space_, *style_, rtl_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min_max_60.min_size, dimensions.size.inline_size);
   EXPECT_EQ(container_size_.inline_size - min_max_60.min_size,
             dimensions.inset.inline_end);
@@ -192,10 +192,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(left, NGAuto, width, NGAuto, right);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   LayoutUnit margin_space = (container_size_.inline_size - left - right -
                              dimensions.size.inline_size) /
                             2;
@@ -229,10 +229,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   // left, right, and width are known, not enough space for margins LTR.
   SetHorizontalStyle(left, NGAuto, LayoutUnit(200), NGAuto, right);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(left, dimensions.inset.inline_start);
   EXPECT_EQ(-left, dimensions.inset.inline_end);
 
@@ -240,10 +240,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(left, NGAuto, LayoutUnit(200), NGAuto, right,
                      WritingMode::kHorizontalTb);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(rtl_space_, *style_, rtl_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kRtl, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      rtl_space_, *style_, rtl_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kRtl, &dimensions);
   EXPECT_EQ(-right, dimensions.inset.inline_start);
   EXPECT_EQ(right, dimensions.inset.inline_end);
 
@@ -251,20 +251,20 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(NGAuto, margin_left, NGAuto, margin_right, right);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), true);
   estimated_inline = min_max_60;
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min_max_60.min_size, dimensions.size.inline_size);
 
   // Rule 2 left and right are auto LTR.
   SetHorizontalStyle(NGAuto, margin_left, width, margin_right, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(margin_left, dimensions.inset.inline_start);
   EXPECT_EQ(container_size_.inline_size - margin_left - width,
             dimensions.inset.inline_end);
@@ -273,10 +273,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(NGAuto, margin_left, width, margin_right, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(rtl_space_, *style_, rtl_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      rtl_space_, *style_, rtl_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(margin_left, dimensions.inset.inline_start);
   EXPECT_EQ(container_size_.inline_size - margin_left - width,
             dimensions.inset.inline_end);
@@ -285,10 +285,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(left, margin_left, NGAuto, margin_right, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), true);
   estimated_inline = min_max_60;
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(
       container_size_.inline_size - min_max_60.min_size - left - margin_left,
       dimensions.inset.inline_end);
@@ -298,10 +298,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(NGAuto, margin_left, width, margin_right, right);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(left + margin_left, dimensions.inset.inline_start);
 
   // Rule 4: left is auto, EBoxSizing::kContentBox
@@ -311,10 +311,10 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
                      margin_right, right);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(left + margin_left, dimensions.inset.inline_start);
   style_->SetBoxSizing(EBoxSizing::kBorderBox);
 
@@ -322,20 +322,20 @@ TEST_F(NGAbsoluteUtilsTest, Horizontal) {
   SetHorizontalStyle(left, margin_left, width, margin_right, NGAuto);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(right + margin_right, dimensions.inset.inline_end);
 
   // Rule 6: width is auto.
   SetHorizontalStyle(left, margin_left, NGAuto, margin_right, right);
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   estimated_inline.reset();
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(width, dimensions.size.inline_size);
 }
 
@@ -430,7 +430,7 @@ TEST_F(NGAbsoluteUtilsTest, Vertical) {
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   ComputeOutOfFlowInlineDimensions(vlr_space_, *style_, vlr_border_padding,
                                    static_position, min_max_60, base::nullopt,
-                                   WritingMode::kHorizontalTb,
+                                   base::nullopt, WritingMode::kHorizontalTb,
                                    TextDirection::kLtr, &dimensions);
   EXPECT_EQ(top + margin_space, dimensions.inset.inline_start);
   EXPECT_EQ(bottom + margin_space, dimensions.inset.inline_end);
@@ -441,7 +441,7 @@ TEST_F(NGAbsoluteUtilsTest, Vertical) {
   EXPECT_EQ(AbsoluteNeedsChildInlineSize(*style_), false);
   ComputeOutOfFlowInlineDimensions(vrl_space_, *style_, vrl_border_padding,
                                    static_position, min_max_60, base::nullopt,
-                                   WritingMode::kHorizontalTb,
+                                   base::nullopt, WritingMode::kHorizontalTb,
                                    TextDirection::kLtr, &dimensions);
   EXPECT_EQ(top + margin_space, dimensions.inset.inline_start);
   EXPECT_EQ(bottom + margin_space, dimensions.inset.inline_end);
@@ -549,7 +549,7 @@ TEST_F(NGAbsoluteUtilsTest, CenterStaticPosition) {
 
   ComputeOutOfFlowInlineDimensions(
       ltr_space_, *style_, border_padding, static_position,
-      MinMaxSizes{LayoutUnit(), LayoutUnit(1000)}, base::nullopt,
+      MinMaxSizes{LayoutUnit(), LayoutUnit(1000)}, base::nullopt, base::nullopt,
       WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(LayoutUnit(100), dimensions.size.inline_size);
   EXPECT_EQ(LayoutUnit(100), dimensions.inset.inline_start);
@@ -557,7 +557,7 @@ TEST_F(NGAbsoluteUtilsTest, CenterStaticPosition) {
 
   ComputeOutOfFlowInlineDimensions(
       ltr_space_, *style_, border_padding, static_position,
-      MinMaxSizes{LayoutUnit(), LayoutUnit(1000)}, base::nullopt,
+      MinMaxSizes{LayoutUnit(), LayoutUnit(1000)}, base::nullopt, base::nullopt,
       WritingMode::kHorizontalTb, TextDirection::kRtl, &dimensions);
   EXPECT_EQ(LayoutUnit(100), dimensions.size.inline_size);
   EXPECT_EQ(LayoutUnit(100), dimensions.inset.inline_start);
@@ -595,26 +595,26 @@ TEST_F(NGAbsoluteUtilsTest, MinMax) {
 
   // width < min gets set to min.
   SetHorizontalStyle(NGAuto, NGAuto, LayoutUnit(5), NGAuto, NGAuto);
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min, dimensions.size.inline_size);
 
   // width > max gets set to max.
   SetHorizontalStyle(NGAuto, NGAuto, LayoutUnit(200), NGAuto, NGAuto);
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(max, dimensions.size.inline_size);
 
   // Unspecified width becomes min_max, gets clamped to min.
   SetHorizontalStyle(NGAuto, NGAuto, NGAuto, NGAuto, NGAuto);
-  ComputeOutOfFlowInlineDimensions(ltr_space_, *style_, ltr_border_padding,
-                                   static_position, estimated_inline,
-                                   base::nullopt, WritingMode::kHorizontalTb,
-                                   TextDirection::kLtr, &dimensions);
+  ComputeOutOfFlowInlineDimensions(
+      ltr_space_, *style_, ltr_border_padding, static_position,
+      estimated_inline, base::nullopt, base::nullopt,
+      WritingMode::kHorizontalTb, TextDirection::kLtr, &dimensions);
   EXPECT_EQ(min, dimensions.size.inline_size);
 
   // HEIGHT TESTS

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

@@ -746,13 +746,16 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
   bool should_be_considered_as_replaced = node.ShouldBeConsideredAsReplaced();
   bool absolute_needs_child_block_size =
       AbsoluteNeedsChildBlockSize(candidate_style);
+  base::Optional<MinMaxSizes> minmax_intrinsic_sizes_for_ar;
 
   // We also include items with aspect ratio here, because if the inline size
   // is auto and we have a definite block size, we want to use that for the
   // inline size calculation.
+  bool compute_inline_from_ar =
+      IsInlineSizeComputableFromBlockSize(candidate_style);
   if (AbsoluteNeedsChildInlineSize(candidate_style) ||
       NeedMinMaxSize(candidate_style) || should_be_considered_as_replaced ||
-      IsInlineSizeComputableFromBlockSize(candidate_style)) {
+      compute_inline_from_ar) {
     MinMaxSizesInput input(kIndefiniteSize, MinMaxSizesType::kContent);
     if (is_replaced) {
       input.percentage_resolution_block_size =
@@ -767,6 +770,15 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
       has_computed_block_dimensions = true;
       input.percentage_resolution_block_size = node_dimensions.size.block_size;
     }
+    if (compute_inline_from_ar &&
+        candidate_style.OverflowInlineDirection() == EOverflow::kVisible) {
+      MinMaxSizesInput intrinsic_input(input);
+      intrinsic_input.type = MinMaxSizesType::kIntrinsic;
+      minmax_intrinsic_sizes_for_ar =
+          node.ComputeMinMaxSizes(candidate_writing_mode, intrinsic_input,
+                                  &candidate_constraint_space)
+              .sizes;
+    }
 
     min_max_sizes = node.ComputeMinMaxSizes(candidate_writing_mode, input,
                                             &candidate_constraint_space)
@@ -798,10 +810,11 @@ scoped_refptr<const NGLayoutResult> NGOutOfFlowLayoutPart::Layout(
                     kIndefiniteSize};
   }
 
-  ComputeOutOfFlowInlineDimensions(
-      candidate_constraint_space, candidate_style, border_padding,
-      candidate_static_position, min_max_sizes, replaced_size,
-      default_writing_mode, container_direction, &node_dimensions);
+  ComputeOutOfFlowInlineDimensions(candidate_constraint_space, candidate_style,
+                                   border_padding, candidate_static_position,
+                                   min_max_sizes, minmax_intrinsic_sizes_for_ar,
+                                   replaced_size, default_writing_mode,
+                                   container_direction, &node_dimensions);
 
   // |should_be_considered_as_replaced| sets the inline-size.
   // It does not set the block-size. This is a compatibility quirk.

third_party/blink/web_tests/TestExpectations

@@ -273,7 +273,6 @@ crbug.com/1004547 external/wpt/intersection-observer/cross-origin-iframe.sub.htm
 crbug.com/1007229 external/wpt/intersection-observer/same-origin-grand-child-iframe.sub.html [ Pass Failure ]
 
 # Not supported yet
-crbug.com/1045668 external/wpt/css/css-sizing/aspect-ratio/abspos-013.tentative.html [ Failure ]
 crbug.com/1045668 external/wpt/css/css-sizing/aspect-ratio/flex-aspect-ratio-013.tentative.html [ Failure ]
 crbug.com/1045668 external/wpt/css/css-sizing/aspect-ratio/flex-aspect-ratio-014.tentative.html [ Failure ]
 crbug.com/1045668 external/wpt/css/css-sizing/aspect-ratio/replaced-element-016.tentative.html [ Failure ]