From 8ba251c95fca13e3cd3b4f577ad93b71514bea7a Mon Sep 17 00:00:00 2001 From: atbrakhi Date: Mon, 12 Feb 2024 23:49:50 +0100 Subject: [PATCH] layout: make `padding` and `border` use `Au` in `pbm` (#31289) * use au for padding and border in pbm * review fix --- components/layout_2020/flexbox/layout.rs | 13 +- components/layout_2020/flow/float.rs | 8 +- components/layout_2020/flow/inline.rs | 50 ++++---- components/layout_2020/flow/line.rs | 30 ++--- components/layout_2020/flow/mod.rs | 119 +++++++++--------- components/layout_2020/geom.rs | 22 ++++ components/layout_2020/positioned.rs | 18 +-- components/layout_2020/style_ext.rs | 30 +++-- components/layout_2020/table/layout.rs | 4 +- .../the-hr-element-0/width.html.ini | 2 + 10 files changed, 168 insertions(+), 128 deletions(-) create mode 100644 tests/wpt/meta/html/rendering/non-replaced-elements/the-hr-element-0/width.html.ini diff --git a/components/layout_2020/flexbox/layout.rs b/components/layout_2020/flexbox/layout.rs index c19a4e509c9..0f93c7da1c1 100644 --- a/components/layout_2020/flexbox/layout.rs +++ b/components/layout_2020/flexbox/layout.rs @@ -517,7 +517,10 @@ impl<'a> FlexItem<'a> { let padding = flex_context.sides_to_flex_relative(pbm.padding); let border = flex_context.sides_to_flex_relative(pbm.border); let padding_border = padding.sum_by_axis() + border.sum_by_axis(); - let pbm_auto_is_zero = padding_border + margin_auto_is_zero.sum_by_axis(); + let pbm_auto_is_zero = FlexRelativeVec2 { + main: padding_border.main.into(), + cross: padding_border.cross.into(), + } + margin_auto_is_zero.sum_by_axis(); let align_self = flex_context.align_for(&box_.style().clone_align_self()); @@ -540,8 +543,8 @@ impl<'a> FlexItem<'a> { content_box_size, content_min_size, content_max_size, - padding: padding.map(|t| (*t).into()), - border: border.map(|t| (*t).into()), + padding, + border, margin, pbm_auto_is_zero, flex_base_size, @@ -557,7 +560,7 @@ fn flex_base_size( flex_item: &mut IndependentFormattingContext, cross_axis_is_item_block_axis: bool, content_box_size: FlexRelativeVec2, - padding_border_sums: FlexRelativeVec2, + padding_border_sums: FlexRelativeVec2, ) -> Length { let used_flex_basis = match &flex_item.style().get_position().flex_basis { FlexBasis::Content => FlexBasis::Content, @@ -568,7 +571,7 @@ fn flex_base_size( BoxSizing::BorderBox => { // This may make `length` negative, // but it will be clamped in the hypothetical main size - length - padding_border_sums.main + length - padding_border_sums.main.into() }, } }; diff --git a/components/layout_2020/flow/float.rs b/components/layout_2020/flow/float.rs index 95c64c81b30..4ddb1878912 100644 --- a/components/layout_2020/flow/float.rs +++ b/components/layout_2020/flow/float.rs @@ -900,7 +900,7 @@ impl FloatBox { // or non-replaced. let pbm = style.padding_border_margin(containing_block); let margin = pbm.margin.auto_is(Length::zero); - let pbm_sums = &(&pbm.padding + &pbm.border) + &margin; + let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone().into(); let (content_size, children); match self.contents { @@ -918,7 +918,7 @@ impl FloatBox { let tentative_inline_size = box_size.inline.auto_is(|| { let available_size = - containing_block.inline_size - pbm_sums.inline_sum(); + containing_block.inline_size - pbm_sums.inline_sum().into(); non_replaced .inline_content_sizes(layout_context) .shrink_to_fit(available_size.into()) @@ -976,8 +976,8 @@ impl FloatBox { style.clone(), children, content_rect, - pbm.padding, - pbm.border, + pbm.padding.into(), + pbm.border.into(), margin, // Clearance is handled internally by the float placement logic, so there's no need // to store it explicitly in the fragment. diff --git a/components/layout_2020/flow/inline.rs b/components/layout_2020/flow/inline.rs index ca4c796281f..b90ee2857ed 100644 --- a/components/layout_2020/flow/inline.rs +++ b/components/layout_2020/flow/inline.rs @@ -648,13 +648,14 @@ impl<'a, 'b> InlineFormattingContextState<'a, 'b> { ); if inline_box.is_first_fragment { - self.current_line.inline_position += inline_box_state.pbm.padding.inline_start + - inline_box_state.pbm.border.inline_start + - inline_box_state - .pbm - .margin - .inline_start - .auto_is(Length::zero); + self.current_line.inline_position += Length::from( + inline_box_state.pbm.padding.inline_start + + inline_box_state.pbm.border.inline_start, + ) + inline_box_state + .pbm + .margin + .inline_start + .auto_is(Length::zero) } let line_item = inline_box_state @@ -686,10 +687,10 @@ impl<'a, 'b> InlineFormattingContextState<'a, 'b> { } if inline_box_state.is_last_fragment { - let pbm_end = inline_box_state.pbm.padding.inline_end + - inline_box_state.pbm.border.inline_end + - inline_box_state.pbm.margin.inline_end.auto_is(Length::zero); - self.current_line_segment.inline_size += pbm_end; + let pbm_end = Length::from( + inline_box_state.pbm.padding.inline_end + inline_box_state.pbm.border.inline_end, + ) + inline_box_state.pbm.margin.inline_end.auto_is(Length::zero); + self.current_line_segment.inline_size += pbm_end.into(); } } @@ -1819,7 +1820,7 @@ impl IndependentFormattingContext { let style = self.style(); let pbm = style.padding_border_margin(ifc.containing_block); let margin = pbm.margin.auto_is(Length::zero); - let pbm_sums = &(&pbm.padding + &pbm.border) + &margin; + let pbm_sums = &(&pbm.padding + &pbm.border) + &margin.clone().into(); let mut child_positioning_context = None; // We need to know the inline size of the atomic before deciding whether to do the line break. @@ -1836,16 +1837,16 @@ impl IndependentFormattingContext { .make_fragments(&replaced.style, size.clone()); let content_rect = LogicalRect { start_corner: pbm_sums.start_offset(), - size: size.into(), + size, }; BoxFragment::new( replaced.base_fragment_info, replaced.style.clone(), fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, None, /* clearance */ CollapsedBlockMargins::zero(), @@ -1865,7 +1866,8 @@ impl IndependentFormattingContext { // https://drafts.csswg.org/css2/visudet.html#inlineblock-width let tentative_inline_size = box_size.inline.auto_is(|| { - let available_size = ifc.containing_block.inline_size - pbm_sums.inline_sum(); + let available_size = + ifc.containing_block.inline_size - pbm_sums.inline_sum().into(); non_replaced .inline_content_sizes(layout_context) .shrink_to_fit(available_size.into()) @@ -1915,8 +1917,8 @@ impl IndependentFormattingContext { let content_rect = LogicalRect { start_corner: pbm_sums.start_offset(), size: LogicalVec2 { - block: block_size, - inline: inline_size, + block: block_size.into(), + inline: inline_size.into(), }, }; @@ -1924,9 +1926,9 @@ impl IndependentFormattingContext { non_replaced.base_fragment_info, non_replaced.style.clone(), independent_layout.fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, None, CollapsedBlockMargins::zero(), @@ -1943,11 +1945,11 @@ impl IndependentFormattingContext { ifc.process_soft_wrap_opportunity(); } - let size = &pbm_sums.sum() + &fragment.content_rect.size; + let size = &pbm_sums.sum().into() + &fragment.content_rect.size; let baseline_offset = fragment .baselines .last - .map(|baseline| Au::from(pbm_sums.block_start) + baseline) + .map(|baseline| pbm_sums.block_start + baseline) .unwrap_or(size.block.into()); let (block_sizes, baseline_offset_in_parent) = diff --git a/components/layout_2020/flow/line.rs b/components/layout_2020/flow/line.rs index b7262ddb6f0..cf384422673 100644 --- a/components/layout_2020/flow/line.rs +++ b/components/layout_2020/flow/line.rs @@ -298,12 +298,17 @@ impl InlineBoxLineItem { let mut margin = self.pbm.margin.auto_is(Length::zero); if !self.is_first_fragment { - padding.inline_start = Length::zero(); - border.inline_start = Length::zero(); + padding.inline_start = Au::zero(); + border.inline_start = Au::zero(); margin.inline_start = Length::zero(); } - let pbm_sums = &(&padding + &border) + &margin; - state.inline_position += pbm_sums.inline_start; + if !self.is_last_fragment_of_ib_split { + padding.inline_end = Au::zero(); + border.inline_end = Au::zero(); + margin.inline_end = Length::zero(); + } + let pbm_sums = &(&padding + &border) + &margin.map(|t| (*t).into()); + state.inline_position += pbm_sums.inline_start.into(); let space_above_baseline = self.calculate_space_above_baseline(); let block_start_offset = self.calculate_block_start(state, space_above_baseline); @@ -336,14 +341,14 @@ impl InlineBoxLineItem { // potential block-in-inline split and this line included the actual end of this // fragment (it doesn't continue on the next line). if !self.is_last_fragment_of_ib_split || !saw_end { - padding.inline_end = Length::zero(); - border.inline_end = Length::zero(); + padding.inline_end = Au::zero(); + border.inline_end = Au::zero(); margin.inline_end = Length::zero(); } - let pbm_sums = &(&padding + &border) + &margin; + let pbm_sums = &(&padding + &border) + &margin.clone().into(); // If the inline box didn't have any content at all, don't add a Fragment for it. - let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Length::zero(); + let box_has_padding_border_or_margin = pbm_sums.inline_sum() > Au::zero(); let box_had_absolutes = original_nested_positioning_context_length != nested_state.positioning_context.len(); if !self.is_first_fragment && @@ -374,22 +379,19 @@ impl InlineBoxLineItem { content_rect.start_corner += &relative_adjustement(&style, state.ifc_containing_block); } - // NB: There is no need to set a baseline offset for this BoxFragment, because the - // baselines of this InlineFormattingContext is what will propagate to `display: - // inline-block` ancestors. let mut fragment = BoxFragment::new( self.base_fragment_info, self.style.clone(), fragments, content_rect, - padding, - border, + padding.into(), + border.into(), margin, None, /* clearance */ CollapsedBlockMargins::zero(), ); - state.inline_position = nested_state.inline_position + pbm_sums.inline_end; + state.inline_position = nested_state.inline_position + pbm_sums.inline_end.into(); if let Some(mut positioning_context) = positioning_context.take() { assert!(original_nested_positioning_context_length == PositioningContextLength::zero()); diff --git a/components/layout_2020/flow/mod.rs b/components/layout_2020/flow/mod.rs index 539b51af999..e04670c42c1 100644 --- a/components/layout_2020/flow/mod.rs +++ b/components/layout_2020/flow/mod.rs @@ -126,7 +126,7 @@ impl BlockLevelBox { _ => return false, }; - if pbm.padding.block_start != Length::zero() || pbm.border.block_start != Length::zero() { + if pbm.padding.block_start != Au::zero() || pbm.border.block_start != Au::zero() { return false; } @@ -142,7 +142,7 @@ impl BlockLevelBox { let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero); containing_block.inline_size - - pbm.padding_border_sums.inline - + pbm.padding_border_sums.inline.into() - margin_inline_start - margin_inline_end }) @@ -169,10 +169,7 @@ impl BlockLevelBox { style.content_block_size().is_definitely_zero() || style.content_block_size().is_auto(); let min_block_size_zero = style.min_block_size().is_definitely_zero() || style.min_block_size().is_auto(); - if !min_block_size_zero || - !block_size_zero || - pbm.padding_border_sums.block != Length::zero() - { + if !min_block_size_zero || !block_size_zero || pbm.padding_border_sums.block != Au::zero() { return false; } @@ -637,9 +634,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( let computed_block_size = style.content_block_size(); let start_margin_can_collapse_with_children = - pbm.padding.block_start == Length::zero() && pbm.border.block_start == Length::zero(); - let end_margin_can_collapse_with_children = pbm.padding.block_end == Length::zero() && - pbm.border.block_end == Length::zero() && + pbm.padding.block_start == Au::zero() && pbm.border.block_start == Au::zero(); + let end_margin_can_collapse_with_children = pbm.padding.block_end == Au::zero() && + pbm.border.block_end == Au::zero() && computed_block_size.is_auto(); let mut clearance = None; @@ -688,10 +685,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( // NB: This will be a no-op if we're collapsing margins with our children since that // can only happen if we have no block-start padding and border. sequential_layout_state.advance_block_position( - (pbm.padding.block_start + + pbm.padding.block_start + pbm.border.block_start + - clearance.unwrap_or_else(Au::zero).into()) - .into(), + clearance.unwrap_or_else(Au::zero), ); // We are about to lay out children. Update the offset between the block formatting @@ -703,8 +699,8 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( .floats .containing_block_info .inline_start + - pbm.padding.inline_start.into() + - pbm.border.inline_start.into() + + pbm.padding.inline_start + + pbm.border.inline_start + margin.inline_start.into(); let new_cb_offsets = ContainingBlockPositionInfo { block_start: sequential_layout_state.bfc_relative_block_position, @@ -754,7 +750,7 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( let computed_min_block_size = style.min_block_size(); block_margins_collapsed_with_children.collapsed_through = collapsible_margins_in_children .collapsed_through && - pbm.padding_border_sums.block == Length::zero() && + pbm.padding_border_sums.block == Au::zero() && (computed_block_size.is_definitely_zero() || computed_block_size.is_auto()) && (computed_min_block_size.is_definitely_zero() || computed_min_block_size.is_auto()); @@ -778,7 +774,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( // the block direction. In that case, the ceiling for floats is effectively raised // as long as no floats in the overflowing content lowered it. sequential_layout_state.advance_block_position( - (block_size - content_block_size + pbm.padding.block_end + pbm.border.block_end).into(), + Au::from(block_size - content_block_size) + + pbm.padding.block_end + + pbm.border.block_end, ); if !end_margin_can_collapse_with_children { @@ -791,12 +789,12 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( start_corner: LogicalVec2 { block: (pbm.padding.block_start + pbm.border.block_start + - clearance.unwrap_or_else(Au::zero).into()), - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, + clearance.unwrap_or_else(Au::zero)), + inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start.into(), }, size: LogicalVec2 { - block: block_size, - inline: containing_block_for_children.inline_size, + block: block_size.into(), + inline: containing_block_for_children.inline_size.into(), }, }; @@ -804,9 +802,9 @@ fn layout_in_flow_non_replaced_block_level_same_formatting_context( base_fragment_info, style.clone(), flow_layout.fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, clearance.map(|t| t.into()), block_margins_collapsed_with_children, @@ -866,22 +864,25 @@ impl NonReplacedFormattingContext { let content_rect = LogicalRect { start_corner: LogicalVec2 { block: pbm.padding.block_start + pbm.border.block_start, - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, + inline: pbm.padding.inline_start + + pbm.border.inline_start + + margin.inline_start.into(), }, size: LogicalVec2 { - block: block_size, - inline: containing_block_for_children.inline_size, + block: block_size.into(), + inline: containing_block_for_children.inline_size.into(), }, }; let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( self.base_fragment_info, self.style.clone(), layout.fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, None, /* clearance */ block_margins_collapsed_with_children, @@ -961,7 +962,7 @@ impl NonReplacedFormattingContext { containing_block, &collapsed_margin_block_start, &pbm, - &content_size + &pbm.padding_border_sums, + &content_size + &pbm.padding_border_sums.clone().into(), &self.style, ); } else { @@ -980,11 +981,13 @@ impl NonReplacedFormattingContext { let minimum_size_of_block = &LogicalVec2 { inline: min_box_size.inline, block: block_size.auto_is(|| min_box_size.block), - } + &pbm.padding_border_sums; + } + .into() + + &pbm.padding_border_sums; let mut placement = PlacementAmongFloats::new( &sequential_layout_state.floats, ceiling, - minimum_size_of_block.into(), + minimum_size_of_block, &pbm, ); let mut placement_rect; @@ -992,10 +995,9 @@ impl NonReplacedFormattingContext { loop { // First try to place the block using the minimum size as the object size. placement_rect = placement.place(); - let proposed_inline_size = Length::from( - placement_rect.size.inline - pbm.padding_border_sums.inline.into(), - ) - .clamp_between_extremums(min_box_size.inline, max_box_size.inline); + let proposed_inline_size = + Length::from(placement_rect.size.inline - pbm.padding_border_sums.inline) + .clamp_between_extremums(min_box_size.inline, max_box_size.inline); // Now lay out the block using the inline size we calculated from the placement. // Later we'll check to see if the resulting block size is compatible with the @@ -1027,7 +1029,7 @@ impl NonReplacedFormattingContext { // size of auto. Try to fit it into our precalculated placement among the // floats. If it fits, then we can stop trying layout candidates. if placement.try_to_expand_for_auto_block_size( - (content_size.block + pbm.padding_border_sums.block).into(), + Au::from(content_size.block) + pbm.padding_border_sums.block, &placement_rect.size, ) { break; @@ -1057,7 +1059,7 @@ impl NonReplacedFormattingContext { sequential_layout_state, containing_block, &pbm, - content_size.inline + pbm.padding_border_sums.inline, + content_size.inline + pbm.padding_border_sums.inline.into(), placement_rect.into(), ); } @@ -1079,10 +1081,8 @@ impl NonReplacedFormattingContext { // Margins can never collapse into independent formatting contexts. sequential_layout_state.collapse_margins(); sequential_layout_state.advance_block_position( - (pbm.padding_border_sums.block + - content_size.block + - clearance.unwrap_or_else(Length::zero)) - .into(), + pbm.padding_border_sums.block + + (content_size.block + clearance.unwrap_or_else(Length::zero)).into(), ); sequential_layout_state.adjoin_assign(&CollapsedMargin::new(margin.block_end)); @@ -1090,19 +1090,22 @@ impl NonReplacedFormattingContext { start_corner: LogicalVec2 { block: pbm.padding.block_start + pbm.border.block_start + - clearance.unwrap_or_else(Length::zero), - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, + clearance.unwrap_or_else(Length::zero).into(), + inline: pbm.padding.inline_start + + pbm.border.inline_start + + margin.inline_start.into(), }, - size: content_size, + size: content_size.into(), }; let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( self.base_fragment_info, self.style.clone(), layout.fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, clearance, block_margins_collapsed_with_children, @@ -1142,7 +1145,7 @@ fn layout_in_flow_replaced_block_level<'a>( // than defined by section 10.3.3. CSS 2 does not define when a UA may put said // element next to the float or by how much said element may become narrower." let collapsed_margin_block_start = CollapsedMargin::new(margin_block_start); - let size = &content_size + &pbm.padding_border_sums.clone().into(); + let size = &content_size + &pbm.padding_border_sums.clone(); (clearance, (margin_inline_start, margin_inline_end)) = solve_clearance_and_inline_margins_avoiding_floats( sequential_layout_state, @@ -1184,22 +1187,23 @@ fn layout_in_flow_replaced_block_level<'a>( let start_corner = LogicalVec2 { block: pbm.padding.block_start + pbm.border.block_start + - clearance.unwrap_or_else(Length::zero), - inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start, + clearance.unwrap_or_else(Length::zero).into(), + inline: pbm.padding.inline_start + pbm.border.inline_start + margin.inline_start.into(), }; let content_rect = LogicalRect { start_corner, - size: content_size.into(), + size: content_size, }; let block_margins_collapsed_with_children = CollapsedBlockMargins::from_margin(&margin); + BoxFragment::new( base_fragment_info, style.clone(), fragments, - content_rect, - pbm.padding, - pbm.border, + content_rect.into(), + pbm.padding.into(), + pbm.border.into(), margin, clearance, block_margins_collapsed_with_children, @@ -1238,7 +1242,7 @@ fn solve_containing_block_padding_border_and_margin_for_in_flow_box<'a>( let margin_inline_start = pbm.margin.inline_start.auto_is(Length::zero); let margin_inline_end = pbm.margin.inline_end.auto_is(Length::zero); containing_block.inline_size - - pbm.padding_border_sums.inline - + pbm.padding_border_sums.inline.into() - margin_inline_start - margin_inline_end }) @@ -1348,7 +1352,8 @@ fn solve_inline_margins_for_in_flow_block_level( pbm: &PaddingBorderMargin, inline_size: Length, ) -> (Length, Length) { - let free_space = containing_block.inline_size - pbm.padding_border_sums.inline - inline_size; + let free_space = + containing_block.inline_size - pbm.padding_border_sums.inline.into() - inline_size; let margin_inline_start = match (pbm.margin.inline_start, pbm.margin.inline_end) { (LengthOrAuto::Auto, LengthOrAuto::Auto) => Length::zero().max(free_space / 2.), (LengthOrAuto::Auto, LengthOrAuto::LengthPercentage(end)) => { diff --git a/components/layout_2020/geom.rs b/components/layout_2020/geom.rs index 2729da46c7f..0540111fd03 100644 --- a/components/layout_2020/geom.rs +++ b/components/layout_2020/geom.rs @@ -362,6 +362,28 @@ impl LogicalSides { } } +impl From> for LogicalSides { + fn from(value: LogicalSides) -> Self { + LogicalSides { + inline_start: value.inline_start.into(), + inline_end: value.inline_end.into(), + block_start: value.block_start.into(), + block_end: value.block_end.into(), + } + } +} + +impl From> for LogicalSides { + fn from(value: LogicalSides) -> Self { + LogicalSides { + inline_start: value.inline_start.into(), + inline_end: value.inline_end.into(), + block_start: value.block_start.into(), + block_end: value.block_end.into(), + } + } +} + impl LogicalRect { pub fn max_inline_position(&self) -> T where diff --git a/components/layout_2020/positioned.rs b/components/layout_2020/positioned.rs index 98bf5333a7c..e742ab0d184 100644 --- a/components/layout_2020/positioned.rs +++ b/components/layout_2020/positioned.rs @@ -500,7 +500,7 @@ impl HoistedAbsolutelyPositionedBox { let shared_fragment = self.fragment.borrow(); let inline_axis_solver = AbsoluteAxisSolver { containing_size: cbis, - padding_border_sum: pbm.padding_border_sums.inline, + padding_border_sum: pbm.padding_border_sums.inline.into(), computed_margin_start: pbm.margin.inline_start, computed_margin_end: pbm.margin.inline_end, avoid_negative_margin_start: true, @@ -509,7 +509,7 @@ impl HoistedAbsolutelyPositionedBox { let block_axis_solver = AbsoluteAxisSolver { containing_size: cbbs, - padding_border_sum: pbm.padding_border_sums.block, + padding_border_sum: pbm.padding_border_sums.block.into(), computed_margin_start: pbm.margin.block_start, computed_margin_end: pbm.margin.block_end, avoid_negative_margin_start: false, @@ -558,7 +558,7 @@ impl HoistedAbsolutelyPositionedBox { }; let margin_sum = inline_axis.margin_start + inline_axis.margin_end; let available_size = - cbis - anchor - pbm.padding_border_sums.inline - margin_sum; + cbis - anchor - pbm.padding_border_sums.inline.into() - margin_sum; non_replaced .inline_content_sizes(layout_context) .shrink_to_fit(available_size.into()) @@ -672,15 +672,15 @@ impl HoistedAbsolutelyPositionedBox { let pb = &pbm.padding + &pbm.border; let inline_start = match inline_axis.anchor { - Anchor::Start(start) => start + pb.inline_start + margin.inline_start, + Anchor::Start(start) => start + pb.inline_start.into() + margin.inline_start, Anchor::End(end) => { - cbis - end - pb.inline_end - margin.inline_end - content_size.inline + cbis - end - pb.inline_end.into() - margin.inline_end - content_size.inline }, }; let block_start = match block_axis.anchor { - Anchor::Start(start) => start + pb.block_start + margin.block_start, + Anchor::Start(start) => start + pb.block_start.into() + margin.block_start, Anchor::End(end) => { - cbbs - end - pb.block_end - margin.block_end - content_size.block + cbbs - end - pb.block_end.into() - margin.block_end - content_size.block }, }; @@ -700,8 +700,8 @@ impl HoistedAbsolutelyPositionedBox { absolutely_positioned_box.context.style().clone(), fragments, content_rect, - pbm.padding, - pbm.border, + pbm.padding.into(), + pbm.border.into(), margin, None, /* clearance */ // We do not set the baseline offset, because absolutely positioned diff --git a/components/layout_2020/style_ext.rs b/components/layout_2020/style_ext.rs index 8df270589bd..7399614e34e 100644 --- a/components/layout_2020/style_ext.rs +++ b/components/layout_2020/style_ext.rs @@ -116,12 +116,12 @@ impl DisplayLayoutInternal { /// Percentages resolved but not `auto` margins #[derive(Clone)] pub(crate) struct PaddingBorderMargin { - pub padding: LogicalSides, - pub border: LogicalSides, + pub padding: LogicalSides, + pub border: LogicalSides, pub margin: LogicalSides, /// Pre-computed sums in each axis - pub padding_border_sums: LogicalVec2, + pub padding_border_sums: LogicalVec2, } impl PaddingBorderMargin { @@ -288,8 +288,12 @@ impl ComputedValuesExt for ComputedValues { BoxSizing::BorderBox => LogicalVec2 { // These may be negative, but will later be clamped by `min-width`/`min-height` // which is clamped to zero. - inline: box_size.inline.map(|i| i - pbm.padding_border_sums.inline), - block: box_size.block.map(|b| b - pbm.padding_border_sums.block), + inline: box_size + .inline + .map(|i| i - pbm.padding_border_sums.inline.into()), + block: box_size + .block + .map(|b| b - pbm.padding_border_sums.block.into()), }, } } @@ -308,10 +312,10 @@ impl ComputedValuesExt for ComputedValues { // Clamp to zero to make sure the used size components are non-negative inline: min_box_size .inline - .map(|i| (i - pbm.padding_border_sums.inline).max(Length::zero())), + .map(|i| (i - pbm.padding_border_sums.inline.into()).max(Length::zero())), block: min_box_size .block - .map(|b| (b - pbm.padding_border_sums.block).max(Length::zero())), + .map(|b| (b - pbm.padding_border_sums.block.into()).max(Length::zero())), }, } } @@ -332,10 +336,10 @@ impl ComputedValuesExt for ComputedValues { LogicalVec2 { inline: max_box_size .inline - .map(|i| i - pbm.padding_border_sums.inline), + .map(|i| i - pbm.padding_border_sums.inline.into()), block: max_box_size .block - .map(|b| b - pbm.padding_border_sums.block), + .map(|b| b - pbm.padding_border_sums.block.into()), } }, } @@ -349,11 +353,11 @@ impl ComputedValuesExt for ComputedValues { let border = self.border_width(containing_block.style.writing_mode); PaddingBorderMargin { padding_border_sums: LogicalVec2 { - inline: padding.inline_sum() + border.inline_sum(), - block: padding.block_sum() + border.block_sum(), + inline: (padding.inline_sum() + border.inline_sum()).into(), + block: (padding.block_sum() + border.block_sum()).into(), }, - padding, - border, + padding: padding.into(), + border: border.into(), margin: self .margin(containing_block.style.writing_mode) .percentages_relative_to(cbis), diff --git a/components/layout_2020/table/layout.rs b/components/layout_2020/table/layout.rs index 88df03dac08..0afbe567c04 100644 --- a/components/layout_2020/table/layout.rs +++ b/components/layout_2020/table/layout.rs @@ -202,8 +202,8 @@ impl<'a> TableLayout<'a> { let percentage_contribution = Percentage(inline_size_percent.0.min(max_inline_size_percent.0)); - outer_min_content_width += pbm.padding_border_sums.inline.into(); - outer_max_content_width += pbm.padding_border_sums.inline.into(); + outer_min_content_width += pbm.padding_border_sums.inline; + outer_max_content_width += pbm.padding_border_sums.inline; row_measures[column_index] = CellOrColumnMeasure { content_sizes: ContentSizes { min_content: outer_min_content_width, diff --git a/tests/wpt/meta/html/rendering/non-replaced-elements/the-hr-element-0/width.html.ini b/tests/wpt/meta/html/rendering/non-replaced-elements/the-hr-element-0/width.html.ini new file mode 100644 index 00000000000..363b6e92cc6 --- /dev/null +++ b/tests/wpt/meta/html/rendering/non-replaced-elements/the-hr-element-0/width.html.ini @@ -0,0 +1,2 @@ +[width.html] + expected: FAIL \ No newline at end of file