diff --git a/moli-renderer-v8/src/native_bridge/document.rs b/moli-renderer-v8/src/native_bridge/document.rs index ce2212a05e0..79a102c19e7 100644 --- a/moli-renderer-v8/src/native_bridge/document.rs +++ b/moli-renderer-v8/src/native_bridge/document.rs @@ -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: (), diff --git a/moli-renderer-v8/src/native_bridge/document/construction.rs b/moli-renderer-v8/src/native_bridge/document/construction.rs index 39e6c3ede02..9e2064cdc83 100644 --- a/moli-renderer-v8/src/native_bridge/document/construction.rs +++ b/moli-renderer-v8/src/native_bridge/document/construction.rs @@ -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 { - 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; }; diff --git a/moli-renderer-v8/src/native_bridge/document/construction/import_adopt.rs b/moli-renderer-v8/src/native_bridge/document/construction/import_adopt.rs index 4aa90478557..c338494b30c 100644 --- a/moli-renderer-v8/src/native_bridge/document/construction/import_adopt.rs +++ b/moli-renderer-v8/src/native_bridge/document/construction/import_adopt.rs @@ -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::(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::::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::(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::::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; diff --git a/moli-renderer-v8/src/native_bridge/document/custom_element_options.rs b/moli-renderer-v8/src/native_bridge/document/custom_element_options.rs index d4a24d8b876..1a815b606cf 100644 --- a/moli-renderer-v8/src/native_bridge/document/custom_element_options.rs +++ b/moli-renderer-v8/src/native_bridge/document/custom_element_options.rs @@ -155,42 +155,48 @@ pub(in crate::native_bridge::document) struct ImportNodeOptions { Option, } -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>, + #[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 { - 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::( + 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, }) } diff --git a/moli-renderer-v8/src/native_bridge/document/detached_install/bridge_methods/document.rs b/moli-renderer-v8/src/native_bridge/document/detached_install/bridge_methods/document.rs index 3171df888a9..f0943e5ee46 100644 --- a/moli-renderer-v8/src/native_bridge/document/detached_install/bridge_methods/document.rs +++ b/moli-renderer-v8/src/native_bridge/document/detached_install/bridge_methods/document.rs @@ -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( diff --git a/moli-renderer-v8/src/native_bridge/document/detached_objects/method_forwarders.rs b/moli-renderer-v8/src/native_bridge/document/detached_objects/method_forwarders.rs index 4663a291e16..fdfd48195f7 100644 --- a/moli-renderer-v8/src/native_bridge/document/detached_objects/method_forwarders.rs +++ b/moli-renderer-v8/src/native_bridge/document/detached_objects/method_forwarders.rs @@ -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::(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::(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" diff --git a/moli-renderer-v8/src/native_bridge/document/detached_surface/creation/clone_adopt.rs b/moli-renderer-v8/src/native_bridge/document/detached_surface/creation/clone_adopt.rs index 98e9bd0e7ba..0fc1bbdb7da 100644 --- a/moli-renderer-v8/src/native_bridge/document/detached_surface/creation/clone_adopt.rs +++ b/moli-renderer-v8/src/native_bridge/document/detached_surface/creation/clone_adopt.rs @@ -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; } diff --git a/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.js b/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.js new file mode 100644 index 00000000000..65ca2a595fe --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.js @@ -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('

fixture

', 'text/html')], + ['parser-xml', () => new w.DOMParser().parseFromString('', '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(); } +})() diff --git a/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.rs b/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.rs new file mode 100644 index 00000000000..05d1456d441 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/document_import_adopt_webidl.rs @@ -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::::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"); +} diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/document_state_and_form_controls.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/document_state_and_form_controls.rs index 27b50ea9bc9..267c2dbf677 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/document_state_and_form_controls.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/detached/document_state_and_form_controls.rs @@ -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], diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs index 39a9cb324c9..63f0d6c678f 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs @@ -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'; diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index b59ed9cd125..7b6856416ae 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -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;