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

Auto merge of #26968 - servo:layout-2020-lazy-content-sizes, r=SimonSapin

Browse source 
Compute content sizes lazily in layout 2020
This commit is contained in:
bors-servo 2020-06-19 13:50:29 -04:00 • committed by GitHub
commit 53263595f1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
11 changed files with 184 additions and 264 deletions
Download patch file Download diff file Expand all files Collapse all files

143
components/layout_2020/flow/construct.rs
View file

@ -14,14 +14,12 @@ use crate::flow::{BlockContainer, BlockFormattingContext, BlockLevelBox};
use crate::formatting_contexts::IndependentFormattingContext;
use crate::fragments::Tag;
use crate::positioned::AbsolutelyPositionedBox;
use crate::sizing::{self, BoxContentSizes, ContentSizes, ContentSizesRequest};
use crate::style_ext::{ComputedValuesExt, DisplayGeneratingBox, DisplayInside, DisplayOutside};
use crate::style_ext::{DisplayGeneratingBox, DisplayInside, DisplayOutside};
use rayon::iter::{IntoParallelIterator, ParallelIterator};
use rayon_croissant::ParallelIteratorExt;
use servo_arc::Arc;
use std::borrow::Cow;
use std::convert::{TryFrom, TryInto};
use style::logical_geometry::WritingMode;
use style::properties::ComputedValues;
use style::selector_parser::PseudoElement;
use style::values::specified::text::TextDecorationLine;
@ -31,34 +29,24 @@ impl BlockFormattingContext {
context: &LayoutContext,
info: &NodeAndStyleInfo<Node>,
contents: NonReplacedContents,
content_sizes: ContentSizesRequest,
propagated_text_decoration_line: TextDecorationLine,
) -> (Self, BoxContentSizes)
) -> Self
where
Node: NodeExt<'dom>,
{
let (contents, contains_floats, inline_content_sizes) = BlockContainer::construct(
context,
info,
contents,
content_sizes,
propagated_text_decoration_line,
);
// FIXME: add contribution to `inline_content_sizes` of floats in this formatting context
// https://dbaron.org/css/intrinsic/#intrinsic
let (contents, contains_floats) =
BlockContainer::construct(context, info, contents, propagated_text_decoration_line);
let bfc = Self {
contents,
contains_floats: contains_floats == ContainsFloats::Yes,
};
(bfc, inline_content_sizes)
bfc
}
pub fn construct_for_text_runs<'dom>(
context: &LayoutContext,
runs: impl Iterator<Item = TextRun>,
content_sizes: ContentSizesRequest,
text_decoration_line: TextDecorationLine,
) -> (Self, BoxContentSizes) {
) -> Self {
// FIXME: do white space collapsing
let inline_level_boxes = runs
.map(|run| ArcRefCell::new(InlineLevelBox::TextRun(run)))
@ -68,18 +56,12 @@ impl BlockFormattingContext {
inline_level_boxes,
text_decoration_line,
};
// FIXME: this is the wrong writing mode
// but we plan to remove eager content size computation.
let not_actually_containing_block_writing_mode = WritingMode::empty();
let content_sizes = content_sizes.compute(|| {
ifc.inline_content_sizes(context, not_actually_containing_block_writing_mode)
});
let contents = BlockContainer::InlineFormattingContext(ifc);
let bfc = Self {
contents,
contains_floats: false,
};
(bfc, content_sizes)
bfc
}
}
@ -181,9 +163,8 @@ impl BlockContainer {
context: &LayoutContext,
info: &NodeAndStyleInfo<Node>,
contents: NonReplacedContents,
content_sizes: ContentSizesRequest,
propagated_text_decoration_line: TextDecorationLine,
) -> (BlockContainer, ContainsFloats, BoxContentSizes)
) -> (BlockContainer, ContainsFloats)
where
Node: NodeExt<'dom>,
{
@ -209,36 +190,18 @@ impl BlockContainer {
.is_empty()
{
if builder.block_level_boxes.is_empty() {
// FIXME: this is the wrong writing mode
// but we plan to remove eager content size computation.
let not_actually_containing_block_writing_mode = info.style.writing_mode;
let content_sizes = content_sizes.compute(|| {
builder
.ongoing_inline_formatting_context
.inline_content_sizes(context, not_actually_containing_block_writing_mode)
});
let container = BlockContainer::InlineFormattingContext(
builder.ongoing_inline_formatting_context,
);
return (container, builder.contains_floats, content_sizes);
return (container, builder.contains_floats);
}
builder.end_ongoing_inline_formatting_context();
}
struct Accumulator {
contains_floats: ContainsFloats,
outer_content_sizes_of_children: ContentSizes,
}
let mut acc = Accumulator {
contains_floats: builder.contains_floats,
outer_content_sizes_of_children: ContentSizes::zero(),
};
let mapfold = |acc: &mut Accumulator, creator: BlockLevelJob<'dom, _>| {
let (block_level_box, box_contains_floats) = creator.finish(
context,
content_sizes.if_requests_inline(|| &mut acc.outer_content_sizes_of_children),
);
acc.contains_floats |= box_contains_floats;
let mut contains_floats = builder.contains_floats;
let mapfold = |contains_floats: &mut ContainsFloats, creator: BlockLevelJob<'dom, _>| {
let (block_level_box, box_contains_floats) = creator.finish(context);
*contains_floats |= box_contains_floats;
block_level_box
};
let block_level_boxes = if context.use_rayon {
@ -246,18 +209,11 @@ impl BlockContainer {
.block_level_boxes
.into_par_iter()
.mapfold_reduce_into(
&mut acc,
&mut contains_floats,
mapfold,
|| Accumulator {
contains_floats: ContainsFloats::No,
outer_content_sizes_of_children: ContentSizes::zero(),
},
|| ContainsFloats::No,
|left, right| {
left.contains_floats |= right.contains_floats;
if content_sizes.requests_inline() {
left.outer_content_sizes_of_children
.max_assign(&right.outer_content_sizes_of_children)
}
*left |= right;
},
)
.collect()
@ -265,17 +221,12 @@ impl BlockContainer {
builder
.block_level_boxes
.into_iter()
.map(|x| mapfold(&mut acc, x))
.map(|x| mapfold(&mut contains_floats, x))
.collect()
};
let container = BlockContainer::BlockLevelBoxes(block_level_boxes);
let Accumulator {
contains_floats,
outer_content_sizes_of_children,
} = acc;
let content_sizes = content_sizes.compute(|| outer_content_sizes_of_children);
(container, contains_floats, content_sizes)
(container, contains_floats)
}
}
@ -439,7 +390,6 @@ where
display_inside: DisplayInside,
contents: Contents,
) -> ArcRefCell<InlineLevelBox> {
let style = &info.style;
let box_ = if display_inside == DisplayInside::Flow && !contents.is_replaced() {
// We found un inline box.
// Whatever happened before, all we need to do before recurring
@ -464,14 +414,12 @@ where
inline_box.last_fragment = true;
ArcRefCell::new(InlineLevelBox::InlineBox(inline_box))
} else {
let content_sizes = ContentSizesRequest::inline_if(!style.inline_size_is_length());
ArcRefCell::new(InlineLevelBox::Atomic(
IndependentFormattingContext::construct(
self.context,
info,
display_inside,
contents,
content_sizes,
// Text decorations are not propagated to atomic inline-level descendants.
TextDecorationLine::NONE,
),
@ -681,32 +629,11 @@ impl<'dom, Node> BlockLevelJob<'dom, Node>
where
Node: NodeExt<'dom>,
{
fn finish(
self,
context: &LayoutContext,
max_assign_in_flow_outer_content_sizes_to: Option<&mut ContentSizes>,
) -> (ArcRefCell<BlockLevelBox>, ContainsFloats) {
fn finish(self, context: &LayoutContext) -> (ArcRefCell<BlockLevelBox>, ContainsFloats) {
let info = &self.info;
// FIXME: this is the wrong writing mode
// but we plan to remove eager content size computation.
let not_actually_containing_block_writing_mode = info.style.writing_mode;
let (block_level_box, contains_floats) = match self.kind {
BlockLevelCreator::SameFormattingContextBlock(contents) => {
let (contents, contains_floats, box_content_sizes) = contents.finish(
context,
info,
ContentSizesRequest::inline_if(
max_assign_in_flow_outer_content_sizes_to.is_some() &&
!info.style.inline_size_is_length(),
),
);
if let Some(to) = max_assign_in_flow_outer_content_sizes_to {
to.max_assign(&sizing::outer_inline(
&info.style,
not_actually_containing_block_writing_mode,
|| box_content_sizes.expect_inline().clone(),
))
}
let (contents, contains_floats) = contents.finish(context, info);
let block_level_box = ArcRefCell::new(BlockLevelBox::SameFormattingContextBlock {
tag: Tag::from_node_and_style_info(info),
contents,
@ -719,25 +646,13 @@ where
contents,
propagated_text_decoration_line,
} => {
let content_sizes = ContentSizesRequest::inline_if(
max_assign_in_flow_outer_content_sizes_to.is_some() &&
!info.style.inline_size_is_length(),
);
let context = IndependentFormattingContext::construct(
context,
info,
display_inside,
contents,
content_sizes,
propagated_text_decoration_line,
);
if let Some(to) = max_assign_in_flow_outer_content_sizes_to {
to.max_assign(&sizing::outer_inline(
&context.style(),
not_actually_containing_block_writing_mode,
|| context.content_sizes(),
))
}
(
ArcRefCell::new(BlockLevelBox::Independent(context)),
ContainsFloats::No,
@ -775,35 +690,21 @@ impl IntermediateBlockContainer {
self,
context: &LayoutContext,
info: &NodeAndStyleInfo<Node>,
content_sizes: ContentSizesRequest,
) -> (BlockContainer, ContainsFloats, BoxContentSizes)
) -> (BlockContainer, ContainsFloats)
where
Node: NodeExt<'dom>,
{
match self {
IntermediateBlockContainer::Deferred(contents, propagated_text_decoration_line) => {
BlockContainer::construct(
context,
info,
contents,
content_sizes,
propagated_text_decoration_line,
)
BlockContainer::construct(context, info, contents, propagated_text_decoration_line)
},
IntermediateBlockContainer::InlineFormattingContext(ifc) => {
// FIXME: this is the wrong writing mode
// but we plan to remove eager content size computation.
let not_actually_containing_block_writing_mode = info.style.writing_mode;
let content_sizes = content_sizes.compute(|| {
ifc.inline_content_sizes(context, not_actually_containing_block_writing_mode)
});
// If that inline formatting context contained any float, those
// were already taken into account during the first phase of
// box construction.
(
BlockContainer::InlineFormattingContext(ifc),
ContainsFloats::No,
content_sizes,
)
},
}

5
components/layout_2020/flow/float.rs
View file

@ -5,8 +5,7 @@
use crate::context::LayoutContext;
use crate::dom_traversal::{Contents, NodeAndStyleInfo, NodeExt};
use crate::formatting_contexts::IndependentFormattingContext;
use crate::sizing::ContentSizesRequest;
use crate::style_ext::{ComputedValuesExt, DisplayInside};
use crate::style_ext::DisplayInside;
use style::values::specified::text::TextDecorationLine;
#[derive(Debug, Serialize)]
@ -32,14 +31,12 @@ impl FloatBox {
display_inside: DisplayInside,
contents: Contents,
) -> Self {
let content_sizes = ContentSizesRequest::inline_if(!info.style.inline_size_is_length());
Self {
contents: IndependentFormattingContext::construct(
context,
info,
display_inside,
contents,
content_sizes,
// Text decorations are not propagated to any out-of-flow descendants
TextDecorationLine::NONE,
),

11
components/layout_2020/flow/inline.rs
View file

@ -16,7 +16,7 @@ use crate::positioned::{
relative_adjustement, AbsolutelyPositionedBox, HoistedAbsolutelyPositionedBox,
PositioningContext,
};
use crate::sizing::{self, ContentSizes};
use crate::sizing::ContentSizes;
use crate::style_ext::{ComputedValuesExt, Display, DisplayGeneratingBox, DisplayOutside};
use crate::ContainingBlock;
use app_units::Au;
@ -200,10 +200,9 @@ impl InlineFormattingContext {
}
},
InlineLevelBox::Atomic(atomic) => {
let (outer, pc) = sizing::outer_inline_and_percentages(
&atomic.style(),
let (outer, pc) = atomic.outer_inline_content_sizes_and_percentages(
self.layout_context,
self.containing_block_writing_mode,
|| atomic.content_sizes(),
);
self.current_line.min_content += outer.min_content;
self.current_line.max_content += outer.max_content;
@ -595,7 +594,9 @@ fn layout_atomic(
// 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();
non_replaced.content_sizes.shrink_to_fit(available_size)
non_replaced
.inline_content_sizes(layout_context)
.shrink_to_fit(available_size)
});
// https://drafts.csswg.org/css2/visudet.html#min-max-widths

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

@ -18,11 +18,13 @@ use crate::fragments::{
use crate::geom::flow_relative::{Rect, Sides, Vec2};
use crate::positioned::{AbsolutelyPositionedBox, PositioningContext};
use crate::replaced::ReplacedContent;
use crate::sizing::{self, ContentSizes};
use crate::style_ext::{ComputedValuesExt, PaddingBorderMargin};
use crate::ContainingBlock;
use rayon::iter::{IndexedParallelIterator, IntoParallelRefIterator, ParallelIterator};
use rayon_croissant::ParallelIteratorExt;
use servo_arc::Arc;
use style::logical_geometry::WritingMode;
use style::properties::ComputedValues;
use style::values::computed::{Length, LengthOrAuto};
use style::Zero;
@ -132,6 +134,25 @@ impl BlockContainer {
),
}
}
pub(super) fn inline_content_sizes(
&self,
layout_context: &LayoutContext,
containing_block_writing_mode: WritingMode,
) -> ContentSizes {
match &self {
Self::BlockLevelBoxes(boxes) => boxes
.par_iter()
.map(|box_| {
box_.borrow_mut()
.inline_content_sizes(layout_context, containing_block_writing_mode)
})
.reduce(ContentSizes::zero, ContentSizes::max),
Self::InlineFormattingContext(context) => {
context.inline_content_sizes(layout_context, containing_block_writing_mode)
},
}
}
}
fn layout_block_level_children(
@ -350,6 +371,27 @@ impl BlockLevelBox {
},
}
}
fn inline_content_sizes(
&mut self,
layout_context: &LayoutContext,
containing_block_writing_mode: WritingMode,
) -> ContentSizes {
match self {
Self::SameFormattingContextBlock {
style, contents, ..
} => sizing::outer_inline(style, containing_block_writing_mode, || {
contents.inline_content_sizes(layout_context, style.writing_mode)
}),
Self::Independent(independent) => independent
.outer_inline_content_sizes(layout_context, containing_block_writing_mode),
BlockLevelBox::OutOfFlowAbsolutelyPositionedBox(_) => ContentSizes::zero(),
BlockLevelBox::OutOfFlowFloatBox(_box_) => {
// TODO: Actually implement that.
ContentSizes::zero()
},
}
}
}
enum NonReplacedContents<'a> {

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

@ -22,7 +22,6 @@ use crate::geom::{PhysicalPoint, PhysicalRect, PhysicalSize};
use crate::positioned::AbsolutelyPositionedBox;
use crate::positioned::PositioningContext;
use crate::replaced::ReplacedContent;
use crate::sizing::ContentSizesRequest;
use crate::style_ext::ComputedValuesExt;
use crate::style_ext::{Display, DisplayGeneratingBox, DisplayInside};
use crate::wrapper::GetStyleAndLayoutData;
@ -292,7 +291,6 @@ fn construct_for_root_element<'dom>(
&info,
display_inside,
contents,
ContentSizesRequest::None,
propagated_text_decoration_line,
)),
)