fix(dom): preserve DocumentType UTF-16 across native copies and serialization

This commit is contained in:
ldm0
2026-11-22 02:02:00 +08:00
parent 37c554da34
commit f43538b809
21 changed files with 374 additions and 192 deletions
+59 -42
View File
@@ -715,6 +715,65 @@ mod tests {
}
}
#[test]
fn document_type_clone_and_foreign_import_preserve_all_utf16_fields() {
use crate::native::DomStringValue;
let mut source = test_host();
let values = [
DomStringValue::from_utf16(&[0xd800]),
DomStringValue::from_utf16(&[0xd801, 0]),
DomStringValue::from_utf16(&[0xdc00, 0xd83d, 0xde00]),
];
let handle = source.create_document_type(&values[0], &values[1], &values[2]);
let clone = source.clone_node(handle, true).unwrap();
let mut markup: Vec<u16> = "<!DOCTYPE ".encode_utf16().collect();
markup.extend(values[0].utf16_units().iter().copied());
markup.extend(" PUBLIC \"".encode_utf16());
markup.extend(values[1].utf16_units().iter().copied());
markup.extend("\" \"".encode_utf16());
markup.extend(values[2].utf16_units().iter().copied());
markup.extend("\">".encode_utf16());
assert_eq!(
source.outer_html_utf16_with_shadow_roots(
handle,
&|_| true,
crate::native::ShadowRootInclusion::None,
None
),
Some(markup)
);
let mut target = test_host();
target.create_comment("offset the arena");
let imported = target
.import_foreign_node(target.document_handle(), source.dom(), handle, true)
.unwrap();
for (host, id) in [(&source, handle), (&source, clone), (&target, imported)] {
let node = host.node(id).unwrap();
let doctype = node.as_document_type().unwrap();
assert_eq!(doctype.name_value(), &values[0]);
assert_eq!(doctype.public_id_value(), &values[1]);
assert_eq!(doctype.system_id_value(), &values[2]);
assert_eq!(node.node_name_value(), values[0]);
}
assert!(
source
.node(handle)
.unwrap()
.is_equal_node(source.dom(), source.node(clone).unwrap())
);
for index in 0..3 {
let mut different = values.clone();
different[index] = DomStringValue::from_utf16(&[0xfffd]);
let other = source.create_document_type(&different[0], &different[1], &different[2]);
assert!(
!source
.node(handle)
.unwrap()
.is_equal_node(source.dom(), source.node(other).unwrap())
);
}
}
#[test]
fn character_data_clone_and_foreign_import_preserve_utf16_values() {
use crate::native::DomStringValue;
@@ -1154,46 +1213,4 @@ mod tests {
}
}
}
#[test]
fn document_type_clone_and_foreign_import_preserve_all_utf16_fields() {
use crate::native::DomStringValue;
let mut source = test_host();
let values = [
DomStringValue::from_utf16(&[0xd800]),
DomStringValue::from_utf16(&[0xd801, 0]),
DomStringValue::from_utf16(&[0xdc00, 0xd83d, 0xde00]),
];
let handle = source.create_document_type(&values[0], &values[1], &values[2]);
let clone = source.clone_node(handle, true).unwrap();
let mut target = test_host();
target.create_comment("offset the arena");
let imported = target
.import_foreign_node(target.document_handle(), source.dom(), handle, true)
.unwrap();
for (host, id) in [(&source, handle), (&source, clone), (&target, imported)] {
let node = host.node(id).unwrap();
let doctype = node.as_document_type().unwrap();
assert_eq!(doctype.name_value(), &values[0]);
assert_eq!(doctype.public_id_value(), &values[1]);
assert_eq!(doctype.system_id_value(), &values[2]);
assert_eq!(node.node_name_value(), values[0]);
}
assert!(
source
.node(handle)
.unwrap()
.is_equal_node(source.dom(), source.node(clone).unwrap())
);
for index in 0..3 {
let mut different = values.clone();
different[index] = DomStringValue::from_utf16(&[0xfffd]);
let other = source.create_document_type(&different[0], &different[1], &different[2]);
assert!(
!source
.node(handle)
.unwrap()
.is_equal_node(source.dom(), source.node(other).unwrap())
);
}
}
}
@@ -696,12 +696,12 @@ impl<'dom, S: HtmlSerializationSink, const EMBEDDED: bool, const POLICY: bool>
}
NodeData::DocumentType(document_type) => {
self.out.push_str("<!DOCTYPE ");
self.out.push_str(document_type.name());
self.out.push_dom_string(document_type.name_value());
if !document_type.public_id().is_empty() || !document_type.system_id().is_empty() {
self.out.push_str(" PUBLIC \"");
self.out.push_str(document_type.public_id());
self.out.push_dom_string(document_type.public_id_value());
self.out.push_str("\" \"");
self.out.push_str(document_type.system_id());
self.out.push_dom_string(document_type.system_id_value());
self.out.push('"');
}
self.out.push('>');
@@ -45,19 +45,22 @@ struct DomImplementationPrototypeMethodsDeclaration {
struct DomImplementationCreateDocumentTypeArgs {
#[webidl(
required,
converter = "dom_string16",
missing_message = "Failed to execute 'createDocumentType' on 'DOMImplementation': 3 arguments required."
)]
qualified_name: String,
qualified_name: Vec<u16>,
#[webidl(
required,
converter = "dom_string16",
missing_message = "Failed to execute 'createDocumentType' on 'DOMImplementation': 3 arguments required."
)]
public_id: String,
public_id: Vec<u16>,
#[webidl(
required,
converter = "dom_string16",
missing_message = "Failed to execute 'createDocumentType' on 'DOMImplementation': 3 arguments required."
)]
system_id: String,
system_id: Vec<u16>,
}
#[derive(webidl::WebIdlArgs)]
@@ -123,9 +126,9 @@ fn create_document_type_value<'s>(
parsed: &DomImplementationCreateDocumentTypeArgs,
owner_document: Option<v8::Local<'s, v8::Object>>,
) -> Option<v8::Local<'s, v8::Value>> {
let qualified_name = v8_string(scope, &parsed.qualified_name)?;
let public_id = v8_string(scope, &parsed.public_id)?;
let system_id = v8_string(scope, &parsed.system_id)?;
let qualified_name = crate::util::v8_string_from_utf16_units(scope, &parsed.qualified_name)?;
let public_id = crate::util::v8_string_from_utf16_units(scope, &parsed.public_id)?;
let system_id = crate::util::v8_string_from_utf16_units(scope, &parsed.system_id)?;
let mut argv = vec![qualified_name.into(), public_id.into(), system_id.into()];
if let Some(owner_document) = owner_document {
argv.push(owner_document.into());
@@ -164,10 +167,10 @@ fn dom_implementation_create_document_type_callback<'s>(
}
}
fn is_valid_document_type_name(name: &str) -> bool {
fn is_valid_document_type_name(name: &[u16]) -> bool {
!name
.chars()
.any(|ch| ch == '\0' || ch.is_ascii_whitespace() || ch == '>')
.iter()
.any(|unit| matches!(*unit, 0 | 9 | 10 | 12 | 13 | 32 | 62))
}
fn dom_implementation_create_html_document_callback<'s>(
@@ -517,9 +517,9 @@ impl DocumentRuntime {
pub(crate) fn create_document_type(
&mut self,
name: &str,
public_id: &str,
system_id: &str,
name: impl Into<moli_dom::native::DomStringValue>,
public_id: impl Into<moli_dom::native::DomStringValue>,
system_id: impl Into<moli_dom::native::DomStringValue>,
) -> DomHandle {
self.dom_host
.create_document_type(name, public_id, system_id)
@@ -4,9 +4,9 @@ use crate::util::context_host_ptr_from_global_bridge;
pub(in crate::native_bridge::document) fn build_detached_document_type_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
name: &str,
public_id: &str,
system_id: &str,
name: &moli_dom::native::DomStringValue,
public_id: &moli_dom::native::DomStringValue,
system_id: &moli_dom::native::DomStringValue,
) -> Option<v8::Local<'s, v8::Object>> {
let object = new_detached_object_with_prototype(
scope,
@@ -17,17 +17,17 @@ pub(in crate::native_bridge::document) fn build_detached_document_type_object<'s
let _ = state.set(
scope,
v8str(scope, "name").into(),
v8_string(scope, name)?.into(),
crate::util::v8_string_from_dom_string_value(scope, name)?.into(),
);
let _ = state.set(
scope,
v8str(scope, "publicId").into(),
v8_string(scope, public_id)?.into(),
crate::util::v8_string_from_dom_string_value(scope, public_id)?.into(),
);
let _ = state.set(
scope,
v8str(scope, "systemId").into(),
v8_string(scope, system_id)?.into(),
crate::util::v8_string_from_dom_string_value(scope, system_id)?.into(),
);
define_detached_state(scope, object, state);
if let Some(runtime_ptr) = context_host_ptr_from_global_bridge(scope) {
@@ -11,7 +11,7 @@ pub(in crate::native_bridge::document) fn new_detached_state_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
kind: &str,
node_type: i32,
node_name: &str,
node_name: impl Into<moli_dom::native::DomStringValue>,
) -> Option<v8::Local<'s, v8::Object>> {
let state = new_null_prototype_object(scope);
let _ = state.set(
@@ -27,7 +27,7 @@ pub(in crate::native_bridge::document) fn new_detached_state_object<'s>(
let _ = state.set(
scope,
v8str(scope, "nodeName").into(),
v8_string(scope, node_name)?.into(),
crate::util::v8_string_from_dom_string_value(scope, &node_name.into())?.into(),
);
let _ = state.set(
scope,
@@ -524,9 +524,9 @@ fn clone_processing_instruction_target<'s>(
}
struct CloneDocumentTypeMetadata {
name: String,
public_id: String,
system_id: String,
name: moli_dom::native::DomStringValue,
public_id: moli_dom::native::DomStringValue,
system_id: moli_dom::native::DomStringValue,
}
fn clone_document_type_metadata<'s>(
@@ -540,21 +540,21 @@ fn clone_document_type_metadata<'s>(
.and_then(Node::as_document_type)
{
return CloneDocumentTypeMetadata {
name: doctype.name().to_owned(),
public_id: doctype.public_id().to_owned(),
system_id: doctype.system_id().to_owned(),
name: doctype.name_value().clone(),
public_id: doctype.public_id_value().clone(),
system_id: doctype.system_id_value().clone(),
};
}
CloneDocumentTypeMetadata {
name: detached_doctype_name(scope, node)
.or_else(|| object_string_property(scope, node, "name"))
.or_else(|| object_string_property(scope, node, "nodeName"))
.or_else(|| object_dom_string_property(scope, node, "name"))
.or_else(|| object_dom_string_property(scope, node, "nodeName"))
.unwrap_or_default(),
public_id: detached_doctype_public_id(scope, node)
.or_else(|| object_string_property(scope, node, "publicId"))
.or_else(|| object_dom_string_property(scope, node, "publicId"))
.unwrap_or_default(),
system_id: detached_doctype_system_id(scope, node)
.or_else(|| object_string_property(scope, node, "systemId"))
.or_else(|| object_dom_string_property(scope, node, "systemId"))
.unwrap_or_default(),
}
}
@@ -1048,29 +1048,14 @@ pub(in crate::native_bridge::document) fn clone_js_node_like_into_document_objec
public_id,
system_id,
} = clone_document_type_metadata(scope, node);
if detached_state_kind(scope, document).as_deref() == Some("document") {
let cloned =
build_detached_document_type_object(scope, &name, &public_id, &system_id)?;
detached_set_owner_document(scope, cloned, document);
return Some(cloned);
}
let implementation = document.get(scope, v8str(scope, "implementation").into())?;
let implementation = v8::Local::<v8::Object>::try_from(implementation).ok()?;
let create_doctype =
implementation.get(scope, v8str(scope, "createDocumentType").into())?;
let create_doctype = v8::Local::<v8::Function>::try_from(create_doctype).ok()?;
let cloned = call_script_visible_function(
scope,
create_doctype,
implementation.into(),
&[
v8_string(scope, &name)?.into(),
v8_string(scope, &public_id)?.into(),
v8_string(scope, &system_id)?.into(),
],
"detached clone createDocumentType fallback",
)?;
v8::Local::<v8::Object>::try_from(cloned).ok()
let context = crate::native_bridge::node_relevant_context(scope, document)
.or_else(|| document.get_creation_context(scope))
.unwrap_or_else(|| scope.get_current_context());
let target_scope = &mut v8::ContextScope::new(scope, context);
let cloned =
build_detached_document_type_object(target_scope, &name, &public_id, &system_id)?;
detached_set_owner_document(target_scope, cloned, document);
Some(cloned)
}
11 => {
let cloned = build_detached_document_fragment_object(scope, document)?;
@@ -231,14 +231,14 @@ fn live_native_attribute_snapshot<'s>(
struct LiveNativeNodeSnapshot {
node_type: i32,
node_name: String,
node_name: moli_dom::native::DomStringValue,
local_name: Option<String>,
namespace_uri: Option<String>,
prefix: Option<String>,
script_already_started: bool,
doctype_name: Option<String>,
doctype_public_id: Option<String>,
doctype_system_id: Option<String>,
doctype_name: Option<moli_dom::native::DomStringValue>,
doctype_public_id: Option<moli_dom::native::DomStringValue>,
doctype_system_id: Option<moli_dom::native::DomStringValue>,
}
fn live_native_node_snapshot(
@@ -251,7 +251,7 @@ fn live_native_node_snapshot(
let doctype = node.as_document_type();
Some(LiveNativeNodeSnapshot {
node_type: node.node_type() as i32,
node_name: node.node_name(),
node_name: node.node_name_value(),
local_name: element.map(|element| element.local_name().to_owned()),
namespace_uri: element
.and_then(|element| (!element.namespace().is_empty()).then(|| element.namespace()))
@@ -260,9 +260,9 @@ fn live_native_node_snapshot(
script_already_started: element
.filter(|element| element.local_name().eq_ignore_ascii_case("script"))
.is_some_and(|element| element.script_already_started()),
doctype_name: doctype.map(|doctype| doctype.name().to_owned()),
doctype_public_id: doctype.map(|doctype| doctype.public_id().to_owned()),
doctype_system_id: doctype.map(|doctype| doctype.system_id().to_owned()),
doctype_name: doctype.map(|doctype| doctype.name_value().clone()),
doctype_public_id: doctype.map(|doctype| doctype.public_id_value().clone()),
doctype_system_id: doctype.map(|doctype| doctype.system_id_value().clone()),
})
}
@@ -415,7 +415,7 @@ fn adopt_live_node_as_detached_with_parent<'s>(
let node_name = native_snapshot
.as_ref()
.map(|snapshot| snapshot.node_name.clone())
.or_else(|| object_string_property(scope, node, "nodeName"))
.or_else(|| object_dom_string_property(scope, node, "nodeName"))
.unwrap_or_default();
let state_kind = match node_type {
1 => "element",
@@ -441,7 +441,7 @@ fn adopt_live_node_as_detached_with_parent<'s>(
.and_then(|snapshot| snapshot.local_name.clone())
.or_else(|| object_string_property(scope, node, "localName"))
.or_else(|| object_string_property(scope, node, "tagName"))
.unwrap_or_else(|| node_name.clone());
.unwrap_or_else(|| node_name.as_str_lossy().to_owned());
let namespace_uri = native_snapshot
.as_ref()
.and_then(|snapshot| snapshot.namespace_uri.clone())
@@ -476,7 +476,7 @@ fn adopt_live_node_as_detached_with_parent<'s>(
"xml"
};
let node_name = if document_kind == "html" {
node_name.clone()
node_name.as_str_lossy().to_owned()
} else {
qualified_name.clone()
};
@@ -593,7 +593,7 @@ fn adopt_live_node_as_detached_with_parent<'s>(
let _ = state.set(
scope,
v8str(scope, "target").into(),
v8_string(scope, &node_name)?.into(),
crate::util::v8_string_from_dom_string_value(scope, &node_name)?.into(),
);
}
if native_snapshot.is_none() {
@@ -627,12 +627,12 @@ fn adopt_live_node_as_detached_with_parent<'s>(
let value = native_doctype_values
.as_ref()
.map(|values| values[index].clone())
.or_else(|| object_string_property(scope, node, property))
.or_else(|| object_dom_string_property(scope, node, property))
.unwrap_or_default();
let _ = state.set(
scope,
v8str(scope, property).into(),
v8_string(scope, &value)?.into(),
crate::util::v8_string_from_dom_string_value(scope, &value)?.into(),
);
}
define_detached_state(scope, node, state);
@@ -1,6 +1,7 @@
use super::*;
pub(in crate::native_bridge::document) use crate::util::{
call_object_method, get_property as object_property_value,
object_defined_dom_string_property as object_dom_string_property,
object_defined_string_property as object_string_property, object_property_as_object,
};
use moli_webapi_declare::WebApiObject;
@@ -333,63 +333,51 @@ pub(in crate::native_bridge::document) fn read_detached_native_node_type<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<i32> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
let (runtime_ptr, handle) =
node_runtime_and_handle_from_object_or_detached(scope, node).ok()?;
unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.map(|node| node.node_type() as i32)
}
pub(in crate::native_bridge::document) fn read_detached_native_node_name<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.map(|node| node.node_name())
}
pub(in crate::native_bridge::document) fn read_detached_native_doctype_name<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
) -> Option<moli_dom::native::DomStringValue> {
let (runtime_ptr, handle) =
node_runtime_and_handle_from_object_or_detached(scope, node).ok()?;
unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.and_then(|node| node.as_document_type())
.map(|doctype| doctype.name().to_owned())
.map(|doctype| doctype.name_value().clone())
}
pub(in crate::native_bridge::document) fn read_detached_native_doctype_public_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
) -> Option<moli_dom::native::DomStringValue> {
let (runtime_ptr, handle) =
node_runtime_and_handle_from_object_or_detached(scope, node).ok()?;
unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.and_then(|node| node.as_document_type())
.map(|doctype| doctype.public_id().to_owned())
.map(|doctype| doctype.public_id_value().clone())
}
pub(in crate::native_bridge::document) fn read_detached_native_doctype_system_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
let runtime_ptr = context_host_ptr_from_global_bridge(scope)?;
let handle = detached_native_handle_for_runtime(scope, runtime_ptr, node)?;
) -> Option<moli_dom::native::DomStringValue> {
let (runtime_ptr, handle) =
node_runtime_and_handle_from_object_or_detached(scope, node).ok()?;
unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.and_then(|node| node.as_document_type())
.map(|doctype| doctype.system_id().to_owned())
.map(|doctype| doctype.system_id_value().clone())
}
pub(in crate::native_bridge::document) fn read_detached_native_processing_instruction_target<'s>(
@@ -414,36 +402,49 @@ pub(in crate::native_bridge::document) fn detached_node_type<'s>(
.or_else(|| object_node_type(scope, node))
}
pub(in crate::native_bridge::document) fn detached_node_name<'s>(
pub(in crate::native_bridge::document) fn detached_node_name_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
detached_state_string(scope, node, "nodeName")
.or_else(|| read_detached_native_node_name(scope, node))
) -> Option<moli_dom::native::DomStringValue> {
if let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object_or_detached(scope, node)
{
return unsafe { &*runtime_ptr }
.dom_host()
.node(handle)
.map(Node::node_name_value);
}
detached_state_object(scope, node)
.and_then(|state| object_dom_string_property(scope, state, "nodeName"))
}
pub(in crate::native_bridge) fn detached_doctype_name<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
read_detached_native_doctype_name(scope, node)
.or_else(|| detached_state_string(scope, node, "name"))
) -> Option<moli_dom::native::DomStringValue> {
read_detached_native_doctype_name(scope, node).or_else(|| {
detached_state_object(scope, node)
.and_then(|state| object_dom_string_property(scope, state, "name"))
})
}
pub(in crate::native_bridge) fn detached_doctype_public_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
read_detached_native_doctype_public_id(scope, node)
.or_else(|| detached_state_string(scope, node, "publicId"))
) -> Option<moli_dom::native::DomStringValue> {
read_detached_native_doctype_public_id(scope, node).or_else(|| {
detached_state_object(scope, node)
.and_then(|state| object_dom_string_property(scope, state, "publicId"))
})
}
pub(in crate::native_bridge) fn detached_doctype_system_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
node: v8::Local<'s, v8::Object>,
) -> Option<String> {
read_detached_native_doctype_system_id(scope, node)
.or_else(|| detached_state_string(scope, node, "systemId"))
) -> Option<moli_dom::native::DomStringValue> {
read_detached_native_doctype_system_id(scope, node).or_else(|| {
detached_state_object(scope, node)
.and_then(|state| object_dom_string_property(scope, state, "systemId"))
})
}
pub(in crate::native_bridge) fn detached_processing_instruction_target<'s>(
@@ -26,9 +26,12 @@ pub(in crate::native_bridge) fn bridge_create_detached_document_type_callback<'a
args: v8::FunctionCallbackArguments<'a>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let name = callback_arg_string(scope, &args, 0).unwrap_or_default();
let public_id = callback_arg_string(scope, &args, 1).unwrap_or_default();
let system_id = callback_arg_string(scope, &args, 2).unwrap_or_default();
let Some(parsed) = crate::webidl::parse_args::<DetachedDocumentTypeArgs>(scope, &args) else {
return;
};
let name = moli_dom::native::DomStringValue::from_utf16(&parsed.name);
let public_id = moli_dom::native::DomStringValue::from_utf16(&parsed.public_id);
let system_id = moli_dom::native::DomStringValue::from_utf16(&parsed.system_id);
match build_detached_document_type_object(scope, &name, &public_id, &system_id) {
Some(doctype) => {
if let Ok(owner_document) = v8::Local::<v8::Object>::try_from(args.get(3)) {
@@ -40,6 +43,16 @@ pub(in crate::native_bridge) fn bridge_create_detached_document_type_callback<'a
}
}
#[derive(crate::webidl::WebIdlArgs)]
struct DetachedDocumentTypeArgs {
#[webidl(required, converter = "dom_string16")]
name: Vec<u16>,
#[webidl(required, converter = "dom_string16")]
public_id: Vec<u16>,
#[webidl(required, converter = "dom_string16")]
system_id: Vec<u16>,
}
pub(in crate::native_bridge) fn bridge_create_detached_html_document_callback<'a>(
scope: &mut v8::PinScope<'a, '_>,
args: v8::FunctionCallbackArguments<'a>,
@@ -22,8 +22,10 @@ pub(in crate::native_bridge) fn bridge_detached_node_name_callback<'a>(
rv.set_empty_string();
return;
};
let node_name = detached_node_name(scope, node).unwrap_or_default();
set_string_return_value(scope, &mut rv, &node_name);
let node_name = detached_node_name_value(scope, node).unwrap_or_default();
if let Some(value) = crate::util::v8_string_from_dom_string_value(scope, &node_name) {
rv.set(value.into());
}
}
pub(in crate::native_bridge) fn bridge_detached_node_value_getter_callback<'a>(
@@ -101,7 +103,9 @@ pub(in crate::native_bridge) fn bridge_detached_doctype_name_callback<'a>(
return;
};
let name = detached_doctype_name(scope, node).unwrap_or_default();
set_string_return_value(scope, &mut rv, &name);
if let Some(value) = crate::util::v8_string_from_dom_string_value(scope, &name) {
rv.set(value.into());
}
}
pub(in crate::native_bridge) fn bridge_detached_doctype_public_id_callback<'a>(
@@ -114,7 +118,9 @@ pub(in crate::native_bridge) fn bridge_detached_doctype_public_id_callback<'a>(
return;
};
let public_id = detached_doctype_public_id(scope, node).unwrap_or_default();
set_string_return_value(scope, &mut rv, &public_id);
if let Some(value) = crate::util::v8_string_from_dom_string_value(scope, &public_id) {
rv.set(value.into());
}
}
pub(in crate::native_bridge) fn bridge_detached_doctype_system_id_callback<'a>(
@@ -127,7 +133,9 @@ pub(in crate::native_bridge) fn bridge_detached_doctype_system_id_callback<'a>(
return;
};
let system_id = detached_doctype_system_id(scope, node).unwrap_or_default();
set_string_return_value(scope, &mut rv, &system_id);
if let Some(value) = crate::util::v8_string_from_dom_string_value(scope, &system_id) {
rv.set(value.into());
}
}
pub(in crate::native_bridge) fn bridge_detached_processing_instruction_target_callback<'a>(
+8 -8
View File
@@ -197,14 +197,14 @@ struct DocumentTypePrototypeDeclaration {
fn set_document_type_string_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: Option<String>,
value: Option<moli_dom::native::DomStringValue>,
mut rv: v8::ReturnValue<'s, v8::Value>,
) {
let Some(value) = value else {
rv.set_undefined();
return;
};
let Some(value) = v8_string(scope, &value) else {
let Some(value) = crate::util::v8_string_from_dom_string_value(scope, &value) else {
rv.set_null();
return;
};
@@ -396,8 +396,8 @@ fn live_document_type_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
member: &str,
value: for<'a> fn(&'a DocumentType) -> &'a str,
) -> std::result::Result<String, ()> {
value: for<'a> fn(&'a DocumentType) -> &'a moli_dom::native::DomStringValue,
) -> std::result::Result<moli_dom::native::DomStringValue, ()> {
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_args(scope, args) else {
webidl::throw_type_error(
scope,
@@ -410,7 +410,7 @@ fn live_document_type_value<'s>(
.node(handle)
.and_then(Node::as_document_type)
.map(value)
.map(str::to_owned)
.cloned()
else {
webidl::throw_type_error(
scope,
@@ -427,7 +427,7 @@ fn document_type_name_getter_function<'s>(
rv: v8::ReturnValue<'s, v8::Value>,
) {
let value = super::document::detached_doctype_name(scope, args.this())
.or_else(|| live_document_type_value(scope, &args, "name", DocumentType::name).ok());
.or_else(|| live_document_type_value(scope, &args, "name", DocumentType::name_value).ok());
set_document_type_string_value(scope, value, rv);
}
@@ -437,7 +437,7 @@ fn document_type_public_id_getter_function<'s>(
rv: v8::ReturnValue<'s, v8::Value>,
) {
let value = super::document::detached_doctype_public_id(scope, args.this()).or_else(|| {
live_document_type_value(scope, &args, "publicId", DocumentType::public_id).ok()
live_document_type_value(scope, &args, "publicId", DocumentType::public_id_value).ok()
});
set_document_type_string_value(scope, value, rv);
}
@@ -448,7 +448,7 @@ fn document_type_system_id_getter_function<'s>(
rv: v8::ReturnValue<'s, v8::Value>,
) {
let value = super::document::detached_doctype_system_id(scope, args.this()).or_else(|| {
live_document_type_value(scope, &args, "systemId", DocumentType::system_id).ok()
live_document_type_value(scope, &args, "systemId", DocumentType::system_id_value).ok()
});
set_document_type_string_value(scope, value, rv);
}
@@ -31,16 +31,19 @@ pub(super) fn node_node_name_getter_function<'s>(
return;
};
let name = match node {
NativeNodeReference::Attr(attr) => attr.name(scope),
NativeNodeReference::Attr(attr) => attr.name(scope).map(DomStringValue::from),
NativeNodeReference::Tree { node, .. } => {
let runtime = unsafe { &*node.runtime_ptr };
runtime.dom_host().node(node.handle).map(|value| {
element_name_for_owner_document(runtime, node.handle)
.unwrap_or_else(|| value.node_name())
.map(DomStringValue::from)
.unwrap_or_else(|| value.node_name_value())
})
}
};
if let Some(name) = name.and_then(|name| v8_string(scope, &name)) {
if let Some(name) =
name.and_then(|name| crate::util::v8_string_from_dom_string_value(scope, &name))
{
rv.set(name.into());
}
}
@@ -88,11 +88,11 @@ fn materialize_foreign_node_arg_handle(
Some(handle)
}
fn materialize_foreign_node_arg_handle_for_identity(
scope: &mut v8::PinScope<'_, '_>,
fn materialize_foreign_node_arg_handle_for_identity<'s>(
scope: &mut v8::PinScope<'s, '_>,
runtime_ptr: *mut PageScriptHost,
document_handle: DomHandle,
object: v8::Local<'_, v8::Object>,
object: v8::Local<'s, v8::Object>,
) -> Option<DomHandle> {
let handle =
clone_js_node_like_into_document(scope, runtime_ptr, document_handle, object, true)?;
@@ -47,11 +47,11 @@ fn append_cloned_child_without_mutation_effects(
.append_child_without_mutation_effects(parent, child)
}
pub(super) fn clone_js_node_like_into_document(
scope: &mut v8::PinScope<'_, '_>,
pub(super) fn clone_js_node_like_into_document<'s>(
scope: &mut v8::PinScope<'s, '_>,
runtime_ptr: *mut PageScriptHost,
document_handle: DomHandle,
object: v8::Local<'_, v8::Object>,
object: v8::Local<'s, v8::Object>,
deep: bool,
) -> Option<DomHandle> {
let node_type = js_node_type(scope, object)?;
@@ -118,11 +118,23 @@ pub(super) fn clone_js_node_like_into_document(
Some(document)
}
10 => {
let name = js_string_property(scope, object, "name")
.or_else(|| js_string_property(scope, object, "nodeName"))
.unwrap_or_default();
let public_id = js_string_property(scope, object, "publicId").unwrap_or_default();
let system_id = js_string_property(scope, object, "systemId").unwrap_or_default();
let native = node_runtime_and_handle_from_object_or_detached(scope, object)
.ok()
.and_then(|(owner, handle)| unsafe { &*owner }.dom_host().node(handle))
.and_then(Node::as_document_type)
.map(|doctype| {
[
doctype.name_value().clone(),
doctype.public_id_value().clone(),
doctype.system_id_value().clone(),
]
});
let [name, public_id, system_id] = native.unwrap_or_else(|| {
["name", "publicId", "systemId"].map(|key| {
crate::util::object_defined_dom_string_property(scope, object, key)
.unwrap_or_default()
})
});
Some(unsafe { &mut *runtime_ptr }.create_document_type(&name, &public_id, &system_id))
}
11 => {
@@ -0,0 +1,84 @@
(async () => {
const checks = [];
const check = (name, actual, expected) => checks.push({name, actual, expected, passed: JSON.stringify(actual) === JSON.stringify(expected)});
const observe = (name, action, expected) => { let actual; try { actual = action(); } catch (error) { actual = {exception: error.name}; } check(name, actual, expected); };
const quote = id => (id.includes('"') ? "'" : '"') + id + (id.includes('"') ? "'" : '"');
const markup = ([name, pub, sys]) => '<!DOCTYPE ' + name + (pub ? ' PUBLIC ' + quote(pub) : sys ? ' SYSTEM' : '') + (sys ? ' ' + quote(sys) : '') + '>';
const fields = node => [node.name, node.nodeName, node.publicId, node.systemId];
const cases = [
['root', '', ''], ['', '', ''], ['\uD800', '\uD801', '\uDC00'], ['\uD801', 'p', 's'],
['\uDC00', 'p\0', 's\0'], ['root', 'p', ''], ['root', '', 's'],
['root', 'p"b', ''], ['root', '', 's"b'], ['root', "p'b", ''], ['root', '', "s'b"],
['root', 'p"\'b', 's"\'b'], ['\uFFFD', '\uFFFD', '\uFFFD'], ['😀', '😀', '😀'],
['root', '&<>\t\n\r', '&<>\t\n\r'], ['root', 'p\0\uD800', 's\uDC00\0'],
];
const frame = document.createElement('iframe'); document.body.appendChild(frame);
let popup;
const includePopup = globalThis.__documentTypeIncludePopup !== false;
try {
const realms = [['main', window], ['iframe', frame.contentWindow]];
if (includePopup) {
popup = window.open('', '_blank');
if (!popup) throw new Error('popup unavailable');
await new Promise(resolve => setTimeout(resolve, 0));
realms.push(['popup', popup]);
}
for (const [ownerName, owner] of realms) {
const documents = [
['live', owner.document], ['html', owner.document.implementation.createHTMLDocument('')],
['xml', owner.document.implementation.createDocument(null, 'root')],
['parsed-html', new owner.DOMParser().parseFromString('<!doctype html><body>', 'text/html')],
['parsed-xml', new owner.DOMParser().parseFromString('<root/>', 'application/xml')],
['new-document', new owner.Document()],
];
for (const [docName, doc] of documents) for (const [calleeName, callee] of realms) {
const prefix = `${ownerName}/${docName}/${calleeName}`;
const create = callee.DOMImplementation.prototype.createDocumentType;
const serialize = node => callee.XMLSerializer.prototype.serializeToString.call(new callee.XMLSerializer(), node);
for (const [index, input] of cases.entries()) {
const label = prefix + '/' + index;
const expected = [input[0], input[0], input[1], input[2]];
const node = create.call(doc.implementation, ...input);
check(label + '/fields', fields(node), expected);
check(label + '/owner', [node.ownerDocument === doc, node instanceof owner.DocumentType], [true, true]);
check(label + '/serialize', serialize(node), markup(input));
for (const deep of [false, true]) {
observe(label + '/clone-' + deep, () => {
const clone = callee.Node.prototype.cloneNode.call(node, deep);
return [fields(clone), node.isEqualNode(clone), clone !== node, clone.ownerDocument === doc];
}, [expected, true, true, true]);
}
const destination = owner.document.implementation.createDocument(null, 'root');
const imported = destination.importNode(node, true);
check(label + '/import', [fields(imported), imported.ownerDocument === destination, imported.isEqualNode(node)], [expected, true, true]);
destination.insertBefore(imported, destination.documentElement);
check(label + '/connected', [fields(destination.doctype), serialize(destination)], [expected, markup(input) + '<root/>']);
const adopted = owner.document.implementation.createDocument(null, 'root');
const source = destination.doctype;
check(label + '/adopt', [adopted.adoptNode(source) === source, source.ownerDocument === adopted, fields(source)], [true, true, expected]);
adopted.insertBefore(source, adopted.documentElement);
check(label + '/adopt-connected', [fields(adopted.doctype), serialize(adopted)], [expected, markup(input) + '<root/>']);
for (const key of ['name', 'nodeName', 'publicId', 'systemId']) Object.defineProperty(node, key, {get() {throw new Error('author getter: ' + key);}, configurable: true});
observe(label + '/native-fields', () => {
const cleanClone = callee.Node.prototype.cloneNode.call(node, false);
return [serialize(node), fields(cleanClone), cleanClone.isEqualNode(node)];
}, [markup(input), expected, true]);
}
for (const field of ['name', 'publicId', 'systemId']) {
const left = ['root', 'p', 's']; const right = left.slice();
const position = field === 'name' ? 0 : field === 'publicId' ? 1 : 2;
left[position] = '\uD800'; right[position] = '\uD801';
const a = create.call(doc.implementation, ...left), b = create.call(doc.implementation, ...right);
right[position] = '\uFFFD'; const replacement = create.call(doc.implementation, ...right);
check(prefix + '/identity/' + field, [a.isEqualNode(b), b.isEqualNode(a), a.isEqualNode(replacement), a.isEqualNode(callee.Node.prototype.cloneNode.call(a))], [false, false, false, true]);
}
const log = [];
const strings = ['r\uD800', 'p\uD801', 's\uDC00'];
const converted = create.call(doc.implementation, ...strings.map((value, index) => ({toString() {log.push(index); return value;}})));
check(prefix + '/conversion', [log, fields(converted)], [[0, 1, 2], [strings[0], strings[0], strings[1], strings[2]]]);
}
}
globalThis.__uiEventResults = {complete: true, includePopup, total: checks.length, passed: checks.filter(row => row.passed).length, checks};
return true;
} finally { frame.remove(); if (popup) popup.close(); }
})()
@@ -305,6 +305,32 @@ fn mutation_observer_observe_accepts_registered_native_proxy_targets_and_receive
})()"#).unwrap(), "true");
}
#[tokio::test(flavor = "current_thread")]
async fn document_type_preserves_utf16_across_native_copy_and_serialization() {
let loader = static_http_loader(std::iter::empty::<String>());
let mut vm = new_page_task_executor_test_vm_with_loader("https://doctype-utf16.test/", &loader);
// Real popup Pages run the same fixture over CDP.
vm.exec("globalThis.__documentTypeIncludePopup = false;", None)
.unwrap();
vm.exec(include_str!("document_type_utf16_complete.js"), None)
.unwrap();
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"String(globalThis.__uiEventResults?.complete === true)",
"true",
"DocumentType native DOMString storage",
)
.await;
assert_eq!(
vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")
.unwrap(),
"[]"
);
assert_eq!(vm.eval("__uiEventResults.includePopup").unwrap(), "false");
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "3936");
}
#[tokio::test(flavor = "current_thread")]
async fn dom_implementation_derives_receiver_and_argument_conversion_in_each_document_realm() {
let loader = static_http_loader(std::iter::empty::<String>());
+16 -1
View File
@@ -1015,7 +1015,7 @@ pub(crate) fn v8_value_to_dom_string_u16<'s>(
}
pub(crate) fn v8_string_from_dom_string_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
scope: &v8::PinScope<'s, '_>,
value: &moli_dom::native::DomStringValue,
) -> Option<v8::Local<'s, v8::String>> {
if let Some(text) = value.as_str() {
@@ -1025,6 +1025,21 @@ pub(crate) fn v8_string_from_dom_string_value<'s>(
}
}
pub(crate) fn object_defined_dom_string_property(
scope: &mut v8::PinScope<'_, '_>,
object: v8::Local<'_, v8::Object>,
key: &str,
) -> Option<moli_dom::native::DomStringValue> {
let value = get_property(scope, object, key)?;
if value.is_null_or_undefined() {
return None;
}
let value = value.to_string(scope)?;
Some(moli_dom::native::DomStringValue::from_utf16(
v8_string_to_u16_string(scope, value).as_slice(),
))
}
pub(crate) fn utf16_units(value: &str) -> Vec<u16> {
value.encode_utf16().collect()
}
+23 -9
View File
@@ -135,6 +135,21 @@ impl XmlMarkup {
self.units.extend(value.encode_utf16());
}
fn push_value(&mut self, value: &DomStringValue) {
value.append_utf16_units_to(&mut self.units);
}
fn push_doctype_id(&mut self, value: &DomStringValue) {
let quote = if value.as_str_lossy().contains('"') {
0x27
} else {
0x22
};
self.units.push(quote);
self.push_value(value);
self.units.push(quote);
}
fn escaped_units(&mut self, units: impl Iterator<Item = u16>, attribute: bool) {
for unit in units {
let replacement = match unit {
@@ -263,17 +278,16 @@ fn serialize_native_node(
return;
};
markup.push_str("<!DOCTYPE ");
markup.push_str(doctype.name());
markup.push_value(doctype.name_value());
if !doctype.public_id().is_empty() {
markup.push_str(" PUBLIC \"");
markup.push_str(doctype.public_id());
markup.push_str("\" \"");
markup.push_str(doctype.system_id());
markup.push_str("\"");
markup.push_str(" PUBLIC ");
markup.push_doctype_id(doctype.public_id_value());
} else if !doctype.system_id().is_empty() {
markup.push_str(" SYSTEM \"");
markup.push_str(doctype.system_id());
markup.push_str("\"");
markup.push_str(" SYSTEM");
}
if !doctype.system_id().is_empty() {
markup.push_str(" ");
markup.push_doctype_id(doctype.system_id_value());
}
markup.push_str(">");
}
+1 -1
View File
@@ -18,7 +18,7 @@ pub fn is_nullish(value: Local<'_, Value>) -> bool {
}
pub fn v8_string_from_utf16_units<'s>(
scope: &mut v8::PinScope<'s, '_>,
scope: &v8::PinScope<'s, '_>,
units: &[u16],
) -> Option<v8::Local<'s, v8::String>> {
v8::String::new_from_two_byte(scope, units, v8::NewStringType::Normal)