diff --git a/moli-dom/src/native/html_serialization/attributes.rs b/moli-dom/src/native/html_serialization/attributes.rs
new file mode 100644
index 00000000000..ac4587e6f0d
--- /dev/null
+++ b/moli-dom/src/native/html_serialization/attributes.rs
@@ -0,0 +1,78 @@
+use super::{Attribute, HtmlSerializationPolicy, NativeNodeId};
+
+pub(super) enum EmbeddedAttribute {
+ Srcdoc,
+ FrameUrl,
+}
+
+impl EmbeddedAttribute {
+ pub(super) fn for_attribute(attribute: &Attribute) -> Option {
+ if !attribute.namespace().is_empty() {
+ return None;
+ }
+ match attribute.local_name() {
+ "srcdoc" => Some(Self::Srcdoc),
+ "data-moli-frame-url" => Some(Self::FrameUrl),
+ _ => None,
+ }
+ }
+}
+
+/// A borrowed view; only the index must survive an embedded Document traversal.
+pub(super) struct EffectiveAttributes<'a> {
+ owner: NativeNodeId,
+ original: &'a [Attribute],
+ overrides: &'a [Attribute],
+ filter: Option<&'a dyn HtmlSerializationPolicy>,
+}
+
+impl<'a> EffectiveAttributes<'a> {
+ pub(super) fn new(
+ owner: NativeNodeId,
+ original: &'a [Attribute],
+ overrides: &'a [Attribute],
+ filter: Option<&'a dyn HtmlSerializationPolicy>,
+ ) -> Self {
+ Self {
+ owner,
+ original,
+ overrides,
+ filter,
+ }
+ }
+
+ #[inline]
+ pub(super) fn next(&self, index: &mut usize, embedded: bool) -> Option<&'a Attribute> {
+ loop {
+ let position = *index;
+ let attribute = if let Some(original) = self.original.get(position) {
+ *index += 1;
+ self.overrides
+ .iter()
+ .find(|a| same_key(a, original))
+ .unwrap_or(original)
+ } else {
+ let added = self.overrides.get(position - self.original.len())?;
+ *index += 1;
+ if self.original.iter().any(|a| same_key(a, added)) {
+ continue;
+ }
+ added
+ };
+ // Live frame output always replaces these values, even when a
+ // source-attribute filter would exclude them. Ordinary attributes
+ // are filtered after overrides in both traversal paths.
+ if embedded && EmbeddedAttribute::for_attribute(attribute).is_some()
+ || self
+ .filter
+ .is_none_or(|p| p.include_attribute(self.owner, attribute))
+ {
+ return Some(attribute);
+ }
+ }
+ }
+}
+
+fn same_key(a: &Attribute, b: &Attribute) -> bool {
+ a.namespace() == b.namespace() && a.local_name() == b.local_name()
+}
diff --git a/moli-dom/src/native/html_serialization/embedded_tests.rs b/moli-dom/src/native/html_serialization/embedded_tests.rs
index 31731df6451..f5cea2c9452 100644
--- a/moli-dom/src/native/html_serialization/embedded_tests.rs
+++ b/moli-dom/src/native/html_serialization/embedded_tests.rs
@@ -361,3 +361,105 @@ fn namespaced_frame_attributes_do_not_replace_the_null_namespace_export_values()
);
}
}
+
+#[test]
+fn effective_attribute_order_and_filtering_match_with_and_without_embedded_documents() {
+ struct Policy {
+ owner: NativeNodeId,
+ overrides: Vec,
+ filtering: bool,
+ }
+ impl HtmlSerializationPolicy for Policy {
+ fn has_filters(&self) -> bool {
+ self.filtering
+ }
+ fn attribute_overrides(&self, node: NativeNodeId) -> &[Attribute] {
+ if node == self.owner {
+ &self.overrides
+ } else {
+ &[]
+ }
+ }
+ fn include_attribute(&self, _: NativeNodeId, attribute: &Attribute) -> bool {
+ assert!(self.filtering, "inactive filters must not be called");
+ attribute.value() != "drop"
+ }
+ }
+ for existing_srcdoc in [false, true] {
+ let mut host = host();
+ let root = host.document_handle();
+ let owner = child(&mut host, root, "iframe");
+ assert!(host.set_attribute(owner, "title", "old"));
+ assert!(host.set_attribute(owner, "data-removed", "drop"));
+ if existing_srcdoc {
+ assert!(host.set_attribute(owner, "srcdoc", "stale"));
+ }
+ assert!(host.set_attribute_ns(owner, Some("urn:code"), Some("before"), "code", "old"));
+ assert!(host.set_attribute(owner, "data-after", "kept"));
+ let document = host.create_detached_html_document();
+ let b = child(&mut host, document, "b");
+ text(&mut host, b, "live");
+ let docs = Documents {
+ entries: vec![(owner, document, "about:blank".into())],
+ ..Default::default()
+ };
+ let mut policy = Policy {
+ owner,
+ overrides: vec![
+ Attribute::new("title".into(), "".into(), None, "new & title".into()),
+ Attribute::new(
+ "code".into(),
+ "urn:code".into(),
+ Some("after".into()),
+ "new".into(),
+ ),
+ Attribute::new("srcdoc".into(), "".into(), None, "override".into()),
+ Attribute::new("data-added-drop".into(), "".into(), None, "drop".into()),
+ Attribute::new("code".into(), "".into(), None, "plain".into()),
+ Attribute::new("data-extra".into(), "".into(), None, "last".into()),
+ ],
+ filtering: true,
+ };
+ let before = host.dom().serialize_document();
+ for filtering in [true, false] {
+ policy.filtering = filtering;
+ for embedded in [false, true] {
+ let output = host
+ .get_html_for_export(
+ root,
+ &|_| true,
+ Some(&policy),
+ embedded.then_some(&docs as &dyn HtmlEmbeddedDocumentProvider),
+ None,
+ )
+ .unwrap();
+ let srcdoc = if embedded {
+ " srcdoc=\"<b>live</b>\""
+ } else {
+ " srcdoc=\"override\""
+ };
+ let mut expected = "");
+ assert_eq!(output, expected);
+ assert_eq!(host.dom().serialize_document(), before);
+ }
+ }
+ }
+}
diff --git a/moli-dom/src/native/html_serialization/engine.rs b/moli-dom/src/native/html_serialization/engine.rs
index 56b5b0a1676..429ee942a00 100644
--- a/moli-dom/src/native/html_serialization/engine.rs
+++ b/moli-dom/src/native/html_serialization/engine.rs
@@ -1,5 +1,6 @@
use super::super::NativeDom;
use super::super::node::{NativeNodeId, Node, NodeData};
+use super::attributes::{EffectiveAttributes, EmbeddedAttribute};
use super::{
HtmlEmbeddedDocument, HtmlEmbeddedDocumentProvider, HtmlInsertionPoint, HtmlSerializationError,
HtmlSerializationInsertion, HtmlSerializationLimitExceeded, HtmlSerializationPolicy,
@@ -500,23 +501,16 @@ impl<'dom, S: HtmlSerializationSink, const EMBEDDED: bool, const POLICY: bool>
self.out.attribute(attribute);
}
} else {
- for attribute in element.attributes() {
+ let attributes =
+ EffectiveAttributes::new(id, element.attributes(), overrides, filter);
+ let mut index = 0;
+ loop {
if self.out.limit_exceeded() {
return Ok(());
}
- let output = replacement_attribute(attribute, overrides);
- if filter.is_none_or(|p| p.include_attribute(id, output)) {
- self.out.attribute(output);
- }
- }
- }
- for attribute in overrides {
- if !element
- .attributes()
- .iter()
- .any(|a| attribute_key_eq(a, attribute))
- && filter.is_none_or(|p| p.include_attribute(id, attribute))
- {
+ let Some(attribute) = attributes.next(&mut index, false) else {
+ break;
+ };
self.out.attribute(attribute);
}
}
@@ -608,34 +602,28 @@ impl<'dom, S: HtmlSerializationSink, const EMBEDDED: bool, const POLICY: bool>
.options
.policy
.filter(|_| POLICY && self.options.filtering);
- while state.next_attribute < element.attributes().len() + overrides.len() {
- let index = state.next_attribute;
- state.next_attribute += 1;
- let attribute = if let Some(attribute) = element.attributes().get(index) {
- replacement_attribute(attribute, overrides)
- } else {
- let attribute = &overrides[index - element.attributes().len()];
- if element
- .attributes()
- .iter()
- .any(|a| attribute_key_eq(a, attribute))
- {
- continue;
- }
- attribute
- };
- if attribute.namespace().is_empty() && attribute.local_name() == "srcdoc" {
- state.wrote_srcdoc = true;
- self.start_embedded(state)?;
+ let attributes =
+ EffectiveAttributes::new(state.owner, element.attributes(), overrides, filter);
+ loop {
+ if self.out.limit_exceeded() {
return Ok(());
}
- if attribute.namespace().is_empty() && attribute.local_name() == "data-moli-frame-url" {
- state.wrote_url = true;
- self.out.push_str(" data-moli-frame-url=\"");
- self.out.attribute_value(&state.embedded.url);
- self.out.push('"');
- } else if filter.is_none_or(|p| p.include_attribute(state.owner, attribute)) {
- self.out.attribute(attribute);
+ let Some(attribute) = attributes.next(&mut state.next_attribute, true) else {
+ break;
+ };
+ match EmbeddedAttribute::for_attribute(attribute) {
+ Some(EmbeddedAttribute::Srcdoc) => {
+ state.wrote_srcdoc = true;
+ self.start_embedded(state)?;
+ return Ok(());
+ }
+ Some(EmbeddedAttribute::FrameUrl) => {
+ state.wrote_url = true;
+ self.out.push_str(" data-moli-frame-url=\"");
+ self.out.attribute_value(&state.embedded.url);
+ self.out.push('"');
+ }
+ None => self.out.attribute(attribute),
}
}
if !state.wrote_srcdoc {
@@ -674,18 +662,6 @@ impl<'dom, S: HtmlSerializationSink, const EMBEDDED: bool, const POLICY: bool>
}
}
-fn attribute_key_eq(a: &super::super::Attribute, b: &super::super::Attribute) -> bool {
- a.namespace() == b.namespace() && a.local_name() == b.local_name()
-}
-fn replacement_attribute<'a>(
- attribute: &'a super::super::Attribute,
- overrides: &'a [super::super::Attribute],
-) -> &'a super::super::Attribute {
- overrides
- .iter()
- .find(|a| attribute_key_eq(a, attribute))
- .unwrap_or(attribute)
-}
#[inline(always)]
fn serialize_attribute(attribute: &super::super::Attribute, out: &mut S) {
out.push(' ');
diff --git a/moli-dom/src/native/html_serialization/mod.rs b/moli-dom/src/native/html_serialization/mod.rs
index 1c71037d41c..1d34c36e2a7 100644
--- a/moli-dom/src/native/html_serialization/mod.rs
+++ b/moli-dom/src/native/html_serialization/mod.rs
@@ -1,3 +1,4 @@
+mod attributes;
mod engine;
#[cfg(test)]