fix(dom): derive import and adoption argument conversion

This commit is contained in:
ldm0
2026-11-21 20:03:31 +08:00
parent 7d9dac44f6
commit ef1e1bb76f
12 changed files with 458 additions and 181 deletions
@@ -1727,7 +1727,7 @@ struct DocumentPrototypeMethodsDeclaration {
callback = node_create_cdata_section_callback
)]
create_cdata_section: (),
#[webapi(method = "importNode", length = 2, callback = node_import_node_callback)]
#[webapi(method = "importNode", length = 1, callback = node_import_node_callback)]
import_node: (),
#[webapi(method = "adoptNode", length = 1, callback = node_adopt_node_callback)]
adopt_node: (),
@@ -1,8 +1,8 @@
use super::super::super::{custom_elements, util::call_global_bridge_method};
use super::super::node::{
node_arg_handle, node_is_document, node_or_foreign_arg_handle_allow_detached,
node_runtime_and_handle_from_args, node_runtime_and_handle_from_args_or_detached,
node_runtime_and_handle_from_object,
node_runtime_and_handle_from_args, node_runtime_and_handle_from_object,
node_runtime_and_handle_from_object_or_detached,
};
use super::super::{
PageScriptHost, throw_dom_exception, validate_attribute_name, validate_element_name,
@@ -97,14 +97,16 @@ enum DetachedDocumentReceiverKind {
Xml,
}
fn detached_document_receiver_kind(
scope: &mut v8::PinScope<'_, '_>,
args: &v8::FunctionCallbackArguments<'_>,
fn detached_document_receiver_kind<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<DetachedDocumentReceiverKind> {
if node_runtime_and_handle_from_args(scope, args).is_ok() {
let receiver = moli_webapi_declare::web_api_object_target(scope, args.this())?;
if node_runtime_and_handle_from_object(scope, receiver).is_ok() {
return None;
}
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_args_or_detached(scope, args)
let Ok((runtime_ptr, handle)) =
node_runtime_and_handle_from_object_or_detached(scope, receiver)
else {
return None;
};
@@ -1,21 +1,30 @@
use super::*;
use crate::native_bridge::DomHandle;
use crate::native_bridge::document::{
detached_native_handle_for_runtime, detached_node_type, detached_set_owner_document,
object_is_shadow_root, parse_import_node_options, validate_registry_association_for_document,
detached_native_handle_for_runtime, detached_set_owner_document, object_is_shadow_root,
parse_import_node_options, validate_registry_association_for_document,
};
use crate::native_bridge::node::RequiredNodeArgs;
use crate::native_bridge::set_wrapped_handle_or_null_for_receiver;
use crate::web_api_interfaces;
pub(in crate::native_bridge) fn node_import_node_callback<'a>(
scope: &mut v8::PinScope<'a, '_>,
args: v8::FunctionCallbackArguments<'a>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let receiver = moli_webapi_declare::web_api_object_target(scope, args.this())
.expect("binding validated Document receiver");
let Some(parsed) = webidl::parse_args::<RequiredNodeArgs>(scope, &args) else {
return;
};
let source = moli_webapi_declare::web_api_object_target(scope, parsed.node)
.expect("converted Node has native identity");
if detached_document_receiver_kind(scope, &args).is_some() {
detached_import_node_method_callback(scope, args, rv);
return;
}
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_args(scope, &args) else {
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object(scope, receiver) else {
rv.set_null();
return;
};
@@ -27,6 +36,17 @@ pub(in crate::native_bridge) fn node_import_node_callback<'a>(
return;
};
let deep = options.deep;
if web_api_interfaces::Document::is_instance(scope, source)
|| object_is_shadow_root(scope, source)
{
throw_dom_exception(
scope,
"NotSupportedError",
9,
"Document and ShadowRoot nodes cannot be imported.",
);
return;
}
if !validate_registry_association_for_document(
scope,
runtime_ptr,
@@ -35,71 +55,50 @@ pub(in crate::native_bridge) fn node_import_node_callback<'a>(
) {
return;
}
let Some(node) = node_arg_handle(scope, runtime_ptr, args.get(0)) else {
if let Ok(node) = v8::Local::<v8::Object>::try_from(args.get(0)) {
if object_is_shadow_root(scope, node) {
throw_dom_exception(
scope,
"NotSupportedError",
9,
"This operation is not supported for ShadowRoot nodes.",
);
let Some(node) = node_arg_handle(scope, runtime_ptr, source.into()) else {
if let Some(imported) =
import_cross_runtime_node_with_shadow_roots(scope, runtime_ptr, handle, source, deep)
{
set_wrapped_handle_or_null_for_receiver(
scope,
&mut rv,
runtime_ptr,
args.this(),
Some(imported),
);
return;
}
if let Some(source_handle) = detached_native_handle_for_runtime(scope, runtime_ptr, source)
{
let Some(imported) = unsafe { &mut *runtime_ptr }.import_node(
scope,
runtime_ptr,
handle,
source_handle,
deep,
options.fallback_registry,
) else {
rv.set_null();
return;
}
if let Some(imported) =
import_cross_runtime_node_with_shadow_roots(scope, runtime_ptr, handle, node, deep)
{
set_wrapped_handle_or_null_for_receiver(
scope,
&mut rv,
runtime_ptr,
args.this(),
Some(imported),
);
return;
}
if let Some(source_handle) =
detached_native_handle_for_runtime(scope, runtime_ptr, node)
{
let Some(imported) = unsafe { &mut *runtime_ptr }.import_node(
scope,
runtime_ptr,
handle,
source_handle,
deep,
options.fallback_registry,
) else {
rv.set_null();
return;
};
set_wrapped_handle_or_null_for_receiver(
scope,
&mut rv,
runtime_ptr,
args.this(),
Some(imported),
);
return;
}
if let Some(cloned) =
clone_js_node_like_into_document_object(scope, args.this(), node, deep)
{
rv.set(cloned.into());
return;
}
};
set_wrapped_handle_or_null_for_receiver(
scope,
&mut rv,
runtime_ptr,
args.this(),
Some(imported),
);
return;
}
if let Some(cloned) =
clone_js_node_like_into_document_object(scope, args.this(), source, deep)
{
rv.set(cloned.into());
return;
}
rv.set_null();
return;
};
if unsafe { &*runtime_ptr }.dom_host().is_shadow_root(node) {
throw_dom_exception(
scope,
"NotSupportedError",
9,
"This operation is not supported for ShadowRoot nodes.",
);
return;
}
let Some(imported) = unsafe { &mut *runtime_ptr }.import_node(
scope,
runtime_ptr,
@@ -148,11 +147,18 @@ pub(in crate::native_bridge) fn node_adopt_node_callback<'a>(
args: v8::FunctionCallbackArguments<'a>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let receiver = moli_webapi_declare::web_api_object_target(scope, args.this())
.expect("binding validated Document receiver");
let Some(parsed) = webidl::parse_args::<RequiredNodeArgs>(scope, &args) else {
return;
};
let source = moli_webapi_declare::web_api_object_target(scope, parsed.node)
.expect("converted Node has native identity");
if detached_document_receiver_kind(scope, &args).is_some() {
detached_adopt_node_method_callback(scope, args, rv);
return;
}
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_args(scope, &args) else {
let Ok((runtime_ptr, handle)) = node_runtime_and_handle_from_object(scope, receiver) else {
rv.set_null();
return;
};
@@ -160,58 +166,16 @@ pub(in crate::native_bridge) fn node_adopt_node_callback<'a>(
rv.set_null();
return;
}
let Some(node) = node_arg_handle(scope, runtime_ptr, args.get(0)) else {
if let Ok(node) = v8::Local::<v8::Object>::try_from(args.get(0)) {
if object_is_shadow_root(scope, node) {
throw_dom_exception(
scope,
"HierarchyRequestError",
3,
"ShadowRoot nodes cannot be adopted.",
);
return;
}
if detached_node_type(scope, node) == Some(9) {
throw_dom_exception(
scope,
"NotSupportedError",
9,
"This operation is not supported for Document nodes.",
);
return;
}
if let Some(adopted_handle) = node_or_foreign_arg_handle_allow_detached(
scope,
runtime_ptr,
Some(handle),
node.into(),
) {
let runtime = unsafe { &mut *runtime_ptr };
if runtime
.adopt_node(scope, runtime_ptr, handle, adopted_handle)
.is_none()
{
rv.set_null();
return;
}
detached_set_owner_document(scope, node, args.this());
rv.set(node.into());
return;
}
if let Some(adopted) = call_global_bridge_method(
scope,
"__adoptNodeIntoDocument",
&[args.this().into(), node.into()],
) {
rv.set(adopted);
return;
}
}
rv.set_null();
if web_api_interfaces::Document::is_instance(scope, source) {
throw_dom_exception(
scope,
"NotSupportedError",
9,
"Document nodes cannot be adopted.",
);
return;
};
let runtime = unsafe { &mut *runtime_ptr };
if runtime.dom_host().is_shadow_root(node) {
}
if object_is_shadow_root(scope, source) {
throw_dom_exception(
scope,
"HierarchyRequestError",
@@ -220,6 +184,37 @@ pub(in crate::native_bridge) fn node_adopt_node_callback<'a>(
);
return;
}
let Some(node) = node_arg_handle(scope, runtime_ptr, source.into()) else {
if let Some(adopted_handle) = node_or_foreign_arg_handle_allow_detached(
scope,
runtime_ptr,
Some(handle),
source.into(),
) {
let runtime = unsafe { &mut *runtime_ptr };
if runtime
.adopt_node(scope, runtime_ptr, handle, adopted_handle)
.is_none()
{
rv.set_null();
return;
}
detached_set_owner_document(scope, source, args.this());
rv.set(source.into());
return;
}
if let Some(adopted) = call_global_bridge_method(
scope,
"__adoptNodeIntoDocument",
&[args.this().into(), source.into()],
) {
rv.set(adopted);
return;
}
rv.set_null();
return;
};
let runtime = unsafe { &mut *runtime_ptr };
let Some(adopted) = runtime.adopt_node(scope, runtime_ptr, handle, node) else {
rv.set_null();
return;
@@ -155,42 +155,48 @@ pub(in crate::native_bridge::document) struct ImportNodeOptions {
Option<custom_elements::CustomElementRegistryAssociation>,
}
pub(in crate::native_bridge::document) fn parse_import_node_options(
scope: &mut v8::PinScope<'_, '_>,
value: v8::Local<'_, v8::Value>,
#[derive(Default, webidl::WebIdlDictionary)]
#[webidl(prefix = "ImportNodeOptions")]
struct ImportNodeDictionary<'s> {
#[webidl(interface = web_api_interfaces::CustomElementRegistry)]
custom_element_registry: Option<v8::Local<'s, v8::Object>>,
#[webidl(default = false)]
self_only: bool,
}
pub(in crate::native_bridge::document) fn parse_import_node_options<'s>(
scope: &mut v8::PinScope<'s, '_>,
value: v8::Local<'s, v8::Value>,
) -> Option<ImportNodeOptions> {
if value.is_undefined() || value.is_null() {
return Some(ImportNodeOptions {
deep: false,
fallback_registry: None,
});
}
if !value.is_object() {
// The optional argument defaults to false for missing/undefined values.
// Null selects the dictionary member of the union, whose selfOnly default
// makes the import deep. Other primitives select boolean via ToBoolean.
if value.is_undefined() || (!value.is_object() && !value.is_null()) {
return Some(ImportNodeOptions {
deep: value.boolean_value(scope),
fallback_registry: None,
});
}
let options = value.to_object(scope)?;
let self_only = options
.get(scope, v8str(scope, "selfOnly").into())
.is_some_and(|value| value.boolean_value(scope));
let registry_value = options.get(scope, v8str(scope, "customElementRegistry").into());
let fallback_registry = match registry_value {
Some(value) if value.is_null() => {
throw_type_error(
scope,
"Document.importNode customElementRegistry cannot be null.",
);
let options = match webidl::parse_dictionary::<ImportNodeDictionary>(
scope,
value,
webidl::Context::argument("Document.importNode", 2),
) {
Ok(options) => options.unwrap_or_default(),
Err(error) => {
webidl::throw_error(scope, &error);
return None;
}
Some(value) => custom_elements::registry_association_from_value(scope, value),
None => None,
};
let fallback_registry = options.custom_element_registry.and_then(|registry| {
let target = moli_webapi_declare::web_api_object_target(scope, registry)
.expect("converted CustomElementRegistry has native identity");
custom_elements::registry_association_from_value(scope, target.into())
});
Some(ImportNodeOptions {
deep: !self_only,
deep: !options.self_only,
fallback_registry,
})
}
@@ -79,10 +79,10 @@ struct DetachedDocumentCommonMethodsDeclaration {
#[webapi(method, callback = detached_create_processing_instruction_method_callback)]
create_processing_instruction: (),
#[webapi(method, callback = detached_import_node_method_callback)]
#[webapi(method, length = 1, callback = detached_import_node_method_callback, receiver = web_api_interfaces::Document::is_instance)]
import_node: (),
#[webapi(method, callback = detached_adopt_node_method_callback)]
#[webapi(method, length = 1, callback = detached_adopt_node_method_callback, receiver = web_api_interfaces::Document::is_instance)]
adopt_node: (),
#[webapi(
@@ -316,14 +316,51 @@ pub(in crate::native_bridge::document) fn detached_create_cdata_section_html_met
);
}
detached_bridge_method_forwarder!(
detached_import_node_method_callback,
"__cloneNodeIntoDocument"
);
detached_bridge_method_forwarder!(
detached_adopt_node_method_callback,
"__adoptNodeIntoDocument"
);
pub(in crate::native_bridge) fn detached_import_node_method_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let receiver = moli_webapi_declare::web_api_object_target(scope, args.this())
.expect("binding validated Document receiver");
let Some(parsed) =
webidl::parse_args::<crate::native_bridge::node::RequiredNodeArgs>(scope, &args)
else {
return;
};
let node = moli_webapi_declare::web_api_object_target(scope, parsed.node)
.expect("converted Node has native identity");
if let Some(value) = call_global_bridge_method(
scope,
"__cloneNodeIntoDocument",
&[receiver.into(), node.into(), args.get(1)],
) {
rv.set(value);
}
}
pub(in crate::native_bridge) fn detached_adopt_node_method_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let receiver = moli_webapi_declare::web_api_object_target(scope, args.this())
.expect("binding validated Document receiver");
let Some(parsed) =
webidl::parse_args::<crate::native_bridge::node::RequiredNodeArgs>(scope, &args)
else {
return;
};
let node = moli_webapi_declare::web_api_object_target(scope, parsed.node)
.expect("converted Node has native identity");
if let Some(value) = call_global_bridge_method(
scope,
"__adoptNodeIntoDocument",
&[receiver.into(), node.into()],
) {
rv.set(value);
}
}
detached_bridge_method_forwarder!(
detached_get_element_by_id_method_callback,
"__detachedGetElementById"
@@ -4,6 +4,7 @@ use crate::native_bridge::document::{
};
use crate::native_bridge::set_wrapped_handle_or_null_for_receiver;
use crate::util::context_host_ptr_from_global_bridge;
use crate::web_api_interfaces;
use super::super::super::super::node::node_runtime_and_handle_from_object;
@@ -55,12 +56,13 @@ pub(in crate::native_bridge) fn bridge_clone_node_into_document_callback<'a>(
return;
};
let deep = options.deep;
if object_is_shadow_root(scope, node) {
if web_api_interfaces::Document::is_instance(scope, node) || object_is_shadow_root(scope, node)
{
throw_dom_exception(
scope,
"NotSupportedError",
9,
"This operation is not supported for ShadowRoot nodes.",
"Document and ShadowRoot nodes cannot be imported.",
);
return;
}
@@ -0,0 +1,158 @@
(async () => {
const checks = [], resources = [];
const check = (name, run) => {
let passed = false, error;
try { passed = run() === true; } catch (caught) { error = String(caught); }
checks.push({ name, passed, ...(error === undefined ? {} : { error }) });
};
const capture = run => { try { run(); } catch (error) { return error; } };
const frame = document.createElement('iframe');
document.body.appendChild(frame);
resources.push(frame);
const popup = window.open('about:blank');
if (popup) resources.push({ remove() { popup.close(); } });
try {
for (const [realmName, w] of [['main', window], ['iframe', frame.contentWindow], ['popup', popup]]) {
if (!w) { check(`${realmName}/realm available`, () => false); continue; }
const providers = [
['live', () => w.document],
['html', () => w.document.implementation.createHTMLDocument('')],
['xml', () => w.document.implementation.createDocument(null, 'root')],
['parser-html', () => new w.DOMParser().parseFromString('<p>fixture</p>', 'text/html')],
['parser-xml', () => new w.DOMParser().parseFromString('<root/>', 'application/xml')],
];
for (const [provider, create] of providers) {
const doc = create(), prefix = `${realmName}/${provider}`;
const methods = { importNode: doc.importNode, adoptNode: doc.adoptNode };
for (const name of ['importNode', 'adoptNode']) {
check(`${prefix}/${name} reflection`, () => methods[name].name === name && methods[name].length === 1);
}
const real = doc.createElement('section');
const revoked = w.Proxy.revocable(real, {}); revoked.revoke();
const invalid = [
['undefined', undefined], ['null', null], ['number', 1], ['boolean', true],
['string', 'node'], ['symbol', w.Symbol('node')], ['bigint', 1n],
['object', {}], ['array', []], ['function', () => {}],
['Node prototype', Object.create(w.Node.prototype)],
['inherits real', Object.create(real)], ['author Proxy', new w.Proxy(real, {})],
['revoked Proxy', revoked.proxy], ['spoof element', { nodeType: 1, nodeName: 'DIV', childNodes: [] }],
['spoof document', { nodeType: 9, nodeName: '#document' }],
];
for (const [caseName, node] of invalid) {
for (const name of ['importNode', 'adoptNode']) {
check(`${prefix}/${name} rejects ${caseName} before options`, () => {
let reads = 0;
const options = { get customElementRegistry() { reads++; return undefined; }, get selfOnly() { reads++; return false; } };
const error = capture(() => methods[name].call(doc, node, options));
return error instanceof w.TypeError && reads === 0;
});
}
}
for (const name of ['importNode', 'adoptNode']) {
check(`${prefix}/${name} required Node`, () => capture(() => methods[name].call(doc)) instanceof w.TypeError);
check(`${prefix}/${name} rejects receiver before options`, () => {
let reads = 0;
const options = { get selfOnly() { reads++; throw new Error('wrong order'); } };
const error = capture(() => methods[name].call({}, real, options));
return error instanceof w.TypeError && reads === 0;
});
}
for (const name of ['importNode', 'adoptNode']) {
check(`${prefix}/${name} rejects trapping author Proxy`, () => {
let traps = 0, reads = 0;
const node = new w.Proxy(real, { get() { traps++; throw new Error('node trap'); }, getPrototypeOf() { traps++; throw new Error('prototype trap'); } });
const options = { get selfOnly() { reads++; return false; } };
const error = capture(() => methods[name].call(doc, node, options));
return error instanceof w.TypeError && traps === 0 && reads === 0;
});
}
const parent = doc.createElement('div'); parent.appendChild(doc.createTextNode('\ud800 text'));
const optionCases = [
['missing', [], false], ['undefined', [undefined], false], ['false', [false], false],
['true', [true], true], ['null dictionary', [null], true],
['zero', [0], false], ['NaN', [NaN], false], ['one', [1], true],
['empty string', [''], false], ['string', ['false'], true],
['zero bigint', [0n], false], ['bigint', [2n], true], ['symbol', [w.Symbol('deep')], true],
['empty dictionary', [{}], true], ['dictionary selfOnly true', [{ selfOnly: true }], false],
['dictionary selfOnly false', [{ selfOnly: false }], true], ['array dictionary', [[]], true],
['function dictionary', [() => {}], true], ['boxed false dictionary', [new w.Boolean(false)], true],
['truthy selfOnly', [{ selfOnly: { valueOf() { throw new Error('ToBoolean has no conversion hooks'); } } }], false],
['undefined registry', [{ customElementRegistry: undefined }], true],
];
for (const [caseName, supplied, deep] of optionCases) {
check(`${prefix}/importNode ${caseName}`, () => {
const clone = methods.importNode.call(doc, parent, ...supplied);
return clone !== parent && clone.ownerDocument === doc && clone.parentNode === null &&
clone.childNodes.length === (deep ? 1 : 0) && (!deep || clone.firstChild.data === '\ud800 text') &&
parent.childNodes.length === 1;
});
}
check(`${prefix}/dictionary lexical member order`, () => {
const reads = [];
const options = new w.Proxy({}, { get(target, key) { reads.push(key); return undefined; } });
const clone = methods.importNode.call(doc, parent, options);
return clone.childNodes.length === 1 && reads.join(',') === 'customElementRegistry,selfOnly';
});
for (const member of ['customElementRegistry', 'selfOnly']) {
check(`${prefix}/${member} getter exception identity and stop`, () => {
const marker = {}, reads = [];
const options = new w.Proxy({}, { get(target, key) { reads.push(key); if (key === member) throw marker; return undefined; } });
const error = capture(() => methods.importNode.call(doc, parent, options));
return error === marker && reads.join(',') === (member === 'customElementRegistry' ? member : 'customElementRegistry,selfOnly') && parent.childNodes.length === 1;
});
}
const registryRevoked = w.Proxy.revocable(w.customElements, {}); registryRevoked.revoke();
const badRegistries = [
['null', null], ['boolean', true], ['number', 1], ['string', 'registry'],
['symbol', w.Symbol('registry')], ['object', {}],
['forged', Object.create(w.CustomElementRegistry.prototype)],
['inherits real', Object.create(w.customElements)],
['author Proxy', new w.Proxy(w.customElements, {})], ['revoked Proxy', registryRevoked.proxy],
];
for (const [caseName, registry] of badRegistries) {
check(`${prefix}/registry rejects ${caseName} before selfOnly`, () => {
let reads = 0;
const error = capture(() => methods.importNode.call(doc, parent, { customElementRegistry: registry, get selfOnly() { reads++; return true; } }));
return error instanceof w.TypeError && reads === 0;
});
}
for (const [name, type, code] of [['importNode', 'NotSupportedError', 9], ['adoptNode', 'NotSupportedError', 9]]) {
check(`${prefix}/${name} rejects Document`, () => {
const error = capture(() => methods[name].call(doc, doc));
return error instanceof w.DOMException && error.name === type && error.code === code;
});
}
const shadowHost = doc.createElementNS('http://www.w3.org/1999/xhtml', 'div'), root = shadowHost.attachShadow({ mode: 'closed' });
for (const [name, type, code] of [['importNode', 'NotSupportedError', 9], ['adoptNode', 'HierarchyRequestError', 3]]) {
check(`${prefix}/${name} rejects ShadowRoot`, () => {
const error = capture(() => methods[name].call(doc, root));
return error instanceof w.DOMException && error.name === type && error.code === code;
});
}
for (const node of [doc, root]) {
check(`${prefix}/conversion precedes prohibited ${node === doc ? 'Document' : 'ShadowRoot'} algorithm`, () => {
const marker = {};
return capture(() => methods.importNode.call(doc, node, { get customElementRegistry() { throw marker; } })) === marker;
});
}
for (const [kind, make] of [
['element', () => doc.createElement('p')], ['text', () => doc.createTextNode('\udfff')],
['comment', () => doc.createComment('\ud800')], ['fragment', () => doc.createDocumentFragment()],
['pi', () => doc.createProcessingInstruction('fixture', 'text')],
]) {
check(`${prefix}/importNode genuine ${kind}`, () => {
const source = make(), clone = methods.importNode.call(doc, source);
return clone !== source && clone.nodeType === source.nodeType && clone.ownerDocument === doc && clone.parentNode === null;
});
check(`${prefix}/adoptNode genuine ${kind}`, () => {
const source = make(); parent.appendChild(source);
return methods.adoptNode.call(doc, source) === source && source.ownerDocument === doc && source.parentNode === null;
});
}
}
}
globalThis.__documentImportAdoptResults = { complete: true, total: checks.length, passed: checks.filter(row => row.passed).length, checks };
globalThis.__uiEventResults = globalThis.__documentImportAdoptResults;
return true;
} finally { for (const resource of resources.reverse()) resource.remove(); }
})()
@@ -0,0 +1,78 @@
use super::*;
#[test]
fn document_import_and_adopt_use_webidl_node_and_dictionary_conversion() {
let mut vm = new_storage_page_task_executor_test_vm("https://document-import-adopt.test/");
vm.eval(include_str!("document_import_adopt_webidl.js"))
.expect("Document import/adopt WebIDL matrix should evaluate");
assert_eq!(
vm.eval("JSON.stringify(__documentImportAdoptResults.checks.filter(row => !row.passed))")
.unwrap(),
"[]"
);
assert_eq!(
vm.eval("__documentImportAdoptResults.complete && __documentImportAdoptResults.total === 1350 && __documentImportAdoptResults.passed === 1350")
.unwrap(),
"true"
);
}
#[test]
fn document_import_and_adopt_accept_registered_native_proxy_arguments_and_receivers() {
let mut vm = new_storage_page_task_executor_test_vm("https://document-import-proxy.test/");
vm.eval(
r#"
globalThis.__importElement = document.createElement('section');
__importElement.appendChild(document.createTextNode('text'));
globalThis.__importDocument = document;
globalThis.__importRegistry = customElements;
globalThis.__importTraps = 0;
globalThis.__importTrap = () => { __importTraps++; throw Error('author trap'); };
"#,
)
.unwrap();
let context_ptr = &vm.page_default_context as *const _;
vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
let global = scope.get_current_context().global(scope);
let key = crate::util::v8str(scope, "__importTrap");
let trap = global.get(scope, key.into()).unwrap();
for name in ["Element", "Document", "Registry"] {
let key = crate::util::v8_string(scope, &format!("__import{name}")).unwrap();
let target = global.get(scope, key.into()).unwrap();
let target = v8::Local::<v8::Object>::try_from(target).unwrap();
let handler = crate::util::new_null_prototype_object(scope);
let key = crate::util::v8str(scope, "get");
assert_eq!(
handler.create_data_property(scope, key.into(), trap),
Some(true)
);
let proxy = v8::Proxy::new(scope, target, handler).unwrap();
moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();
let key = crate::util::v8_string(scope, &format!("__import{name}Proxy")).unwrap();
assert_eq!(
global.create_data_property(scope, key.into(), proxy.into()),
Some(true)
);
}
Ok(())
})
.unwrap();
assert_eq!(vm.eval(r#"(() => {
const clone = Document.prototype.importNode.call(__importDocumentProxy, __importElementProxy,
{ customElementRegistry: __importRegistryProxy, selfOnly: true });
if (clone === __importElement || clone.ownerDocument !== document || clone.childNodes.length !== 0) return 'clone';
if (Document.prototype.adoptNode.call(__importDocumentProxy, __importElementProxy) !== __importElement) return 'adopt';
for (const [method, receiver, node] of [
['importNode', __importDocumentProxy, new Proxy(__importElementProxy, {})],
['adoptNode', __importDocumentProxy, new Proxy(__importElementProxy, {})],
['importNode', new Proxy(__importDocumentProxy, {}), __importElementProxy],
['adoptNode', new Proxy(__importDocumentProxy, {}), __importElementProxy],
]) {
let reads = 0, error;
try { Document.prototype[method].call(receiver, node, { get customElementRegistry() { reads++; return undefined; } }); }
catch (caught) { error = caught; }
if (!(error instanceof TypeError) || reads !== 0) return 'author proxy';
}
return __importTraps === 0 ? 'ok' : 'trap';
})()"#).unwrap(), "ok");
}
@@ -992,7 +992,7 @@ fn document_template_methods_keep_declared_reflection_shape() {
["createDocumentFragment", 0],
["createProcessingInstruction", 2],
["createCDATASection", 1],
["importNode", 2],
["importNode", 1],
["adoptNode", 1],
["write", 0],
["writeln", 0],
@@ -3454,7 +3454,7 @@ fn shadow_root_init_state_reflects_attach_shadow_options() {
}
#[test]
fn clonable_shadow_roots_are_copied_by_host_clone_node() {
let mut vm = new_storage_test_vm("https://shadow-root-clonable.test/");
let mut vm = new_storage_page_task_executor_test_vm("https://shadow-root-clonable.test/");
let result = vm
.eval(
@@ -3492,28 +3492,26 @@ fn clonable_shadow_roots_are_copied_by_host_clone_node() {
closedCloneDuplicate = error && error.name;
}
const foreignElement = (localName) => ({
nodeType: 1,
localName,
namespaceURI: 'http://www.w3.org/1999/xhtml',
prefix: null,
childNodes: [],
getAttributeNames() { return []; },
getAttribute() { return null; }
});
const implicitForeignShadowHost = foreignElement('div');
implicitForeignShadowHost.shadowRoot = {
mode: 'open',
childNodes: [foreignElement('span')]
};
let forgedNodeError;
try {
document.importNode({ nodeType: 1, localName: 'div', childNodes: [] }, true);
} catch (error) {
forgedNodeError = error;
}
if (!(forgedNodeError instanceof TypeError)) throw Error('importNode must reject forged Nodes');
const frame = document.createElement('iframe');
document.body.appendChild(frame);
const foreignDocument = frame.contentDocument;
const implicitForeignShadowHost = foreignDocument.createElement('div');
implicitForeignShadowHost.attachShadow({ mode: 'open' })
.appendChild(foreignDocument.createElement('span'));
const implicitForeignShadowClone = document.importNode(implicitForeignShadowHost, true);
const clonableForeignShadowHost = foreignElement('section');
clonableForeignShadowHost.shadowRoot = {
mode: 'open',
clonable: true,
childNodes: [foreignElement('strong')]
};
const clonableForeignShadowHost = foreignDocument.createElement('section');
clonableForeignShadowHost.attachShadow({ mode: 'open', clonable: true })
.appendChild(foreignDocument.createElement('strong'));
const clonableForeignShadowClone = document.importNode(clonableForeignShadowHost, true);
frame.remove();
const template = document.createElement('template');
const svgNs = 'http://www.w3.org/2000/svg';
@@ -2328,6 +2328,7 @@ mod svg_length_native_receivers;
mod gamepad_interfaces;
mod document_create_event;
mod document_import_adopt_webidl;
mod dom_elements;
mod dom_exception_proxy_identity;