The headless browser for AI agents and web scraping
fix(render): avoid redundant layout and text shaping
SGavrld579bddf79e0
diff --git a/crates/obscura-render/src/dom.rs b/crates/obscura-render/src/dom.rsindex 436d5bb8..cc9da6e9 100644--- a/crates/obscura-render/src/dom.rs+++ b/crates/obscura-render/src/dom.rs@@ -4076,6 +4076,59 @@ fn retained_style_plan(}}+/// A selector-only `tabindex` mutation cannot change layout or paint when the+/// current stylesheet has no dependency on it. Keep this deliberately narrow:+/// other zero-dirty attributes can still affect native geometry.+pub(crate) fn can_retain_layout_for_tabindex(+ tree: &DomTree,+ viewport: (f32, f32),+ cache: &mut crate::css::StylesheetCache,+ mutations: &[RetainedStyleMutation],+) -> bool {+ if mutations.is_empty()+ || !mutations.iter().all(|mutation| {+ matches!(mutation, RetainedStyleMutation::Attribute(attribute)+ if attribute.name.eq_ignore_ascii_case("tabindex")+ && retained_attribute_mutation_kind(tree, attribute.node, &attribute.name)+ == RetainedAttributeMutationKind::Selector)+ })+ {+ return false;+ }++ let nodes = tree.descendants(tree.document());+ if nodes.iter().any(|node| tree.shadow_root(*node).is_some()) {+ return false;+ }+ let sources = nodes+ .into_iter()+ .filter_map(|id| {+ let node = tree.get_node(id)?;+ let element = node.as_element()?;+ (element.local.as_ref() == "style"+ && node.get_attribute("media").is_none_or(|media| {+ media.trim().is_empty()+ || crate::css::media_query_applies_for_viewport_and_type(+ media,+ viewport,+ crate::CssMediaType::Screen,+ )+ }))+ .then(|| tree.text_content(id))+ })+ .collect::<Vec<_>>();+ let (sheet, cache_hit) =+ cache.get_or_parse(tree, &sources, viewport, crate::CssMediaType::Screen);+ cache_hit+ && matches!(+ retained_style_plan(tree, &sheet, mutations),+ RetainedStylePlan::Reuse {+ dirty,+ has_animation_damage: false,+ } if dirty.is_empty()+ )+}+pub(crate) fn layout_dom_with_web_fonts(tree: &DomTree,viewport: (f32, f32),@@ -16866,6 +16919,72 @@ mod tests {assert!(telemetry.retained_reused >= 1_000, "{telemetry:?}");}+ #[test]+ fn unreferenced_tabindex_can_retain_layout_but_css_dependencies_cannot() {+ for (css, reusable) in [+ ("#target { width: 80px }", true),+ ("[tabindex] { width: 160px }", false),+ ("p::before { content: attr(tabindex) }", false),+ ("section:has([tabindex]) p { height: 50px }", false),+ ] {+ let tree = parse_html(&format!(+ "<style>{css}</style><section><p id=target>text</p></section>"+ ));+ let target = tree.get_element_by_id("target").unwrap();+ let viewport = (500.0, 300.0);+ let mut cache = crate::css::StylesheetCache::default();+ let _ = layout_dom_with_web_fonts_and_stylesheet_cache(+ &tree,+ viewport,+ &HashMap::new(),+ &[],+ &mut cache,+ );+ let mutation = |name: &str| {+ RetainedStyleMutation::Attribute(AttributeStyleMutation {+ node: target,+ name: name.into(),+ old_value: None,+ new_value: Some("0".into()),+ })+ };++ assert_eq!(+ can_retain_layout_for_tabindex(+ &tree,+ viewport,+ &mut cache,+ &[mutation("tabindex")],+ ),+ reusable,+ "{css}"+ );+ for name in ["data-sized", "style", "hidden", "open"] {+ assert!(+ !can_retain_layout_for_tabindex(+ &tree,+ viewport,+ &mut cache,+ &[mutation(name)],+ ),+ "{name}"+ );+ }+ assert!(!can_retain_layout_for_tabindex(+ &tree,+ viewport,+ &mut cache,+ &[RetainedStyleMutation::Resource],+ ));+ assert!(!can_retain_layout_for_tabindex(+ &tree,+ (600.0, 300.0),+ &mut cache,+ &[mutation("tabindex")],+ ));+ }+ }+#[test]fn retained_nested_universal_container_reset_is_bounded_and_matches_full() {let mut queried = String::new();diff --git a/crates/obscura-render/src/inline.rs b/crates/obscura-render/src/inline.rsindex d5a20941..9684c12a 100644--- a/crates/obscura-render/src/inline.rs+++ b/crates/obscura-render/src/inline.rs@@ -780,6 +780,8 @@ pub struct InlineItem {/// Empty for ordinary IFCs and for nested inlines that remain at their/// normal-flow position, so paint pays no provenance cost on that path.relative_owner_ranges: Vec<RelativeOwnerTextRange>,+ /// Exact measurement results retained across repeated Taffy probes.+ measured: Vec<(Option<u32>, Wrap, (f32, f32))>,}#[derive(Clone, Copy, Debug)]@@ -1736,6 +1738,7 @@ impl TextEngine {owner_boxes,boundary_events,relative_owner_ranges: Vec::new(),+ measured: Vec::new(),});Some(idx)}@@ -1756,20 +1759,33 @@ impl TextEngine {}fn measure_text_with_wrap(&mut self, idx: usize, width: Option<f32>, wrap: Wrap) -> (f32, f32) {+ let key = width.map(f32::to_bits);+ if let Some((_, _, size)) = self.items[idx]+ .measured+ .iter()+ .find(|(cached_width, cached_wrap, _)| *cached_width == key && *cached_wrap == wrap)+ {+ return *size;+ }let TextEngine {font_system, items, ..} = self;let item = &mut items[idx];shape_with_text_indent(font_system, item, width, wrap);let (width, height, clamped) = buffer_size(item);- (+ let size = (width,if clamped {height} else {height.max(item.forced_min_height)},- )+ );+ if item.measured.len() == 16 {+ item.measured.remove(0);+ }+ item.measured.push((key, wrap, size));+ size}/// Exact max-content size for one fallback word item. Paragraph IFCs keep@@ -3843,6 +3859,63 @@ mod tests {);}+ #[test]+ fn repeated_measurements_reuse_exact_results_and_preserve_final_paint() {+ let tree = obscura_dom::parse_html(+ "<p id='copy'>alpha <span id='inline'>beta gamma delta epsilon</span> zeta</p>",+ );+ let copy = tree.get_element_by_id("copy").unwrap();+ let inline = tree.get_element_by_id("inline").unwrap();+ let base = LayoutStyle {+ display: Display::Block,+ font_size: Some(16.0),+ text_indent: Some(Dimension::Px(7.25)),+ ..Default::default()+ };+ let child = LayoutStyle {+ display: Display::Inline,+ padding: crate::Edges {+ left: 3.5,+ right: 2.25,+ ..Default::default()+ },+ ..base.clone()+ };+ let styles = HashMap::from([(copy, base), (inline, child)]);+ let mut engine = TextEngine::new();+ let item = engine.try_build(&tree, copy, &styles).unwrap();++ for (width, wrap) in [+ (None, Wrap::WordOrGlyph),+ (Some(0.0), Wrap::WordOrGlyph),+ (Some(100.01), Wrap::None),+ (Some(100.49), Wrap::WordOrGlyph),+ (Some(100.51), Wrap::Glyph),+ ] {+ let actual = engine.measure_text_with_wrap(item, width, wrap);+ let cached_entries = engine.items[item].measured.len();+ assert_eq!(+ engine.measure_text_with_wrap(item, width, wrap),+ actual+ );+ assert_eq!(engine.items[item].measured.len(), cached_entries);++ let mut fresh = TextEngine::new();+ let fresh_item = fresh.try_build(&tree, copy, &styles).unwrap();+ assert_eq!(+ actual,+ fresh.measure_text_with_wrap(fresh_item, width, wrap)+ );+ engine.finalize(item, (0.0, 0.0), 100.49, None);+ fresh.finalize(fresh_item, (0.0, 0.0), 100.49, None);+ let mut actual_image = tiny_skia::Pixmap::new(220, 120).unwrap();+ let mut expected_image = tiny_skia::Pixmap::new(220, 120).unwrap();+ engine.paint_item(item, &mut actual_image, (0.0, 0.0));+ fresh.paint_item(fresh_item, &mut expected_image, (0.0, 0.0));+ assert_eq!(actual_image.data(), expected_image.data());+ }+ }+#[test]fn configured_font_directory_loads_nested_fonts_and_skips_symlinks() {let root = std::env::temp_dir().join(format!(diff --git a/crates/obscura-render/src/paint.rs b/crates/obscura-render/src/paint.rsindex c77b78c3..6fb93f0f 100644--- a/crates/obscura-render/src/paint.rs+++ b/crates/obscura-render/src/paint.rs@@ -2501,6 +2501,22 @@ pub fn prepare_dom_with_retained_styles_with_animation_state({return Some(previous);}+ if previous.viewport == viewport+ && previous.base_url.as_deref() == base_url+ && !previous.has_dynamic_fonts+ && dynamic_fonts.is_empty()+ && crate::dom::can_retain_layout_for_tabindex(+ tree,+ viewport,+ stylesheet_cache,+ mutations,+ )+ && (!sample_changed+ || (forward_document_sample+ && previous.advance_inactive_animation_sample_time(animation_sample.time)))+ {+ return Some(previous);+ }let sampled_animation_mutations = sample_changed.then(|| {retained_animation_restyle_mutations(