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

layout: Make Fragment hold ArcRefCell inside (#34923)

Browse source 
Push the interior mutability into enum variants of `Fragment`, so that
they can be cloned. This saves memory in the `Fragment` tree as the
`Fragment` enum is now a relatively wee 16 bytes and the interior parts
can be a variety of sizes. Before, every `Fragment` was the size of the
biggest kind (`BoxFragment` - 248 bytes).

This a step on the way toward incremental layout.

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
Co-authored-by: Oriol Brufau <obrufau@igalia.com>
This commit is contained in:
Martin Robinson 2025-01-13 10:59:59 +01:00 • committed by GitHub
parent c936dd6c4e
commit de780dcde4
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 257 additions and 233 deletions
Download patch file Download diff file Expand all files Collapse all files

121
components/layout_2020/display_list/mod.rs
View file

@ -246,6 +246,7 @@ impl Fragment {
) {
match self {
Fragment::Box(box_fragment) | Fragment::Float(box_fragment) => {
let box_fragment = &*box_fragment.borrow();
match box_fragment.style.get_inherited_box().visibility {
Visibility::Visible => BuilderForBoxFragment::new(
box_fragment,
@ -259,6 +260,7 @@ impl Fragment {
},
Fragment::AbsoluteOrFixedPositioned(_) => {},
Fragment::Positioning(positioning_fragment) => {
let positioning_fragment = positioning_fragment.borrow();
if let Some(style) = positioning_fragment.style.as_ref() {
let rect = positioning_fragment
.rect
@ -272,65 +274,74 @@ impl Fragment {
);
}
},
Fragment::Image(image) => match image.style.get_inherited_box().visibility {
Visibility::Visible => {
builder.is_contentful = true;
Fragment::Image(image) => {
let image = image.borrow();
match image.style.get_inherited_box().visibility {
Visibility::Visible => {
builder.is_contentful = true;
let image_rendering = image
.style
.get_inherited_box()
.image_rendering
.to_webrender();
let rect = image
.rect
.translate(containing_block.origin.to_vector())
.to_webrender();
let clip = image
.clip
.translate(containing_block.origin.to_vector())
.to_webrender();
let common = builder.common_properties(clip, &image.style);
let image_rendering = image
.style
.get_inherited_box()
.image_rendering
.to_webrender();
let rect = image
.rect
.translate(containing_block.origin.to_vector())
.to_webrender();
let clip = image
.clip
.translate(containing_block.origin.to_vector())
.to_webrender();
let common = builder.common_properties(clip, &image.style);
if let Some(image_key) = image.image_key {
builder.wr().push_image(
&common,
rect,
image_rendering,
wr::AlphaType::PremultipliedAlpha,
image_key,
wr::ColorF::WHITE,
if let Some(image_key) = image.image_key {
builder.wr().push_image(
&common,
rect,
image_rendering,
wr::AlphaType::PremultipliedAlpha,
image_key,
wr::ColorF::WHITE,
);
}
},
Visibility::Hidden => (),
Visibility::Collapse => (),
}
},
Fragment::IFrame(iframe) => {
let iframe = iframe.borrow();
match iframe.style.get_inherited_box().visibility {
Visibility::Visible => {
builder.is_contentful = true;
let rect = iframe.rect.translate(containing_block.origin.to_vector());
let common = builder.common_properties(rect.to_webrender(), &iframe.style);
builder.wr().push_iframe(
rect.to_webrender(),
common.clip_rect,
&wr::SpaceAndClipInfo {
spatial_id: common.spatial_id,
clip_chain_id: common.clip_chain_id,
},
iframe.pipeline_id.into(),
true,
);
}
},
Visibility::Hidden => (),
Visibility::Collapse => (),
},
Visibility::Hidden => (),
Visibility::Collapse => (),
}
},
Fragment::IFrame(iframe) => match iframe.style.get_inherited_box().visibility {
Visibility::Visible => {
builder.is_contentful = true;
let rect = iframe.rect.translate(containing_block.origin.to_vector());
let common = builder.common_properties(rect.to_webrender(), &iframe.style);
builder.wr().push_iframe(
rect.to_webrender(),
common.clip_rect,
&wr::SpaceAndClipInfo {
spatial_id: common.spatial_id,
clip_chain_id: common.clip_chain_id,
},
iframe.pipeline_id.into(),
true,
);
},
Visibility::Hidden => (),
Visibility::Collapse => (),
},
Fragment::Text(t) => match t.parent_style.get_inherited_box().visibility {
Visibility::Visible => {
self.build_display_list_for_text_fragment(t, builder, containing_block)
},
Visibility::Hidden => (),
Visibility::Collapse => (),
Fragment::Text(text) => {
let text = &*text.borrow();
match text.parent_style.get_inherited_box().visibility {
Visibility::Visible => {
self.build_display_list_for_text_fragment(text, builder, containing_block)
},
Visibility::Hidden => (),
Visibility::Collapse => (),
}
},
}
}

55
components/layout_2020/display_list/stacking_context.rs
View file

@ -31,7 +31,6 @@ use wr::{ClipChainId, SpatialTreeItemKey, StickyOffsetBounds};
use super::clip_path::build_clip_path_clip_chain_if_necessary;
use super::DisplayList;
use crate::cell::ArcRefCell;
use crate::display_list::conversions::{FilterToWebRender, ToWebRender};
use crate::display_list::{BuilderForBoxFragment, DisplayListBuilder};
use crate::fragment_tree::{
@ -142,8 +141,7 @@ impl DisplayList {
let mut root_stacking_context = StackingContext::create_root(&self.wr, debug);
for fragment in &fragment_tree.root_fragments {
fragment.borrow_mut().build_stacking_context_tree(
fragment,
fragment.build_stacking_context_tree(
self,
&containing_block_info,
&mut root_stacking_context,
@ -260,7 +258,7 @@ pub(crate) enum StackingContextContent {
clip_chain_id: wr::ClipChainId,
section: StackingContextSection,
containing_block: PhysicalRect<Au>,
fragment: ArcRefCell<Fragment>,
fragment: Fragment,
is_hit_test_for_scrollable_overflow: bool,
},
@ -296,7 +294,7 @@ impl StackingContextContent {
builder.current_scroll_node_id = *scroll_node_id;
builder.current_reference_frame_scroll_node_id = *reference_frame_scroll_node_id;
builder.current_clip_chain_id = *clip_chain_id;
fragment.borrow().build_display_list(
fragment.build_display_list(
builder,
containing_block,
*section,
@ -632,13 +630,11 @@ impl StackingContext {
else {
debug_panic!("Expected a fragment, not a stacking container");
};
let fragment = fragment.borrow();
let box_fragment = match &*fragment {
let box_fragment = match fragment {
Fragment::Box(box_fragment) | Fragment::Float(box_fragment) => box_fragment,
_ => {
debug_panic!("Expected a box-generated fragment");
},
_ => debug_panic!("Expected a box-generated fragment"),
};
let box_fragment = &*box_fragment.borrow();
// The `StackingContextFragment` we found is for the root DOM element:
debug_assert_eq!(
@ -849,16 +845,17 @@ pub(crate) enum StackingContextBuildMode {
impl Fragment {
pub(crate) fn build_stacking_context_tree(
&mut self,
fragment_ref: &ArcRefCell<Fragment>,
&self,
display_list: &mut DisplayList,
containing_block_info: &ContainingBlockInfo,
stacking_context: &mut StackingContext,
mode: StackingContextBuildMode,
) {
let containing_block = containing_block_info.get_containing_block_for_fragment(self);
let fragment_clone = self.clone();
match self {
Fragment::Box(fragment) | Fragment::Float(fragment) => {
let fragment = fragment.borrow();
if mode == StackingContextBuildMode::SkipHoisted &&
fragment.style.clone_position().is_absolutely_positioned()
{
@ -876,7 +873,7 @@ impl Fragment {
}
fragment.build_stacking_context_tree(
fragment_ref,
fragment_clone,
display_list,
containing_block,
containing_block_info,
@ -890,8 +887,7 @@ impl Fragment {
None => unreachable!("Found hoisted box with missing fragment."),
};
fragment_ref.borrow_mut().build_stacking_context_tree(
fragment_ref,
fragment_ref.build_stacking_context_tree(
display_list,
containing_block_info,
stacking_context,
@ -899,6 +895,7 @@ impl Fragment {
);
},
Fragment::Positioning(fragment) => {
let fragment = fragment.borrow();
fragment.build_stacking_context_tree(
display_list,
containing_block,
@ -917,7 +914,7 @@ impl Fragment {
.scroll_node_id,
clip_chain_id: containing_block.clip_chain_id,
containing_block: containing_block.rect,
fragment: fragment_ref.clone(),
fragment: fragment_clone,
is_hit_test_for_scrollable_overflow: false,
});
},
@ -971,8 +968,8 @@ impl BoxFragment {
}
fn build_stacking_context_tree(
&mut self,
fragment: &ArcRefCell<Fragment>,
&self,
fragment: Fragment,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
containing_block_info: &ContainingBlockInfo,
@ -988,8 +985,8 @@ impl BoxFragment {
}
fn build_stacking_context_tree_maybe_creating_reference_frame(
&mut self,
fragment: &ArcRefCell<Fragment>,
&self,
fragment: Fragment,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
containing_block_info: &ContainingBlockInfo,
@ -1052,8 +1049,8 @@ impl BoxFragment {
}
fn build_stacking_context_tree_maybe_creating_stacking_context(
&mut self,
fragment: &ArcRefCell<Fragment>,
&self,
fragment: Fragment,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
containing_block_info: &ContainingBlockInfo,
@ -1128,8 +1125,8 @@ impl BoxFragment {
}
fn build_stacking_context_tree_for_children(
&mut self,
fragment: &ArcRefCell<Fragment>,
&self,
fragment: Fragment,
display_list: &mut DisplayList,
containing_block: &ContainingBlock,
containing_block_info: &ContainingBlockInfo,
@ -1273,8 +1270,7 @@ impl BoxFragment {
};
for child in &self.children {
child.borrow_mut().build_stacking_context_tree(
child,
child.build_stacking_context_tree(
display_list,
&new_containing_block_info,
stacking_context,
@ -1381,7 +1377,7 @@ impl BoxFragment {
}
fn build_sticky_frame_if_necessary(
&mut self,
&self,
display_list: &mut DisplayList,
parent_scroll_node_id: &ScrollTreeNodeId,
containing_block_rect: &PhysicalRect<Au>,
@ -1411,7 +1407,7 @@ impl BoxFragment {
offsets.bottom.map(|v| v.to_used_value(scroll_frame_height)),
offsets.left.map(|v| v.to_used_value(scroll_frame_width)),
);
self.resolved_sticky_insets = Some(offsets);
*self.resolved_sticky_insets.borrow_mut() = Some(offsets);
if scroll_frame_size.is_none() {
return None;
@ -1610,8 +1606,7 @@ impl PositioningFragment {
containing_block_info.new_for_non_absolute_descendants(&new_containing_block);
for child in &self.children {
child.borrow_mut().build_stacking_context_tree(
child,
child.build_stacking_context_tree(
display_list,
&new_containing_block_info,
stacking_context,

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

@ -947,7 +947,7 @@ impl FlexContainer {
// per flex item, in the original order.
let (fragment, mut child_positioning_context) =
flex_item_fragments.next().unwrap();
let fragment = Fragment::Box(fragment);
let fragment = Fragment::Box(ArcRefCell::new(fragment));
child_positioning_context.adjust_static_position_of_hoisted_fragments(
&fragment,
PositioningContextLength::zero(),

28
components/layout_2020/flow/inline/line.rs
View file

@ -292,9 +292,9 @@ impl LineItemLayout<'_, '_> {
// We do not know the actual physical position of a logically laid out inline element, until
// we know the width of the containing inline block. This step converts the logical rectangle
// into a physical one based on the inline formatting context width.
if let Some(content_rect) = fragment.content_rect_mut() {
fragment.mutate_content_rect(|content_rect| {
*content_rect = logical_rect.as_physical(Some(self.layout.containing_block))
}
});
fragment
})
@ -436,7 +436,7 @@ impl LineItemLayout<'_, '_> {
.into_iter()
.map(|(mut fragment, logical_rect)| {
let is_float = matches!(fragment, Fragment::Float(_));
if let Some(content_rect) = fragment.content_rect_mut() {
fragment.mutate_content_rect(|content_rect| {
if is_float {
content_rect.origin -=
pbm_sums.start_offset().to_physical_size(ifc_writing_mode);
@ -446,7 +446,7 @@ impl LineItemLayout<'_, '_> {
// into a physical one now that we've computed inline size of the containing inline block above.
*content_rect = logical_rect.as_physical(Some(&inline_box_containing_block))
}
}
});
fragment
})
.collect();
@ -495,7 +495,7 @@ impl LineItemLayout<'_, '_> {
self.current_state.inline_advance += inner_state.inline_advance + pbm_sums.inline_sum();
self.current_state
.fragments
.push((Fragment::Box(fragment), content_rect));
.push((Fragment::Box(ArcRefCell::new(fragment)), content_rect));
}
fn calculate_inline_box_block_start(
@ -566,7 +566,7 @@ impl LineItemLayout<'_, '_> {
self.current_state.inline_advance += inline_advance;
self.current_state.fragments.push((
Fragment::Text(TextFragment {
Fragment::Text(ArcRefCell::new(TextFragment {
base: text_item.base_fragment_info.into(),
parent_style: text_item.parent_style,
rect: PhysicalRect::zero(),
@ -575,7 +575,7 @@ impl LineItemLayout<'_, '_> {
glyphs: text_item.text,
text_decoration_line: text_item.text_decoration_line,
justification_adjustment: self.justification_adjustment,
}),
})),
content_rect,
));
}
@ -627,9 +627,10 @@ impl LineItemLayout<'_, '_> {
}
self.current_state.inline_advance += atomic.size.inline;
self.current_state
.fragments
.push((Fragment::Box(atomic.fragment), content_rect));
self.current_state.fragments.push((
Fragment::Box(ArcRefCell::new(atomic.fragment)),
content_rect,
));
}
fn layout_absolute(&mut self, absolute: AbsolutelyPositionedLineItem) {
@ -706,9 +707,10 @@ impl LineItemLayout<'_, '_> {
float.fragment.content_rect.origin -= distance_from_parent_to_ifc
.to_physical_size(self.layout.containing_block.style.writing_mode);
self.current_state
.fragments
.push((Fragment::Float(float.fragment), LogicalRect::zero()));
self.current_state.fragments.push((
Fragment::Float(ArcRefCell::new(float.fragment)),
LogicalRect::zero(),
));
}
}

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

@ -289,9 +289,9 @@ impl OutsideMarker {
.fold(Au::zero(), |current_max, fragment| {
current_max.max(
match fragment {
Fragment::Text(text) => text.rect,
Fragment::Image(image) => image.rect,
Fragment::Positioning(positioning) => positioning.rect,
Fragment::Text(text) => text.borrow().rect,
Fragment::Image(image) => image.borrow().rect,
Fragment::Positioning(positioning) => positioning.borrow().rect,
Fragment::Box(_) |
Fragment::Float(_) |
Fragment::AbsoluteOrFixedPositioned(_) |
@ -331,7 +331,7 @@ impl OutsideMarker {
let mut base_fragment_info = BaseFragmentInfo::anonymous();
base_fragment_info.flags |= FragmentFlags::IS_OUTSIDE_LIST_ITEM_MARKER;
Fragment::Box(BoxFragment::new(
Fragment::Box(ArcRefCell::new(BoxFragment::new(
base_fragment_info,
self.marker_style.clone(),
flow_layout.fragments,
@ -341,7 +341,7 @@ impl OutsideMarker {
PhysicalSides::zero(),
None,
CollapsedBlockMargins::zero(),
))
)))
}
}
@ -724,8 +724,8 @@ impl BlockLevelBox {
collapsible_with_parent_start_margin: Option<CollapsibleWithParentStartMargin>,
) -> Fragment {
match self {
BlockLevelBox::SameFormattingContextBlock { base, contents, .. } => {
Fragment::Box(positioning_context.layout_maybe_position_relative_fragment(
BlockLevelBox::SameFormattingContextBlock { base, contents, .. } => Fragment::Box(
ArcRefCell::new(positioning_context.layout_maybe_position_relative_fragment(
layout_context,
containing_block,
&base.style,
@ -740,10 +740,10 @@ impl BlockLevelBox {
collapsible_with_parent_start_margin,
)
},
))
},
BlockLevelBox::Independent(independent) => {
Fragment::Box(positioning_context.layout_maybe_position_relative_fragment(
)),
),
BlockLevelBox::Independent(independent) => Fragment::Box(ArcRefCell::new(
positioning_context.layout_maybe_position_relative_fragment(
layout_context,
containing_block,
independent.style(),
@ -755,8 +755,8 @@ impl BlockLevelBox {
sequential_layout_state,
)
},
))
},
),
)),
BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(box_) => {
// The static position of zero here is incorrect, however we do not know
// the correct positioning until later, in place_block_level_fragment, and
@ -777,10 +777,8 @@ impl BlockLevelBox {
positioning_context.push(hoisted_box);
Fragment::AbsoluteOrFixedPositioned(hoisted_fragment)
},
BlockLevelBox::OutOfFlowFloatBox(float_box) => Fragment::Float(float_box.layout(
layout_context,
positioning_context,
containing_block,
BlockLevelBox::OutOfFlowFloatBox(float_box) => Fragment::Float(ArcRefCell::new(
float_box.layout(layout_context, positioning_context, containing_block),
)),
BlockLevelBox::OutsideMarker(outside_marker) => outside_marker.layout(
layout_context,
@ -1912,6 +1910,7 @@ impl<'container> PlacementState<'container> {
Fragment::Box(box_fragment) => box_fragment,
_ => return,
};
let box_fragment = box_fragment.borrow();
// From <https://drafts.csswg.org/css-align-3/#baseline-export>:
// > When finding the first/last baseline set of an inline-block, any baselines
@ -1955,6 +1954,7 @@ impl<'container> PlacementState<'container> {
// between the marker and the item. For instance the marker should be positioned at
// the baseline of list item content and the first line of the item content should
// be at least as tall as the marker -- not the entire list item itself.
let fragment = &mut *fragment.borrow_mut();
let is_outside_marker = fragment
.base
.flags
@ -2049,6 +2049,7 @@ impl<'container> PlacementState<'container> {
.expect("Found float fragment without SequentialLayoutState");
let block_offset_from_containing_block_top =
self.current_block_direction_position + self.current_margin.solve();
let box_fragment = &mut *box_fragment.borrow_mut();
sequential_layout_state.place_float_fragment(
box_fragment,
self.containing_block,

8
components/layout_2020/flow/root.rs
View file

@ -357,11 +357,7 @@ impl BoxTree {
&(&initial_containing_block).into(),
);
let mut root_fragments = independent_layout
.fragments
.into_iter()
.map(ArcRefCell::new)
.collect::<Vec<_>>();
let mut root_fragments = independent_layout.fragments.into_iter().collect::<Vec<_>>();
// Zero box for `:root { display: none }`, one for the root element otherwise.
assert!(root_fragments.len() <= 1);
@ -378,7 +374,7 @@ impl BoxTree {
let scrollable_overflow = root_fragments
.iter()
.fold(PhysicalRect::zero(), |acc, child| {
let child_overflow = child.borrow().scrollable_overflow();
let child_overflow = child.scrollable_overflow();
// https://drafts.csswg.org/css-overflow/#scrolling-direction
// We want to clip scrollable overflow on box-start and inline-start

2
components/layout_2020/fragment_tree/base_fragment.rs
View file

@ -13,7 +13,7 @@ use crate::layout_debug::DebugId;
/// This data structure stores fields that are common to all non-base
/// Fragment types and should generally be the first member of all
/// concrete fragments.
#[derive(Debug, Serialize)]
#[derive(Clone, Debug, Serialize)]
pub(crate) struct BaseFragment {
/// A tag which identifies the DOM node and pseudo element of this
/// Fragment's content. If this fragment isn't related to any DOM

15
components/layout_2020/fragment_tree/box_fragment.rs
View file

@ -3,6 +3,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
use app_units::Au;
use atomic_refcell::AtomicRefCell;
use base::print_tree::PrintTree;
use serde::Serialize;
use servo_arc::Arc as ServoArc;
@ -13,7 +14,6 @@ use style::properties::ComputedValues;
use style::Zero;
use super::{BaseFragment, BaseFragmentInfo, CollapsedBlockMargins, Fragment};
use crate::cell::ArcRefCell;
use crate::formatting_contexts::Baselines;
use crate::fragment_tree::FragmentFlags;
use crate::geom::{
@ -53,7 +53,7 @@ pub(crate) struct BoxFragment {
#[serde(skip_serializing)]
pub style: ServoArc<ComputedValues>,
pub children: Vec<ArcRefCell<Fragment>>,
pub children: Vec<Fragment>,
/// The content rect of this fragment in the parent fragment's content rectangle. This
/// does not include padding, border, or margin -- it only includes content.
@ -84,7 +84,8 @@ pub(crate) struct BoxFragment {
/// The resolved box insets if this box is `position: sticky`. These are calculated
/// during stacking context tree construction because they rely on the size of the
/// scroll container.
pub(crate) resolved_sticky_insets: Option<PhysicalSides<AuOrAuto>>,
#[serde(skip_serializing)]
pub(crate) resolved_sticky_insets: AtomicRefCell<Option<PhysicalSides<AuOrAuto>>>,
#[serde(skip_serializing)]
pub background_mode: BackgroundMode,
@ -115,7 +116,7 @@ impl BoxFragment {
BoxFragment {
base: base_fragment_info.into(),
style,
children: children.into_iter().map(ArcRefCell::new).collect(),
children,
content_rect,
padding,
border,
@ -124,7 +125,7 @@ impl BoxFragment {
baselines: Baselines::default(),
block_margins_collapsed_with_children,
scrollable_overflow_from_children,
resolved_sticky_insets: None,
resolved_sticky_insets: AtomicRefCell::default(),
background_mode: BackgroundMode::Normal,
detailed_layout_info: None,
}
@ -234,7 +235,7 @@ impl BoxFragment {
));
for child in &self.children {
child.borrow().print(tree);
child.print(tree);
}
tree.end_level();
}
@ -278,7 +279,7 @@ impl BoxFragment {
"Should not call this method on statically positioned box."
);
if let Some(resolved_sticky_insets) = self.resolved_sticky_insets {
if let Some(resolved_sticky_insets) = *self.resolved_sticky_insets.borrow() {
return resolved_sticky_insets;
}

2
components/layout_2020/fragment_tree/containing_block.rs
View file

@ -52,7 +52,7 @@ pub(crate) struct ContainingBlockManager<'a, T> {
impl<'a, T> ContainingBlockManager<'a, T> {
pub(crate) fn get_containing_block_for_fragment(&self, fragment: &Fragment) -> &T {
if let Fragment::Box(box_fragment) = fragment {
match box_fragment.style.clone_position() {
match box_fragment.borrow().style.clone_position() {
ComputedPosition::Fixed => self.for_absolute_and_fixed_descendants,
ComputedPosition::Absolute => self
.for_absolute_descendants

69
components/layout_2020/fragment_tree/fragment.rs
View file

@ -23,16 +23,16 @@ use crate::cell::ArcRefCell;
use crate::geom::{LogicalSides, PhysicalRect};
use crate::style_ext::ComputedValuesExt;
#[derive(Serialize)]
#[derive(Clone, Serialize)]
pub(crate) enum Fragment {
Box(BoxFragment),
Box(ArcRefCell<BoxFragment>),
/// Floating content. A floated fragment is very similar to a normal
/// [BoxFragment] but it isn't positioned using normal in block flow
/// positioning rules (margin collapse, etc). Instead, they are laid
/// out by the [crate::flow::float::SequentialLayoutState] of their
/// float containing block formatting context.
Float(BoxFragment),
Positioning(PositioningFragment),
Float(ArcRefCell<BoxFragment>),
Positioning(ArcRefCell<PositioningFragment>),
/// Absolute and fixed position fragments are hoisted up so that they
/// are children of the BoxFragment that establishes their containing
/// blocks, so that they can be laid out properly. When this happens
@ -41,9 +41,9 @@ pub(crate) enum Fragment {
/// regard to their original tree order during stacking context tree /
/// display list construction.
AbsoluteOrFixedPositioned(ArcRefCell<HoistedSharedFragment>),
Text(TextFragment),
Image(ImageFragment),
IFrame(IFrameFragment),
Text(ArcRefCell<TextFragment>),
Image(ArcRefCell<ImageFragment>),
IFrame(ArcRefCell<IFrameFragment>),
}
#[derive(Serialize)]
@ -99,26 +99,26 @@ pub(crate) struct IFrameFragment {
}
impl Fragment {
pub fn base(&self) -> Option<&BaseFragment> {
pub fn base(&self) -> Option<BaseFragment> {
Some(match self {
Fragment::Box(fragment) => &fragment.base,
Fragment::Text(fragment) => &fragment.base,
Fragment::Box(fragment) => fragment.borrow().base.clone(),
Fragment::Text(fragment) => fragment.borrow().base.clone(),
Fragment::AbsoluteOrFixedPositioned(_) => return None,
Fragment::Positioning(fragment) => &fragment.base,
Fragment::Image(fragment) => &fragment.base,
Fragment::IFrame(fragment) => &fragment.base,
Fragment::Float(fragment) => &fragment.base,
Fragment::Positioning(fragment) => fragment.borrow().base.clone(),
Fragment::Image(fragment) => fragment.borrow().base.clone(),
Fragment::IFrame(fragment) => fragment.borrow().base.clone(),
Fragment::Float(fragment) => fragment.borrow().base.clone(),
})
}
pub(crate) fn content_rect_mut(&mut self) -> Option<&mut PhysicalRect<Au>> {
pub(crate) fn mutate_content_rect(&mut self, callback: impl FnOnce(&mut PhysicalRect<Au>)) {
match self {
Fragment::Box(box_fragment) | Fragment::Float(box_fragment) => {
Some(&mut box_fragment.content_rect)
callback(&mut box_fragment.borrow_mut().content_rect)
},
Fragment::Positioning(_) | Fragment::AbsoluteOrFixedPositioned(_) => None,
Fragment::Text(text_fragment) => Some(&mut text_fragment.rect),
Fragment::Image(image_fragment) => Some(&mut image_fragment.rect),
Fragment::IFrame(iframe_fragment) => Some(&mut iframe_fragment.rect),
Fragment::Positioning(_) | Fragment::AbsoluteOrFixedPositioned(_) => {},
Fragment::Text(text_fragment) => callback(&mut text_fragment.borrow_mut().rect),
Fragment::Image(image_fragment) => callback(&mut image_fragment.borrow_mut().rect),
Fragment::IFrame(iframe_fragment) => callback(&mut iframe_fragment.borrow_mut().rect),
}
}
@ -128,25 +128,26 @@ impl Fragment {
pub fn print(&self, tree: &mut PrintTree) {
match self {
Fragment::Box(fragment) => fragment.print(tree),
Fragment::Box(fragment) => fragment.borrow().print(tree),
Fragment::Float(fragment) => {
tree.new_level("Float".to_string());
fragment.print(tree);
fragment.borrow().print(tree);
tree.end_level();
},
Fragment::AbsoluteOrFixedPositioned(_) => {
tree.add_item("AbsoluteOrFixedPositioned".to_string());
},
Fragment::Positioning(fragment) => fragment.print(tree),
Fragment::Text(fragment) => fragment.print(tree),
Fragment::Image(fragment) => fragment.print(tree),
Fragment::IFrame(fragment) => fragment.print(tree),
Fragment::Positioning(fragment) => fragment.borrow().print(tree),
Fragment::Text(fragment) => fragment.borrow().print(tree),
Fragment::Image(fragment) => fragment.borrow().print(tree),
Fragment::IFrame(fragment) => fragment.borrow().print(tree),
}
}
pub fn scrolling_area(&self, containing_block: &PhysicalRect<Au>) -> PhysicalRect<Au> {
match self {
Fragment::Box(fragment) | Fragment::Float(fragment) => fragment
.borrow()
.scrollable_overflow()
.translate(containing_block.origin.to_vector()),
_ => self.scrollable_overflow(),
@ -156,13 +157,13 @@ impl Fragment {
pub fn scrollable_overflow(&self) -> PhysicalRect<Au> {
match self {
Fragment::Box(fragment) | Fragment::Float(fragment) => {
fragment.scrollable_overflow_for_parent()
fragment.borrow().scrollable_overflow_for_parent()
},
Fragment::AbsoluteOrFixedPositioned(_) => PhysicalRect::zero(),
Fragment::Positioning(fragment) => fragment.scrollable_overflow,
Fragment::Text(fragment) => fragment.rect,
Fragment::Image(fragment) => fragment.rect,
Fragment::IFrame(fragment) => fragment.rect,
Fragment::Positioning(fragment) => fragment.borrow().scrollable_overflow,
Fragment::Text(fragment) => fragment.borrow().rect,
Fragment::Image(fragment) => fragment.borrow().rect,
Fragment::IFrame(fragment) => fragment.borrow().rect,
}
}
@ -179,6 +180,7 @@ impl Fragment {
match self {
Fragment::Box(fragment) | Fragment::Float(fragment) => {
let fragment = fragment.borrow();
let content_rect = fragment
.content_rect
.translate(containing_block.origin.to_vector());
@ -202,15 +204,16 @@ impl Fragment {
fragment
.children
.iter()
.find_map(|child| child.borrow().find(&new_manager, level + 1, process_func))
.find_map(|child| child.find(&new_manager, level + 1, process_func))
},
Fragment::Positioning(fragment) => {
let fragment = fragment.borrow();
let content_rect = fragment.rect.translate(containing_block.origin.to_vector());
let new_manager = manager.new_for_non_absolute_descendants(&content_rect);
fragment
.children
.iter()
.find_map(|child| child.borrow().find(&new_manager, level + 1, process_func))
.find_map(|child| child.find(&new_manager, level + 1, process_func))
},
_ => None,
}

19
components/layout_2020/fragment_tree/fragment_tree.rs
View file

@ -13,7 +13,6 @@ use webrender_api::units;
use webrender_traits::display_list::ScrollSensitivity;
use super::{ContainingBlockManager, Fragment, Tag};
use crate::cell::ArcRefCell;
use crate::display_list::StackingContext;
use crate::flow::CanvasBackground;
use crate::geom::PhysicalRect;
@ -28,7 +27,7 @@ pub struct FragmentTree {
/// * The first fragment is generated by the root element.
/// * There may be additional fragments generated by positioned boxes
/// that have the initial containing block.
pub(crate) root_fragments: Vec<ArcRefCell<Fragment>>,
pub(crate) root_fragments: Vec<Fragment>,
/// The scrollable overflow rectangle for the entire tree
/// <https://drafts.csswg.org/css-overflow/#scrollable>
@ -63,7 +62,7 @@ impl FragmentTree {
pub fn print(&self) {
let mut print_tree = PrintTree::new("Fragment Tree".to_string());
for fragment in &self.root_fragments {
fragment.borrow().print(&mut print_tree);
fragment.print(&mut print_tree);
}
}
@ -85,7 +84,7 @@ impl FragmentTree {
};
self.root_fragments
.iter()
.find_map(|child| child.borrow().find(&info, 0, &mut process_func))
.find_map(|child| child.find(&info, 0, &mut process_func))
}
pub fn remove_nodes_in_fragment_tree_from_set(&self, set: &mut FxHashSet<AnimationSetKey>) {
@ -110,9 +109,11 @@ impl FragmentTree {
}
let fragment_relative_rect = match fragment {
Fragment::Box(fragment) | Fragment::Float(fragment) => fragment.border_rect(),
Fragment::Positioning(fragment) => fragment.rect,
Fragment::Text(fragment) => fragment.rect,
Fragment::Box(fragment) | Fragment::Float(fragment) => {
fragment.borrow().border_rect()
},
Fragment::Positioning(fragment) => fragment.borrow().rect,
Fragment::Text(fragment) => fragment.borrow().rect,
Fragment::AbsoluteOrFixedPositioned(_) |
Fragment::Image(_) |
Fragment::IFrame(_) => return None,
@ -140,6 +141,7 @@ impl FragmentTree {
// CSS layout box is inline, return zero." For this check we
// also explicitly ignore the list item portion of the display
// style.
let fragment = fragment.borrow();
if fragment.is_inline_box() {
return Some(Rect::zero());
}
@ -151,7 +153,7 @@ impl FragmentTree {
Size2D::new(padding_rect.size.width, padding_rect.size.height),
)
},
Fragment::Positioning(fragment) => fragment.rect.cast_unit(),
Fragment::Positioning(fragment) => fragment.borrow().rect.cast_unit(),
_ => return None,
};
@ -168,7 +170,6 @@ impl FragmentTree {
let mut scroll_area = self.initial_containing_block;
for fragment in self.root_fragments.iter() {
scroll_area = fragment
.borrow()
.scrolling_area(&self.initial_containing_block)
.union(&scroll_area);
}

3
components/layout_2020/fragment_tree/hoisted_shared_fragment.rs
View file

@ -8,7 +8,6 @@ use style::logical_geometry::WritingMode;
use style::values::specified::align::AlignFlags;
use super::Fragment;
use crate::cell::ArcRefCell;
use crate::geom::{LogicalVec2, PhysicalRect, PhysicalVec};
/// A reference to a Fragment which is shared between `HoistedAbsolutelyPositionedBox`
@ -16,7 +15,7 @@ use crate::geom::{LogicalVec2, PhysicalRect, PhysicalVec};
/// This will be used later in order to paint this hoisted box in tree order.
#[derive(Serialize)]
pub(crate) struct HoistedSharedFragment {
pub fragment: Option<ArcRefCell<Fragment>>,
pub fragment: Option<Fragment>,
/// The "static-position rect" of this absolutely positioned box. This is defined by the
/// layout mode from which the box originates.
///

16
components/layout_2020/fragment_tree/positioning_fragment.rs
View file

@ -19,7 +19,7 @@ use crate::geom::PhysicalRect;
pub(crate) struct PositioningFragment {
pub base: BaseFragment,
pub rect: PhysicalRect<Au>,
pub children: Vec<ArcRefCell<Fragment>>,
pub children: Vec<Fragment>,
/// The scrollable overflow of this anonymous fragment's children.
pub scrollable_overflow: PhysicalRect<Au>,
@ -29,7 +29,7 @@ pub(crate) struct PositioningFragment {
}
impl PositioningFragment {
pub fn new_anonymous(rect: PhysicalRect<Au>, children: Vec<Fragment>) -> Self {
pub fn new_anonymous(rect: PhysicalRect<Au>, children: Vec<Fragment>) -> ArcRefCell<Self> {
Self::new_with_base_fragment(BaseFragment::anonymous(), None, rect, children)
}
@ -37,7 +37,7 @@ impl PositioningFragment {
base_fragment_info: BaseFragmentInfo,
rect: PhysicalRect<Au>,
style: ServoArc<ComputedValues>,
) -> Self {
) -> ArcRefCell<Self> {
Self::new_with_base_fragment(base_fragment_info.into(), Some(style), rect, Vec::new())
}
@ -46,7 +46,7 @@ impl PositioningFragment {
style: Option<ServoArc<ComputedValues>>,
rect: PhysicalRect<Au>,
children: Vec<Fragment>,
) -> Self {
) -> ArcRefCell<Self> {
let content_origin = rect.origin;
let scrollable_overflow = children.iter().fold(PhysicalRect::zero(), |acc, child| {
acc.union(
@ -55,13 +55,13 @@ impl PositioningFragment {
.translate(content_origin.to_vector()),
)
});
PositioningFragment {
ArcRefCell::new(PositioningFragment {
base,
style,
rect,
children: children.into_iter().map(ArcRefCell::new).collect(),
children,
scrollable_overflow,
}
})
}
pub fn print(&self, tree: &mut PrintTree) {
@ -74,7 +74,7 @@ impl PositioningFragment {
));
for child in &self.children {
child.borrow().print(tree);
child.print(tree);
}
tree.end_level();
}

32
components/layout_2020/positioned.rs
View file

@ -161,9 +161,11 @@ impl PositioningContext {
index: PositioningContextLength,
) {
let start_offset = match &parent_fragment {
Fragment::Box(fragment) | Fragment::Float(fragment) => &fragment.content_rect.origin,
Fragment::Box(fragment) | Fragment::Float(fragment) => {
fragment.borrow().content_rect.origin
},
Fragment::AbsoluteOrFixedPositioned(_) => return,
Fragment::Positioning(fragment) => &fragment.rect.origin,
Fragment::Positioning(fragment) => fragment.borrow().rect.origin,
_ => unreachable!(),
};
self.adjust_static_position_of_hoisted_fragments_with_offset(
@ -335,7 +337,7 @@ impl PositioningContext {
&mut self,
layout_context: &LayoutContext,
initial_containing_block: &DefiniteContainingBlock,
fragments: &mut Vec<ArcRefCell<Fragment>>,
fragments: &mut Vec<Fragment>,
) {
debug_assert!(self.for_nearest_positioned_ancestor.is_none());
@ -409,7 +411,7 @@ impl HoistedAbsolutelyPositionedBox {
pub(crate) fn layout_many(
layout_context: &LayoutContext,
boxes: &mut [Self],
fragments: &mut Vec<ArcRefCell<Fragment>>,
fragments: &mut Vec<Fragment>,
for_nearest_containing_block_for_all_descendants: &mut Vec<HoistedAbsolutelyPositionedBox>,
containing_block: &DefiniteContainingBlock,
) {
@ -421,14 +423,15 @@ impl HoistedAbsolutelyPositionedBox {
.par_iter_mut()
.map(|hoisted_box| {
let mut new_hoisted_boxes: Vec<HoistedAbsolutelyPositionedBox> = Vec::new();
let new_fragment = ArcRefCell::new(Fragment::Box(hoisted_box.layout(
let new_fragment = hoisted_box.layout(
layout_context,
&mut new_hoisted_boxes,
containing_block,
)));
);
hoisted_box.fragment.borrow_mut().fragment = Some(new_fragment.clone());
(new_fragment, new_hoisted_boxes)
hoisted_box.fragment.borrow_mut().fragment =
Some(Fragment::Box(new_fragment.clone()));
(Fragment::Box(new_fragment), new_hoisted_boxes)
})
.unzip_into_vecs(&mut new_fragments, &mut new_hoisted_boxes);
@ -437,13 +440,14 @@ impl HoistedAbsolutelyPositionedBox {
.extend(new_hoisted_boxes.into_iter().flatten());
} else {
fragments.extend(boxes.iter_mut().map(|box_| {
let new_fragment = ArcRefCell::new(Fragment::Box(box_.layout(
let new_fragment = box_.layout(
layout_context,
for_nearest_containing_block_for_all_descendants,
containing_block,
)));
box_.fragment.borrow_mut().fragment = Some(new_fragment.clone());
new_fragment
);
box_.fragment.borrow_mut().fragment = Some(Fragment::Box(new_fragment.clone()));
Fragment::Box(new_fragment)
}))
}
}
@ -453,7 +457,7 @@ impl HoistedAbsolutelyPositionedBox {
layout_context: &LayoutContext,
for_nearest_containing_block_for_all_descendants: &mut Vec<HoistedAbsolutelyPositionedBox>,
containing_block: &DefiniteContainingBlock,
) -> BoxFragment {
) -> ArcRefCell<BoxFragment> {
let cbis = containing_block.size.inline;
let cbbs = containing_block.size.block;
let containing_block_writing_mode = containing_block.style.writing_mode;
@ -696,7 +700,7 @@ impl HoistedAbsolutelyPositionedBox {
for_nearest_containing_block_for_all_descendants
.extend(positioning_context.for_nearest_containing_block_for_all_descendants);
new_fragment
ArcRefCell::new(new_fragment)
}
}

28
components/layout_2020/query.rs
View file

@ -192,6 +192,7 @@ pub fn process_resolved_style_request<'dom>(
let (content_rect, margins, padding, detailed_layout_info) = match fragment {
Fragment::Box(ref box_fragment) | Fragment::Float(ref box_fragment) => {
let box_fragment = box_fragment.borrow();
if style.get_box().position != Position::Static {
let resolved_insets = || {
box_fragment.calculate_resolved_insets_if_positioned(containing_block)
@ -213,16 +214,16 @@ pub fn process_resolved_style_request<'dom>(
let content_rect = box_fragment.content_rect;
let margins = box_fragment.margin;
let padding = box_fragment.padding;
let detailed_layout_info = &box_fragment.detailed_layout_info;
let detailed_layout_info = box_fragment.detailed_layout_info.clone();
(content_rect, margins, padding, detailed_layout_info)
},
Fragment::Positioning(positioning_fragment) => {
let content_rect = positioning_fragment.rect;
let content_rect = positioning_fragment.borrow().rect;
(
content_rect,
SideOffsets2D::zero(),
SideOffsets2D::zero(),
&None,
None,
)
},
_ => return None,
@ -235,7 +236,7 @@ pub fn process_resolved_style_request<'dom>(
// > When an element generates a grid container box...
if display.inside() == DisplayInside::Grid {
if let Some(SpecificLayoutInfo::Grid(info)) = detailed_layout_info {
if let Some(value) = resolve_grid_template(info, style, longhand_id) {
if let Some(value) = resolve_grid_template(&info, style, longhand_id) {
return Some(value);
}
}
@ -274,7 +275,7 @@ fn resolved_size_should_be_used_value(fragment: &Fragment) -> bool {
// https://drafts.csswg.org/css-sizing-3/#preferred-size-properties
// > Applies to: all elements except non-replaced inlines
match fragment {
Fragment::Box(box_fragment) => !box_fragment.is_inline_box(),
Fragment::Box(box_fragment) => !box_fragment.borrow().is_inline_box(),
Fragment::Float(_) |
Fragment::Positioning(_) |
Fragment::AbsoluteOrFixedPositioned(_) |
@ -446,9 +447,9 @@ fn process_offset_parent_query_inner(
//
// [1]: https://github.com/w3c/csswg-drafts/issues/4541
let fragment_relative_rect = match fragment {
Fragment::Box(fragment) | Fragment::Float(fragment) => fragment.border_rect(),
Fragment::Text(fragment) => fragment.rect,
Fragment::Positioning(fragment) => fragment.rect,
Fragment::Box(fragment) | Fragment::Float(fragment) => fragment.borrow().border_rect(),
Fragment::Text(fragment) => fragment.borrow().rect,
Fragment::Positioning(fragment) => fragment.borrow().rect,
Fragment::AbsoluteOrFixedPositioned(_) |
Fragment::Image(_) |
Fragment::IFrame(_) => unreachable!(),
@ -460,7 +461,7 @@ fn process_offset_parent_query_inner(
// this algorithm: [...] The element’s computed value of the
// `position` property is `fixed`."
let is_fixed = matches!(
fragment, Fragment::Box(fragment) if fragment.style.get_box().position == Position::Fixed
fragment, Fragment::Box(fragment) if fragment.borrow().style.get_box().position == Position::Fixed
);
if is_body_element {
@ -489,6 +490,7 @@ fn process_offset_parent_query_inner(
// Record the paths of the nodes being traversed.
let parent_node_address = match fragment {
Fragment::Box(fragment) | Fragment::Float(fragment) => {
let fragment = &*fragment.borrow();
let is_eligible_parent = is_eligible_parent(fragment);
let is_static_body_element = is_body_element &&
fragment.style.get_box().position == Position::Static;
@ -538,14 +540,15 @@ fn process_offset_parent_query_inner(
unreachable!();
};
// Again, take the *first* associated CSS layout box.
fragment.border_rect().origin.to_vector() + containing_block.origin.to_vector()
fragment.borrow().border_rect().origin.to_vector() +
containing_block.origin.to_vector()
}
let containing_block = &fragment_tree.initial_containing_block;
let fragment = &(*fragment_tree.root_fragments[0].borrow());
let fragment = &fragment_tree.root_fragments[0];
if let Fragment::AbsoluteOrFixedPositioned(shared_fragment) = fragment {
let shared_fragment = &*shared_fragment.borrow();
let fragment = &*shared_fragment.fragment.as_ref().unwrap().borrow();
let fragment = shared_fragment.fragment.as_ref().unwrap();
extract_box_fragment(fragment, containing_block)
} else {
extract_box_fragment(fragment, containing_block)
@ -561,6 +564,7 @@ fn process_offset_parent_query_inner(
.find(|fragment, _, containing_block| {
match fragment {
Fragment::Box(fragment) | Fragment::Float(fragment) => {
let fragment = fragment.borrow();
if fragment.base.tag == Some(offset_parent_node_tag) {
// Again, take the *first* associated CSS layout box.
let padding_box_corner = fragment.padding_rect().origin.to_vector()

29
components/layout_2020/replaced.rs
View file

@ -27,6 +27,7 @@ use style::Zero;
use url::Url;
use webrender_api::ImageKey;
use crate::cell::ArcRefCell;
use crate::context::LayoutContext;
use crate::dom::NodeExt;
use crate::fragment_tree::{BaseFragmentInfo, Fragment, IFrameFragment, ImageFragment};
@ -334,23 +335,25 @@ impl ReplacedContents {
.as_ref()
.and_then(|image| image.id)
.map(|image_key| {
Fragment::Image(ImageFragment {
Fragment::Image(ArcRefCell::new(ImageFragment {
base: self.base_fragment_info.into(),
style: style.clone(),
rect,
clip,
image_key: Some(image_key),
})
}))
})
.into_iter()
.collect(),
ReplacedContentKind::Video(video) => vec![Fragment::Image(ImageFragment {
base: self.base_fragment_info.into(),
style: style.clone(),
rect,
clip,
image_key: video.as_ref().map(|video| video.image_key),
})],
ReplacedContentKind::Video(video) => {
vec![Fragment::Image(ArcRefCell::new(ImageFragment {
base: self.base_fragment_info.into(),
style: style.clone(),
rect,
clip,
image_key: video.as_ref().map(|video| video.image_key),
}))]
},
ReplacedContentKind::IFrame(iframe) => {
let size = Size2D::new(rect.size.width.to_f32_px(), rect.size.height.to_f32_px());
layout_context.iframe_sizes.lock().insert(
@ -361,13 +364,13 @@ impl ReplacedContents {
size,
},
);
vec![Fragment::IFrame(IFrameFragment {
vec![Fragment::IFrame(ArcRefCell::new(IFrameFragment {
base: self.base_fragment_info.into(),
style: style.clone(),
pipeline_id: iframe.pipeline_id,
browsing_context_id: iframe.browsing_context_id,
rect,
})]
}))]
},
ReplacedContentKind::Canvas(canvas_info) => {
if self.natural_size.width == Some(Au::zero()) ||
@ -392,13 +395,13 @@ impl ReplacedContents {
},
CanvasSource::Empty => return vec![],
};
vec![Fragment::Image(ImageFragment {
vec![Fragment::Image(ArcRefCell::new(ImageFragment {
base: self.base_fragment_info.into(),
style: style.clone(),
rect,
clip,
image_key: Some(image_key),
})]
}))]
},
}
}

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

@ -24,7 +24,9 @@ use style::values::generics::box_::{GenericVerticalAlign as VerticalAlign, Verti
use style::values::generics::length::GenericLengthPercentageOrAuto::{Auto, LengthPercentage};
use style::Zero;
use super::{Table, TableCaption, TableSlot, TableSlotCell, TableTrack, TableTrackGroup};
use super::{
ArcRefCell, Table, TableCaption, TableSlot, TableSlotCell, TableTrack, TableTrackGroup,
};
use crate::context::LayoutContext;
use crate::formatting_contexts::{Baselines, IndependentLayout};
use crate::fragment_tree::{
@ -1740,7 +1742,7 @@ impl<'a> TableLayout<'a> {
.to_logical(table_writing_mode)
.block;
let caption_fragment = Fragment::Box(caption_fragment);
let caption_fragment = Fragment::Box(ArcRefCell::new(caption_fragment));
positioning_context.adjust_static_position_of_hoisted_fragments(
&caption_fragment,
original_positioning_context_length,
@ -1790,7 +1792,7 @@ impl<'a> TableLayout<'a> {
.block;
table_layout.content_inline_size_for_table = Some(logical_grid_content_rect.size.inline);
let grid_fragment = Fragment::Box(grid_fragment);
let grid_fragment = Fragment::Box(ArcRefCell::new(grid_fragment));
positioning_context.adjust_static_position_of_hoisted_fragments(
&grid_fragment,
original_positioning_context_length,
@ -1831,7 +1833,7 @@ impl<'a> TableLayout<'a> {
.to_logical(table_writing_mode)
.block;
let caption_fragment = Fragment::Box(caption_fragment);
let caption_fragment = Fragment::Box(ArcRefCell::new(caption_fragment));
positioning_context.adjust_static_position_of_hoisted_fragments(
&caption_fragment,
original_positioning_context_length,
@ -2182,7 +2184,9 @@ impl<'a> TableLayout<'a> {
rect,
})
}
row_fragment_layout.fragments.push(Fragment::Box(fragment));
row_fragment_layout
.fragments
.push(Fragment::Box(ArcRefCell::new(fragment)));
}
fn make_fragments_for_columns_and_column_groups(
@ -2345,7 +2349,7 @@ impl<'a> RowFragmentLayout<'a> {
containing_block_for_logical_conversion: &ContainingBlock,
containing_block_for_children: &ContainingBlock,
row_group_fragment_layout: &mut Option<RowGroupFragmentLayout>,
) -> BoxFragment {
) -> ArcRefCell<BoxFragment> {
if self.positioning_context.is_some() {
self.rect.start_corner +=
relative_adjustement(&self.row.style, containing_block_for_children);
@ -2396,7 +2400,7 @@ impl<'a> RowFragmentLayout<'a> {
positioning_context.append(row_positioning_context);
}
row_fragment
ArcRefCell::new(row_fragment)
}
}
@ -2432,7 +2436,7 @@ impl RowGroupFragmentLayout {
table_positioning_context: &mut PositioningContext,
containing_block_for_logical_conversion: &ContainingBlock,
containing_block_for_children: &ContainingBlock,
) -> BoxFragment {
) -> ArcRefCell<BoxFragment> {
if self.positioning_context.is_some() {
self.rect.start_corner +=
relative_adjustement(&self.style, containing_block_for_children);
@ -2458,7 +2462,7 @@ impl RowGroupFragmentLayout {
table_positioning_context.append(row_positioning_context);
}
row_group_fragment
ArcRefCell::new(row_group_fragment)
}
}

4
components/layout_2020/taffy/layout.rs
View file

@ -551,7 +551,7 @@ impl TaffyContainer {
match &mut child.taffy_level_box {
TaffyItemBoxInner::InFlowBox(independent_box) => {
let fragment = Fragment::Box(
let fragment = Fragment::Box(ArcRefCell::new(
BoxFragment::new(
independent_box.base_fragment_info(),
independent_box.style().clone(),
@ -568,7 +568,7 @@ impl TaffyContainer {
last: None,
})
.with_detailed_layout_info(child_detailed_layout_info),
);
));
child
.positioning_context