Skip to content

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.rs
index 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.rs
index 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.rs
index 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(