fix(svg): share one published scene between geometry and paint

This commit is contained in:
ldm0
2026-11-13 17:32:47 +08:00
committed by Donough Liu
parent 690cea9e44
commit 78eceb89a0
11 changed files with 389 additions and 452 deletions
+7
View File
@@ -312,6 +312,13 @@ Source lookup and hit-test candidates are derived from the frozen tree when
queried. The system has no incrementally maintained layout tree, damage graph,
retained display list, GPU compositor, or persistent window.
Inline SVG object geometry is collected before clipping and paint-tree
simplification, then frozen with its CSS viewport in that same layout pass.
Computed paint styles are supplied separately from the original SVG XML, so
they cannot change author selector matching or inflate the encoded-input
budget. Geometry queries read the published numeric results without reparsing
the SVG or mixing live child geometry with an older outer layout.
## Benchmark
The following measurements show Moli's current capability envelope. They cover
@@ -1,9 +1,80 @@
from __future__ import annotations
import base64
from typing import Any
from ..assertions import assert_equal, record_contract
from ..config import REPO_ROOT
from ..assertions import SmokeError, assert_equal, record_contract
from ..config import REPO_ROOT, is_moli_browser
from ..diagnostics import new_cdp_session
from ..png_image import decode_png
async def _check_inline_svg(page: Any, results: list[dict[str, Any]]) -> None:
session = await new_cdp_session(page.context, page)
async def capture() -> Any:
response = await session.send("Page.captureScreenshot", {"format": "png"})
return decode_png(base64.b64decode(response["data"]))
cases = [
("original_style_selector", '<style>rect[style]{transform:matrix(1,0,0,1,40,0);fill:blue!important}</style><rect width="20" height="20" fill="red"/>', [0, 0, 20, 20]),
("original_id_selector", '<style>rect[id]{transform:matrix(1,0,0,1,40,0)}</style><rect width="20" height="20" fill="red"/>', [0, 0, 20, 20]),
("empty_clip_geometry", '<defs><clipPath id="empty"/></defs><rect x="10" y="20" width="30" height="40" clip-path="url(#empty)"/>', [10, 20, 30, 40]),
("nested_visible_geometry", '<svg x="10" y="20" width="100" height="80" overflow="visible"><rect x="2" y="3" width="30" height="40"/></svg>', [12, 23, 30, 40]),
]
try:
for name, content, expected in cases:
await page.evaluate("""content => {
document.head.innerHTML='<style>html,body{margin:0;background:white}svg{display:block}</style>';
document.body.innerHTML='<svg width="300" height="150">'+content+'</svg>';
}""", content)
image = await capture()
observed = await page.evaluate("""() => {
const e=document.querySelector('body>svg>svg,rect'), r=e.getBoundingClientRect();
return {rect:[r.x,r.y,r.width,r.height], count:e.getClientRects().length};
}""")
assert_equal(observed, {"rect": expected, "count": 1}, name)
if name.startswith("original_"):
assert_equal(image.pixel(10, 10), (255, 0, 0, 255), name + " paint")
assert_equal(image.pixel(50, 10), (255, 255, 255, 255), name + " unmatched transform")
record_contract(results, "svg/" + name, observed=observed,
contract="Final computed styles and source geometry preserve original SVG XML identity.",
source="Chromium 145.0.7632.116 executable comparison (2026-11-13)", commands=["Runtime.evaluate", "Page.captureScreenshot"])
await page.evaluate("""() => {
document.body.innerHTML='<svg width="100" height="100">'+'<circle r="1"></circle>'.repeat(30000)+'</svg>';
}""")
image = await capture()
if any(channel > 2 for channel in image.pixel(0, 0)[:3]):
raise SmokeError("690 KB SVG disappeared after applying computed styles")
record_contract(results, "svg/original_source_budget", observed={"circles": 30000},
contract="Derived styles do not inflate the bounded encoded SVG input.",
source="Chromium 145.0.7632.116 executable comparison (2026-11-13)", commands=["Page.captureScreenshot"])
await page.evaluate("""() => {
document.body.innerHTML='<svg style="position:absolute;left:100px;top:0" width="200" height="100">'+
'<rect x="10" width="10" height="10"/>'.repeat(1000)+'</svg>';
}""")
await capture()
count = await page.evaluate("""() => {
const r=document.createRange();r.selectNodeContents(document.querySelector('svg'));
return r.getClientRects().length;
}""")
assert_equal(count, 1000, "SVG Range geometry batch")
observed = await page.evaluate("""() => {
document.querySelector('svg').style.left='300px';
document.querySelector('rect').setAttribute('x','30');
return [document.querySelector('svg'),document.querySelector('rect')].map(e=>e.getBoundingClientRect().x);
}""")
assert_equal(observed, [100, 110] if is_moli_browser() else [300, 330], "coherent SVG geometry publication")
await capture()
updated = await page.evaluate("document.querySelector('rect').getBoundingClientRect().x")
assert_equal(updated, 330, "SVG geometry after publication")
record_contract(results, "svg/coherent_batch_publication", observed={"count": count, "immediate": observed, "published": updated},
contract="SVG object and viewport coordinates come from one publication; Moli freezes ordinary queries, Chromium flushes live layout.",
source="Chromium executable comparison and Moli frozen-layout contract", commands=["Runtime.evaluate", "Page.captureScreenshot"])
finally:
await session.detach()
async def run_svg_rect_group(
@@ -24,5 +95,6 @@ async def run_svg_rect_group(
commands=["Runtime.evaluate"],
observed=observed,
)
await _check_inline_svg(page, results)
finally:
await context.close()
@@ -54,7 +54,6 @@ struct HtmlSerializationOptions<'a> {
// whose owner Document has different scripting state from the outer tree.
scripting_enabled_for_node: &'a dyn Fn(NativeNodeId) -> bool,
shadow_root_provider: Option<&'a dyn HtmlShadowRootProvider>,
attribute_overrides: Option<&'a dyn Fn(NativeNodeId) -> Vec<(String, String)>>,
}
impl<'a> HtmlSerializationOptions<'a> {
@@ -66,7 +65,6 @@ impl<'a> HtmlSerializationOptions<'a> {
target,
scripting_enabled_for_node,
shadow_root_provider: None,
attribute_overrides: None,
}
}
@@ -267,9 +265,6 @@ fn serialize_html_node_frame<'a, S>(
out.push('>');
}
NodeData::Element(element) => {
let overrides = options
.attribute_overrides
.map(|attributes| attributes(node_id));
out.push('<');
out.push_str(element.local_name());
if let Some(is_name) = element.custom_element_is_name()
@@ -283,31 +278,12 @@ fn serialize_html_node_frame<'a, S>(
if out.limit_exceeded() {
return;
}
if overrides.as_ref().is_some_and(|attributes| {
attributes
.iter()
.any(|(name, _)| attribute.name_matches(name))
}) {
continue;
}
out.push(' ');
attribute.push_html_serialized_name(|part| out.push_str(part));
out.push_str("=\"");
escape_html_attribute(attribute.value(), out);
out.push('"');
}
if let Some(overrides) = overrides {
for (name, value) in overrides {
if out.limit_exceeded() {
return;
}
out.push(' ');
out.push_str(&name);
out.push_str("=\"");
escape_html_attribute(&value, out);
out.push('"');
}
}
out.push('>');
if !is_void_html_element(element.namespace(), element.local_name()) {
@@ -506,24 +482,18 @@ pub(super) fn serialize_html_with_limit(
dom: &NativeDom,
node_id: NativeNodeId,
max_bytes: usize,
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
serialize_html_with_limit_and_attributes(dom, node_id, max_bytes, None)
}
pub(super) fn serialize_html_with_limit_and_attributes(
dom: &NativeDom,
node_id: NativeNodeId,
max_bytes: usize,
attributes: Option<&dyn Fn(NativeNodeId) -> Vec<(String, String)>>,
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
let scripting_enabled_for_node = |_: NativeNodeId| true;
let mut out = BoundedHtmlSerialization::new(max_bytes);
let mut options = HtmlSerializationOptions::new(
HtmlSerializationTarget::IncludeNode,
&scripting_enabled_for_node,
);
options.attribute_overrides = attributes;
if !serialize_html_into_sink(dom, node_id, options, &mut out) {
if !serialize_html_into_sink(
dom,
node_id,
HtmlSerializationOptions::new(
HtmlSerializationTarget::IncludeNode,
&scripting_enabled_for_node,
),
&mut out,
) {
return Ok(None);
}
out.finish().map(Some)
+1 -13
View File
@@ -8,7 +8,7 @@ pub(super) use engine::{
HtmlSerializationTarget, HtmlSerializedShadowRoot, escape_html_attribute_into_string,
serialize_html_with_shadow_root_provider,
};
use engine::{serialize_html, serialize_html_with_limit, serialize_html_with_limit_and_attributes};
use engine::{serialize_html, serialize_html_with_limit};
/// A bounded serialization stopped before appending bytes past its limit.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -73,18 +73,6 @@ impl NativeDom {
serialize_html_with_limit(self, node_id, max_bytes)
}
/// Bounded serialization for derived consumers that need resolved attributes
/// without mutating or cloning the live DOM. Replacement names must be valid
/// qualified attribute names; values are escaped by the serializer.
pub fn outer_html_with_limit_and_attributes(
&self,
node_id: NativeNodeId,
max_bytes: usize,
attributes: &dyn Fn(NativeNodeId) -> Vec<(String, String)>,
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
serialize_html_with_limit_and_attributes(self, node_id, max_bytes, Some(attributes))
}
pub fn inner_html(&self, node_id: NativeNodeId) -> Option<String> {
self.inner_html_with_scripting_enabled(node_id, true)
}
@@ -9,44 +9,6 @@ fn scripting_enabled(_: NativeNodeId) -> bool {
true
}
#[test]
fn bounded_attribute_projection_preserves_live_dom_and_escapes_values() {
let mut dom = NativeDom::new_html(test_url());
let root = dom.create_element("div");
let child = dom.create_element("span");
dom.set_attribute(root, "style", "color:red");
dom.append_child(root, child);
let original = dom.outer_html(root).unwrap();
let attributes = |node| {
if node == root {
vec![("style".into(), "font-family:\"A&B\"".into())]
} else {
vec![("id".into(), "derived".into())]
}
};
let projected = dom
.outer_html_with_limit_and_attributes(root, 512, &attributes)
.unwrap()
.unwrap();
assert_eq!(
projected,
"<div style=\"font-family:&quot;A&amp;B&quot;\"><span id=\"derived\"></span></div>"
);
assert_eq!(dom.outer_html(root).unwrap(), original);
assert_eq!(
dom.outer_html_with_limit_and_attributes(root, projected.len(), &attributes)
.unwrap()
.unwrap(),
projected
);
assert_eq!(
dom.outer_html_with_limit_and_attributes(root, projected.len() - 1, &attributes),
Err(HtmlSerializationLimitExceeded {
max_bytes: projected.len() - 1
})
);
}
#[test]
fn template_contents_require_the_exact_html_element_identity() {
for (namespace, name, is_template) in [
+147 -165
View File
@@ -1,15 +1,19 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
//
// This is a narrow port of Blitz's inline-SVG replaced-element bridge. The
// live SVG subtree remains owned by NativeDom; a fresh paint pass serializes
// it into one bounded, immutable `usvg::Tree`. No SVG child layout tree or
// cross-pass resource cache is retained here.
// live SVG subtree remains owned by NativeDom; a layout pass serializes its
// original XML into one bounded, immutable `usvg::Tree`. Only numeric source
// geometry survives with the outer frozen layout; paint retains the image.
//
// The isolated tree also needs document CSS: sample the computed SVG paint
// and text inputs while serializing, without changing the live DOM. Geometry
// queries use the same decoder and font shaping as paint.
// and text inputs separately, after matching selectors on original attributes.
// Geometry and paint share one decode and the same font shaping.
use std::{cell::RefCell, collections::HashSet, sync::Arc};
use std::{
cell::RefCell,
collections::{HashMap, HashSet},
sync::Arc,
};
use moli_layout::{LayoutImageResource, PaintColor, ReplacedMetrics, ResolvedLayoutStyle};
use style::color::ColorSpace;
@@ -40,48 +44,44 @@ pub(super) fn replaced_metrics(element: &Element) -> ReplacedMetrics {
}
}
pub(super) fn replaced_resource(
runtime: &PageScriptHost,
node: DomHandle,
style: &ResolvedLayoutStyle,
reads: &RefCell<StyleObservation<'_>>,
) -> Option<LayoutImageResource> {
let svg = Arc::new(parse_live_svg(runtime, node, style, reads, None)?);
// Inline SVG box sizing comes from Stylo's width/height presentation
// hints. The vector object's own dimensions must use the same resolved
// root font context, so use the parsed tree size rather than the
// context-free metadata probe (which deliberately cannot resolve `em`).
let tree_size = svg.tree().size();
Some(LayoutImageResource {
intrinsic_width: tree_size.width(),
intrinsic_height: tree_size.height(),
pixels: None,
svg: Some(svg),
})
#[cfg(test)]
thread_local! { static PARSE_COUNT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; }
#[cfg(test)]
pub(crate) fn parse_count() -> usize {
PARSE_COUNT.with(std::cell::Cell::get)
}
pub(super) struct GeometryTarget<'a> {
pub node: DomHandle,
pub id: &'a str,
pub viewport: moli_layout::LayoutSize,
}
pub(super) fn parse_live_svg(
pub(super) fn layout_content(
runtime: &PageScriptHost,
root: DomHandle,
root_style: &ResolvedLayoutStyle,
viewport: moli_layout::LayoutSize,
reads: &RefCell<StyleObservation<'_>>,
geometry: Option<GeometryTarget<'_>>,
) -> Option<moli_image::SvgImage> {
paint: bool,
) -> Option<moli_layout::LayoutSvgContent<DomHandle>> {
if viewport.width <= 0.0 || viewport.height <= 0.0 {
return None;
}
let host = runtime.dom_host();
// Admit the original XML, before adding any embedding information.
let source = host
.dom()
.outer_html_with_limit(
root,
moli_image::MAX_ENCODED_SVG_BYTES
.saturating_sub(SERIALIZED_SOURCE_FIXED_INJECTION_RESERVE),
)
.ok()
.flatten()?;
let source = prepare_source(source)?;
let mut elements = Vec::new();
let mut pending = vec![(root, None)];
let mut referenced_ids = HashSet::new();
let mut pending = vec![root];
while let Some(node) = pending.pop() {
if let Some(element) = host.node(node).and_then(|node| node.as_element())
&& element.is_svg_element("use")
&& let Some(id) = element
.attribute("href")
.or_else(|| {
while let Some((node, parent)) = pending.pop() {
let parent = if let Some(element) = host.node(node).and_then(|node| node.as_element()) {
if element.is_svg_element("use") {
let href = element.attribute("href").or_else(|| {
element
.attributes()
.iter()
@@ -90,63 +90,60 @@ pub(super) fn parse_live_svg(
&& attribute.local_name() == "href"
})
.map(|attribute| attribute.value())
})
.and_then(|href| href.strip_prefix('#'))
{
referenced_ids.insert(id);
}
pending.extend(host.dom().child_ids(node));
}
let attributes = |node| {
let mut attributes = Vec::new();
let Some(element) = host.node(node).and_then(|node| node.as_element()) else {
return attributes;
});
if let Some(id) = href.and_then(|href| href.strip_prefix('#')) {
referenced_ids.insert(id);
}
}
let index = elements.len();
elements.push((node, parent));
Some(index)
} else {
parent
};
if element.namespace() != "http://www.w3.org/2000/svg" {
return attributes;
}
if let Some(geometry) = geometry.as_ref()
&& node == geometry.node
&& element.attribute("id").is_none_or(str::is_empty)
{
attributes.push(("id".into(), geometry.id.into()));
}
// A referenced definition inherits at its <use> instance, not at its
// original DOM position. This also applies to references outside
// <defs>. Preserve their authored inheritance instead of freezing it.
let mut parent = Some(node);
while let Some(ancestor) = parent {
if host
.node(ancestor)
.and_then(|node| node.as_element())
.is_some_and(|element| {
element.is_svg_element("defs")
|| (ancestor != root
&& element
.attribute("id")
.is_some_and(|id| referenced_ids.contains(id)))
})
{
return attributes;
}
if ancestor == root {
break;
}
parent = host.dom().parent_node(ancestor);
pending.extend(
host.dom()
.child_ids(node)
.collect::<Vec<_>>()
.into_iter()
.rev()
.map(|node| (node, parent)),
);
}
let mut profiles = HashMap::<String, moli_image::SvgElementStyle>::new();
let mut styles = Vec::with_capacity(elements.len());
let mut referenced_scope = vec![false; elements.len()];
for (index, (node, parent)) in elements.iter().copied().enumerate() {
let element = host
.node(node)
.and_then(|node| node.as_element())
.expect("serialized SVG element");
referenced_scope[index] = index != 0
&& (parent.is_some_and(|parent| referenced_scope[parent])
|| element.is_svg_element("defs")
|| element
.attribute("id")
.is_some_and(|id| referenced_ids.contains(id)));
if referenced_scope[index] || element.namespace() != "http://www.w3.org/2000/svg" {
styles.push(None);
continue;
}
let mut declarations = if node == root {
let mut declarations = computed_root_declarations(root_style);
// The CSS replaced-element box applies the outer SVG transform.
// Reapplying it inside the vector resource would transform both
// paint and client geometry twice. Descendant SVG transforms stay.
let mut declarations = computed_svg_declarations(root_style);
// The outer CSS box already owns its transform and opacity.
append_serialized_declaration(&mut declarations, "transform", "none");
append_serialized_declaration(&mut declarations, "opacity", "1");
for (name, value) in [("width", viewport.width), ("height", viewport.height)] {
append_serialized_declaration(&mut declarations, name, &format!("{value}px"));
}
declarations
} else {
let Some(computed) = reads.borrow_mut().read(node).computed_values() else {
return attributes;
styles.push(None);
continue;
};
let style = ResolvedLayoutStyle::from_stylo(computed);
let mut declarations = computed_root_declarations(&style);
let mut declarations = computed_svg_declarations(&style);
let computed = style.stylo_computed_values().expect("resolved SVG style");
for (name, value) in [
("display", computed.clone_display().to_css_string()),
@@ -158,87 +155,72 @@ pub(super) fn parse_live_svg(
}
declarations
};
if let Some(geometry) = geometry.as_ref()
&& node == root
{
for (name, value) in [
("width", geometry.viewport.width),
("height", geometry.viewport.height),
] {
attributes.push((name.into(), value.to_string()));
append_serialized_declaration(&mut declarations, name, &format!("{value}px"));
}
if let Some(profile) = profiles.get(&declarations) {
styles.push(Some(profile.clone()));
} else {
let properties =
moli_css_parse::parse_declaration_list(&declarations, Default::default())
.into_iter()
.map(|property| {
moli_image::SvgStyleProperty::new(property.name, &property.value)
})
.collect::<Vec<_>>();
let profile: moli_image::SvgElementStyle = Arc::from(properties);
profiles.insert(std::mem::take(&mut declarations), profile.clone());
styles.push(Some(profile));
}
let declarations = merge_computed_declarations(
element.attribute("style").unwrap_or_default(),
&declarations,
);
attributes.push(("style".into(), declarations));
attributes
};
let source_limit =
moli_image::MAX_ENCODED_SVG_BYTES.saturating_sub(SERIALIZED_SOURCE_FIXED_INJECTION_RESERVE);
let source =
match host
.dom()
.outer_html_with_limit_and_attributes(root, source_limit, &attributes)
{
Ok(Some(source)) => source,
Ok(None) => return None,
Err(error) => {
tracing::debug!(
node = root.index(),
error = ?error,
"fresh inline SVG serialization exceeded its input budget"
);
return None;
}
};
let Some(source) = prepare_source(source) else {
tracing::debug!(
node = root.index(),
"inline SVG serialization did not produce an SVG root"
);
return None;
};
match moli_image::decode_svg_image(source.as_bytes()) {
Ok(svg) => Some(svg),
}
#[cfg(test)]
PARSE_COUNT.with(|count| count.set(count.get() + 1));
let scene = match moli_image::decode_inline_svg_scene(
source.as_bytes(),
&styles,
(viewport.width, viewport.height),
) {
Ok(scene) => scene,
Err(error) => {
tracing::debug!(
node = root.index(),
error = ?error,
"fresh inline SVG resource parse failed"
?error,
"inline SVG scene decode failed"
);
None
return None;
}
}
}
fn merge_computed_declarations(authored: &str, computed: &str) -> String {
// usvg's simplecss parser stops at an empty declaration and gives the
// first !important declaration precedence. Normalize authored CSS and
// remove the properties whose final values have already been sampled.
let options = moli_css_parse::DeclarationParseOptions::default();
let computed = moli_css_parse::parse_declaration_list(computed, options);
let mut declarations = String::new();
for property in moli_css_parse::parse_declaration_list(authored, options) {
if !computed
.iter()
.any(|projected| projected.name.eq_ignore_ascii_case(&property.name))
{
declarations.push_str(&property.name);
declarations.push(':');
declarations.push_str(&property.value);
if property.important {
declarations.push_str(" !important");
};
let objects = scene
.objects
.into_iter()
.filter_map(|geometry| {
if geometry.element_index == 0 {
return None;
}
declarations.push(';');
let (source, _) = *elements.get(geometry.element_index)?;
let [x, y, width, height] = geometry.bounds;
let [a, b, c, d, e, f] = geometry.transform;
let map = |x, y| moli_layout::LayoutPoint::new(a * x + c * y + e, b * x + d * y + f);
Some((
source,
moli_layout::LayoutQuad {
points: [
map(x, y),
map(x + width, y),
map(x + width, y + height),
map(x, y + height),
],
},
))
})
.collect();
let image = paint.then(|| {
let size = scene.image.tree().size();
LayoutImageResource {
intrinsic_width: size.width(),
intrinsic_height: size.height(),
pixels: None,
svg: Some(Arc::new(scene.image)),
}
}
for property in computed {
append_serialized_declaration(&mut declarations, &property.name, &property.value);
}
declarations
});
Some(moli_layout::LayoutSvgContent { image, objects })
}
fn prepare_source(mut source: String) -> Option<String> {
@@ -267,7 +249,7 @@ fn prepare_source(mut source: String) -> Option<String> {
Some(source)
}
fn computed_root_declarations(style: &ResolvedLayoutStyle) -> String {
fn computed_svg_declarations(style: &ResolvedLayoutStyle) -> String {
let mut declarations = inherited_context_declarations(style.current_color(), style.font_size());
let Some(computed) = style.stylo_computed_values() else {
return declarations;
@@ -276,8 +258,8 @@ fn computed_root_declarations(style: &ResolvedLayoutStyle) -> String {
// Blink paints every SVG LayoutObject from its ComputedStyle. Moli's
// bounded usvg bridge instead serializes the live subtree, so document
// stylesheets are no longer present when usvg reparses it. Snapshot the
// root's inherited SVG paint group into that isolated document. Child
// declarations still override inherited values normally.
// element's computed paint group into the isolated scene as final values,
// without changing the XML that author selectors match.
let current_color = computed.clone_color();
append_svg_paint(
&mut declarations,
@@ -342,7 +324,7 @@ fn computed_root_declarations(style: &ResolvedLayoutStyle) -> String {
append_serialized_declaration(
&mut declarations,
"font-family",
// Attribute projection escapes quoted family names at serialization.
// Kept out of XML attributes, including quoted family names.
&computed.clone_font_family().to_css_string(),
);
append_serialized_declaration(
+9 -11
View File
@@ -1,7 +1,8 @@
mod inline_svg;
#[cfg(test)]
pub(crate) use inline_svg::parse_count as svg_parse_count;
mod source_view;
mod style_resolver;
mod svg_geometry;
use std::collections::HashMap;
@@ -12,8 +13,6 @@ use moli_layout::{
use crate::{document_runtime::DomHandle, native_bridge::PageScriptHost};
pub(crate) use svg_geometry::svg_client_rect;
pub(crate) fn build_native_layout_pass(
runtime: &PageScriptHost,
root: DomHandle,
@@ -55,14 +54,13 @@ fn build_native_layout_pass_recursive(
let source = source_view::NativeLayoutSourceView::with_paint_resources(
runtime,
root,
request.requests_paint().then(|| {
style_resolver::layout_style_read_scope(
runtime,
document,
request.viewport,
environment_override,
)
}),
style_resolver::layout_style_read_scope(
runtime,
document,
request.viewport,
environment_override,
),
request.requests_paint(),
);
let source_ready = profile_started.map(|_| std::time::Instant::now());
let mut styles = style_resolver::NativeLayoutStyleResolver::new(
@@ -23,26 +23,29 @@ pub(super) struct NativeLayoutSourceView<'a> {
runtime: &'a PageScriptHost,
root: DomHandle,
document: Option<DomHandle>,
paint_styles: Option<RefCell<StyleObservation<'a>>>,
styles: RefCell<StyleObservation<'a>>,
paint_resources: bool,
text_selections: HashMap<DomHandle, LayoutTextSelection>,
}
impl<'a> NativeLayoutSourceView<'a> {
#[cfg(test)]
pub(super) fn new(runtime: &'a PageScriptHost, root: DomHandle) -> Self {
Self::with_paint_resources(runtime, root, None)
Self::with_paint_resources(runtime, root, StyleObservation::new(runtime), false)
}
pub(super) fn with_paint_resources(
runtime: &'a PageScriptHost,
root: DomHandle,
paint_styles: Option<StyleObservation<'a>>,
styles: StyleObservation<'a>,
paint_resources: bool,
) -> Self {
Self {
runtime,
root,
document: runtime.dom_host().owner_document_handle(root),
paint_styles: paint_styles.map(RefCell::new),
styles: RefCell::new(styles),
paint_resources,
text_selections: document_text_selections(runtime, root),
}
}
@@ -239,9 +242,11 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
fn replaced_image(
&self,
node: Self::NodeId,
style: &moli_layout::ResolvedLayoutStyle,
_style: &moli_layout::ResolvedLayoutStyle,
) -> Option<LayoutImageResource> {
let paint_styles = self.paint_styles.as_ref()?;
if !self.paint_resources {
return None;
}
let semantics = self
.host()
.node(node)
@@ -257,9 +262,6 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
svg: ready.svg,
})
}
Some(LayoutReplacedKind::Svg) => {
super::inline_svg::replaced_resource(self.runtime, node, style, paint_styles)
}
Some(LayoutReplacedKind::Canvas) => {
let pixels = self.runtime.canvas_pixels_for_layout(node)?;
Some(LayoutImageResource {
@@ -274,7 +276,9 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
}
fn css_image_resource(&self, resolved_url: &str) -> Option<LayoutImageResource> {
self.paint_styles.as_ref()?;
if !self.paint_resources {
return None;
}
let parsed = url::Url::parse(resolved_url).ok()?;
// Blink shares the fetched bytes using a fragment-free cache key, but
// then applies SVG view/element-fragment semantics separately. Until
@@ -293,6 +297,22 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
svg: ready.svg,
})
}
fn svg_content(
&self,
node: DomHandle,
style: &moli_layout::ResolvedLayoutStyle,
viewport: moli_layout::LayoutSize,
) -> Option<moli_layout::LayoutSvgContent<DomHandle>> {
super::inline_svg::layout_content(
self.runtime,
node,
style,
viewport,
&self.styles,
self.paint_resources,
)
}
}
fn document_text_selections(
@@ -1,158 +0,0 @@
use std::cell::RefCell;
use moli_layout::{
LayoutError, LayoutPoint, LayoutQuad, LayoutQuery, LayoutQueryAnswer, ResolvedLayoutStyle,
};
use crate::{
document_runtime::DomHandle,
native_bridge::{PageScriptHost, element::StyleObservation},
};
use super::inline_svg::{GeometryTarget, parse_live_svg};
/// SVG graphics have object geometry rather than CSS layout boxes. CSSOM View
/// requires a single transformed object rectangle for these elements.
pub(crate) fn svg_client_rect(
runtime: &PageScriptHost,
document: DomHandle,
source: DomHandle,
) -> Result<Option<Vec<LayoutQuad>>, LayoutError> {
let host = runtime.dom_host();
let Some(element) = host.node(source).and_then(|node| node.as_element()) else {
return Ok(None);
};
if element.namespace() != "http://www.w3.org/2000/svg" {
return Ok(None);
}
let mut root = source;
let mut ancestor = host.dom().parent_node(source);
while let Some(parent) = ancestor {
let Some(parent_element) = host.node(parent).and_then(|node| node.as_element()) else {
break;
};
if parent_element.namespace() != "http://www.w3.org/2000/svg" {
break;
}
root = parent;
ancestor = host.dom().parent_node(parent);
}
if root == source
|| host
.node(root)
.is_none_or(|node| node.local_name() != Some("svg"))
{
// The outer SVG has a CSS replaced-element box, just like <img>.
return Ok(None);
}
let mut reads = StyleObservation::new(runtime);
let mut ancestor = Some(source);
while let Some(node) = ancestor {
if host
.node(node)
.and_then(|node| node.as_element())
.is_some_and(|element| {
element.namespace() == "http://www.w3.org/2000/svg"
&& matches!(
element.local_name(),
"defs" | "symbol" | "marker" | "pattern" | "clipPath" | "mask"
)
})
{
return Ok(Some(Vec::new()));
}
if let Some(computed) = reads.read(node).computed_values()
&& computed.clone_display().is_none()
{
return Ok(Some(Vec::new()));
}
ancestor = host.dom().parent_node(node);
if ancestor == Some(document) {
break;
}
}
let Some(computed) = reads.read(root).computed_values() else {
return Ok(Some(Vec::new()));
};
let style = ResolvedLayoutStyle::from_stylo(computed);
let model = match runtime
.answer_layout_query_for_document(document, &LayoutQuery::BoxModel { source: root })?
{
LayoutQueryAnswer::BoxModel(model) => model,
_ => unreachable!("SVG viewport box model query"),
};
let metrics = match runtime
.answer_layout_query_for_document(document, &LayoutQuery::ElementMetrics { source: root })?
{
LayoutQueryAnswer::ElementMetrics(metrics) => metrics,
_ => unreachable!("SVG viewport metrics query"),
};
// A newly inserted SVG may not yet have a box in the published layout.
// Its local geometry can still be measured, using its SVG viewport; once
// layout publishes the outer box, include that box's placement/transforms.
let metadata = super::inline_svg::replaced_metrics(
host.node(root)
.and_then(|node| node.as_element())
.expect("SVG root"),
);
let viewport = metrics
.as_ref()
.map(|metrics| metrics.content_size)
.unwrap_or_else(|| {
moli_layout::LayoutSize::new(
metadata.intrinsic_width.unwrap_or(300.0),
metadata.intrinsic_height.unwrap_or(150.0),
)
});
if viewport.width <= 0.0 || viewport.height <= 0.0 {
return Ok(Some(Vec::new()));
}
let marker = format!("__moli_svg_geometry_{}", source.index());
let id = element
.attribute("id")
.filter(|id| !id.is_empty())
.unwrap_or(&marker);
let Some(svg) = parse_live_svg(
runtime,
root,
&style,
&RefCell::new(reads),
Some(GeometryTarget {
node: source,
id,
viewport,
}),
) else {
return Ok(Some(Vec::new()));
};
let Some(node) = svg.tree().node_by_id(id) else {
return Ok(Some(Vec::new()));
};
let bounds = node.bounding_box();
let transform = node.abs_transform();
let map = |x, y| {
let x2 = transform.sx * x + transform.kx * y + transform.tx;
let y2 = transform.ky * x + transform.sy * y + transform.ty;
if let Some(model) = model.as_ref() {
let [origin, right, _, bottom] = model.content.points;
LayoutPoint::new(
origin.x
+ (right.x - origin.x) * x2 / viewport.width
+ (bottom.x - origin.x) * y2 / viewport.height,
origin.y
+ (right.y - origin.y) * x2 / viewport.width
+ (bottom.y - origin.y) * y2 / viewport.height,
)
} else {
LayoutPoint::new(x2, y2)
}
};
Ok(Some(vec![LayoutQuad {
points: [
map(bounds.left(), bounds.top()),
map(bounds.right(), bounds.top()),
map(bounds.right(), bounds.bottom()),
map(bounds.left(), bounds.bottom()),
],
}]))
}
@@ -44,12 +44,6 @@ fn published_geometry_query(
query: &LayoutQuery<DomHandle>,
) -> Result<LayoutQueryAnswer<DomHandle>, LayoutError> {
if runtime.layout_policy().uses_real_layout() {
if let LayoutQuery::ClientRects { source } = query
&& let Some(rects) =
crate::layout_renderer::svg_client_rect(runtime, document, *source)?
{
return Ok(LayoutQueryAnswer::ClientRects(rects));
}
runtime.answer_layout_query_for_document(document, query)
} else {
Ok(answer_mock_query(runtime, document, query))
@@ -72,16 +66,7 @@ pub(crate) fn published_geometry_batch(
batch: &LayoutQueryBatch<DomHandle>,
) -> Result<LayoutAnswers<DomHandle>, LayoutError> {
if runtime.layout_policy().uses_real_layout() {
let mut answers = runtime.answer_layout_for_document(document, batch)?;
for (query, answer) in batch.queries.iter().zip(&mut answers.answers) {
if let LayoutQuery::ClientRects { source } = query
&& let Some(rects) =
crate::layout_renderer::svg_client_rect(runtime, document, *source)?
{
*answer = LayoutQueryAnswer::ClientRects(rects);
}
}
Ok(answers)
runtime.answer_layout_for_document(document, batch)
} else {
Ok(answer_mock_queries(
runtime,
@@ -1,5 +1,116 @@
use super::*;
#[tokio::test(flavor = "current_thread")]
async fn inline_svg_final_styles_do_not_become_author_selector_attributes() {
run_page_vm_async_test(async move {
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
let mut page_vm = test_page_vm_with_loader_and_document_url(
&loader, Vec::new(), Url::parse("https://example.com/svg-original-attributes.html")?,
);
page_vm.vm_mut().eval(r##"
document.head.innerHTML = '<style>html,body{margin:0;background:white}svg{display:block}</style>';
document.body.innerHTML = `<svg width="100" height="50">
<style>rect[style]{transform:matrix(1,0,0,1,40,0);fill:blue!important}rect[id]{transform:matrix(1,0,0,1,60,0)}</style>
<rect width="20" height="20" fill="red"/>
</svg>`;
'installed'
"##)?;
page_vm.vm_mut().sync_live_document_style_sources();
let snapshot = page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(100, 50, 1.0))?.unwrap();
assert_eq!(page_vm.vm_mut().eval("JSON.stringify((r=>[r.x,r.y,r.width,r.height])(document.querySelector('rect').getBoundingClientRect()))")?, "[0,0,20,20]");
assert_eq!(page_vm.vm_mut().eval("document.querySelector('rect').getAttributeNames().join(',')")?, "width,height,fill");
let raster = moli_paint::raster_snapshot(&snapshot)?;
let pixel = |x: usize| &raster.rgba[(10 * raster.width as usize + x) * 4..][..4];
assert_eq!(pixel(10), [255, 0, 0, 255]);
assert_eq!(pixel(50), [255, 255, 255, 255]);
assert_eq!(pixel(70), [255, 255, 255, 255]);
Ok::<_, anyhow::Error>(())
}).await.expect("final SVG styles must not change selector matching");
}
#[tokio::test(flavor = "current_thread")]
async fn inline_svg_dense_source_keeps_its_original_input_budget() {
run_page_vm_async_test(async move {
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
let mut page_vm = test_page_vm_with_loader_and_document_url(
&loader, Vec::new(), Url::parse("https://example.com/svg-dense.html")?,
);
page_vm.vm_mut().eval(r#"
document.head.innerHTML = '<style>html,body{margin:0;background:white}svg{display:block}</style>';
document.body.innerHTML = '<svg width="100" height="100">' + '<circle r="1"></circle>'.repeat(30000) + '</svg>';
'installed'
"#)?;
page_vm.vm_mut().sync_live_document_style_sources();
let snapshot = page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(100, 100, 1.0))?.unwrap();
assert_eq!(snapshot.svg_images.len(), 1, "690 KB of original XML must remain a vector image");
let raster = moli_paint::raster_snapshot(&snapshot)?;
// The sampled quarter-circle edge is antialiased; repeated source-over
// composition can round to 1 rather than exactly 0.
assert!(raster.rgba[..3].iter().all(|channel| *channel <= 2));
assert_eq!(raster.rgba[3], 255);
Ok::<_, anyhow::Error>(())
}).await.expect("derived styles must not consume the encoded SVG input budget");
}
#[tokio::test(flavor = "current_thread")]
async fn inline_svg_batch_geometry_uses_one_frozen_scene() {
run_page_vm_async_test(async move {
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
let mut page_vm = test_page_vm_with_loader_and_document_url(
&loader, Vec::new(), Url::parse("https://example.com/svg-frozen-geometry.html")?,
);
page_vm.vm_mut().eval(r#"
document.head.innerHTML = '<style>html,body{margin:0}svg{position:absolute;left:100px;top:0}</style>';
document.body.innerHTML = '<svg width="200" height="100">' + '<rect x="10" width="10" height="10"/>'.repeat(1000) + '</svg>';
'installed'
"#)?;
page_vm.vm_mut().sync_live_document_style_sources();
let before = crate::layout_renderer::svg_parse_count();
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(500, 150, 1.0))?;
assert_eq!(crate::layout_renderer::svg_parse_count() - before, 1);
let frozen = crate::layout_renderer::svg_parse_count();
assert_eq!(page_vm.vm_mut().eval("(()=>{const r=document.createRange();r.selectNodeContents(document.querySelector('svg'));return r.getClientRects().length})()")?, "1000");
assert_eq!(crate::layout_renderer::svg_parse_count(), frozen, "a batch must only read the published numeric geometry");
assert_eq!(page_vm.vm_mut().eval(r#"(()=>{
document.querySelector('svg').style.left='300px';
document.querySelector('rect').setAttribute('x','30');
return JSON.stringify([document.querySelector('svg').getBoundingClientRect().x,document.querySelector('rect').getBoundingClientRect().x]);
})()"#)?, "[100,110]", "both coordinate levels must stay in the same frozen publication");
assert_eq!(crate::layout_renderer::svg_parse_count(), frozen);
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(500, 150, 1.0))?;
assert_eq!(page_vm.vm_mut().eval("document.querySelector('rect').getBoundingClientRect().x")?, "330");
assert_eq!(crate::layout_renderer::svg_parse_count() - frozen, 1);
Ok::<_, anyhow::Error>(())
}).await.expect("SVG geometry must share its outer layout's publication");
}
#[tokio::test(flavor = "current_thread")]
async fn inline_svg_geometry_keeps_clipped_and_flattened_source_elements() {
run_page_vm_async_test(async move {
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
let mut page_vm = test_page_vm_with_loader_and_document_url(
&loader, Vec::new(), Url::parse("https://example.com/svg-source-geometry.html")?,
);
page_vm.vm_mut().eval(r##"
document.head.innerHTML = '<style>html,body{margin:0}svg{display:block}</style>';
document.body.innerHTML = `<svg width="300" height="150">
<defs><clipPath id="empty"/></defs>
<g id="group"><rect id="clipped" x="10" y="20" width="30" height="40" clip-path="url(#empty)"/></g>
<svg id="nested" x="10" y="20" width="100" height="80" overflow="visible">
<rect id="same" x="2" y="3" width="30" height="40"/>
<rect id="same" x="40" y="3" width="10" height="40"/>
</svg>
</svg>`;
'installed'
"##)?;
page_vm.vm_mut().sync_live_document_style_sources();
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(300, 150, 1.0))?;
assert_eq!(page_vm.vm_mut().eval(r#"JSON.stringify(['#clipped','#group','#nested'].flatMap(s=>[...document.querySelectorAll(s)]).concat([...document.querySelectorAll('#same')]).map(e=>{const r=e.getBoundingClientRect();return [r.x,r.y,r.width,r.height]}))"#)?,
"[[10,20,30,40],[10,20,30,40],[12,23,48,40],[12,23,30,40],[50,23,10,40]]");
Ok::<_, anyhow::Error>(())
}).await.expect("object geometry must not depend on retained paint nodes or unique author IDs");
}
#[tokio::test(flavor = "current_thread")]
async fn inline_svg_client_rects_include_graphics_text_and_viewport_transforms() {
run_page_vm_async_test(async move {