Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-23 13:20:11 +01:00
Code Issues Projects Releases Packages Wiki Activity

layout: Add style to ConstraintSpace and IndefiniteContainingBlock (#39229)

Browse source 
They only had the writing mode, now they will have the entire computed
style.
This is needed for #39230.

Testing: Not needed, no behavior change

Signed-off-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
Oriol Brufau 2025-09-11 23:53:14 +02:00 • committed by GitHub
parent dfdcba88d4
commit 9e9bd80bba
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
10 changed files with 44 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

9
components/layout/flexbox/layout.rs
View file

@ -2050,7 +2050,7 @@ impl FlexItemBox {
let flex_axis = config.flex_axis; let flex_axis = config.flex_axis;
let style = self.style(); let style = self.style();
let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis( let cross_axis_is_item_block_axis = cross_axis_is_item_block_axis(
containing_block.writing_mode.is_horizontal(), containing_block.style.writing_mode.is_horizontal(),
style.writing_mode.is_horizontal(), style.writing_mode.is_horizontal(),
flex_axis, flex_axis,
); );
@ -2180,7 +2180,7 @@ impl FlexItemBox {
// 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 constraint_space = let constraint_space =
ConstraintSpace::new(cross_size, style.writing_mode, preferred_aspect_ratio); ConstraintSpace::new(cross_size, style, preferred_aspect_ratio);
let content_sizes = flex_item let content_sizes = flex_item
.inline_content_sizes(layout_context, &constraint_space) .inline_content_sizes(layout_context, &constraint_space)
.sizes; .sizes;
@ -2586,9 +2586,8 @@ impl FlexItemBox {
block_size: SizeConstraint, block_size: SizeConstraint,
preferred_aspect_ratio: Option<AspectRatio>, preferred_aspect_ratio: Option<AspectRatio>,
) -> ContentSizes { ) -> ContentSizes {
let writing_mode = self.independent_formatting_context.style().writing_mode; let style = self.independent_formatting_context.style();
let constraint_space = let constraint_space = ConstraintSpace::new(block_size, style, preferred_aspect_ratio);
ConstraintSpace::new(block_size, writing_mode, preferred_aspect_ratio);
self.independent_formatting_context self.independent_formatting_context
.inline_content_sizes(flex_context.layout_context, &constraint_space) .inline_content_sizes(flex_context.layout_context, &constraint_space)
.sizes .sizes

4
components/layout/flow/inline/mod.rs
View file

@ -2349,7 +2349,7 @@ impl ComputeInlineContentSizes for InlineFormattingContext {
/// 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>,
constraint_space: &'layout_data ConstraintSpace, constraint_space: &'layout_data ConstraintSpace<'layout_data>,
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.
@ -2394,7 +2394,7 @@ impl<'layout_data> ContentSizesComputation<'layout_data> {
// https://drafts.csswg.org/css-sizing-3/#min-percentage-contribution // https://drafts.csswg.org/css-sizing-3/#min-percentage-contribution
let inline_box = inline_box.borrow(); let inline_box = inline_box.borrow();
let zero = Au::zero(); let zero = Au::zero();
let writing_mode = self.constraint_space.writing_mode; let writing_mode = self.constraint_space.style.writing_mode;
let layout_style = inline_box.layout_style(); let layout_style = inline_box.layout_style();
let padding = layout_style let padding = layout_style
.padding(writing_mode) .padding(writing_mode)

30
components/layout/flow/mod.rs
View file

@ -238,7 +238,7 @@ impl BlockLevelBox {
let get_inline_content_sizes = || { let get_inline_content_sizes = || {
let constraint_space = ConstraintSpace::new( let constraint_space = ConstraintSpace::new(
tentative_block_size, tentative_block_size,
style.writing_mode, style,
None, /* TODO: support preferred aspect ratios on non-replaced boxes */ None, /* TODO: support preferred aspect ratios on non-replaced boxes */
); );
self.inline_content_sizes(layout_context, &constraint_space) self.inline_content_sizes(layout_context, &constraint_space)
@ -508,16 +508,11 @@ fn compute_inline_content_sizes_for_block_level_boxes(
false, /* auto_block_size_stretches_to_containing_block */ false, /* auto_block_size_stretches_to_containing_block */
); );
let style = &float_box.contents.style(); let style = &float_box.contents.style();
let container_writing_mode = containing_block.style.writing_mode;
Some(( Some((
inline_content_sizes_result, inline_content_sizes_result,
FloatSide::from_style_and_container_writing_mode( FloatSide::from_style_and_container_writing_mode(style, container_writing_mode),
style, Clear::from_style_and_container_writing_mode(style, container_writing_mode),
containing_block.writing_mode,
),
Clear::from_style_and_container_writing_mode(
style,
containing_block.writing_mode,
),
)) ))
}, },
BlockLevelBox::SameFormattingContextBlock { base, contents, .. } => { BlockLevelBox::SameFormattingContextBlock { base, contents, .. } => {
@ -551,7 +546,7 @@ fn compute_inline_content_sizes_for_block_level_boxes(
None, None,
Clear::from_style_and_container_writing_mode( Clear::from_style_and_container_writing_mode(
independent.style(), independent.style(),
containing_block.writing_mode, containing_block.style.writing_mode,
), ),
)) ))
}, },
@ -1373,11 +1368,8 @@ impl IndependentFormattingContext {
// With the tentative block size we can compute the inline min/max-content sizes. // With the tentative block size we can compute the inline min/max-content sizes.
let get_inline_content_sizes = || { let get_inline_content_sizes = || {
let constraint_space = ConstraintSpace::new( let constraint_space =
tentative_block_size, ConstraintSpace::new(tentative_block_size, style, preferred_aspect_ratio);
style.writing_mode,
preferred_aspect_ratio,
);
self.inline_content_sizes(layout_context, &constraint_space) self.inline_content_sizes(layout_context, &constraint_space)
.sizes .sizes
}; };
@ -1681,7 +1673,6 @@ fn solve_containing_block_padding_and_border_for_in_flow_box<'a>(
} = layout_style.content_box_sizes_and_padding_border_margin(&containing_block.into()); } = layout_style.content_box_sizes_and_padding_border_margin(&containing_block.into());
let pbm_sums = pbm.sums_auto_is_zero(ignore_block_margins_for_stretch); let pbm_sums = pbm.sums_auto_is_zero(ignore_block_margins_for_stretch);
let writing_mode = style.writing_mode;
let available_inline_size = Au::zero().max(containing_block.size.inline - pbm_sums.inline); let available_inline_size = Au::zero().max(containing_block.size.inline - pbm_sums.inline);
let available_block_size = containing_block let available_block_size = containing_block
.size .size
@ -1721,7 +1712,7 @@ fn solve_containing_block_padding_and_border_for_in_flow_box<'a>(
let get_inline_content_sizes = || { let get_inline_content_sizes = || {
get_inline_content_sizes(&ConstraintSpace::new( get_inline_content_sizes(&ConstraintSpace::new(
tentative_block_size, tentative_block_size,
writing_mode, style,
preferred_aspect_ratio, preferred_aspect_ratio,
)) ))
}; };
@ -2238,7 +2229,6 @@ impl IndependentFormattingContext {
containing_block: &ContainingBlock, containing_block: &ContainingBlock,
) -> IndependentFloatOrAtomicLayoutResult { ) -> IndependentFloatOrAtomicLayoutResult {
let style = self.style(); let style = self.style();
let writing_mode = style.writing_mode;
let container_writing_mode = containing_block.style.writing_mode; let container_writing_mode = containing_block.style.writing_mode;
let layout_style = self.layout_style(); let layout_style = self.layout_style();
let content_box_sizes_and_pbm = let content_box_sizes_and_pbm =
@ -2277,7 +2267,7 @@ impl IndependentFormattingContext {
let get_content_size = || { let get_content_size = || {
let constraint_space = let constraint_space =
ConstraintSpace::new(tentative_block_size, writing_mode, preferred_aspect_ratio); ConstraintSpace::new(tentative_block_size, style, preferred_aspect_ratio);
self.inline_content_sizes(layout_context, &constraint_space) self.inline_content_sizes(layout_context, &constraint_space)
.sizes .sizes
}; };
@ -2300,7 +2290,7 @@ impl IndependentFormattingContext {
}; };
assert_eq!( assert_eq!(
container_writing_mode.is_horizontal(), container_writing_mode.is_horizontal(),
writing_mode.is_horizontal(), style.writing_mode.is_horizontal(),
"Mixed horizontal and vertical writing modes are not supported yet" "Mixed horizontal and vertical writing modes are not supported yet"
); );

36
components/layout/lib.rs
View file

@ -58,74 +58,70 @@ pub(crate) type SharedStyle = ArcRefCell<ServoArc<ComputedValues>>;
/// Represents the set of constraints that we use when computing the min-content /// Represents the set of constraints that we use when computing the min-content
/// and max-content inline sizes of an element. /// and max-content inline sizes of an element.
pub(crate) struct ConstraintSpace { pub(crate) struct ConstraintSpace<'a> {
pub block_size: SizeConstraint, pub block_size: SizeConstraint,
pub writing_mode: WritingMode, pub style: &'a ComputedValues,
pub preferred_aspect_ratio: Option<AspectRatio>, pub preferred_aspect_ratio: Option<AspectRatio>,
} }
impl ConstraintSpace { impl<'a> ConstraintSpace<'a> {
fn new( fn new(
block_size: SizeConstraint, block_size: SizeConstraint,
writing_mode: WritingMode, style: &'a ComputedValues,
preferred_aspect_ratio: Option<AspectRatio>, preferred_aspect_ratio: Option<AspectRatio>,
) -> Self { ) -> Self {
Self { Self {
block_size, block_size,
writing_mode, style,
preferred_aspect_ratio, preferred_aspect_ratio,
} }
} }
fn new_for_style_and_ratio( fn new_for_style_and_ratio(
style: &ComputedValues, style: &'a ComputedValues,
preferred_aspect_ratio: Option<AspectRatio>, preferred_aspect_ratio: Option<AspectRatio>,
) -> Self { ) -> Self {
Self::new( Self::new(SizeConstraint::default(), style, preferred_aspect_ratio)
SizeConstraint::default(),
style.writing_mode,
preferred_aspect_ratio,
)
} }
} }
/// A variant of [`ContainingBlock`] that allows an indefinite inline size. /// A variant of [`ContainingBlock`] that allows an indefinite inline size.
/// Useful for code that is shared for both layout (where we know the inline size /// Useful for code that is shared for both layout (where we know the inline size
/// of the containing block) and intrinsic sizing (where we don't know it). /// of the containing block) and intrinsic sizing (where we don't know it).
pub(crate) struct IndefiniteContainingBlock { pub(crate) struct IndefiniteContainingBlock<'a> {
pub size: LogicalVec2<Option<Au>>, pub size: LogicalVec2<Option<Au>>,
pub writing_mode: WritingMode, pub style: &'a ComputedValues,
} }
impl From<&ConstraintSpace> for IndefiniteContainingBlock { impl<'a> From<&ConstraintSpace<'a>> for IndefiniteContainingBlock<'a> {
fn from(constraint_space: &ConstraintSpace) -> Self { fn from(constraint_space: &ConstraintSpace<'a>) -> Self {
Self { Self {
size: LogicalVec2 { size: LogicalVec2 {
inline: None, inline: None,
block: constraint_space.block_size.to_definite(), block: constraint_space.block_size.to_definite(),
}, },
writing_mode: constraint_space.writing_mode, style: constraint_space.style,
} }
} }
} }
impl<'a> From<&'_ ContainingBlock<'a>> for IndefiniteContainingBlock { impl<'a> From<&'_ ContainingBlock<'a>> for IndefiniteContainingBlock<'a> {
fn from(containing_block: &ContainingBlock<'a>) -> Self { fn from(containing_block: &ContainingBlock<'a>) -> Self {
Self { Self {
size: LogicalVec2 { size: LogicalVec2 {
inline: Some(containing_block.size.inline), inline: Some(containing_block.size.inline),
block: containing_block.size.block.to_definite(), block: containing_block.size.block.to_definite(),
}, },
writing_mode: containing_block.style.writing_mode, style: containing_block.style,
} }
} }
} }
impl<'a> From<&'_ DefiniteContainingBlock<'a>> for IndefiniteContainingBlock { impl<'a> From<&'_ DefiniteContainingBlock<'a>> for IndefiniteContainingBlock<'a> {
fn from(containing_block: &DefiniteContainingBlock<'a>) -> Self { fn from(containing_block: &DefiniteContainingBlock<'a>) -> Self {
Self { Self {
size: containing_block.size.map(|v| Some(*v)), size: containing_block.size.map(|v| Some(*v)),
writing_mode: containing_block.style.writing_mode, style: containing_block.style,
} }
} }
} }

