mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(dom): derive import and adoption argument conversion
This commit is contained in:
@@ -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,
|
||||
})
|
||||
}
|
||||
|
||||
+2
-2
@@ -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
-2
@@ -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");
|
||||
}
|
||||
+1
-1
@@ -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;
|
||||
|
||||
|
||||
Reference in New Issue
Block a user