Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
perf(renderer): reuse style work within layout observations
ldm0a50bc689ed33
diff --git a/moli-layout/src/builder.rs b/moli-layout/src/builder.rsindex 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 @@ wherelet 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 @@ whereLayoutDisplay::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 @@ whereroot_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 @@ wherelet 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 @@ wherematch 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 @@ wherereturn 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 @@ whereworld: &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 @@ whereworld: &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.rsindex 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.rsindex 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>whereN: 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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());hostdiff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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();