Make IndependentFormattingContext a struct that owns styles

… and has a private enum for its contents.

Privacy forces the rest of the code to go through methods
rather than matching on the enum,
reducing accidental layout-mode-specific behavior.

components/layout_2020/dom_traversal.rs

@@ -30,7 +30,7 @@ pub(super) enum Contents<Node> {
     /// <https://drafts.csswg.org/css2/conform.html#replaced-element>
     Replaced(ReplacedContent),
 
-    /// Content of a `::before` or `::after` pseudo-element this is being generated.
+    /// Content of a `::before` or `::after` pseudo-element that is being generated.
     /// <https://drafts.csswg.org/css2/generate.html#content>
     OfPseudoElement(Vec<PseudoElementContentItem>),
 }

components/layout_2020/flow/construct.rs

@@ -7,9 +7,10 @@ use crate::element_data::LayoutBox;
 use crate::flow::float::FloatBox;
 use crate::flow::inline::{InlineBox, InlineFormattingContext, InlineLevelBox, TextRun};
 use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
+use crate::formatting_contexts::IndependentFormattingContext;
 use crate::positioned::AbsolutelyPositionedBox;
 use crate::style_ext::{DisplayGeneratingBox, DisplayInside, DisplayOutside};
-use crate::{take, IndependentFormattingContext};
+use crate::take;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use rayon_croissant::ParallelIteratorExt;
 use servo_arc::Arc;
@@ -450,11 +451,10 @@ where
                 AbsolutelyPositionedBox {
                     contents: IndependentFormattingContext::construct(
                         unimplemented!(),
-                        &style,
+                        style,
                         display_inside,
                         contents,
                     ),
-                    style,
                 },
             ));
             self.current_inline_level_boxes().push(box_.clone());
@@ -482,11 +482,10 @@ where
             let box_ = Arc::new(InlineLevelBox::OutOfFlowFloatBox(FloatBox {
                 contents: IndependentFormattingContext::construct(
                     self.context,
-                    &style,
+                    style,
                     display_inside,
                     contents,
                 ),
-                style,
             }));
             self.current_inline_level_boxes().push(box_.clone());
             box_slot.set(LayoutBox::InlineLevel(box_))
@@ -562,12 +561,12 @@ where
             } => {
                 let contents = IndependentFormattingContext::construct(
                     context,
-                    &style,
+                    style,
                     display_inside,
                     contents,
                 );
                 (
-                    Arc::new(BlockLevelBox::Independent { style, contents }),
+                    Arc::new(BlockLevelBox::Independent(contents)),
                     ContainsFloats::No,
                 )
             },
@@ -580,11 +579,10 @@ where
                     AbsolutelyPositionedBox {
                         contents: IndependentFormattingContext::construct(
                             context,
-                            &style,
+                            style,
                             display_inside,
                             contents,
                         ),
-                        style: style,
                     },
                 ));
                 (block_level_box, ContainsFloats::No)
@@ -596,14 +594,12 @@ where
             } => {
                 let contents = IndependentFormattingContext::construct(
                     context,
-                    &style,
+                    style,
                     display_inside,
                     contents,
                 );
-                let block_level_box = Arc::new(BlockLevelBox::OutOfFlowFloatBox(FloatBox {
-                    contents,
-                    style,
-                }));
+                let block_level_box =
+                    Arc::new(BlockLevelBox::OutOfFlowFloatBox(FloatBox { contents }));
                 (block_level_box, ContainsFloats::Yes)
             },
         }

components/layout_2020/flow/float.rs

@@ -2,13 +2,12 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-use crate::IndependentFormattingContext;
+use crate::formatting_contexts::IndependentFormattingContext;
 use servo_arc::Arc;
 use style::properties::ComputedValues;
 
 #[derive(Debug)]
 pub(crate) struct FloatBox {
-    pub style: Arc<ComputedValues>,
     pub contents: IndependentFormattingContext,
 }
 

components/layout_2020/flow/inline.rs

