Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

perf(renderer): reuse style work within layout observations

ldm0a50bc689ed33
diff --git a/moli-layout/src/builder.rs b/moli-layout/src/builder.rs
index b865e83ff..003a487ac 100644
--- a/moli-layout/src/builder.rs
+++ b/moli-layout/src/builder.rs
@@ -15,7 +15,8 @@ use std::{
use crate::{
LayoutAnonymousReason, LayoutBoxId, LayoutBoxKind, LayoutCapabilityDiagnostic, LayoutDisplay,
LayoutElementCategory, LayoutElementSemantics, LayoutError, LayoutPseudo, LayoutSource,
- LayoutSourceKind, LayoutStyleResolver, LayoutWorld, ResolvedLayoutStyle,
+ LayoutSourceKind, LayoutStyleResolver, LayoutWorld, ResolvedLayoutPseudoStyle,
+ ResolvedLayoutStyle,
form::form_control_context,
replaced::ReplacedContext,
style::{InlineWhiteSpaceCollapse, LayoutOverflowMode},
@@ -92,9 +93,10 @@ where
let root_semantics = self.validated_element_semantics(source_root, source_kind)?;
self.source_root = Some(source_root);
self.root_is_html = root_semantics.is_html_element("html");
- let Some(mut root_style) = self.styles.primary_style(source_root)? else {
+ let Some(root_styles) = self.styles.element_styles(source_root)? else {
return Err(LayoutError::MissingRootStyle { source_label });
};
+ let (mut root_style, root_before, root_after) = root_styles.into_parts();
let root_metrics = self.source.replaced_metrics(source_root);
if root_semantics.is_hidden_input()
|| (root_style.display() == LayoutDisplay::Contents
@@ -143,7 +145,14 @@ where
LayoutDisplay::None | LayoutDisplay::Contents
) && !is_leaf_element(&root_semantics, root_kind, &root_style)
{
- self.populate_root(&mut world, root_box, source_root, &root_style)?;
+ self.populate_root(
+ &mut world,
+ root_box,
+ source_root,
+ &root_style,
+ root_before,
+ root_after,
+ )?;
}
world.compact_reachable();
@@ -159,6 +168,8 @@ where
root_box: LayoutBoxId,
source_node: S::NodeId,
style: &ResolvedLayoutStyle,
+ before: Option<ResolvedLayoutPseudoStyle>,
+ after: Option<ResolvedLayoutPseudoStyle>,
) -> Result<(), LayoutError> {
if !self.active_sources.insert(source_node) {
return Err(LayoutError::SourceCycle {
@@ -166,7 +177,8 @@ where
});
}
let result = (|| {
- let children = self.build_element_child_stream(world, source_node, style)?;
+ let children =
+ self.build_element_child_stream(world, source_node, style, before, after)?;
let _ = self.attach_children(world, root_box, source_node, style, children, false)?;
Ok(())
})();
@@ -225,9 +237,10 @@ where
let result = (|| {
let semantics =
self.validated_element_semantics(source_node, self.source.node_kind(source_node))?;
- let Some(mut style) = self.styles.primary_style(source_node)? else {
+ let Some(styles) = self.styles.element_styles(source_node)? else {
return Ok(Vec::new());
};
+ let (mut style, before, after) = styles.into_parts();
if self.viewport_body_candidate.is_none()
&& self.root_is_html
&& self
@@ -261,7 +274,8 @@ where
match style.display() {
LayoutDisplay::None => Ok(Vec::new()),
LayoutDisplay::Contents => {
- let children = self.build_element_child_stream(world, source_node, &style)?;
+ let children =
+ self.build_element_child_stream(world, source_node, &style, before, after)?;
world.map_display_contents_source(source_node, &children);
Ok(children)
}
@@ -282,7 +296,8 @@ where
return Ok(vec![id]);
}
- let children = self.build_element_child_stream(world, source_node, &style)?;
+ let children =
+ self.build_element_child_stream(world, source_node, &style, before, after)?;
self.attach_children(world, id, source_node, &style, children, true)
}
}
@@ -381,16 +396,19 @@ where
world: &mut LayoutWorld<S::NodeId>,
source_node: S::NodeId,
style: &ResolvedLayoutStyle,
+ before: Option<ResolvedLayoutPseudoStyle>,
+ after: Option<ResolvedLayoutPseudoStyle>,
) -> Result<Vec<LayoutBoxId>, LayoutError> {
let mut children = Vec::new();
if style.display().is_list_item() {
- children.extend(self.build_pseudo(world, source_node, LayoutPseudo::Marker)?);
+ let marker = self.styles.marker_style(source_node)?;
+ children.extend(self.build_pseudo(world, source_node, LayoutPseudo::Marker, marker)?);
}
- children.extend(self.build_pseudo(world, source_node, LayoutPseudo::Before)?);
+ children.extend(self.build_pseudo(world, source_node, LayoutPseudo::Before, before)?);
for child in self.checked_flat_children(source_node)? {
children.extend(self.build_source_node(world, child, style)?);
}
- children.extend(self.build_pseudo(world, source_node, LayoutPseudo::After)?);
+ children.extend(self.build_pseudo(world, source_node, LayoutPseudo::After, after)?);
Ok(children)
}
@@ -399,10 +417,12 @@ where
world: &mut LayoutWorld<S::NodeId>,
owner: S::NodeId,
pseudo: LayoutPseudo,
+ style: Option<ResolvedLayoutPseudoStyle>,
) -> Result<Vec<LayoutBoxId>, LayoutError> {
- let Some(style) = self.styles.pseudo_style(owner, pseudo)? else {
+ let Some(style) = style else {
return Ok(Vec::new());
};
+ let style = style.into_style();
let is_marker = pseudo == LayoutPseudo::Marker;
if style.display() == LayoutDisplay::None || !style.generates_pseudo_box(is_marker) {
return Ok(Vec::new());
diff --git a/moli-layout/src/lib.rs b/moli-layout/src/lib.rs
index 0a367fb69..24716033a 100644
--- a/moli-layout/src/lib.rs
+++ b/moli-layout/src/lib.rs
@@ -89,7 +89,7 @@ pub use source::{
LayoutFormControlKind, LayoutImageResource, LayoutInputControlKind, LayoutListData,
LayoutListRole, LayoutNamespace, LayoutPseudo, LayoutReplacedKind, LayoutSource,
LayoutSourceKind, LayoutStyleResolver, LayoutTableData, LayoutTableRole, LayoutTextSelection,
- ReplacedMetrics,
+ ReplacedMetrics, ResolvedLayoutElementStyles, ResolvedLayoutPseudoStyle,
};
pub use style::{
LayoutDisplay, LayoutInlineAlignment, LayoutListMarkerPosition, LayoutListMarkerType,
diff --git a/moli-layout/src/source.rs b/moli-layout/src/source.rs
index 728b82e67..45922e190 100644
--- a/moli-layout/src/source.rs
+++ b/moli-layout/src/source.rs
@@ -524,18 +524,76 @@ pub trait LayoutSource {
}
}
-/// Renderer-owned access to primary, pseudo, and anonymous computed styles.
+/// One element's primary style and the pseudo styles eagerly cascaded with it.
+///
+/// The bundle is owned by one box-construction stack frame. It lets layout
+/// retain `::after` until after descendant construction without holding a
+/// renderer style-store borrow or introducing a side cache.
+pub struct ResolvedLayoutElementStyles {
+ primary: ResolvedLayoutStyle,
+ before: Option<ResolvedLayoutPseudoStyle>,
+ after: Option<ResolvedLayoutPseudoStyle>,
+}
+
+impl ResolvedLayoutElementStyles {
+ pub fn new(
+ primary: ResolvedLayoutStyle,
+ before: Option<ResolvedLayoutStyle>,
+ after: Option<ResolvedLayoutStyle>,
+ ) -> Self {
+ Self {
+ primary,
+ before: before.map(ResolvedLayoutPseudoStyle::new),
+ after: after.map(ResolvedLayoutPseudoStyle::new),
+ }
+ }
+
+ pub fn from_primary(primary: ResolvedLayoutStyle) -> Self {
+ Self::new(primary, None, None)
+ }
+
+ pub(crate) fn into_parts(
+ self,
+ ) -> (
+ ResolvedLayoutStyle,
+ Option<ResolvedLayoutPseudoStyle>,
+ Option<ResolvedLayoutPseudoStyle>,
+ ) {
+ (self.primary, self.before, self.after)
+ }
+}
+
+/// Heap-owned pseudo style carried through recursive box construction.
+///
+/// `ResolvedLayoutStyle` is intentionally rich and therefore large. Keeping
+/// absent `::before` and `::after` values inline would reserve room for two
+/// complete styles in every recursive builder frame. This wrapper keeps the
+/// frame representation pointer-sized without introducing shared state.
+pub struct ResolvedLayoutPseudoStyle(Box<ResolvedLayoutStyle>);
+
+impl ResolvedLayoutPseudoStyle {
+ pub fn new(style: ResolvedLayoutStyle) -> Self {
+ Self(Box::new(style))
+ }
+
+ pub(crate) fn into_style(self) -> ResolvedLayoutStyle {
+ *self.0
+ }
+}
+
+/// Renderer-owned access to element, lazy marker, and anonymous styles.
pub trait LayoutStyleResolver<N>
where
N: Copy + Debug + Eq + Hash,
{
- fn primary_style(&mut self, node: N) -> Result<Option<ResolvedLayoutStyle>, LayoutError>;
-
- fn pseudo_style(
+ fn element_styles(
&mut self,
node: N,
- pseudo: LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError>;
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError>;
+
+ fn marker_style(&mut self, _node: N) -> Result<Option<ResolvedLayoutPseudoStyle>, LayoutError> {
+ Ok(None)
+ }
fn anonymous_style(
&mut self,
diff --git a/moli-layout/tests/box_builder_contract.rs b/moli-layout/tests/box_builder_contract.rs
index 30cb49580..8c5d9b382 100644
--- a/moli-layout/tests/box_builder_contract.rs
+++ b/moli-layout/tests/box_builder_contract.rs
@@ -6,8 +6,9 @@ use moli_layout::{
LayoutFormControlKind, LayoutInlineAlignment, LayoutInputControlKind, LayoutListRole,
LayoutNamespace, LayoutPosition, LayoutPseudo, LayoutReplacedKind, LayoutSource,
LayoutSourceKind, LayoutStyleResolver, LayoutTableRole, PaintColor, PaintFragment, PaintRect,
- PaintViewport, ReplacedMetrics, ResolvedLayoutStyle, ScreenshotLayoutRequest,
- build_layout_world, build_screenshot_snapshot, normalize_layout_source,
+ PaintViewport, ReplacedMetrics, ResolvedLayoutElementStyles, ResolvedLayoutPseudoStyle,
+ ResolvedLayoutStyle, ScreenshotLayoutRequest, build_layout_world, build_screenshot_snapshot,
+ normalize_layout_source,
};
use style::Atom;
use taffy::{Dimension, Display, FlexDirection, Rect, Size, Style, style_helpers::length};
@@ -157,24 +158,37 @@ impl LayoutSource for TestSource {
struct TestStyles {
primary: HashMap<usize, ResolvedLayoutStyle>,
pseudo: HashMap<(usize, LayoutPseudo), ResolvedLayoutStyle>,
- primary_queries: Vec<usize>,
- pseudo_queries: Vec<(usize, LayoutPseudo)>,
+ element_queries: Vec<usize>,
+ marker_queries: Vec<usize>,
anonymous_queries: Vec<(usize, LayoutDisplay)>,
}
impl LayoutStyleResolver<usize> for TestStyles {
- fn primary_style(&mut self, node: usize) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- self.primary_queries.push(node);
- Ok(self.primary.get(&node).cloned())
+ fn element_styles(
+ &mut self,
+ node: usize,
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError> {
+ self.element_queries.push(node);
+ let Some(primary) = self.primary.get(&node).cloned() else {
+ return Ok(None);
+ };
+ Ok(Some(ResolvedLayoutElementStyles::new(
+ primary,
+ self.pseudo.get(&(node, LayoutPseudo::Before)).cloned(),
+ self.pseudo.get(&(node, LayoutPseudo::After)).cloned(),
+ )))
}
- fn pseudo_style(
+ fn marker_style(
&mut self,
node: usize,
- pseudo: LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- self.pseudo_queries.push((node, pseudo));
- Ok(self.pseudo.get(&(node, pseudo)).cloned())
+ ) -> Result<Option<ResolvedLayoutPseudoStyle>, LayoutError> {
+ self.marker_queries.push(node);
+ Ok(self
+ .pseudo
+ .get(&(node, LayoutPseudo::Marker))
+ .cloned()
+ .map(ResolvedLayoutPseudoStyle::new))
}
fn anonymous_style(
@@ -230,7 +244,7 @@ fn simple_block_ignores_comment_and_is_stable() {
let second = build_layout_world(&source, &mut styles).unwrap();
assert_eq!(first_normalized, second.normalized_tree().to_string());
- assert_eq!(styles.primary_queries, vec![0, 2, 0, 2]);
+ assert_eq!(styles.element_queries, vec![0, 2, 0, 2]);
}
#[test]
@@ -252,7 +266,7 @@ fn display_none_prunes_the_whole_subtree() {
assert_eq!(world.len(), 1);
assert_eq!(world.source_box(1), None);
assert_eq!(world.source_box(2), None);
- assert_eq!(styles.primary_queries, vec![0, 1]);
+ assert_eq!(styles.element_queries, vec![0, 1]);
}
#[test]
@@ -273,7 +287,7 @@ fn a_missing_non_root_style_prunes_that_source_subtree() {
assert_eq!(world.len(), 1);
assert_eq!(world.source_box(1), None);
assert_eq!(world.source_box(2), None);
- assert_eq!(styles.primary_queries, vec![0, 1]);
+ assert_eq!(styles.element_queries, vec![0, 1]);
}
#[test]
@@ -327,7 +341,7 @@ fn display_contents_on_unusual_html_elements_suppresses_the_element_and_subtree(
assert_eq!(world.len(), 1, "element={local_name}");
assert_eq!(world.source_box(1), None, "element={local_name}");
assert_eq!(world.source_box(2), None, "element={local_name}");
- assert_eq!(styles.primary_queries, vec![0, 1]);
+ assert_eq!(styles.element_queries, vec![0, 1]);
}
}
@@ -385,7 +399,7 @@ fn hidden_input_never_constructs_a_box_even_when_css_requests_block() {
assert_eq!(world.len(), 1);
assert_eq!(world.source_box(1), None);
assert_eq!(world.source_box(2), None);
- assert_eq!(styles.primary_queries, vec![0, 1]);
+ assert_eq!(styles.element_queries, vec![0, 1]);
}
#[test]
@@ -710,14 +724,7 @@ fn list_marker_precedes_before_content_and_keeps_normal_marker_state() {
world.box_by_id(children[1]).unwrap().pseudo(),
Some(LayoutPseudo::Before)
);
- assert_eq!(
- styles.pseudo_queries,
- vec![
- (0, LayoutPseudo::Marker),
- (0, LayoutPseudo::Before),
- (0, LayoutPseudo::After),
- ]
- );
+ assert_eq!(styles.marker_queries, vec![0],);
}
#[test]
@@ -766,10 +773,7 @@ fn list_item_and_marker_construction_follow_computed_display_not_the_html_tag()
let li = li_world.box_by_id(li_world.root()).unwrap();
assert_eq!(li.kind(), LayoutBoxKind::PrincipalBlock);
assert!(li.children().is_empty());
- assert_eq!(
- li_styles.pseudo_queries,
- vec![(0, LayoutPseudo::Before), (0, LayoutPseudo::After)]
- );
+ assert_eq!(li_styles.marker_queries, Vec::<usize>::new());
}
#[test]
@@ -1319,7 +1323,7 @@ fn replaced_and_line_break_boxes_are_leaves_but_object_fallback_content_is_not()
assert_eq!(object.children(), &[world.source_box(6).unwrap()]);
assert_eq!(world.source_box(2), None);
assert_eq!(world.source_box(4), None);
- assert_eq!(styles.primary_queries, vec![0, 1, 3, 5]);
+ assert_eq!(styles.element_queries, vec![0, 1, 3, 5]);
assert!(line_break.capability_diagnostics().is_empty());
}
diff --git a/moli-layout/tests/main_layout_contract.rs b/moli-layout/tests/main_layout_contract.rs
index 6af100af8..857a7689c 100644
--- a/moli-layout/tests/main_layout_contract.rs
+++ b/moli-layout/tests/main_layout_contract.rs
@@ -2,10 +2,10 @@ use std::collections::HashMap;
use moli_layout::{
DocumentLayoutServices, LayoutDisplay, LayoutElementCategory, LayoutElementSemantics,
- LayoutError, LayoutNamespace, LayoutPosition, LayoutPseudo, LayoutReplacedKind, LayoutSource,
+ LayoutError, LayoutNamespace, LayoutPosition, LayoutReplacedKind, LayoutSource,
LayoutSourceKind, LayoutStyleResolver, PaintBlendMode, PaintColor, PaintFragment, PaintRect,
- PaintSnapshot, PaintViewport, ReplacedMetrics, ResolvedLayoutStyle, ScreenshotLayoutRequest,
- build_screenshot_snapshot,
+ PaintSnapshot, PaintViewport, ReplacedMetrics, ResolvedLayoutElementStyles,
+ ResolvedLayoutStyle, ScreenshotLayoutRequest, build_screenshot_snapshot,
};
use style::Atom;
use taffy::{
@@ -127,16 +127,15 @@ impl LayoutSource for FixtureSource {
struct FixtureStyles(HashMap<usize, ResolvedLayoutStyle>);
impl LayoutStyleResolver<usize> for FixtureStyles {
- fn primary_style(&mut self, node: usize) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(self.0.get(&node).cloned())
- }
-
- fn pseudo_style(
+ fn element_styles(
&mut self,
- _node: usize,
- _pseudo: LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(None)
+ node: usize,
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError> {
+ Ok(self
+ .0
+ .get(&node)
+ .cloned()
+ .map(ResolvedLayoutElementStyles::from_primary))
}
fn anonymous_style(
diff --git a/moli-layout/tests/phase4_layout_contract.rs b/moli-layout/tests/phase4_layout_contract.rs
index 1d28ef865..9a0d84664 100644
--- a/moli-layout/tests/phase4_layout_contract.rs
+++ b/moli-layout/tests/phase4_layout_contract.rs
@@ -8,7 +8,8 @@ use moli_layout::{
LayoutReplacedKind, LayoutSource, LayoutSourceKind, LayoutStyleResolver, LayoutTableData,
LayoutTableRole, LayoutTextSelection, PaintBrush, PaintColor, PaintFragment, PaintRect,
PaintShape, PaintSnapshot, PaintTransform2D, PaintViewport, ReplacedMetrics,
- ResolvedLayoutStyle, ScreenshotLayoutRequest, build_screenshot_snapshot,
+ ResolvedLayoutElementStyles, ResolvedLayoutPseudoStyle, ResolvedLayoutStyle,
+ ScreenshotLayoutRequest, build_screenshot_snapshot,
};
use style::Atom;
use taffy::{
@@ -154,16 +155,26 @@ struct Styles {
}
impl LayoutStyleResolver<usize> for Styles {
- fn primary_style(&mut self, node: usize) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(self.primary.get(&node).cloned())
+ fn element_styles(
+ &mut self,
+ node: usize,
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError> {
+ Ok(self
+ .primary
+ .get(&node)
+ .cloned()
+ .map(ResolvedLayoutElementStyles::from_primary))
}
- fn pseudo_style(
+ fn marker_style(
&mut self,
node: usize,
- pseudo: LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(self.pseudo.get(&(node, pseudo)).cloned())
+ ) -> Result<Option<ResolvedLayoutPseudoStyle>, LayoutError> {
+ Ok(self
+ .pseudo
+ .get(&(node, LayoutPseudo::Marker))
+ .cloned()
+ .map(ResolvedLayoutPseudoStyle::new))
}
}
diff --git a/moli-layout/tests/phase5_output_contract.rs b/moli-layout/tests/phase5_output_contract.rs
index ec241f85f..232dda604 100644
--- a/moli-layout/tests/phase5_output_contract.rs
+++ b/moli-layout/tests/phase5_output_contract.rs
@@ -7,8 +7,8 @@ use moli_layout::{
LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch, LayoutRect, LayoutScrollbarColors,
LayoutScrollbarGutter, LayoutScrollbarPart, LayoutScrollbarWidth, LayoutSource,
LayoutSourceKind, LayoutStyleResolver, LayoutTransform2D, LayoutViewport, PaintBrush,
- PaintCaptureRequest, PaintColor, PaintFragment, PaintShape, ResolvedLayoutStyle,
- build_layout_pass,
+ PaintCaptureRequest, PaintColor, PaintFragment, PaintShape, ResolvedLayoutElementStyles,
+ ResolvedLayoutStyle, build_layout_pass,
};
use style::Atom;
use taffy::{
@@ -113,16 +113,15 @@ impl LayoutSource for Source {
struct Styles(HashMap<usize, ResolvedLayoutStyle>);
impl LayoutStyleResolver<usize> for Styles {
- fn primary_style(&mut self, node: usize) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(self.0.get(&node).cloned())
- }
-
- fn pseudo_style(
+ fn element_styles(
&mut self,
- _node: usize,
- _pseudo: moli_layout::LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- Ok(None)
+ node: usize,
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError> {
+ Ok(self
+ .0
+ .get(&node)
+ .cloned()
+ .map(ResolvedLayoutElementStyles::from_primary))
}
}
diff --git a/moli-renderer-v8/src/layout_renderer/mod.rs b/moli-renderer-v8/src/layout_renderer/mod.rs
index ab1b7bd17..858ef7572 100644
--- a/moli-renderer-v8/src/layout_renderer/mod.rs
+++ b/moli-renderer-v8/src/layout_renderer/mod.rs
@@ -68,6 +68,7 @@ fn build_native_layout_pass_recursive(
};
build_layout_pass_with_embedded_frames(&source, &mut styles, services, request, &mut frames)
};
+ styles.trace_profile(document);
document_stack.pop();
result
}
diff --git a/moli-renderer-v8/src/layout_renderer/style_resolver.rs b/moli-renderer-v8/src/layout_renderer/style_resolver.rs
index 46f4484b0..350ff44af 100644
--- a/moli-renderer-v8/src/layout_renderer/style_resolver.rs
+++ b/moli-renderer-v8/src/layout_renderer/style_resolver.rs
@@ -1,7 +1,8 @@
use moli_layout::{
- LayoutDisplay, LayoutError, LayoutPseudo, LayoutStyleResolver, LayoutViewport,
- ResolvedLayoutStyle,
+ LayoutDisplay, LayoutError, LayoutStyleResolver, LayoutViewport, ResolvedLayoutElementStyles,
+ ResolvedLayoutPseudoStyle, ResolvedLayoutStyle,
};
+use std::time::Instant;
use crate::{
document_runtime::DomHandle,
@@ -13,6 +14,23 @@ pub(super) struct NativeLayoutStyleResolver<'a> {
runtime: &'a JsContextHost,
reads: StyleObservation<'a>,
scripting_enabled: bool,
+ profile: Option<NativeLayoutStyleResolverProfile>,
+}
+
+#[derive(Default)]
+struct NativeLayoutStyleResolverProfile {
+ primary_count: u64,
+ primary_read_ns: u128,
+ primary_projection_ns: u128,
+ primary_policy_ns: u128,
+ eager_pseudo_count: u64,
+ eager_pseudo_projection_ns: u128,
+ marker_count: u64,
+ marker_read_ns: u128,
+ marker_projection_ns: u128,
+ anonymous_count: u64,
+ anonymous_read_ns: u128,
+ anonymous_projection_ns: u128,
}
impl<'a> NativeLayoutStyleResolver<'a> {
@@ -28,8 +46,33 @@ impl<'a> NativeLayoutStyleResolver<'a> {
runtime,
reads,
scripting_enabled: runtime.document_scripting_enabled(document),
+ profile: moli_trace::cpu_profile_enabled()
+ .then(NativeLayoutStyleResolverProfile::default),
}
}
+
+ pub(super) fn trace_profile(&self, document: crate::document_runtime::DomHandle) {
+ let Some(profile) = self.profile.as_ref() else {
+ return;
+ };
+ tracing::info!(
+ target: "moli_cpu_profile",
+ stage = "layout_style_resolver",
+ document = document.index_u32(),
+ primary_count = profile.primary_count,
+ primary_read_us = profile.primary_read_ns / 1_000,
+ primary_projection_us = profile.primary_projection_ns / 1_000,
+ primary_policy_us = profile.primary_policy_ns / 1_000,
+ eager_pseudo_count = profile.eager_pseudo_count,
+ eager_pseudo_projection_us = profile.eager_pseudo_projection_ns / 1_000,
+ marker_count = profile.marker_count,
+ marker_read_us = profile.marker_read_ns / 1_000,
+ marker_projection_us = profile.marker_projection_ns / 1_000,
+ anonymous_count = profile.anonymous_count,
+ anonymous_read_us = profile.anonymous_read_ns / 1_000,
+ anonymous_projection_us = profile.anonymous_projection_ns / 1_000,
+ );
+ }
}
fn layout_style_read_scope<'a>(
@@ -58,15 +101,55 @@ fn layout_style_viewport(runtime: &JsContextHost, viewport: LayoutViewport) -> S
}
impl LayoutStyleResolver<DomHandle> for NativeLayoutStyleResolver<'_> {
- fn primary_style(
+ fn element_styles(
&mut self,
node: DomHandle,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
+ ) -> Result<Option<ResolvedLayoutElementStyles>, LayoutError> {
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
let read = self.reads.read(node);
- let Some(computed) = read.computed_values() else {
+ let Some((computed, before, after)) = read.into_element_computed_values() else {
+ if let Some(profile) = self.profile.as_mut() {
+ profile.primary_count = profile.primary_count.saturating_add(1);
+ profile.primary_read_ns = profile.primary_read_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
return Ok(None);
};
+ let eager_pseudo_count = u64::from(before.is_some()) + u64::from(after.is_some());
+ if let Some(profile) = self.profile.as_mut() {
+ profile.primary_count = profile.primary_count.saturating_add(1);
+ profile.primary_read_ns = profile.primary_read_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
let mut resolved = ResolvedLayoutStyle::from_stylo(computed);
+ if let Some(profile) = self.profile.as_mut() {
+ profile.primary_projection_ns = profile.primary_projection_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
+ let before = before.map(ResolvedLayoutStyle::from_stylo);
+ let after = after.map(ResolvedLayoutStyle::from_stylo);
+ if let Some(profile) = self.profile.as_mut() {
+ profile.eager_pseudo_count = profile
+ .eager_pseudo_count
+ .saturating_add(eager_pseudo_count);
+ profile.eager_pseudo_projection_ns = profile.eager_pseudo_projection_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
if self
.runtime
.dom_host()
@@ -87,18 +170,45 @@ impl LayoutStyleResolver<DomHandle> for NativeLayoutStyleResolver<'_> {
// Document can execute scripts.
resolved.force_display_none();
}
- Ok(Some(resolved))
+ if let Some(profile) = self.profile.as_mut() {
+ profile.primary_policy_ns = profile.primary_policy_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ Ok(Some(ResolvedLayoutElementStyles::new(
+ resolved, before, after,
+ )))
}
- fn pseudo_style(
+ fn marker_style(
&mut self,
node: DomHandle,
- pseudo: LayoutPseudo,
- ) -> Result<Option<ResolvedLayoutStyle>, LayoutError> {
- let pseudo_name = pseudo_style_name(pseudo);
+ ) -> Result<Option<ResolvedLayoutPseudoStyle>, LayoutError> {
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
let read = self.reads.read(node);
- let computed = read.pseudo_computed_values(pseudo_name);
- Ok(computed.map(ResolvedLayoutStyle::from_stylo))
+ let computed = read.pseudo_computed_values("marker");
+ if let Some(profile) = self.profile.as_mut() {
+ profile.marker_count = profile.marker_count.saturating_add(1);
+ profile.marker_read_ns = profile.marker_read_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
+ let resolved = computed.map(|computed| {
+ ResolvedLayoutPseudoStyle::new(ResolvedLayoutStyle::from_stylo(computed))
+ });
+ if let Some(profile) = self.profile.as_mut() {
+ profile.marker_projection_ns = profile.marker_projection_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ Ok(resolved)
}
fn anonymous_style(
@@ -114,6 +224,7 @@ impl LayoutStyleResolver<DomHandle> for NativeLayoutStyleResolver<'_> {
)
})?;
let anonymous_kind = anonymous_box_kind(display);
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
let read = self.reads.read(owner);
let computed = read
.anonymous_computed_values(parent_computed.as_ref(), anonymous_kind)
@@ -123,8 +234,24 @@ impl LayoutStyleResolver<DomHandle> for NativeLayoutStyleResolver<'_> {
format!("Stylo could not resolve {anonymous_kind:?} anonymous style"),
)
})?;
+ if let Some(profile) = self.profile.as_mut() {
+ profile.anonymous_count = profile.anonymous_count.saturating_add(1);
+ profile.anonymous_read_ns = profile.anonymous_read_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
+ let phase_started = self.profile.as_ref().map(|_| Instant::now());
let mut resolved = ResolvedLayoutStyle::from_stylo(computed);
resolved.force_layout_display(display);
+ if let Some(profile) = self.profile.as_mut() {
+ profile.anonymous_projection_ns = profile.anonymous_projection_ns.saturating_add(
+ phase_started
+ .map(|started| started.elapsed().as_nanos())
+ .unwrap_or_default(),
+ );
+ }
Ok(resolved)
}
}
@@ -155,26 +282,11 @@ const fn anonymous_box_kind(display: LayoutDisplay) -> StyloAnonymousBoxKind {
}
}
-const fn pseudo_style_name(pseudo: LayoutPseudo) -> &'static str {
- match pseudo {
- LayoutPseudo::Marker => "marker",
- LayoutPseudo::Before => "before",
- LayoutPseudo::After => "after",
- }
-}
-
#[cfg(test)]
mod tests {
- use super::{anonymous_box_kind, pseudo_style_name};
+ use super::anonymous_box_kind;
use crate::style_engine::StyloAnonymousBoxKind;
- use moli_layout::{LayoutDisplay, LayoutPseudo};
-
- #[test]
- fn all_layout_pseudos_map_to_stylo_names() {
- assert_eq!(pseudo_style_name(LayoutPseudo::Marker), "marker");
- assert_eq!(pseudo_style_name(LayoutPseudo::Before), "before");
- assert_eq!(pseudo_style_name(LayoutPseudo::After), "after");
- }
+ use moli_layout::LayoutDisplay;
#[test]
fn anonymous_table_roles_use_the_matching_servo_precomputed_pseudo() {
diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs
index 7da72795d..a4d060102 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs
@@ -470,6 +470,8 @@ impl JsContextHost {
style_world_shadow_scope_materializations: Cell::new(0),
#[cfg(test)]
stylo_computed_style_property_reads: Cell::new(0),
+ #[cfg(test)]
+ style_observation_environment_resolutions: Cell::new(0),
};
host.sync_owner_style_sheet_texts_for_document_tree_scopes(host.document_handle());
host
diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
index d4a98e35c..6d687ed42 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs
@@ -1691,23 +1691,16 @@ impl JsContextHost {
handle: DomHandle,
read_document: DomHandle,
viewport: StyleViewport,
+ environment: StyloStyleEnvironment,
tree_scope_versions: crate::style_engine::StyleTreeScopeVersions,
) -> StyleObservationSnapshot {
let document_context = self.style_source_document_context_for_read_document(read_document);
- let page_color_schemes = self
- .dom_host()
- .owner_document_handle(handle)
- .map(|document| {
- crate::document_color_scheme::document_page_color_schemes(self.dom_host(), document)
- })
- .unwrap_or_default();
self.style_engine
.computed_style_snapshot_from_current_observation(
self.dom_host(),
self.document_url(),
handle,
- StyloStyleEnvironment::from_emulated_media(self.emulated_media())
- .with_page_color_schemes(page_color_schemes),
+ environment,
document_context.as_ref(),
read_document,
viewport,
@@ -1776,6 +1769,20 @@ impl JsContextHost {
self.stylo_computed_style_property_reads.get()
}
+ #[cfg(test)]
+ pub(crate) fn note_style_observation_environment_resolution_for_test(&self) {
+ self.style_observation_environment_resolutions.set(
+ self.style_observation_environment_resolutions
+ .get()
+ .saturating_add(1),
+ );
+ }
+
+ #[cfg(test)]
+ pub(crate) fn style_observation_environment_resolutions_for_test(&self) -> u64 {
+ self.style_observation_environment_resolutions.get()
+ }
+
pub(crate) fn set_document_url(&mut self, url: url::Url) -> bool {
let target_change = DocumentRuntime::set_document_url(self, url);
if let Some((previous_target, next_target)) = target_change {
diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
index e4b99d7f7..dc84dbd3e 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
@@ -1089,6 +1089,8 @@ pub(crate) struct JsContextHost {
style_world_shadow_scope_materializations: Cell<u64>,
#[cfg(test)]
stylo_computed_style_property_reads: Cell<u64>,
+ #[cfg(test)]
+ style_observation_environment_resolutions: Cell<u64>,
}
struct PendingTextControlChangeCommit {
diff --git a/moli-renderer-v8/src/native_bridge/element/styles/declaration/observation.rs b/moli-renderer-v8/src/native_bridge/element/styles/declaration/observation.rs
index 164993d32..82bf4d878 100644
--- a/moli-renderer-v8/src/native_bridge/element/styles/declaration/observation.rs
+++ b/moli-renderer-v8/src/native_bridge/element/styles/declaration/observation.rs
@@ -4,7 +4,7 @@ use crate::{
document_runtime::DomHandle,
style_engine::{
FullStyleWorldSnapshot, PreparedStyleWorldUpdate, StyleObservationSnapshot, StyleViewport,
- StyleWorldUpdatePlan, StyloComputedStyleSnapshot,
+ StyleWorldUpdatePlan, StyloComputedStyleSnapshot, StyloStyleEnvironment,
},
};
@@ -12,7 +12,7 @@ use super::super::super::super::JsContextHost;
use super::super::style_viewport_for_document;
use super::style_world::{
StyleObservationKey, prepare_style_world_update, stylesheet_query_fallback,
- stylesheet_source_document_for_handle,
+ stylesheet_source_document_for_handle, stylo_style_environment,
};
#[derive(Clone, Copy, Debug, Default)]
@@ -85,6 +85,10 @@ pub(super) struct StyleObservationInputs<'a> {
runtime: &'a JsContextHost,
key: StyleObservationKey,
context: StyleComputationContext,
+ /// Page-level media inputs are stable for one synchronous observation.
+ /// In particular, discovering `<meta name=color-scheme>` requires a
+ /// document-order query and must not be repeated for every layout node.
+ environment: StyloStyleEnvironment,
#[cfg(debug_assertions)]
tracks_persistent_world: bool,
prepared_update: RefCell<Option<Rc<PreparedStyleWorldUpdate>>>,
@@ -98,10 +102,12 @@ impl<'a> StyleObservationInputs<'a> {
context: StyleComputationContext,
_tracks_persistent_world: bool,
) -> Self {
+ let environment = stylo_style_environment(runtime, source_document);
Self {
runtime,
key: StyleObservationKey::for_document(runtime, source_document),
context,
+ environment,
#[cfg(debug_assertions)]
tracks_persistent_world: _tracks_persistent_world,
prepared_update: RefCell::new(None),
@@ -121,11 +127,21 @@ impl<'a> StyleObservationInputs<'a> {
self.context
}
+ fn environment(&self) -> StyloStyleEnvironment {
+ self.environment
+ }
+
fn prepared_update(&self, plan: &StyleWorldUpdatePlan) -> Rc<PreparedStyleWorldUpdate> {
if let Some(update) = self.prepared_update.borrow().as_ref() {
return Rc::clone(update);
}
- let update = prepare_style_world_update(self.runtime, &self.key, self.context, plan);
+ let update = prepare_style_world_update(
+ self.runtime,
+ &self.key,
+ self.context,
+ self.environment,
+ plan,
+ );
*self.prepared_update.borrow_mut() = Some(Rc::clone(&update));
update
}
@@ -140,7 +156,9 @@ impl<'a> StyleObservationInputs<'a> {
self.runtime
.retained_stylesheet_query_snapshot_for_document(document)
})
- .unwrap_or_else(|| stylesheet_query_fallback(self.runtime, &self.key, self.context));
+ .unwrap_or_else(|| {
+ stylesheet_query_fallback(self.runtime, &self.key, self.context, self.environment)
+ });
*self.stylesheet_query_snapshot.borrow_mut() = Some(Rc::clone(&inputs));
inputs
}
@@ -173,6 +191,7 @@ impl RetainedStyleObservation for StyleObservationInputs<'_> {
handle,
read_document,
self.context.viewport,
+ self.environment,
self.tree_scope_versions(),
) {
StyleObservationSnapshot::Current(style) => style,
@@ -289,6 +308,7 @@ impl<'a> StyleObservation<'a> {
handle,
read_document,
context.viewport,
+ observation_inputs.environment(),
observation_inputs.tree_scope_versions(),
) {
StyleObservationSnapshot::Current(style) => style,
diff --git a/moli-renderer-v8/src/native_bridge/element/styles/declaration/style_world.rs b/moli-renderer-v8/src/native_bridge/element/styles/declaration/style_world.rs
index e668d5974..5cfc6e2ca 100644
--- a/moli-renderer-v8/src/native_bridge/element/styles/declaration/style_world.rs
+++ b/moli-renderer-v8/src/native_bridge/element/styles/declaration/style_world.rs
@@ -90,9 +90,9 @@ pub(super) fn prepare_style_world_update(
runtime: &JsContextHost,
key: &StyleObservationKey,
context: StyleComputationContext,
+ media: StyloStyleEnvironment,
plan: &StyleWorldUpdatePlan,
) -> Rc<PreparedStyleWorldUpdate> {
- let media = stylo_style_environment(runtime, key.source_document());
let quirks_mode = quirks_mode(runtime, key.source_document());
let environment = StyleWorldEnvironment::new(
context.viewport(),
@@ -151,19 +151,17 @@ pub(super) fn stylesheet_query_fallback(
runtime: &JsContextHost,
key: &StyleObservationKey,
context: StyleComputationContext,
+ environment: StyloStyleEnvironment,
) -> Rc<FullStyleWorldSnapshot> {
- complete_style_world_snapshot(
- runtime,
- key,
- context,
- stylo_style_environment(runtime, key.source_document()),
- )
+ complete_style_world_snapshot(runtime, key, context, environment)
}
-fn stylo_style_environment(
+pub(super) fn stylo_style_environment(
runtime: &JsContextHost,
document: Option<DomHandle>,
) -> StyloStyleEnvironment {
+ #[cfg(test)]
+ runtime.note_style_observation_environment_resolution_for_test();
StyloStyleEnvironment::from_emulated_media(runtime.emulated_media()).with_page_color_schemes(
document
.map(|document| {
diff --git a/moli-renderer-v8/src/native_bridge/element/styles/declaration/values.rs b/moli-renderer-v8/src/native_bridge/element/styles/declaration/values.rs
index 326df6048..1bde75b21 100644
--- a/moli-renderer-v8/src/native_bridge/element/styles/declaration/values.rs
+++ b/moli-renderer-v8/src/native_bridge/element/styles/declaration/values.rs
@@ -228,6 +228,20 @@ impl<'a> ComputedStyleRead<'a> {
.map(StyloComputedStyleSnapshot::computed_values)
}
+ /// Transfers the observation's owned Stylo handles into box construction.
+ /// The only reference-count increments happened when the canonical
+ /// `ElementStyles` crossed the renderer borrow boundary.
+ pub(crate) fn into_element_computed_values(
+ self,
+ ) -> Option<(
+ ServoArc<ComputedValues>,
+ Option<ServoArc<ComputedValues>>,
+ Option<ServoArc<ComputedValues>>,
+ )> {
+ self.stylo_style
+ .map(StyloComputedStyleSnapshot::into_element_computed_values)
+ }
+
/// Returns the typed resource manifest published with this read's exact
/// retained stylesheet world. No CSS text is serialized or reparsed.
pub(crate) fn stylesheet_resource_snapshot(&self) -> Option<StylesheetResourceSnapshot> {
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/computed_style.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/computed_style.rs
index 3871116bc..103bec066 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/computed_style.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/computed_style.rs
@@ -483,6 +483,40 @@ fn style_observation_reuses_current_world_without_materializing_an_update() {
assert_eq!(host.style_world_full_snapshots_for_test(), full_snapshots);
}
+#[test]
+fn style_observation_resolves_page_environment_once_for_all_element_reads() {
+ let mut vm = new_parsed_test_vm(
+ "https://style-observation-page-environment.test/",
+ "<!doctype html><meta name=color-scheme content='dark light'><div id=first></div><div id=second></div>",
+ );
+ vm.eval("getComputedStyle(document.getElementById('first')).color")
+ .expect("initial style should establish the retained world");
+ let first = element_handle_by_id(&vm, "first");
+ let second = element_handle_by_id(&vm, "second");
+ let host = vm._context_host.borrow();
+ let before = host.style_observation_environment_resolutions_for_test();
+
+ {
+ let mut observation = crate::native_bridge::element::StyleObservation::new(&host);
+ assert!(observation.read(first).computed_values().is_some());
+ assert!(observation.read(second).computed_values().is_some());
+ assert!(observation.read(first).computed_values().is_some());
+ }
+ assert_eq!(
+ host.style_observation_environment_resolutions_for_test() - before,
+ 1,
+ "one synchronous observation must snapshot page-level media inputs once"
+ );
+
+ let mut next_observation = crate::native_bridge::element::StyleObservation::new(&host);
+ assert!(next_observation.read(first).computed_values().is_some());
+ assert_eq!(
+ host.style_observation_environment_resolutions_for_test() - before,
+ 2,
+ "a later observation must take a fresh page-level environment snapshot"
+ );
+}
+
#[test]
fn style_observation_refreshes_dirty_element_without_materializing_a_world_update() {
let mut vm = new_parsed_test_vm(
@@ -542,6 +576,7 @@ fn style_observation_materializes_dirty_scope_once_without_a_full_snapshot() {
let full_snapshots = host.style_world_full_snapshots_for_test();
let document_scopes = host.style_world_document_scope_materializations_for_test();
let shadow_scopes = host.style_world_shadow_scope_materializations_for_test();
+ let environment_resolutions = host.style_observation_environment_resolutions_for_test();
let mut observation = crate::native_bridge::element::StyleObservation::new(&host);
let first = observation
@@ -573,6 +608,11 @@ fn style_observation_materializes_dirty_scope_once_without_a_full_snapshot() {
host.style_world_shadow_scope_materializations_for_test(),
shadow_scopes
);
+ assert_eq!(
+ host.style_observation_environment_resolutions_for_test() - environment_resolutions,
+ 1,
+ "a dirty world update must reuse its observation's page-level environment"
+ );
}
#[test]
diff --git a/moli-renderer-v8/src/style_engine/computed.rs b/moli-renderer-v8/src/style_engine/computed.rs
index 80105f515..08c2d1bee 100644
--- a/moli-renderer-v8/src/style_engine/computed.rs
+++ b/moli-renderer-v8/src/style_engine/computed.rs
@@ -57,6 +57,8 @@ use super::{
#[derive(Clone)]
pub(crate) struct StyloComputedStyleSnapshot {
primary: ServoArc<ComputedValues>,
+ before: Option<ServoArc<ComputedValues>>,
+ after: Option<ServoArc<ComputedValues>>,
}
pub(crate) enum StyleObservationSnapshot {
@@ -149,10 +151,36 @@ pub(crate) struct ComputedRenderedStyleFacts {
}
impl StyloComputedStyleSnapshot {
+ fn from_primary(primary: ServoArc<ComputedValues>) -> Self {
+ Self {
+ primary,
+ before: None,
+ after: None,
+ }
+ }
+
+ fn from_element_styles(styles: &ElementStyles) -> Self {
+ Self {
+ primary: styles.primary().clone(),
+ before: styles.pseudos.get(&PseudoElement::Before).cloned(),
+ after: styles.pseudos.get(&PseudoElement::After).cloned(),
+ }
+ }
+
pub(crate) fn computed_values(&self) -> ServoArc<ComputedValues> {
self.primary.clone()
}
+ pub(crate) fn into_element_computed_values(
+ self,
+ ) -> (
+ ServoArc<ComputedValues>,
+ Option<ServoArc<ComputedValues>>,
+ Option<ServoArc<ComputedValues>>,
+ ) {
+ (self.primary, self.before, self.after)
+ }
+
pub(crate) fn rendered_style_facts(&self) -> ComputedRenderedStyleFacts {
let display = self.primary.clone_display();
let content_visibility_applicable = !display.is_none()
@@ -338,7 +366,7 @@ pub(super) fn computed_style_property_value(
inputs,
document_context,
pseudo_element.as_ref(),
- |style| serialize_computed_custom_property(style, property),
+ |style, _styles| serialize_computed_custom_property(style, property),
);
}
let property_id = PropertyId::parse_enabled_for_all_content(property).ok()?;
@@ -366,7 +394,7 @@ pub(super) fn computed_style_property_value(
inputs,
document_context,
pseudo_element.as_ref(),
- |style| serialize_resolved_computed_property(style, property_id),
+ |style, _styles| serialize_resolved_computed_property(style, property_id),
)
}
@@ -452,11 +480,7 @@ pub(super) fn computed_style_snapshot_from_current_observation(
&world,
quirks_mode,
None,
- |style| {
- Some(StyloComputedStyleSnapshot {
- primary: style.clone(),
- })
- },
+ |_style, styles| styles.map(StyloComputedStyleSnapshot::from_element_styles),
))
}
@@ -520,11 +544,7 @@ pub(super) fn computed_style_snapshot_after_world_update(
&world,
update.environment().quirks_mode,
None,
- |style| {
- Some(StyloComputedStyleSnapshot {
- primary: style.clone(),
- })
- },
+ |_style, styles| styles.map(StyloComputedStyleSnapshot::from_element_styles),
)
}
}
@@ -566,9 +586,9 @@ pub(super) fn computed_pseudo_style_snapshot_from_current_observation(
quirks_mode,
&pseudo_element,
|style| {
- Some(StyloComputedStyleSnapshot {
- primary: ServoArc::new(style.clone()),
- })
+ Some(StyloComputedStyleSnapshot::from_primary(ServoArc::new(
+ style.clone(),
+ )))
},
);
}
@@ -580,11 +600,7 @@ pub(super) fn computed_pseudo_style_snapshot_from_current_observation(
&world,
quirks_mode,
Some(&pseudo_element),
- |style| {
- Some(StyloComputedStyleSnapshot {
- primary: style.clone(),
- })
- },
+ |style, _styles| Some(StyloComputedStyleSnapshot::from_primary(style.clone())),
)
}
@@ -636,7 +652,7 @@ fn computed_anonymous_style_snapshot_in_current_world(
.stylist
.style_for_anonymous::<StyloElement<'_>>(&guards, &pseudo, parent_style)
});
- Some(StyloComputedStyleSnapshot { primary: style })
+ Some(StyloComputedStyleSnapshot::from_primary(style))
})
}
@@ -669,11 +685,7 @@ fn computed_style_snapshot_after_style_update_with_key(
inputs,
document_context,
None,
- |style| {
- Some(StyloComputedStyleSnapshot {
- primary: style.clone(),
- })
- },
+ |_style, styles| styles.map(StyloComputedStyleSnapshot::from_element_styles),
)
}
@@ -699,7 +711,7 @@ fn with_resolved_style<R>(
inputs: &FullStyleWorldSnapshot,
document_context: StyleSourceDocumentContext<'_>,
pseudo_element: Option<&PseudoElement>,
- callback: impl FnOnce(&ServoArc<ComputedValues>) -> Option<R>,
+ callback: impl FnOnce(&ServoArc<ComputedValues>, Option<&ElementStyles>) -> Option<R>,
) -> Option<R> {
let owner_document = owner_document_for_computed_style_read(host, handle)?;
let world = engine.world_for_document(owner_document);
@@ -732,7 +744,7 @@ fn with_resolved_style_in_current_world<R>(
world: &DocumentStyleWorld,
quirks_mode: QuirksMode,
pseudo_element: Option<&PseudoElement>,
- callback: impl FnOnce(&ServoArc<ComputedValues>) -> Option<R>,
+ callback: impl FnOnce(&ServoArc<ComputedValues>, Option<&ElementStyles>) -> Option<R>,
) -> Option<R> {
let computed_cache_generation = world.document_state.computed_cache_generation();
if let Some(pseudo_element) = pseudo_element {
@@ -742,7 +754,7 @@ fn with_resolved_style_in_current_world<R>(
pseudo_element: Some(pseudo_element.clone()),
};
if let Some(style) = world.computed_style_cache.get_pseudo(&pseudo_key) {
- return callback(&style);
+ return callback(&style, None);
}
}
@@ -807,7 +819,7 @@ fn with_resolved_style_in_current_world<R>(
});
canonical_styles.primary().clone()
};
- callback(&style)
+ callback(&style, Some(&canonical_styles))
})
}
@@ -978,7 +990,7 @@ fn with_lazily_resolved_pseudo_style_in_current_world<R>(
world,
quirks_mode,
None,
- |style| Some(style.clone()),
+ |style, _styles| Some(style.clone()),
)?;
engine.dom_adapter.with_bound_host(host, |dom_adapter| {
diff --git a/moli-renderer-v8/src/style_engine/tests/subtree_cache.rs b/moli-renderer-v8/src/style_engine/tests/subtree_cache.rs
index 7de97e19c..e76c3143c 100644
--- a/moli-renderer-v8/src/style_engine/tests/subtree_cache.rs
+++ b/moli-renderer-v8/src/style_engine/tests/subtree_cache.rs
@@ -60,6 +60,56 @@ fn computed_style_is_published_on_canonical_element_data_and_reused() {
);
}
+#[test]
+fn primary_snapshot_carries_applicable_eager_pseudos_without_forcing_absent_ones() {
+ let mut host = test_host();
+ let document = host.document_handle();
+ let generated = host.create_element("div");
+ let plain = host.create_element("div");
+ assert!(host.set_attribute(generated, "class", "generated"));
+ assert!(host.append_child(document, generated));
+ assert!(host.append_child(document, plain));
+
+ let engine = MoliStyleEngine::new();
+ let document_url = url::Url::parse("https://example.test/").unwrap();
+ let mut inputs = FullStyleWorldSnapshot::default();
+ inputs.document_stylesheet_sources.push(
+ StyloStylesheetSource::new(
+ ".generated::before { content: 'before'; }\n\
+ .generated::after { content: 'after'; }"
+ .into(),
+ document_url.clone(),
+ )
+ .with_source_id(Some(StyleSourceId::document_adopted_style_sheet(
+ document, 1,
+ ))),
+ );
+
+ let before = engine.element_style_resolution_count_for_document_for_test(document);
+ let generated_snapshot =
+ computed_style_snapshot_for_test(&engine, &host, &document_url, generated, &inputs);
+ let (_, generated_before, generated_after) = generated_snapshot.into_element_computed_values();
+ assert!(generated_before.is_some());
+ assert!(generated_after.is_some());
+ assert_eq!(
+ engine.element_style_resolution_count_for_document_for_test(document),
+ before + 1,
+ "the primary resolve already cascades both eager pseudo styles"
+ );
+
+ let before = engine.element_style_resolution_count_for_document_for_test(document);
+ let plain_snapshot =
+ computed_style_snapshot_for_test(&engine, &host, &document_url, plain, &inputs);
+ let (_, plain_before, plain_after) = plain_snapshot.into_element_computed_values();
+ assert!(plain_before.is_none());
+ assert!(plain_after.is_none());
+ assert_eq!(
+ engine.element_style_resolution_count_for_document_for_test(document),
+ before + 1,
+ "observing absent eager pseudos must not force two extra resolutions"
+ );
+}
+
#[test]
fn scoped_invalidation_marks_canonical_style_dirty_and_preserves_clean_elements() {
let mut host = test_host();