7
components/layout/positioned.rs
View file

@ -532,11 +532,8 @@ impl HoistedAbsolutelyPositionedBox {
// The inline axis can be fully resolved, computing intrinsic sizes using the // The inline axis can be fully resolved, computing intrinsic sizes using the
// extrinsic block size. // extrinsic block size.
let get_inline_content_size = || { let get_inline_content_size = || {
let constraint_space = ConstraintSpace::new( let constraint_space =
tentative_block_size, ConstraintSpace::new(tentative_block_size, &style, preferred_aspect_ratio);
style.writing_mode,
preferred_aspect_ratio,
);
context context
.inline_content_sizes(layout_context, &constraint_space) .inline_content_sizes(layout_context, &constraint_space)
.sizes .sizes

2
components/layout/replaced.rs
View file

@ -546,7 +546,7 @@ impl ComputeInlineContentSizes for ReplacedContents {
Direction::Inline, Direction::Inline,
constraint_space.preferred_aspect_ratio, constraint_space.preferred_aspect_ratio,
&|| constraint_space.block_size, &|| constraint_space.block_size,
&|| self.fallback_inline_size(constraint_space.writing_mode), &|| self.fallback_inline_size(constraint_space.style.writing_mode),
); );
InlineContentSizesResult { InlineContentSizesResult {
sizes: inline_content_size.into(), sizes: inline_content_size.into(),

9
components/layout/sizing.rs
View file

@ -175,14 +175,14 @@ pub(crate) fn outer_inline(
available_block_size, available_block_size,
) )
}; };
ConstraintSpace::new(block_size, style.writing_mode, aspect_ratio) ConstraintSpace::new(block_size, style, aspect_ratio)
} else { } else {
// This assumes that there is no preferred aspect ratio, or that there is no // This assumes that there is no preferred aspect ratio, or that there is no
// block size constraint to be transferred so the ratio is irrelevant. // block size constraint to be transferred so the ratio is irrelevant.
// We only get into here for anonymous blocks, for which the assumption holds. // We only get into here for anonymous blocks, for which the assumption holds.
ConstraintSpace::new( ConstraintSpace::new(
containing_block.size.block.into(), containing_block.size.block.into(),
containing_block.writing_mode, containing_block.style,
None, None,
) )
}; };
@ -246,13 +246,14 @@ pub(crate) fn outer_inline(
// We need a comment here to avoid breaking `./mach test-tidy`. // We need a comment here to avoid breaking `./mach test-tidy`.
matches!(size, Size::Numeric(numeric) if numeric.has_percentage()) matches!(size, Size::Numeric(numeric) if numeric.has_percentage())
}; };
let writing_mode = containing_block.style.writing_mode;
if content_box_sizes.inline.preferred.is_initial() && if content_box_sizes.inline.preferred.is_initial() &&
has_percentage(style.box_size(containing_block.writing_mode).inline) has_percentage(style.box_size(writing_mode).inline)
{ {
preferred_min_content = Au::zero(); preferred_min_content = Au::zero();
} }
if content_box_sizes.inline.max.is_initial() && if content_box_sizes.inline.max.is_initial() &&
has_percentage(style.max_box_size(containing_block.writing_mode).inline) has_percentage(style.max_box_size(writing_mode).inline)
{ {
max_min_content = Some(Au::zero()); max_min_content = Some(Au::zero());
} }

