Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Replace ComputedValues with WritingMode on IndefiniteContainingBlock (#34090)

Browse source 
We only need the writing mode, not the entire computed style.

Signed-off-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
Oriol Brufau 2024-11-04 19:00:58 +01:00 • committed by GitHub
parent 73d2f3c453
commit 072ff302d2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
9 changed files with 70 additions and 82 deletions
Download patch file Download diff file Expand all files Collapse all files

24
components/layout_2020/flexbox/layout.rs
View file

@ -1826,10 +1826,9 @@ impl FlexItem<'_> {
} else { } else {
( (
cross_size.auto_is(|| { cross_size.auto_is(|| {
let style = ifc.style().clone();
let containing_block_for_children = let containing_block_for_children =
IndefiniteContainingBlock::new_for_style_and_block_size( IndefiniteContainingBlock::new_for_writing_mode_and_block_size(
&style, item_writing_mode,
AuOrAuto::LengthPercentage(used_main_size), AuOrAuto::LengthPercentage(used_main_size),
); );
let content_contributions = ifc let content_contributions = ifc
@ -2439,9 +2438,12 @@ impl FlexItemBox {
// > preferred aspect ratio, by any definite minimum and maximum cross sizes converted through the // > preferred aspect ratio, by any definite minimum and maximum cross sizes converted through the
// > aspect ratio. // > aspect ratio.
let main_content_size = if cross_axis_is_item_block_axis { 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 = 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 self.independent_formatting_context
.inline_content_sizes( .inline_content_sizes(
layout_context, layout_context,
@ -2596,7 +2598,7 @@ impl FlexItemBox {
let flex_basis = if cross_axis_is_item_block_axis { 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 // The main axis is the inline axis, so we can get the content size from the normal
// preferred widths calculation. // 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| { let block_size = content_box_size.cross.map(|v| {
v.clamp_between_extremums( v.clamp_between_extremums(
content_min_box_size.cross, content_min_box_size.cross,
@ -2604,7 +2606,10 @@ impl FlexItemBox {
) )
}); });
let containing_block_for_children = 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 let max_content = flex_item
.inline_content_sizes( .inline_content_sizes(
layout_context, layout_context,
@ -2690,9 +2695,10 @@ impl FlexItemBox {
if item_with_auto_cross_size_stretches_to_container_size { if item_with_auto_cross_size_stretches_to_container_size {
containing_block_inline_size_minus_pbm containing_block_inline_size_minus_pbm
} else { } else {
let style = non_replaced.style.clone();
let containing_block_for_children = let containing_block_for_children =
IndefiniteContainingBlock::new_for_style(&style); IndefiniteContainingBlock::new_for_writing_mode(
non_replaced.style.writing_mode,
);
non_replaced non_replaced
.inline_content_sizes( .inline_content_sizes(
flex_context.layout_context, flex_context.layout_context,

8
components/layout_2020/flow/inline/mod.rs
View file

@ -2188,7 +2188,7 @@ fn inline_container_needs_strut(
/// A struct which takes care of computing [`ContentSizes`] for an [`InlineFormattingContext`]. /// A struct which takes care of computing [`ContentSizes`] for an [`InlineFormattingContext`].
struct ContentSizesComputation<'layout_data> { struct ContentSizesComputation<'layout_data> {
layout_context: &'layout_data LayoutContext<'layout_data>, layout_context: &'layout_data LayoutContext<'layout_data>,
containing_block: &'layout_data IndefiniteContainingBlock<'layout_data>, containing_block: &'layout_data IndefiniteContainingBlock,
paragraph: ContentSizes, paragraph: ContentSizes,
current_line: ContentSizes, current_line: ContentSizes,
/// Size for whitespace pending to be added to this line. /// 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 zero = Au::zero();
let padding = inline_box let padding = inline_box
.style .style
.padding(self.containing_block.style.writing_mode) .padding(self.containing_block.writing_mode)
.percentages_relative_to(zero); .percentages_relative_to(zero);
let border = inline_box let border = inline_box
.style .style
.border_width(self.containing_block.style.writing_mode); .border_width(self.containing_block.writing_mode);
let margin = inline_box let margin = inline_box
.style .style
.margin(self.containing_block.style.writing_mode) .margin(self.containing_block.writing_mode)
.percentages_relative_to(zero) .percentages_relative_to(zero)
.auto_is(Au::zero); .auto_is(Au::zero);

6
components/layout_2020/flow/mod.rs
View file

@ -235,7 +235,7 @@ impl OutsideMarker {
) -> Fragment { ) -> Fragment {
let content_sizes = self.block_container.inline_content_sizes( let content_sizes = self.block_container.inline_content_sizes(
layout_context, 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 { let containing_block_for_children = ContainingBlock {
inline_size: content_sizes.sizes.max_content, inline_size: content_sizes.sizes.max_content,
@ -2058,8 +2058,8 @@ impl IndependentFormattingContext {
let mut get_content_size = || { let mut get_content_size = || {
let containing_block_for_children = let containing_block_for_children =
IndefiniteContainingBlock::new_for_style_and_block_size( IndefiniteContainingBlock::new_for_writing_mode_and_block_size(
&style, style.writing_mode,
tentative_block_size, tentative_block_size,
); );
non_replaced non_replaced

43
components/layout_2020/lib.rs
View file

@ -29,56 +29,60 @@ use app_units::Au;
pub use flow::BoxTree; pub use flow::BoxTree;
pub use fragment_tree::FragmentTree; pub use fragment_tree::FragmentTree;
use geom::AuOrAuto; use geom::AuOrAuto;
use style::logical_geometry::WritingMode;
use style::properties::ComputedValues; use style::properties::ComputedValues;
use crate::geom::LogicalVec2; use crate::geom::LogicalVec2;
/// A containing block useful for calculating inline content sizes, which may /// A containing block useful for calculating inline content sizes, which may
/// have inline sizes that depend on block sizes due to aspect ratio. /// have inline sizes that depend on block sizes due to aspect ratio.
pub(crate) struct IndefiniteContainingBlock<'a> { pub(crate) struct IndefiniteContainingBlock {
pub size: LogicalVec2<AuOrAuto>, pub size: LogicalVec2<AuOrAuto>,
pub style: &'a ComputedValues, pub writing_mode: WritingMode,
} }
impl<'a> IndefiniteContainingBlock<'a> { impl IndefiniteContainingBlock {
fn new_for_style(style: &'a ComputedValues) -> Self { fn new_for_writing_mode(writing_mode: WritingMode) -> Self {
Self::new_for_style_and_block_size(style, AuOrAuto::Auto) Self::new_for_writing_mode_and_block_size(writing_mode, AuOrAuto::Auto)
} }
/// Creates an [`IndefiniteContainingBlock`] with the provided style and block size, /// Creates an [`IndefiniteContainingBlock`] with the provided style and block size,
/// and the inline size is set to auto. /// and the inline size is set to auto.
/// This is useful when finding the min-content or max-content size of an element, /// 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'. /// 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 { Self {
size: LogicalVec2 { size: LogicalVec2 {
inline: AuOrAuto::Auto, inline: AuOrAuto::Auto,
block: block_size, 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 { fn from(containing_block: &ContainingBlock<'a>) -> Self {
Self { Self {
size: LogicalVec2 { size: LogicalVec2 {
inline: AuOrAuto::LengthPercentage(containing_block.inline_size), inline: AuOrAuto::LengthPercentage(containing_block.inline_size),
block: containing_block.block_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 { fn from(containing_block: &DefiniteContainingBlock<'a>) -> Self {
Self { Self {
size: containing_block size: containing_block
.size .size
.map(|v| AuOrAuto::LengthPercentage(*v)), .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, style: &'a ComputedValues,
} }
impl<'a> TryFrom<&'_ IndefiniteContainingBlock<'a>> for ContainingBlock<'a> {
type Error = &'static str;
fn try_from(
indefinite_containing_block: &IndefiniteContainingBlock<'a>,
) -> Result<Self, Self::Error> {
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> { struct DefiniteContainingBlock<'a> {
size: LogicalVec2<Au>, size: LogicalVec2<Au>,
style: &'a ComputedValues, style: &'a ComputedValues,

5
components/layout_2020/positioned.rs
View file

@ -547,7 +547,10 @@ impl HoistedAbsolutelyPositionedBox {
// tentative block size. // tentative block size.
let mut inline_axis = inline_axis_solver.solve(Some(|| { let mut inline_axis = inline_axis_solver.solve(Some(|| {
let containing_block_for_children = 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 context
.inline_content_sizes( .inline_content_sizes(
layout_context, layout_context,

5
components/layout_2020/replaced.rs
View file

@ -277,7 +277,7 @@ impl ReplacedContent {
depends_on_block_constraints: true, 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 { InlineContentSizesResult {
sizes: self sizes: self
.flow_relative_natural_size(writing_mode) .flow_relative_natural_size(writing_mode)
@ -423,8 +423,7 @@ impl ReplacedContent {
style style
.preferred_aspect_ratio( .preferred_aspect_ratio(
self.inline_size_over_block_size_intrinsic_ratio(style), self.inline_size_over_block_size_intrinsic_ratio(style),
containing_block.try_into().ok().as_ref(), containing_block,
containing_block.style.writing_mode,
) )
.or_else(|| { .or_else(|| {
matches!(self.kind, ReplacedContentKind::Video(_)).then(|| { matches!(self.kind, ReplacedContentKind::Video(_)).then(|| {

5
components/layout_2020/sizing.rs
View file

@ -162,7 +162,10 @@ pub(crate) fn outer_inline(
}) })
.map_or(AuOrAuto::Auto, AuOrAuto::LengthPercentage); .map_or(AuOrAuto::Auto, AuOrAuto::LengthPercentage);
let containing_block_for_children = 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) get_content_size(&containing_block_for_children)
}); });
let resolve_non_initial = |inline_size| { let resolve_non_initial = |inline_size| {

46
components/layout_2020/style_ext.rs
View file

@ -318,8 +318,7 @@ pub(crate) trait ComputedValuesExt {
fn preferred_aspect_ratio( fn preferred_aspect_ratio(
&self, &self,
natural_aspect_ratio: Option<CSSFloat>, natural_aspect_ratio: Option<CSSFloat>,
containing_block: Option<&ContainingBlock>, containing_block: &IndefiniteContainingBlock,
containing_block_writing_mode: WritingMode,
) -> Option<AspectRatio>; ) -> Option<AspectRatio>;
fn background_is_transparent(&self) -> bool; fn background_is_transparent(&self) -> bool;
fn get_webrender_primitive_flags(&self) -> wr::PrimitiveFlags; 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 = containing_block.size.map(|value| value.non_auto());
let containing_block_size_auto_is_zero = let containing_block_size_auto_is_zero =
containing_block_size.map(|value| value.unwrap_or_else(Au::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( let pbm = self.padding_border_margin_with_writing_mode_and_containing_block_inline_size(
writing_mode, writing_mode,
containing_block.size.inline.auto_is(Au::zero), containing_block.size.inline.auto_is(Au::zero),
@ -583,22 +582,10 @@ impl ComputedValuesExt for ComputedValues {
&self, &self,
writing_mode: WritingMode, writing_mode: WritingMode,
) -> PaddingBorderMargin { ) -> PaddingBorderMargin {
let padding = self self.padding_border_margin_with_writing_mode_and_containing_block_inline_size(
.padding(writing_mode) writing_mode,
.percentages_relative_to(Au::zero()); 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,
}
} }
fn padding_border_margin_with_writing_mode_and_containing_block_inline_size( fn padding_border_margin_with_writing_mode_and_containing_block_inline_size(
@ -890,8 +877,7 @@ impl ComputedValuesExt for ComputedValues {
fn preferred_aspect_ratio( fn preferred_aspect_ratio(
&self, &self,
natural_aspect_ratio: Option<CSSFloat>, natural_aspect_ratio: Option<CSSFloat>,
containing_block: Option<&ContainingBlock>, containing_block: &IndefiniteContainingBlock,
containing_block_writing_mode: WritingMode,
) -> Option<AspectRatio> { ) -> Option<AspectRatio> {
let GenericAspectRatio { let GenericAspectRatio {
auto, auto,
@ -934,15 +920,15 @@ impl ComputedValuesExt for ComputedValues {
// border when calculating the aspect ratio. // border when calculating the aspect ratio.
let box_sizing_adjustment = match self.clone_box_sizing() { let box_sizing_adjustment = match self.clone_box_sizing() {
BoxSizing::ContentBox => LogicalVec2::zero(), BoxSizing::ContentBox => LogicalVec2::zero(),
BoxSizing::BorderBox => { BoxSizing::BorderBox => containing_block.size.inline.non_auto().map_or_else(
match containing_block { || self.padding_border_margin_for_intrinsic_size(containing_block.writing_mode),
Some(containing_block) => self.padding_border_margin(containing_block), |containing_block_inline_size| self
None => self.padding_border_margin_for_intrinsic_size( .padding_border_margin_with_writing_mode_and_containing_block_inline_size(
containing_block_writing_mode, containing_block.writing_mode,
), containing_block_inline_size,
} )
.padding_border_sums )
}, .padding_border_sums,
}; };
Some(AspectRatio { Some(AspectRatio {
i_over_b: (preferred_ratio.0).0 / (preferred_ratio.1).0, i_over_b: (preferred_ratio.0).0 / (preferred_ratio.1).0,

10
components/layout_2020/table/layout.rs
View file

@ -301,7 +301,9 @@ impl<'a> TableLayout<'a> {
.contents .contents
.inline_content_sizes( .inline_content_sizes(
layout_context, layout_context,
&IndefiniteContainingBlock::new_for_style(&cell.style), &IndefiniteContainingBlock::new_for_writing_mode(
cell.style.writing_mode,
),
) )
.sizes .sizes
}; };
@ -774,6 +776,8 @@ impl<'a> TableLayout<'a> {
/// Compute CAPMIN: <https://drafts.csswg.org/css-tables/#capmin> /// Compute CAPMIN: <https://drafts.csswg.org/css-tables/#capmin>
fn compute_caption_minimum_inline_size(&mut self, layout_context: &LayoutContext) -> Au { 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 self.table
.captions .captions
.iter() .iter()
@ -782,7 +786,7 @@ impl<'a> TableLayout<'a> {
context context
.outer_inline_content_sizes( .outer_inline_content_sizes(
layout_context, layout_context,
&IndefiniteContainingBlock::new_for_style(&self.table.style), &containing_block,
&LogicalVec2::zero(), &LogicalVec2::zero(),
false, /* auto_block_size_stretches_to_containing_block */ false, /* auto_block_size_stretches_to_containing_block */
) )
@ -2628,7 +2632,7 @@ impl Table {
layout_context: &LayoutContext, layout_context: &LayoutContext,
containing_block_for_children: &IndefiniteContainingBlock, containing_block_for_children: &IndefiniteContainingBlock,
) -> InlineContentSizesResult { ) -> 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 layout = TableLayout::new(self);
let mut table_content_sizes = layout.compute_grid_min_max(layout_context, writing_mode); let mut table_content_sizes = layout.compute_grid_min_max(layout_context, writing_mode);