diff --git a/components/layout/construct_modern.rs b/components/layout/construct_modern.rs index d4b3211ab80..bda7fed6174 100644 --- a/components/layout/construct_modern.rs +++ b/components/layout/construct_modern.rs @@ -18,7 +18,6 @@ use crate::flow::inline::construct::InlineFormattingContextBuilder; use crate::flow::{BlockContainer, BlockFormattingContext}; use crate::formatting_contexts::{ IndependentFormattingContext, IndependentFormattingContextContents, - IndependentNonReplacedContents, }; use crate::layout_box_base::LayoutBoxBase; use crate::style_ext::{ComputedValuesExt, DisplayGeneratingBox}; @@ -72,9 +71,7 @@ impl<'dom> ModernContainerJob<'dom> { let info: &NodeAndStyleInfo = anonymous_info; let formatting_context = IndependentFormattingContext { base: LayoutBoxBase::new(info.into(), info.style.clone()), - contents: IndependentFormattingContextContents::NonReplaced( - IndependentNonReplacedContents::Flow(block_formatting_context), - ), + contents: IndependentFormattingContextContents::Flow(block_formatting_context), }; Some(ModernItem { diff --git a/components/layout/flow/inline/mod.rs b/components/layout/flow/inline/mod.rs index 1ebb6327ab6..7326ca2610d 100644 --- a/components/layout/flow/inline/mod.rs +++ b/components/layout/flow/inline/mod.rs @@ -123,9 +123,7 @@ use crate::context::LayoutContext; use crate::dom_traversal::NodeAndStyleInfo; use crate::flow::CollapsibleWithParentStartMargin; use crate::flow::float::{FloatBox, SequentialLayoutState}; -use crate::formatting_contexts::{ - Baselines, IndependentFormattingContext, IndependentNonReplacedContents, -}; +use crate::formatting_contexts::{Baselines, IndependentFormattingContext}; use crate::fragment_tree::{ BoxFragment, CollapsedBlockMargins, CollapsedMargin, Fragment, FragmentFlags, PositioningFragment, @@ -2153,9 +2151,7 @@ impl IndependentFormattingContext { BaselineSource::First => baselines.first, BaselineSource::Last => baselines.last, BaselineSource::Auto => match &self.contents { - IndependentFormattingContextContents::NonReplaced( - IndependentNonReplacedContents::Flow(_), - ) => baselines.last, + IndependentFormattingContextContents::Flow(_) => baselines.last, _ => baselines.first, }, } diff --git a/components/layout/formatting_contexts.rs b/components/layout/formatting_contexts.rs index c32b43a3c9a..8c91e90fd2b 100644 --- a/components/layout/formatting_contexts.rs +++ b/components/layout/formatting_contexts.rs @@ -39,14 +39,7 @@ pub(crate) struct IndependentFormattingContext { #[derive(Debug, MallocSizeOf)] pub(crate) enum IndependentFormattingContextContents { - NonReplaced(IndependentNonReplacedContents), Replaced(ReplacedContents), -} - -// Private so that code outside of this module cannot match variants. -// It should got through methods instead. -#[derive(Debug, MallocSizeOf)] -pub(crate) enum IndependentNonReplacedContents { Flow(BlockFormattingContext), Flex(FlexContainer), Grid(TaffyContainer), @@ -86,16 +79,18 @@ impl IndependentFormattingContext { let contents = match display_inside { DisplayInside::Flow { is_list_item } | DisplayInside::FlowRoot { is_list_item } => { - IndependentNonReplacedContents::Flow(BlockFormattingContext::construct( - context, - node_and_style_info, - non_replaced_contents, - propagated_data, - is_list_item, - )) + IndependentFormattingContextContents::Flow( + BlockFormattingContext::construct( + context, + node_and_style_info, + non_replaced_contents, + propagated_data, + is_list_item, + ), + ) }, DisplayInside::Grid => { - IndependentNonReplacedContents::Grid(TaffyContainer::construct( + IndependentFormattingContextContents::Grid(TaffyContainer::construct( context, node_and_style_info, non_replaced_contents, @@ -103,7 +98,7 @@ impl IndependentFormattingContext { )) }, DisplayInside::Flex => { - IndependentNonReplacedContents::Flex(FlexContainer::construct( + IndependentFormattingContextContents::Flex(FlexContainer::construct( context, node_and_style_info, non_replaced_contents, @@ -120,7 +115,7 @@ impl IndependentFormattingContext { &node_and_style_info.style, ); base_fragment_info.flags.insert(FragmentFlags::DO_NOT_PAINT); - IndependentNonReplacedContents::Table(Table::construct( + IndependentFormattingContextContents::Table(Table::construct( context, node_and_style_info, table_grid_style, @@ -131,7 +126,7 @@ impl IndependentFormattingContext { }; Self { base: LayoutBoxBase::new(base_fragment_info, node_and_style_info.style.clone()), - contents: IndependentFormattingContextContents::NonReplaced(contents), + contents, } }, Contents::Replaced(contents) => { @@ -166,14 +161,8 @@ impl IndependentFormattingContext { layout_context: &LayoutContext, constraint_space: &ConstraintSpace, ) -> InlineContentSizesResult { - match &self.contents { - IndependentFormattingContextContents::NonReplaced(contents) => self - .base - .inline_content_sizes(layout_context, constraint_space, contents), - IndependentFormattingContextContents::Replaced(contents) => self - .base - .inline_content_sizes(layout_context, constraint_space, contents), - } + self.base + .inline_content_sizes(layout_context, constraint_space, &self.contents) } /// Computes the tentative intrinsic block sizes that may be needed while computing @@ -193,7 +182,6 @@ impl IndependentFormattingContext { // See regarding the difference // in behavior for the replaced and non-replaced cases. match &self.contents { - IndependentFormattingContextContents::NonReplaced(_) => None, IndependentFormattingContextContents::Replaced(contents) => { // For replaced elements with no ratio, the returned value doesn't matter. let ratio = preferred_aspect_ratio?; @@ -202,6 +190,7 @@ impl IndependentFormattingContext { let block_size = ratio.compute_dependent_size(Direction::Block, inline_size); Some(block_size.into()) }, + _ => None, } } @@ -225,32 +214,6 @@ impl IndependentFormattingContext { ) } - pub(crate) fn preferred_aspect_ratio( - &self, - padding_border_sums: &LogicalVec2, - ) -> Option { - match &self.contents { - IndependentFormattingContextContents::NonReplaced(content) => { - content.preferred_aspect_ratio() - }, - IndependentFormattingContextContents::Replaced(content) => { - content.preferred_aspect_ratio(self.style(), padding_border_sums) - }, - } - } - - #[inline] - pub(crate) fn layout_style(&self) -> LayoutStyle { - match &self.contents { - IndependentFormattingContextContents::NonReplaced(content) => { - content.layout_style(&self.base) - }, - IndependentFormattingContextContents::Replaced(content) => { - content.layout_style(&self.base) - }, - } - } - pub(crate) fn repair_style( &mut self, context: &SharedStyleContext, @@ -259,13 +222,83 @@ impl IndependentFormattingContext { ) { self.base.repair_style(new_style); match &mut self.contents { - IndependentFormattingContextContents::NonReplaced(content) => { - content.repair_style(context, node, new_style); - }, IndependentFormattingContextContents::Replaced(..) => {}, + IndependentFormattingContextContents::Flow(block_formatting_context) => { + block_formatting_context.repair_style(node, new_style); + }, + IndependentFormattingContextContents::Flex(flex_container) => { + flex_container.repair_style(new_style) + }, + IndependentFormattingContextContents::Grid(taffy_container) => { + taffy_container.repair_style(new_style) + }, + IndependentFormattingContextContents::Table(table) => { + table.repair_style(context, new_style) + }, } } + #[inline] + pub(crate) fn is_table(&self) -> bool { + matches!( + &self.contents, + IndependentFormattingContextContents::Table(_) + ) + } + + #[allow(clippy::too_many_arguments)] + pub(crate) fn layout_without_caching( + &self, + layout_context: &LayoutContext, + positioning_context: &mut PositioningContext, + containing_block_for_children: &ContainingBlock, + containing_block: &ContainingBlock, + preferred_aspect_ratio: Option, + depends_on_block_constraints: bool, + lazy_block_size: &LazySize, + ) -> CacheableLayoutResult { + match &self.contents { + IndependentFormattingContextContents::Replaced(replaced) => replaced.layout( + layout_context, + containing_block_for_children, + preferred_aspect_ratio, + &self.base, + depends_on_block_constraints, + lazy_block_size, + ), + IndependentFormattingContextContents::Flow(bfc) => bfc.layout( + layout_context, + positioning_context, + containing_block_for_children, + depends_on_block_constraints, + ), + IndependentFormattingContextContents::Flex(fc) => fc.layout( + layout_context, + positioning_context, + containing_block_for_children, + depends_on_block_constraints, + lazy_block_size, + ), + IndependentFormattingContextContents::Grid(fc) => fc.layout( + layout_context, + positioning_context, + containing_block_for_children, + containing_block, + ), + IndependentFormattingContextContents::Table(table) => table.layout( + layout_context, + positioning_context, + containing_block_for_children, + containing_block, + depends_on_block_constraints, + ), + } + } + + #[servo_tracing::instrument( + name = "IndependentFormattingContext::layout_with_caching", + skip_all + )] #[allow(clippy::too_many_arguments)] pub(crate) fn layout( &self, @@ -277,94 +310,7 @@ impl IndependentFormattingContext { depends_on_block_constraints: bool, lazy_block_size: &LazySize, ) -> CacheableLayoutResult { - match &self.contents { - IndependentFormattingContextContents::NonReplaced(content) => content.layout( - layout_context, - positioning_context, - containing_block_for_children, - containing_block, - &self.base, - depends_on_block_constraints, - lazy_block_size, - ), - IndependentFormattingContextContents::Replaced(content) => content.layout( - layout_context, - containing_block_for_children, - preferred_aspect_ratio, - &self.base, - depends_on_block_constraints, - lazy_block_size, - ), - } - } - - #[inline] - pub(crate) fn is_table(&self) -> bool { - matches!( - &self.contents, - IndependentFormattingContextContents::NonReplaced( - IndependentNonReplacedContents::Table(_) - ) - ) - } -} - -impl IndependentNonReplacedContents { - pub(crate) fn layout_without_caching( - &self, - layout_context: &LayoutContext, - positioning_context: &mut PositioningContext, - containing_block_for_children: &ContainingBlock, - containing_block: &ContainingBlock, - depends_on_block_constraints: bool, - lazy_block_size: &LazySize, - ) -> CacheableLayoutResult { - match self { - IndependentNonReplacedContents::Flow(bfc) => bfc.layout( - layout_context, - positioning_context, - containing_block_for_children, - depends_on_block_constraints, - ), - IndependentNonReplacedContents::Flex(fc) => fc.layout( - layout_context, - positioning_context, - containing_block_for_children, - depends_on_block_constraints, - lazy_block_size, - ), - IndependentNonReplacedContents::Grid(fc) => fc.layout( - layout_context, - positioning_context, - containing_block_for_children, - containing_block, - ), - IndependentNonReplacedContents::Table(table) => table.layout( - layout_context, - positioning_context, - containing_block_for_children, - containing_block, - depends_on_block_constraints, - ), - } - } - - #[servo_tracing::instrument( - name = "IndependentNonReplacedContents::layout_with_caching", - skip_all - )] - #[allow(clippy::too_many_arguments)] - pub(crate) fn layout( - &self, - layout_context: &LayoutContext, - positioning_context: &mut PositioningContext, - containing_block_for_children: &ContainingBlock, - containing_block: &ContainingBlock, - base: &LayoutBoxBase, - depends_on_block_constraints: bool, - lazy_block_size: &LazySize, - ) -> CacheableLayoutResult { - if let Some(cache) = base.cached_layout_result.borrow().as_ref() { + if let Some(cache) = self.base.cached_layout_result.borrow().as_ref() { let cache = &**cache; if cache.containing_block_for_children_size.inline == containing_block_for_children.size.inline && @@ -390,64 +336,58 @@ impl IndependentNonReplacedContents { &mut child_positioning_context, containing_block_for_children, containing_block, + preferred_aspect_ratio, depends_on_block_constraints, lazy_block_size, ); - *base.cached_layout_result.borrow_mut() = Some(Box::new(CacheableLayoutResultAndInputs { - result: result.clone(), - positioning_context: child_positioning_context.clone(), - containing_block_for_children_size: containing_block_for_children.size.clone(), - })); + *self.base.cached_layout_result.borrow_mut() = + Some(Box::new(CacheableLayoutResultAndInputs { + result: result.clone(), + positioning_context: child_positioning_context.clone(), + containing_block_for_children_size: containing_block_for_children.size.clone(), + })); positioning_context.append(child_positioning_context); result } #[inline] - pub(crate) fn layout_style<'a>(&'a self, base: &'a LayoutBoxBase) -> LayoutStyle<'a> { - match self { - IndependentNonReplacedContents::Flow(fc) => fc.layout_style(base), - IndependentNonReplacedContents::Flex(fc) => fc.layout_style(), - IndependentNonReplacedContents::Grid(fc) => fc.layout_style(), - IndependentNonReplacedContents::Table(fc) => fc.layout_style(None), + pub(crate) fn layout_style(&self) -> LayoutStyle { + match &self.contents { + IndependentFormattingContextContents::Replaced(fc) => fc.layout_style(&self.base), + IndependentFormattingContextContents::Flow(fc) => fc.layout_style(&self.base), + IndependentFormattingContextContents::Flex(fc) => fc.layout_style(), + IndependentFormattingContextContents::Grid(fc) => fc.layout_style(), + IndependentFormattingContextContents::Table(fc) => fc.layout_style(None), } } #[inline] - pub(crate) fn preferred_aspect_ratio(&self) -> Option { - // TODO: support preferred aspect ratios on non-replaced boxes. - None - } - - fn repair_style( - &mut self, - context: &SharedStyleContext, - node: &ServoLayoutNode, - new_style: &Arc, - ) { - match self { - IndependentNonReplacedContents::Flow(block_formatting_context) => { - block_formatting_context.repair_style(node, new_style); + pub(crate) fn preferred_aspect_ratio( + &self, + padding_border_sums: &LogicalVec2, + ) -> Option { + match &self.contents { + IndependentFormattingContextContents::Replaced(replaced) => { + replaced.preferred_aspect_ratio(self.style(), padding_border_sums) }, - IndependentNonReplacedContents::Flex(flex_container) => { - flex_container.repair_style(new_style) - }, - IndependentNonReplacedContents::Grid(taffy_container) => { - taffy_container.repair_style(new_style) - }, - IndependentNonReplacedContents::Table(table) => table.repair_style(context, new_style), + // TODO: support preferred aspect ratios on non-replaced boxes. + _ => None, } } } -impl ComputeInlineContentSizes for IndependentNonReplacedContents { +impl ComputeInlineContentSizes for IndependentFormattingContextContents { fn compute_inline_content_sizes( &self, layout_context: &LayoutContext, constraint_space: &ConstraintSpace, ) -> InlineContentSizesResult { match self { + Self::Replaced(inner) => { + inner.compute_inline_content_sizes(layout_context, constraint_space) + }, Self::Flow(inner) => inner .contents .compute_inline_content_sizes(layout_context, constraint_space), diff --git a/components/layout/replaced.rs b/components/layout/replaced.rs index 443685f1ec9..6c77a056676 100644 --- a/components/layout/replaced.rs +++ b/components/layout/replaced.rs @@ -585,7 +585,6 @@ impl ReplacedContents { depends_on_block_constraints: bool, lazy_block_size: &LazySize, ) -> CacheableLayoutResult { - // TODO: consider caching the result in LayoutBoxBase like we do for non-replaced. let writing_mode = base.style.writing_mode; let inline_size = containing_block_for_children.size.inline; let content_block_size = self.content_size( diff --git a/components/layout/table/construct.rs b/components/layout/table/construct.rs index b5f46ed78ee..72c1730f022 100644 --- a/components/layout/table/construct.rs +++ b/components/layout/table/construct.rs @@ -25,7 +25,6 @@ use crate::dom_traversal::{Contents, NodeAndStyleInfo, NonReplacedContents, Trav use crate::flow::{BlockContainerBuilder, BlockFormattingContext}; use crate::formatting_contexts::{ IndependentFormattingContext, IndependentFormattingContextContents, - IndependentNonReplacedContents, }; use crate::fragment_tree::BaseFragmentInfo; use crate::layout_box_base::LayoutBoxBase; @@ -121,9 +120,7 @@ impl Table { let ifc = IndependentFormattingContext { base: LayoutBoxBase::new((&table_info).into(), table_style), - contents: IndependentFormattingContextContents::NonReplaced( - IndependentNonReplacedContents::Table(table), - ), + contents: IndependentFormattingContextContents::Table(table), }; (table_info, ifc) @@ -875,7 +872,7 @@ impl<'dom> TraversalHandler<'dom> for TableBuilderTraversal<'_, 'dom> { }); let caption = old_caption.unwrap_or_else(|| { - let contents = IndependentNonReplacedContents::Flow( + let contents = IndependentFormattingContextContents::Flow( BlockFormattingContext::construct( self.context, info, @@ -888,9 +885,7 @@ impl<'dom> TraversalHandler<'dom> for TableBuilderTraversal<'_, 'dom> { ArcRefCell::new(TableCaption { context: IndependentFormattingContext { base: LayoutBoxBase::new(info.into(), info.style.clone()), - contents: IndependentFormattingContextContents::NonReplaced( - contents, - ), + contents, }, }) }); diff --git a/components/layout/taffy/layout.rs b/components/layout/taffy/layout.rs index 74a508d694e..7dc5c19bab8 100644 --- a/components/layout/taffy/layout.rs +++ b/components/layout/taffy/layout.rs @@ -136,6 +136,7 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> { // TODO: re-evaluate sizing constraint conversions in light of recent layout changes let containing_block = &self.content_box_size_override; let style = independent_context.style(); + let writing_mode = style.writing_mode; // Adjust known_dimensions from border box to content box let pbm = independent_context @@ -154,43 +155,44 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> { .height .map(|height| height - pb_sum.block), }; + let preferred_aspect_ratio = + independent_context.preferred_aspect_ratio(&pbm.padding_border_sums); - match &independent_context.contents { - IndependentFormattingContextContents::Replaced(replaced) => { - let content_box_size = replaced - .used_size_as_if_inline_element_from_content_box_sizes( - containing_block, - style, - independent_context - .preferred_aspect_ratio(&pbm.padding_border_sums), - LogicalVec2 { - block: &Sizes::new( - option_f32_to_size(content_box_known_dimensions.height), - Size::Initial, - Size::Initial, - ), - inline: &Sizes::new( - option_f32_to_size(content_box_known_dimensions.width), - Size::Initial, - Size::Initial, - ), - }, - Size::FitContent.into(), - pbm.padding_border_sums + pbm.margin.auto_is(Au::zero).sum(), - ) - .to_physical_size(self.style.writing_mode); + // TODO: unify the replaced and non-replaced logic. + if let IndependentFormattingContextContents::Replaced(replaced) = + &independent_context.contents + { + let content_box_size = replaced + .used_size_as_if_inline_element_from_content_box_sizes( + containing_block, + style, + preferred_aspect_ratio, + LogicalVec2 { + block: &Sizes::new( + option_f32_to_size(content_box_known_dimensions.height), + Size::Initial, + Size::Initial, + ), + inline: &Sizes::new( + option_f32_to_size(content_box_known_dimensions.width), + Size::Initial, + Size::Initial, + ), + }, + Size::FitContent.into(), + pbm.padding_border_sums + pbm.margin.auto_is(Au::zero).sum(), + ) + .to_physical_size(writing_mode); - // Create fragments if the RunMode if PerformLayout - // If the RunMode is ComputeSize then only the returned size will be used - if inputs.run_mode == RunMode::PerformLayout { - child.child_fragments = replaced.make_fragments( - self.layout_context, - style, - content_box_size, - ); - } + // Create fragments if the RunMode if PerformLayout + // If the RunMode is ComputeSize then only the returned size will be used + if inputs.run_mode == RunMode::PerformLayout { + child.child_fragments = + replaced.make_fragments(self.layout_context, style, content_box_size); + } - let computed_size = taffy::Size { + let computed_size = + taffy::Size { width: inputs.known_dimensions.width.unwrap_or_else(|| { content_box_size.width.to_f32_px() + pb_sum.inline }), @@ -198,98 +200,96 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> { content_box_size.height.to_f32_px() + pb_sum.block }), }; - let size = inputs.known_dimensions.unwrap_or(computed_size); - taffy::LayoutOutput { - size, - ..taffy::LayoutOutput::DEFAULT - } - }, - - IndependentFormattingContextContents::NonReplaced(non_replaced) => { - // Compute inline size - let inline_size = content_box_known_dimensions.width.unwrap_or_else(|| { - let constraint_space = ConstraintSpace { - // TODO: pass min- and max- size - block_size: SizeConstraint::new( - inputs.parent_size.height.map(Au::from_f32_px), - Au::zero(), - None, - ), - writing_mode: self.style.writing_mode, - preferred_aspect_ratio: non_replaced.preferred_aspect_ratio(), - }; - - let result = independent_context - .inline_content_sizes(self.layout_context, &constraint_space); - let adjusted_available_space = inputs - .available_space - .width - .map_definite_value(|width| width - content_box_inset.inline); - - resolve_content_size(adjusted_available_space, result.sizes) - }); - - // Return early if only inline content sizes are requested - if inputs.run_mode == RunMode::ComputeSize && - inputs.axis == RequestedAxis::Horizontal - { - return taffy::LayoutOutput::from_outer_size(taffy::Size { - width: inline_size + pb_sum.inline, - // If RequestedAxis is Horizontal then height will be ignored. - height: 0.0, - }); - } - - let content_box_size_override = ContainingBlock { - size: ContainingBlockSize { - inline: Au::from_f32_px(inline_size), - block: content_box_known_dimensions - .height - .map(Au::from_f32_px) - .map_or_else(SizeConstraint::default, SizeConstraint::Definite), - }, - style, + let size = inputs.known_dimensions.unwrap_or(computed_size); + taffy::LayoutOutput { + size, + ..taffy::LayoutOutput::DEFAULT + } + } else { + // Compute inline size + let inline_size = content_box_known_dimensions.width.unwrap_or_else(|| { + let constraint_space = ConstraintSpace { + // TODO: pass min- and max- size + block_size: SizeConstraint::new( + inputs.parent_size.height.map(Au::from_f32_px), + Au::zero(), + None, + ), + writing_mode, + preferred_aspect_ratio, }; - let lazy_block_size = match content_box_known_dimensions.height { - // FIXME: use the correct min/max sizes. - None => LazySize::intrinsic(), - Some(height) => Au::from_f32_px(height).into(), - }; + let result = independent_context + .inline_content_sizes(self.layout_context, &constraint_space); + let adjusted_available_space = inputs + .available_space + .width + .map_definite_value(|width| width - content_box_inset.inline); - child.positioning_context = PositioningContext::default(); - let layout = non_replaced.layout_without_caching( - self.layout_context, - &mut child.positioning_context, - &content_box_size_override, - containing_block, - false, /* depends_on_block_constraints */ - &lazy_block_size, - ); + resolve_content_size(adjusted_available_space, result.sizes) + }); - child.child_fragments = layout.fragments; - self.child_specific_layout_infos[usize::from(node_id)] = - layout.specific_layout_info; - - let block_size = lazy_block_size - .resolve(|| layout.content_block_size) - .to_f32_px(); - - let computed_size = taffy::Size { + // Return early if only inline content sizes are requested + if inputs.run_mode == RunMode::ComputeSize && + inputs.axis == RequestedAxis::Horizontal + { + return taffy::LayoutOutput::from_outer_size(taffy::Size { width: inline_size + pb_sum.inline, - height: block_size + pb_sum.block, - }; - let size = inputs.known_dimensions.unwrap_or(computed_size); + // If RequestedAxis is Horizontal then height will be ignored. + height: 0.0, + }); + } - taffy::LayoutOutput { - size, - first_baselines: taffy::Point { - x: None, - y: layout.baselines.first.map(|au| au.to_f32_px()), - }, - ..taffy::LayoutOutput::DEFAULT - } - }, + let content_box_size_override = ContainingBlock { + size: ContainingBlockSize { + inline: Au::from_f32_px(inline_size), + block: content_box_known_dimensions + .height + .map(Au::from_f32_px) + .map_or_else(SizeConstraint::default, SizeConstraint::Definite), + }, + style, + }; + + let lazy_block_size = match content_box_known_dimensions.height { + // FIXME: use the correct min/max sizes. + None => LazySize::intrinsic(), + Some(height) => Au::from_f32_px(height).into(), + }; + + child.positioning_context = PositioningContext::default(); + let layout = independent_context.layout_without_caching( + self.layout_context, + &mut child.positioning_context, + &content_box_size_override, + containing_block, + preferred_aspect_ratio, + false, /* depends_on_block_constraints */ + &lazy_block_size, + ); + + child.child_fragments = layout.fragments; + self.child_specific_layout_infos[usize::from(node_id)] = + layout.specific_layout_info; + + let block_size = lazy_block_size + .resolve(|| layout.content_block_size) + .to_f32_px(); + + let computed_size = taffy::Size { + width: inline_size + pb_sum.inline, + height: block_size + pb_sum.block, + }; + let size = inputs.known_dimensions.unwrap_or(computed_size); + + taffy::LayoutOutput { + size, + first_baselines: taffy::Point { + x: None, + y: layout.baselines.first.map(|au| au.to_f32_px()), + }, + ..taffy::LayoutOutput::DEFAULT + } } }, ) diff --git a/components/layout/taffy/mod.rs b/components/layout/taffy/mod.rs index afacd71ffcd..60747054b9e 100644 --- a/components/layout/taffy/mod.rs +++ b/components/layout/taffy/mod.rs @@ -19,9 +19,7 @@ use crate::construct_modern::{ModernContainerBuilder, ModernItemKind}; use crate::context::LayoutContext; use crate::dom::LayoutBox; use crate::dom_traversal::{NodeAndStyleInfo, NonReplacedContents}; -use crate::formatting_contexts::{ - IndependentFormattingContext, IndependentFormattingContextContents, -}; +use crate::formatting_contexts::IndependentFormattingContext; use crate::fragment_tree::Fragment; use crate::positioned::{AbsolutelyPositionedBox, PositioningContext}; @@ -178,10 +176,7 @@ impl TaffyItemBox { fn is_in_flow_replaced(&self) -> bool { match &self.taffy_level_box { - TaffyItemBoxInner::InFlowBox(fc) => match fc.contents { - IndependentFormattingContextContents::NonReplaced(_) => false, - IndependentFormattingContextContents::Replaced(_) => true, - }, + TaffyItemBoxInner::InFlowBox(fc) => fc.is_replaced(), TaffyItemBoxInner::OutOfFlowAbsolutelyPositionedBox(_) => false, } }