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 {
(
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,

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`].
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);

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

@ -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

43
components/layout_2020/lib.rs
View file

@ -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<AuOrAuto>,
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<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> {
size: LogicalVec2<Au>,
style: &'a ComputedValues,

5
components/layout_2020/positioned.rs
View file

@ -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,

5
components/layout_2020/replaced.rs
View file

@ -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(|| {

5
components/layout_2020/sizing.rs
View file

@ -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| {

46
components/layout_2020/style_ext.rs
View file

@ -318,8 +318,7 @@ pub(crate) trait ComputedValuesExt {
fn preferred_aspect_ratio(
&self,
natural_aspect_ratio: Option<CSSFloat>,
containing_block: Option<&ContainingBlock>,
containing_block_writing_mode: WritingMode,
containing_block: &IndefiniteContainingBlock,
) -> Option<AspectRatio>;
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<CSSFloat>,
containing_block: Option<&ContainingBlock>,
containing_block_writing_mode: WritingMode,
containing_block: &IndefiniteContainingBlock,
) -> Option<AspectRatio> {
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,

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

@ -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: <https://drafts.csswg.org/css-tables/#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);