@@ -118,7 +118,7 @@ impl InlineFormattingContext {
                     },
                     InlineLevelBox::OutOfFlowAbsolutelyPositionedBox(box_) => {
                         let initial_start_corner =
-                            match Display::from(box_.style.get_box().original_display) {
+                            match Display::from(box_.contents.style.get_box().original_display) {
                                 Display::GeneratingBox(DisplayGeneratingBox::OutsideInside {
                                     outside,
                                     inside: _,

components/layout_2020/flow/mod.rs

@@ -7,6 +7,7 @@
 use crate::context::LayoutContext;
 use crate::flow::float::{FloatBox, FloatContext};
 use crate::flow::inline::InlineFormattingContext;
+use crate::formatting_contexts::IndependentFormattingContext;
 use crate::fragments::{
     AnonymousFragment, BoxFragment, CollapsedBlockMargins, CollapsedMargin, Fragment,
 };
@@ -15,7 +16,7 @@ use crate::positioned::{
     adjust_static_positions, AbsolutelyPositionedBox, AbsolutelyPositionedFragment,
 };
 use crate::style_ext::{ComputedValuesExt, Position};
-use crate::{relative_adjustement, ContainingBlock, IndependentFormattingContext};
+use crate::{relative_adjustement, ContainingBlock};
 use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use rayon_croissant::ParallelIteratorExt;
 use servo_arc::Arc;
@@ -50,10 +51,7 @@ pub(crate) enum BlockLevelBox {
     },
     OutOfFlowAbsolutelyPositionedBox(AbsolutelyPositionedBox),
     OutOfFlowFloatBox(FloatBox),
-    Independent {
-        style: Arc<ComputedValues>,
-        contents: IndependentFormattingContext,
-    },
+    Independent(IndependentFormattingContext),
 }
 
 pub(super) struct FlowChildren {
@@ -292,19 +290,24 @@ impl BlockLevelBox {
                     },
                 ))
             },
-            BlockLevelBox::Independent { style, contents } => match contents.as_replaced() {
+            BlockLevelBox::Independent(contents) => match contents.as_replaced() {
                 Ok(replaced) => {
                     // FIXME
                     match *replaced {}
                 },
-                Err(contents) => Fragment::Box(layout_in_flow_non_replaced_block_level(
+                Err(non_replaced) => Fragment::Box(layout_in_flow_non_replaced_block_level(
                     layout_context,
                     containing_block,
                     absolutely_positioned_fragments,
-                    style,
+                    &contents.style,
                     BlockLevelKind::EstablishesAnIndependentFormattingContext,
                     |containing_block, nested_abspos, _| {
-                        contents.layout(layout_context, containing_block, tree_rank, nested_abspos)
+                        non_replaced.layout(
+                            layout_context,
+                            containing_block,
+                            tree_rank,
+                            nested_abspos,
+                        )
                     },
                 )),
             },

components/layout_2020/flow/root.rs

@@ -8,6 +8,7 @@ use crate::dom_traversal::{Contents, NodeExt};
 use crate::flow::construct::ContainsFloats;
 use crate::flow::float::FloatBox;
 use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
+use crate::formatting_contexts::IndependentFormattingContext;
 use crate::fragments::Fragment;
 use crate::geom;
 use crate::geom::flow_relative::Vec2;
@@ -16,7 +17,7 @@ use crate::replaced::ReplacedContent;
 use crate::style_ext::{
     Direction, Display, DisplayGeneratingBox, DisplayInside, DisplayOutside, WritingMode,
 };
-use crate::{ContainingBlock, DefiniteContainingBlock, IndependentFormattingContext};
+use crate::{ContainingBlock, DefiniteContainingBlock};
 use rayon::iter::{IntoParallelRefIterator, ParallelExtend, ParallelIterator};
 use servo_arc::Arc;
 use style::context::SharedStyleContext;
@@ -69,31 +70,32 @@ fn construct_for_root_element<'dom>(
         }
     }
 
+    let position = box_style.position;
+    let float = box_style.float;
     let contents = IndependentFormattingContext::construct(
         context,
-        &style,
+        style,
         display_inside,
         Contents::OfElement(root_element),
     );
-    if box_style.position.is_absolutely_positioned() {
+    if position.is_absolutely_positioned() {
         (
             ContainsFloats::No,
             vec![Arc::new(BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(
-                AbsolutelyPositionedBox { style, contents },
+                AbsolutelyPositionedBox { contents },
             ))],
         )
-    } else if box_style.float.is_floating() {
+    } else if float.is_floating() {
         (
             ContainsFloats::Yes,
             vec![Arc::new(BlockLevelBox::OutOfFlowFloatBox(FloatBox {
                 contents,
-                style,
             }))],
         )
     } else {
         (
             ContainsFloats::No,
-            vec![Arc::new(BlockLevelBox::Independent { style, contents })],
+            vec![Arc::new(BlockLevelBox::Independent(contents))],
         )
     }
 }

components/layout_2020/formatting_contexts.rs

@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+use crate::context::LayoutContext;
+use crate::dom_traversal::{Contents, NodeExt};
+use crate::flow::{BlockFormattingContext, FlowChildren};
+use crate::geom::flow_relative::Vec2;
+use crate::positioned::AbsolutelyPositionedFragment;
+use crate::replaced::ReplacedContent;
+use crate::style_ext::{ComputedValuesExt, Direction, DisplayInside, Position, WritingMode};
+use crate::ContainingBlock;
+use servo_arc::Arc;
+use std::convert::TryInto;
+use style::context::SharedStyleContext;
+use style::properties::ComputedValues;
+
+/// https://drafts.csswg.org/css-display/#independent-formatting-context
+#[derive(Debug)]
+pub(crate) struct IndependentFormattingContext {
+    pub style: Arc<ComputedValues>,
+    contents: IndependentFormattingContextContents,
+}
+
+// Private so that code outside of this module cannot match variants.
+// It should got through methods instead.
+#[derive(Debug)]
+enum IndependentFormattingContextContents {
+    Flow(BlockFormattingContext),
+
+    // Not called FC in specs, but behaves close enough
+    Replaced(ReplacedContent),
+    // Other layout modes go here
+}
+
+pub(crate) struct NonReplacedIFC<'a>(NonReplacedIFCKind<'a>);
+
+enum NonReplacedIFCKind<'a> {
+    Flow(&'a BlockFormattingContext),
+}
+
+impl IndependentFormattingContext {
+    pub fn construct<'dom, 'style>(
+        context: &SharedStyleContext<'style>,
+        style: Arc<ComputedValues>,
+        display_inside: DisplayInside,
+        contents: Contents<impl NodeExt<'dom>>,
+    ) -> Self {
+        use self::IndependentFormattingContextContents as Contents;
+        let contents = match contents.try_into() {
+            Ok(non_replaced) => match display_inside {
+                DisplayInside::Flow | DisplayInside::FlowRoot => Contents::Flow(
+                    BlockFormattingContext::construct(context, &style, non_replaced),
+                ),
+            },
+            Err(replaced) => Contents::Replaced(replaced),
+        };
+        Self { style, contents }
+    }
+
+    pub fn as_replaced(&self) -> Result<&ReplacedContent, NonReplacedIFC> {
+        use self::IndependentFormattingContextContents as Contents;
+        use self::NonReplacedIFC as NR;
+        use self::NonReplacedIFCKind as Kind;
+        match &self.contents {
+            Contents::Replaced(r) => Ok(r),
+            Contents::Flow(f) => Err(NR(Kind::Flow(f))),
+        }
+    }
+
+    pub fn layout<'a>(
+        &'a self,
+        layout_context: &LayoutContext,
+        containing_block: &ContainingBlock,
+        tree_rank: usize,
+        absolutely_positioned_fragments: &mut Vec<AbsolutelyPositionedFragment<'a>>,
+    ) -> FlowChildren {
+        match self.as_replaced() {
+            Ok(replaced) => match *replaced {},
+            Err(ifc) => ifc.layout(
+                layout_context,
+                containing_block,
+                tree_rank,
+                absolutely_positioned_fragments,
+            ),
+        }
+    }
+}
+
+impl<'a> NonReplacedIFC<'a> {
+    pub fn layout(
+        &self,
+        layout_context: &LayoutContext,
+        containing_block: &ContainingBlock,
+        tree_rank: usize,
+        absolutely_positioned_fragments: &mut Vec<AbsolutelyPositionedFragment<'a>>,
+    ) -> FlowChildren {
+        match &self.0 {
+            NonReplacedIFCKind::Flow(bfc) => bfc.layout(
+                layout_context,
+                containing_block,
+                tree_rank,
+                absolutely_positioned_fragments,
+            ),
+        }
+    }
+}