layout: Fix intrinsic contributions of anonymous blocks (#34719)

In order to compute the inline min-content and max-content contributions
of an anonymous block, we were finding its min-content and max-content
inline size with a SizeConstraint coming from the block size of the box.

However, anonymous blocks do not establish a containing block for their
contents, so this patch uses a SizeConstraint from the block size of the
containing block.

Signed-off-by: Oriol Brufau <obrufau@igalia.com>

components/layout_2020/flow/mod.rs

@@ -410,8 +410,9 @@ fn compute_inline_content_sizes_for_block_level_boxes(
                     &base.style,
                     containing_block,
                     &LogicalVec2::zero(),
-                    false,    /* auto_block_size_stretches_to_containing_block */
-                    false,    /* is_table */
+                    false, /* auto_block_size_stretches_to_containing_block */
+                    false, /* is_table */
+                    !matches!(base.style.pseudo(), Some(PseudoElement::ServoAnonymousBox)),
                     |_| None, /* TODO: support preferred aspect ratios on non-replaced boxes */
                     |constraint_space| {
                         base.inline_content_sizes(layout_context, constraint_space, contents)

components/layout_2020/formatting_contexts.rs

@@ -216,6 +216,7 @@ impl IndependentFormattingContext {
             auto_minimum,
             auto_block_size_stretches_to_containing_block,
             is_table,
+            true, /* establishes_containing_block */
             |padding_border_sums| self.preferred_aspect_ratio(padding_border_sums),
             |constraint_space| self.inline_content_sizes(layout_context, constraint_space),
         )

components/layout_2020/geom.rs

@@ -871,6 +871,14 @@ impl SizeConstraint {
     }
 }
 
+impl From<AuOrAuto> for SizeConstraint {
+    fn from(size: AuOrAuto) -> Self {
+        size.non_auto()
+            .map(SizeConstraint::Definite)
+            .unwrap_or_default()
+    }
+}
+
 #[derive(Clone, Default)]
 pub(crate) struct Sizes {
     /// <https://drafts.csswg.org/css-sizing-3/#preferred-size-properties>

components/layout_2020/sizing.rs

@@ -109,12 +109,14 @@ impl From<Au> for ContentSizes {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub(crate) fn outer_inline(
     style: &ComputedValues,
     containing_block: &IndefiniteContainingBlock,
     auto_minimum: &LogicalVec2<Au>,
     auto_block_size_stretches_to_containing_block: bool,
     is_table: bool,
+    establishes_containing_block: bool,
     get_preferred_aspect_ratio: impl FnOnce(&LogicalVec2<Au>) -> Option<AspectRatio>,
     get_content_size: impl FnOnce(&ConstraintSpace) -> InlineContentSizesResult,
 ) -> InlineContentSizesResult {
@@ -129,28 +131,40 @@ pub(crate) fn outer_inline(
         inline: pbm.padding_border_sums.inline + margin.inline_sum(),
     };
     let content_size = LazyCell::new(|| {
-        let available_block_size = containing_block
-            .size
-            .block
-            .non_auto()
-            .map(|v| Au::zero().max(v - pbm_sums.block));
-        let automatic_size = if content_box_sizes.block.preferred.is_initial() &&
-            auto_block_size_stretches_to_containing_block
-        {
-            depends_on_block_constraints = true;
-            Size::Stretch
+        let constraint_space = if establishes_containing_block {
+            let available_block_size = containing_block
+                .size
+                .block
+                .non_auto()
+                .map(|v| Au::zero().max(v - pbm_sums.block));
+            let automatic_size = if content_box_sizes.block.preferred.is_initial() &&
+                auto_block_size_stretches_to_containing_block
+            {
+                depends_on_block_constraints = true;
+                Size::Stretch
+            } else {
+                Size::FitContent
+            };
+            ConstraintSpace::new(
+                content_box_sizes.block.resolve_extrinsic(
+                    automatic_size,
+                    auto_minimum.block,
+                    available_block_size,
+                ),
+                style.writing_mode,
+                get_preferred_aspect_ratio(&pbm.padding_border_sums),
+            )
         } else {
-            Size::FitContent
+            // This assumes that there is no preferred aspect ratio, or that there is no
+            // block size constraint to be transferred so the ratio is irrelevant.
+            // We only get into here for anonymous blocks, for which the assumption holds.
+            ConstraintSpace::new(
+                containing_block.size.block.into(),
+                containing_block.writing_mode,
+                None,
+            )
         };
-        get_content_size(&ConstraintSpace::new(
-            content_box_sizes.block.resolve_extrinsic(
-                automatic_size,
-                auto_minimum.block,
-                available_block_size,
-            ),
-            style.writing_mode,
-            get_preferred_aspect_ratio(&pbm.padding_border_sums),
-        ))
+        get_content_size(&constraint_space)
     });
     let resolve_non_initial = |inline_size| {
         Some(match inline_size {