Rename ReplacedContent::layout to make_fragments and simplify its API

components/layout_2020/flow/inline.rs

@@ -17,7 +17,7 @@ use app_units::Au;
 use gfx::text::text_run::GlyphRun;
 use servo_arc::Arc;
 use style::properties::ComputedValues;
-use style::values::computed::{Length, LengthOrAuto, Percentage};
+use style::values::computed::{Length, Percentage};
 use style::Zero;
 use webrender_api::FontInstanceKey;
 
@@ -418,29 +418,13 @@ fn layout_atomic<'box_tree>(
     let fragment = match atomic.as_replaced() {
         Ok(replaced) => {
             // FIXME: implement https://drafts.csswg.org/css2/visudet.html#inline-replaced-width
-            let inline_size = Length::zero();
+            // and https://drafts.csswg.org/css2/visudet.html#inline-replaced-height
-            let block_size = Length::zero();
+            let size = Vec2::zero();
-            let containing_block_for_children = ContainingBlock {
+            let fragments = replaced.make_fragments(&atomic.style, size.clone());
-                inline_size,
+            let content_rect = Rect { start_corner, size };
-                block_size: LengthOrAuto::LengthPercentage(block_size),
-                mode: atomic.style.writing_mode(),
-            };
-            // https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
-            assert_eq!(
-                ifc.containing_block.mode, containing_block_for_children.mode,
-                "Mixed writing modes are not supported yet"
-            );
-            let independent_layout = replaced.layout(&atomic.style, &containing_block_for_children);
-            let content_rect = Rect {
-                start_corner,
-                size: Vec2 {
-                    block: independent_layout.content_block_size,
-                    inline: inline_size,
-                },
-            };
             BoxFragment {
                 style: atomic.style.clone(),
-                children: independent_layout.fragments,
+                children: fragments,
                 content_rect,
                 padding,
                 border,

components/layout_2020/flow/mod.rs

@@ -516,17 +516,11 @@ fn layout_in_flow_replaced_block_level<'a>(
         block_start: computed_margin.block_start.auto_is(Length::zero),
         block_end: computed_margin.block_end.auto_is(Length::zero),
     };
-    let containing_block_for_children = ContainingBlock {
+    let size = Vec2 {
-        inline_size,
+        block: block_size,
-        block_size: LengthOrAuto::LengthPercentage(block_size),
+        inline: inline_size,
-        mode,
     };
-    // https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
+    let fragments = replaced.make_fragments(style, size.clone());
-    assert_eq!(
-        containing_block.mode, containing_block_for_children.mode,
-        "Mixed writing modes are not supported yet"
-    );
-    let independent_layout = replaced.layout(style, &containing_block_for_children);
     let relative_adjustement = relative_adjustement(
         style,
         inline_size,
@@ -537,14 +531,11 @@ fn layout_in_flow_replaced_block_level<'a>(
             block: pb.block_start + relative_adjustement.block,
             inline: pb.inline_start + relative_adjustement.inline + margin.inline_start,
         },
-        size: Vec2 {
+        size,
-            block: block_size,
-            inline: inline_size,
-        },
     };
     BoxFragment {
         style: style.clone(),
-        children: independent_layout.fragments,
+        children: fragments,
         content_rect,
         padding,
         border,

components/layout_2020/positioned.rs

@@ -302,24 +302,35 @@ impl<'a> AbsolutelyPositionedFragment<'a> {
             }
         });
 
-        let containing_block_for_children = ContainingBlock {
-            inline_size,
-            block_size,
-            mode: style.writing_mode(),
-        };
-        // https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
-        assert_eq!(
-            containing_block.mode, containing_block_for_children.mode,
-            "Mixed writing modes are not supported yet"
-        );
         let mut absolutely_positioned_fragments = Vec::new();
         let mut independent_layout = match self.absolutely_positioned_box.contents.as_replaced() {
-            // FIXME: implement https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
+            Ok(replaced) => {
-            Ok(replaced) => replaced.layout(
+                // FIXME: implement https://drafts.csswg.org/css2/visudet.html#abs-replaced-width
-                &self.absolutely_positioned_box.contents.style,
+                // and https://drafts.csswg.org/css2/visudet.html#abs-replaced-height
-                &containing_block_for_children,
+                let block_size = block_size.auto_is(|| Length::zero());
-            ),
+                let fragments = replaced.make_fragments(
+                    &self.absolutely_positioned_box.contents.style,
+                    Vec2 {
+                        inline: inline_size,
+                        block: block_size,
+                    },
+                );
+                crate::formatting_contexts::IndependentLayout {
+                    fragments,
+                    content_block_size: block_size,
+                }
+            },
             Err(non_replaced) => {
+                let containing_block_for_children = ContainingBlock {
+                    inline_size,
+                    block_size,
+                    mode: style.writing_mode(),
+                };
+                // https://drafts.csswg.org/css-writing-modes/#orthogonal-flows
+                assert_eq!(
+                    containing_block.mode, containing_block_for_children.mode,
+                    "Mixed writing modes are not supported yet"
+                );
                 let dummy_tree_rank = 0;
                 non_replaced.layout(
                     layout_context,
@@ -358,7 +369,7 @@ impl<'a> AbsolutelyPositionedFragment<'a> {
             &mut independent_layout.fragments,
             &content_rect.size,
             &padding,
-            containing_block_for_children.mode,
+            style.writing_mode(),
         );
 
         Fragment::Box(BoxFragment {

components/layout_2020/replaced.rs

@@ -3,10 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::dom_traversal::NodeExt;
-use crate::formatting_contexts::IndependentLayout;
 use crate::fragments::{Fragment, ImageFragment};
 use crate::geom::{flow_relative, physical};
-use crate::ContainingBlock;
 use net_traits::image::base::Image;
 use servo_arc::Arc as ServoArc;
 use std::sync::Arc;
@@ -35,39 +33,27 @@ impl ReplacedContent {
         None
     }
 
-    pub fn layout<'a>(
+    pub fn make_fragments<'a>(
         &'a self,
         style: &ServoArc<ComputedValues>,
-        containing_block: &ContainingBlock,
+        size: flow_relative::Vec2<Length>,
-    ) -> IndependentLayout {
+    ) -> Vec<Fragment> {
-        let (fragments, content_block_size) = match self.kind {
+        match &self.kind {
-            ReplacedContentKind::Image(ref image) => {
+            ReplacedContentKind::Image(image) => image
-                // FIXME(nox): We should not assume block size is known.
+                .as_ref()
-                let block_size = containing_block.block_size.non_auto().unwrap();
+                .and_then(|image| image.id)
-                let fragments = image
+                .map(|image_key| {
-                    .as_ref()
+                    Fragment::Image(ImageFragment {
-                    .and_then(|image| image.id)
+                        style: style.clone(),
-                    .map(|image_key| {
+                        content_rect: flow_relative::Rect {
-                        Fragment::Image(ImageFragment {
+                            start_corner: flow_relative::Vec2::zero(),
-                            style: style.clone(),
+                            size,
-                            content_rect: flow_relative::Rect {
+                        },
-                                start_corner: flow_relative::Vec2::zero(),
+                        image_key,
-                                size: flow_relative::Vec2 {
-                                    inline: containing_block.inline_size,
-                                    block: block_size,
-                                },
-                            },
-                            image_key,
-                        })
                     })
-                    .into_iter()
+                })
-                    .collect::<Vec<_>>();
+                .into_iter()
-                (fragments, block_size)
+                .collect(),
-            },
-        };
-        IndependentLayout {
-            fragments,
-            content_block_size,
         }
     }
 }