diff --git a/components/layout_2020/flexbox/layout.rs b/components/layout_2020/flexbox/layout.rs index bb580c23f8d..698167a213a 100644 --- a/components/layout_2020/flexbox/layout.rs +++ b/components/layout_2020/flexbox/layout.rs @@ -1826,10 +1826,9 @@ impl FlexItem<'_> { } else { ( cross_size.auto_is(|| { - let style = ifc.style().clone(); let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size( - &style, + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + item_writing_mode, AuOrAuto::LengthPercentage(used_main_size), ); let content_contributions = ifc @@ -2439,9 +2438,12 @@ impl FlexItemBox { // > preferred aspect ratio, by any definite minimum and maximum cross sizes converted through the // > aspect ratio. let main_content_size = if cross_axis_is_item_block_axis { - let style = self.independent_formatting_context.style().clone(); + let writing_mode = self.independent_formatting_context.style().writing_mode; let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size(&style, cross_size); + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + writing_mode, + cross_size, + ); self.independent_formatting_context .inline_content_sizes( layout_context, @@ -2596,7 +2598,7 @@ impl FlexItemBox { let flex_basis = if cross_axis_is_item_block_axis { // The main axis is the inline axis, so we can get the content size from the normal // preferred widths calculation. - let style = flex_item.style().clone(); + let writing_mode = flex_item.style().writing_mode; let block_size = content_box_size.cross.map(|v| { v.clamp_between_extremums( content_min_box_size.cross, @@ -2604,7 +2606,10 @@ impl FlexItemBox { ) }); let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size(&style, block_size); + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + writing_mode, + block_size, + ); let max_content = flex_item .inline_content_sizes( layout_context, @@ -2690,9 +2695,10 @@ impl FlexItemBox { if item_with_auto_cross_size_stretches_to_container_size { containing_block_inline_size_minus_pbm } else { - let style = non_replaced.style.clone(); let containing_block_for_children = - IndefiniteContainingBlock::new_for_style(&style); + IndefiniteContainingBlock::new_for_writing_mode( + non_replaced.style.writing_mode, + ); non_replaced .inline_content_sizes( flex_context.layout_context, diff --git a/components/layout_2020/flow/inline/mod.rs b/components/layout_2020/flow/inline/mod.rs index 73c678e0458..c4de3a9ca42 100644 --- a/components/layout_2020/flow/inline/mod.rs +++ b/components/layout_2020/flow/inline/mod.rs @@ -2188,7 +2188,7 @@ fn inline_container_needs_strut( /// A struct which takes care of computing [`ContentSizes`] for an [`InlineFormattingContext`]. struct ContentSizesComputation<'layout_data> { layout_context: &'layout_data LayoutContext<'layout_data>, - containing_block: &'layout_data IndefiniteContainingBlock<'layout_data>, + containing_block: &'layout_data IndefiniteContainingBlock, paragraph: ContentSizes, current_line: ContentSizes, /// Size for whitespace pending to be added to this line. @@ -2236,14 +2236,14 @@ impl<'layout_data> ContentSizesComputation<'layout_data> { let zero = Au::zero(); let padding = inline_box .style - .padding(self.containing_block.style.writing_mode) + .padding(self.containing_block.writing_mode) .percentages_relative_to(zero); let border = inline_box .style - .border_width(self.containing_block.style.writing_mode); + .border_width(self.containing_block.writing_mode); let margin = inline_box .style - .margin(self.containing_block.style.writing_mode) + .margin(self.containing_block.writing_mode) .percentages_relative_to(zero) .auto_is(Au::zero); diff --git a/components/layout_2020/flow/mod.rs b/components/layout_2020/flow/mod.rs index 834b16c304e..c03c8445ae8 100644 --- a/components/layout_2020/flow/mod.rs +++ b/components/layout_2020/flow/mod.rs @@ -235,7 +235,7 @@ impl OutsideMarker { ) -> Fragment { let content_sizes = self.block_container.inline_content_sizes( layout_context, - &IndefiniteContainingBlock::new_for_style(&self.marker_style), + &IndefiniteContainingBlock::new_for_writing_mode(self.marker_style.writing_mode), ); let containing_block_for_children = ContainingBlock { inline_size: content_sizes.sizes.max_content, @@ -2058,8 +2058,8 @@ impl IndependentFormattingContext { let mut get_content_size = || { let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size( - &style, + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + style.writing_mode, tentative_block_size, ); non_replaced diff --git a/components/layout_2020/lib.rs b/components/layout_2020/lib.rs index b7295f952fb..3d00123aa53 100644 --- a/components/layout_2020/lib.rs +++ b/components/layout_2020/lib.rs @@ -29,56 +29,60 @@ use app_units::Au; pub use flow::BoxTree; pub use fragment_tree::FragmentTree; use geom::AuOrAuto; +use style::logical_geometry::WritingMode; use style::properties::ComputedValues; use crate::geom::LogicalVec2; /// A containing block useful for calculating inline content sizes, which may /// have inline sizes that depend on block sizes due to aspect ratio. -pub(crate) struct IndefiniteContainingBlock<'a> { +pub(crate) struct IndefiniteContainingBlock { pub size: LogicalVec2, - pub style: &'a ComputedValues, + pub writing_mode: WritingMode, } -impl<'a> IndefiniteContainingBlock<'a> { - fn new_for_style(style: &'a ComputedValues) -> Self { - Self::new_for_style_and_block_size(style, AuOrAuto::Auto) +impl IndefiniteContainingBlock { + fn new_for_writing_mode(writing_mode: WritingMode) -> Self { + Self::new_for_writing_mode_and_block_size(writing_mode, AuOrAuto::Auto) } /// Creates an [`IndefiniteContainingBlock`] with the provided style and block size, /// and the inline size is set to auto. /// This is useful when finding the min-content or max-content size of an element, /// since then we ignore its 'inline-size', 'min-inline-size' and 'max-inline-size'. - fn new_for_style_and_block_size(style: &'a ComputedValues, block_size: AuOrAuto) -> Self { + fn new_for_writing_mode_and_block_size( + writing_mode: WritingMode, + block_size: AuOrAuto, + ) -> Self { Self { size: LogicalVec2 { inline: AuOrAuto::Auto, block: block_size, }, - style, + writing_mode, } } } -impl<'a> From<&'_ ContainingBlock<'a>> for IndefiniteContainingBlock<'a> { +impl<'a> From<&'_ ContainingBlock<'a>> for IndefiniteContainingBlock { fn from(containing_block: &ContainingBlock<'a>) -> Self { Self { size: LogicalVec2 { inline: AuOrAuto::LengthPercentage(containing_block.inline_size), block: containing_block.block_size, }, - style: containing_block.style, + writing_mode: containing_block.style.writing_mode, } } } -impl<'a> From<&'_ DefiniteContainingBlock<'a>> for IndefiniteContainingBlock<'a> { +impl<'a> From<&'_ DefiniteContainingBlock<'a>> for IndefiniteContainingBlock { fn from(containing_block: &DefiniteContainingBlock<'a>) -> Self { Self { size: containing_block .size .map(|v| AuOrAuto::LengthPercentage(*v)), - style: containing_block.style, + writing_mode: containing_block.style.writing_mode, } } } @@ -89,23 +93,6 @@ pub struct ContainingBlock<'a> { style: &'a ComputedValues, } -impl<'a> TryFrom<&'_ IndefiniteContainingBlock<'a>> for ContainingBlock<'a> { - type Error = &'static str; - - fn try_from( - indefinite_containing_block: &IndefiniteContainingBlock<'a>, - ) -> Result { - match indefinite_containing_block.size.inline { - AuOrAuto::Auto => Err("ContainingBlock doesn't accept auto inline sizes"), - AuOrAuto::LengthPercentage(inline_size) => Ok(ContainingBlock { - inline_size, - block_size: indefinite_containing_block.size.block, - style: indefinite_containing_block.style, - }), - } - } -} - struct DefiniteContainingBlock<'a> { size: LogicalVec2, style: &'a ComputedValues, diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index e1286905549..4e2368575f3 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -547,7 +547,10 @@ impl HoistedAbsolutelyPositionedBox { // tentative block size. let mut inline_axis = inline_axis_solver.solve(Some(|| { let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size(&style, block_axis.size); + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + style.writing_mode, + block_axis.size, + ); context .inline_content_sizes( layout_context, diff --git a/components/layout_2020/replaced.rs b/components/layout_2020/replaced.rs index 589f7bdf0cc..387ad969cd5 100644 --- a/components/layout_2020/replaced.rs +++ b/components/layout_2020/replaced.rs @@ -277,7 +277,7 @@ impl ReplacedContent { depends_on_block_constraints: true, }, _ => { - let writing_mode = containing_block_for_children.style.writing_mode; + let writing_mode = containing_block_for_children.writing_mode; InlineContentSizesResult { sizes: self .flow_relative_natural_size(writing_mode) @@ -423,8 +423,7 @@ impl ReplacedContent { style .preferred_aspect_ratio( self.inline_size_over_block_size_intrinsic_ratio(style), - containing_block.try_into().ok().as_ref(), - containing_block.style.writing_mode, + containing_block, ) .or_else(|| { matches!(self.kind, ReplacedContentKind::Video(_)).then(|| { diff --git a/components/layout_2020/sizing.rs b/components/layout_2020/sizing.rs index 42d998e1fa1..60e9128cb86 100644 --- a/components/layout_2020/sizing.rs +++ b/components/layout_2020/sizing.rs @@ -162,7 +162,10 @@ pub(crate) fn outer_inline( }) .map_or(AuOrAuto::Auto, AuOrAuto::LengthPercentage); let containing_block_for_children = - IndefiniteContainingBlock::new_for_style_and_block_size(style, block_size); + IndefiniteContainingBlock::new_for_writing_mode_and_block_size( + style.writing_mode, + block_size, + ); get_content_size(&containing_block_for_children) }); let resolve_non_initial = |inline_size| { diff --git a/components/layout_2020/style_ext.rs b/components/layout_2020/style_ext.rs index 093ab9d61c9..0e9e873c701 100644 --- a/components/layout_2020/style_ext.rs +++ b/components/layout_2020/style_ext.rs @@ -318,8 +318,7 @@ pub(crate) trait ComputedValuesExt { fn preferred_aspect_ratio( &self, natural_aspect_ratio: Option, - containing_block: Option<&ContainingBlock>, - containing_block_writing_mode: WritingMode, + containing_block: &IndefiniteContainingBlock, ) -> Option; fn background_is_transparent(&self) -> bool; fn get_webrender_primitive_flags(&self) -> wr::PrimitiveFlags; @@ -523,7 +522,7 @@ impl ComputedValuesExt for ComputedValues { let containing_block_size = containing_block.size.map(|value| value.non_auto()); let containing_block_size_auto_is_zero = containing_block_size.map(|value| value.unwrap_or_else(Au::zero)); - let writing_mode = containing_block.style.writing_mode; + let writing_mode = containing_block.writing_mode; let pbm = self.padding_border_margin_with_writing_mode_and_containing_block_inline_size( writing_mode, containing_block.size.inline.auto_is(Au::zero), @@ -583,22 +582,10 @@ impl ComputedValuesExt for ComputedValues { &self, writing_mode: WritingMode, ) -> PaddingBorderMargin { - let padding = self - .padding(writing_mode) - .percentages_relative_to(Au::zero()); - let border = self.border_width(writing_mode); - let margin = self - .margin(writing_mode) - .percentages_relative_to(Au::zero()); - PaddingBorderMargin { - padding_border_sums: LogicalVec2 { - inline: padding.inline_sum() + border.inline_sum(), - block: padding.block_sum() + border.block_sum(), - }, - padding, - border, - margin, - } + self.padding_border_margin_with_writing_mode_and_containing_block_inline_size( + writing_mode, + Au::zero(), + ) } fn padding_border_margin_with_writing_mode_and_containing_block_inline_size( @@ -890,8 +877,7 @@ impl ComputedValuesExt for ComputedValues { fn preferred_aspect_ratio( &self, natural_aspect_ratio: Option, - containing_block: Option<&ContainingBlock>, - containing_block_writing_mode: WritingMode, + containing_block: &IndefiniteContainingBlock, ) -> Option { let GenericAspectRatio { auto, @@ -934,15 +920,15 @@ impl ComputedValuesExt for ComputedValues { // border when calculating the aspect ratio. let box_sizing_adjustment = match self.clone_box_sizing() { BoxSizing::ContentBox => LogicalVec2::zero(), - BoxSizing::BorderBox => { - match containing_block { - Some(containing_block) => self.padding_border_margin(containing_block), - None => self.padding_border_margin_for_intrinsic_size( - containing_block_writing_mode, - ), - } - .padding_border_sums - }, + BoxSizing::BorderBox => containing_block.size.inline.non_auto().map_or_else( + || self.padding_border_margin_for_intrinsic_size(containing_block.writing_mode), + |containing_block_inline_size| self + .padding_border_margin_with_writing_mode_and_containing_block_inline_size( + containing_block.writing_mode, + containing_block_inline_size, + ) + ) + .padding_border_sums, }; Some(AspectRatio { i_over_b: (preferred_ratio.0).0 / (preferred_ratio.1).0, diff --git a/components/layout_2020/table/layout.rs b/components/layout_2020/table/layout.rs index 359f6fe5132..9a521df1927 100644 --- a/components/layout_2020/table/layout.rs +++ b/components/layout_2020/table/layout.rs @@ -301,7 +301,9 @@ impl<'a> TableLayout<'a> { .contents .inline_content_sizes( layout_context, - &IndefiniteContainingBlock::new_for_style(&cell.style), + &IndefiniteContainingBlock::new_for_writing_mode( + cell.style.writing_mode, + ), ) .sizes }; @@ -774,6 +776,8 @@ impl<'a> TableLayout<'a> { /// Compute CAPMIN: fn compute_caption_minimum_inline_size(&mut self, layout_context: &LayoutContext) -> Au { + let containing_block = + IndefiniteContainingBlock::new_for_writing_mode(self.table.style.writing_mode); self.table .captions .iter() @@ -782,7 +786,7 @@ impl<'a> TableLayout<'a> { context .outer_inline_content_sizes( layout_context, - &IndefiniteContainingBlock::new_for_style(&self.table.style), + &containing_block, &LogicalVec2::zero(), false, /* auto_block_size_stretches_to_containing_block */ ) @@ -2628,7 +2632,7 @@ impl Table { layout_context: &LayoutContext, containing_block_for_children: &IndefiniteContainingBlock, ) -> InlineContentSizesResult { - let writing_mode = containing_block_for_children.style.writing_mode; + let writing_mode = containing_block_for_children.writing_mode; let mut layout = TableLayout::new(self); let mut table_content_sizes = layout.compute_grid_min_max(layout_context, writing_mode);