2
components/layout/style_ext.rs
View file

@ -1092,7 +1092,7 @@ impl LayoutStyle<'_> {
// we instead resolve indefinite percentages against zero. // we instead resolve indefinite percentages against zero.
let containing_block_size_or_zero = let containing_block_size_or_zero =
containing_block.size.map(|value| value.unwrap_or_default()); containing_block.size.map(|value| value.unwrap_or_default());
let writing_mode = containing_block.writing_mode; let writing_mode = containing_block.style.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_or_zero.inline, containing_block_size_or_zero.inline,

4
components/layout/table/layout.rs
View file

@ -709,7 +709,7 @@ impl<'a> TableLayout<'a> {
fn compute_caption_minimum_inline_size(&self, layout_context: &LayoutContext) -> Au { fn compute_caption_minimum_inline_size(&self, layout_context: &LayoutContext) -> Au {
let containing_block = IndefiniteContainingBlock { let containing_block = IndefiniteContainingBlock {
size: LogicalVec2::default(), size: LogicalVec2::default(),
writing_mode: self.table.style.writing_mode, style: &self.table.style,
}; };
self.table self.table
.captions .captions
@ -2709,7 +2709,7 @@ impl ComputeInlineContentSizes for Table {
layout_context: &LayoutContext, layout_context: &LayoutContext,
constraint_space: &ConstraintSpace, constraint_space: &ConstraintSpace,
) -> InlineContentSizesResult { ) -> InlineContentSizesResult {
let writing_mode = constraint_space.writing_mode; let writing_mode = constraint_space.style.writing_mode;
let mut layout = TableLayout::new(self); let mut layout = TableLayout::new(self);
layout.compute_border_collapse(writing_mode); layout.compute_border_collapse(writing_mode);
layout.pbm = self layout.pbm = self

3
components/layout/taffy/layout.rs
View file

@ -128,7 +128,6 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> {
// TODO: re-evaluate sizing constraint conversions in light of recent layout changes // TODO: re-evaluate sizing constraint conversions in light of recent layout changes
let containing_block = &self.content_box_size_override; let containing_block = &self.content_box_size_override;
let style = independent_context.style(); let style = independent_context.style();
let writing_mode = style.writing_mode;
// Adjust known_dimensions from border box to content box // Adjust known_dimensions from border box to content box
let pbm = independent_context let pbm = independent_context
@ -160,7 +159,7 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> {
let inline_size = content_box_known_dimensions.width.unwrap_or_else(|| { let inline_size = content_box_known_dimensions.width.unwrap_or_else(|| {
let constraint_space = ConstraintSpace { let constraint_space = ConstraintSpace {
block_size: tentative_block_size, block_size: tentative_block_size,
writing_mode, style,
preferred_aspect_ratio, preferred_aspect_ratio,
}; };