diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs index e681086b8eb..0d09d4f05d9 100644 --- a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs +++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page.rs @@ -6,6 +6,7 @@ mod auxiliary_page_identity; mod auxiliary_page_retirement; mod blank_navigation_inheritance; mod browser_close; +mod native_node_adoption; mod noopener_blank_inheritance; mod popup_navigation_referrer; mod target_opening; diff --git a/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/native_node_adoption.rs b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/native_node_adoption.rs new file mode 100644 index 00000000000..8dcdd793017 --- /dev/null +++ b/moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/native_node_adoption.rs @@ -0,0 +1,302 @@ +use super::auxiliary_page_identity::open_auxiliary; +use super::*; + +// A ScriptVm popup can share its native host with its opener. Publish and +// attach the auxiliary CDP target so these cases exercise two actual Pages. +#[tokio::test(flavor = "multi_thread")] +async fn borrowed_event_target_methods_use_the_native_node_owner() { + let (addr, server) = spawn_test_protocol_server().await; + let (mut browser, _) = + connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}")) + .await + .unwrap(); + let opener_id = create_dynamic_target(&mut browser, 1).await; + let mut opener = connect_dynamic_page(addr, &opener_id).await; + let (producer_id, _producer) = open_auxiliary( + addr, + &mut opener, + "window.foreignNode = p.document.createElement('div'); window.listenerCalls = 0", + ) + .await; + + assert_eq!( + evaluate_window_name_probe( + &mut opener, + 2, + r#"(() => { + const listener = () => { listenerCalls++; }; + EventTarget.prototype.addEventListener.call(foreignNode, 'test', listener); + const registered = EventTarget.prototype.dispatchEvent.call(foreignNode, new Event('test')) && listenerCalls === 1; + EventTarget.prototype.removeEventListener.call(foreignNode, 'test', listener); + foreignNode.dispatchEvent(new Event('test')); + const removed = listenerCalls === 1; + + const nativeProxy = p.document.implementation.createHTMLDocument('').createElement('select'); + let proxyCalls = 0; + EventTarget.prototype.addEventListener.call(nativeProxy, 'test', () => { proxyCalls++; }); + const registeredNativeProxy = EventTarget.prototype.dispatchEvent.call(nativeProxy, new Event('test')) && proxyCalls === 1; + + const localNode = document.createElement('div'); + let reverseCalls = 0; + const reverseListener = () => { reverseCalls++; }; + p.EventTarget.prototype.addEventListener.call(localNode, 'test', reverseListener); + p.EventTarget.prototype.dispatchEvent.call(localNode, new Event('test')); + p.EventTarget.prototype.removeEventListener.call(localNode, 'test', reverseListener); + localNode.dispatchEvent(new Event('test')); + + let conversions = 0, proxyError, forgedError; + const type = {toString() { conversions++; return 'test'; }}; + try { EventTarget.prototype.addEventListener.call(new Proxy(foreignNode, {}), type, listener); } + catch (error) { proxyError = error; } + try { p.EventTarget.prototype.addEventListener.call(Object.create(foreignNode), type, listener); } + catch (error) { forgedError = error; } + return { + registered, removed, registeredNativeProxy, + reverseOwner: reverseCalls === 1, + proxyCalleeRealm: proxyError instanceof TypeError && !(proxyError instanceof p.TypeError), + forgedCalleeRealm: forgedError instanceof p.TypeError && !(forgedError instanceof TypeError), + receiverBeforeConversion: conversions === 0 + }; + })()"#, + ) + .await, + json!({ + "registered": true, + "removed": true, + "registeredNativeProxy": true, + "reverseOwner": true, + "proxyCalleeRealm": true, + "forgedCalleeRealm": true, + "receiverBeforeConversion": true + }) + ); + evaluate_window_name_probe(&mut opener, 3, "p.close(); true").await; + wait_for_target_list(addr, "the producer Page has closed", |targets| { + !targets.iter().any(|target| target["id"] == producer_id) + }) + .await; + assert_eq!( + evaluate_window_name_probe( + &mut opener, + 4, + "EventTarget.prototype.dispatchEvent.call(foreignNode, new Event('test')) && listenerCalls === 1" + ) + .await, + true + ); + abort_test_cdp_server(server).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn native_adoption_preserves_views_and_callbacks_across_pages() { + let (addr, server) = spawn_test_protocol_server().await; + let (mut browser, _) = + connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}")) + .await + .unwrap(); + let opener_id = create_dynamic_target(&mut browser, 1).await; + let mut opener = connect_dynamic_page(addr, &opener_id).await; + let (producer_id, _producer) = open_auxiliary( + addr, + &mut opener, + r#" + window.sourceDocument = p.document; + window.root = sourceDocument.createElement('section'); + window.unmoved = sourceDocument.createElement('div'); + sourceDocument.body.appendChild(unmoved); + for (let index = 0; index < 1200; index++) { + const child = sourceDocument.createElement('span'); + child.id = 'child-' + index; + root.appendChild(child); + } + sourceDocument.body.appendChild(root); + window.first = root.firstChild; + window.last = root.lastChild; + window.originalPrototype = Object.getPrototypeOf(root); + window.children = root.childNodes; + window.tags = root.getElementsByTagName('span'); + window.snapshot = root.querySelectorAll('span'); + window.mixed = sourceDocument.querySelectorAll('div, span'); + window.style = root.style; + window.classes = root.classList; + window.dataset = root.dataset; + window.controller = new p.AbortController(); + window.listenerCalls = 0; + root.addEventListener('owned', () => { listenerCalls++; }, {signal: controller.signal}); + window.realmListener = new p.Function('event', 'this.callbackDocument = document; this.eventInSourceRealm = event instanceof Event;'); + root.addEventListener('realm', realmListener) + "#, + ) + .await; + assert_eq!( + evaluate_window_name_probe( + &mut opener, + 2, + r#"(() => { + const returnedOriginal = document.adoptNode(root) === root; + document.body.appendChild(root); + style.setProperty('color', 'red'); + classes.add('adopted'); + dataset.owner = 'target'; + root.dispatchEvent(new Event('owned')); + root.dispatchEvent(new Event('realm')); + const result = { + returnedOriginal, + prototypeRealm: Object.getPrototypeOf(root) === originalPrototype, + nativeOwners: root.ownerDocument === document && first.ownerDocument === document && last.ownerDocument === document, + liveSameObject: root.childNodes === children && children.length === 1200 && children[0] === first, + tags: tags.length === 1200 && tags[1199] === last, + staticItems: snapshot.length === 1200 && snapshot[0] === first && snapshot.item(1199) === last, + staticDescriptor: Object.getOwnPropertyDescriptor(snapshot, '0').value === first, + staticIterator: Array.from(snapshot)[1199] === last, + mixedOwners: mixed.length === 1201 && mixed[0] === unmoved && unmoved.ownerDocument === sourceDocument && mixed[1200] === last, + retainedViews: root.style === style && root.classList === classes && root.dataset === dataset && root.getAttribute('data-owner') === 'target' && root.className === 'adopted' && root.style.color === 'red', + listenerMoved: listenerCalls === 1, + callbackRealm: root.callbackDocument === sourceDocument && root.eventInSourceRealm === false + }; + controller.abort(); + root.dispatchEvent(new Event('owned')); + result.signalRemovesMovedListener = listenerCalls === 1; + first.remove(); + result.liveMutation = children.length === 1199 && tags.length === 1199 && children[0].id === 'child-1'; + result.staticRemovedNode = snapshot[0] === first && first.parentNode === null && first.ownerDocument === document; + sourceDocument.adoptNode(root); + sourceDocument.body.appendChild(root); + result.secondAdoption = root.ownerDocument === sourceDocument && last.ownerDocument === sourceDocument && snapshot[1199] === last && tags[1198] === last && first.ownerDocument === document; + document.adoptNode(root); + document.body.appendChild(root); + result.thirdAdoption = root.ownerDocument === document && last.ownerDocument === document && snapshot[1199] === last && mixed[0] === unmoved && unmoved.ownerDocument === sourceDocument; + return result; + })()"#, + ) + .await, + json!({ + "returnedOriginal": true, + "prototypeRealm": true, + "nativeOwners": true, + "liveSameObject": true, + "tags": true, + "staticItems": true, + "staticDescriptor": true, + "staticIterator": true, + "mixedOwners": true, + "retainedViews": true, + "listenerMoved": true, + "callbackRealm": true, + "signalRemovesMovedListener": true, + "liveMutation": true, + "staticRemovedNode": true, + "secondAdoption": true, + "thirdAdoption": true + }) + ); + evaluate_window_name_probe(&mut opener, 3, "p.close(); true").await; + wait_for_target_list(addr, "adoption's producer Page has closed", |targets| { + !targets.iter().any(|target| target["id"] == producer_id) + }) + .await; + send_cdp_command( + &mut opener, + 4, + "HeapProfiler.collectGarbage", + None, + json!({}), + ) + .await; + assert_eq!( + evaluate_window_name_probe( + &mut opener, + 5, + r#"(() => { + root.dispatchEvent(new Event('realm')); + const callbackRealm = root.callbackDocument === sourceDocument && root.eventInSourceRealm === false; + root.removeEventListener('realm', realmListener); + root.callbackDocument = null; + root.dispatchEvent(new Event('realm')); + root.appendChild(document.createElement('span')); + return { + movedOwner: root.ownerDocument === document && last.ownerDocument === document, + mixedOwners: mixed[0] === unmoved && unmoved.ownerDocument === sourceDocument && mixed[1200] === last, + removedSnapshot: snapshot[0] === first && first.parentNode === null && first.ownerDocument === document, + liveMutation: children.length === 1200 && tags.length === 1200, + callbackRealm, + callbackRemoved: root.callbackDocument === null + }; + })()"#, + ) + .await, + json!({ + "movedOwner": true, + "mixedOwners": true, + "removedSnapshot": true, + "liveMutation": true, + "callbackRealm": true, + "callbackRemoved": true + }) + ); + abort_test_cdp_server(server).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn retained_closed_page_materializes_nodes_in_their_owner_realm() { + let (addr, server) = spawn_test_protocol_server().await; + let (mut browser, _) = + connect_async(format!("ws://{addr}/devtools/browser/{DEFAULT_BROWSER_ID}")) + .await + .unwrap(); + let opener_id = create_dynamic_target(&mut browser, 1).await; + let mut opener = connect_dynamic_page(addr, &opener_id).await; + let (producer_id, _producer) = open_auxiliary( + addr, + &mut opener, + r#" + window.retainedDocument = p.document; + window.retainedBody = retainedDocument.body; + window.producerElementPrototype = p.HTMLElement.prototype; + retainedBody.innerHTML = '
original
' + "#, + ) + .await; + evaluate_window_name_probe(&mut opener, 2, "p.close(); true").await; + wait_for_target_list(addr, "the retained Document's Page has closed", |targets| { + !targets.iter().any(|target| target["id"] == producer_id) + }) + .await; + send_cdp_command( + &mut opener, + 3, + "HeapProfiler.collectGarbage", + None, + json!({}), + ) + .await; + assert_eq!( + evaluate_window_name_probe( + &mut opener, + 4, + r#"(() => { + const getter = Object.getOwnPropertyDescriptor(Node.prototype, 'firstChild').get; + const child = getter.call(retainedBody); + const freshStyle = getComputedStyle(child); + child.dataset.afterClose = 'yes'; + child.firstChild.textContent = 'changed'; + return { + nativeOwner: child.ownerDocument === retainedDocument, + producerPrototype: producerElementPrototype.isPrototypeOf(child), + nativeRead: child.id === 'late' && child.tagName === 'ARTICLE', + nativeMutation: retainedBody.firstChild === child && retainedBody.textContent === 'changed' && child.getAttribute('data-after-close') === 'yes', + freshStyle: freshStyle.color === 'rgb(255, 0, 0)' + }; + })()"#, + ) + .await, + json!({ + "nativeOwner": true, + "producerPrototype": true, + "nativeRead": true, + "nativeMutation": true, + "freshStyle": true + }) + ); + abort_test_cdp_server(server).await; +} diff --git a/moli-renderer-v8/src/document_runtime/dom_facade.rs b/moli-renderer-v8/src/document_runtime/dom_facade.rs index 093b09d7f80..80df69b6583 100644 --- a/moli-renderer-v8/src/document_runtime/dom_facade.rs +++ b/moli-renderer-v8/src/document_runtime/dom_facade.rs @@ -13,6 +13,15 @@ use html5ever::tree_builder::QuirksMode; // they are the "basic DOM access" layer that other modules depend on, but they do not define // selector semantics or orchestrate mutation side effects on their own. impl DocumentRuntime { + pub(crate) fn transfer_native_event_targets_from( + &mut self, + source: &mut Self, + handles: &HashMap, + ) -> HashSet { + self.events + .transfer_node_targets_from(&mut source.events, handles) + } + pub(crate) fn document_design_mode_enabled(&self, document: DomHandle) -> bool { self.dom_host .document_design_mode_enabled_for_handle(document) diff --git a/moli-renderer-v8/src/host/events.rs b/moli-renderer-v8/src/host/events.rs index 4171da9e828..3b10174c118 100644 --- a/moli-renderer-v8/src/host/events.rs +++ b/moli-renderer-v8/src/host/events.rs @@ -222,6 +222,71 @@ impl Default for HostEventTargetRegistry { } } +impl HostEventTargetRegistry { + pub(crate) fn transfer_node_targets_from( + &mut self, + source: &mut Self, + handles: &HashMap, + ) -> HashSet { + let mut callbacks = HashSet::new(); + for (&old, &new) in handles { + let old = EventTargetHandle::Node(old); + let new = EventTargetHandle::Node(new); + let mut listeners = source.listeners.remove(&old).unwrap_or_default(); + let mut handlers = source.handler_properties.remove(&old).unwrap_or_default(); + let mut event_types = source + .event_type_registration_ids + .remove(&old) + .unwrap_or_default(); + let mut ids = std::collections::BTreeSet::new(); + for entries in listeners.values() { + ids.extend(entries.iter().map(|entry| entry.id)); + } + ids.extend(handlers.values().filter_map(|entry| entry.listener_id)); + ids.extend(event_types.values().copied()); + let ids = ids + .into_iter() + .map(|old| (old, self.allocate_listener_id())) + .collect::>(); + for entries in listeners.values_mut() { + for entry in entries { + entry.id = ids[&entry.id]; + callbacks.insert(entry.callback_id); + } + } + for entry in handlers.values_mut() { + entry.listener_id = entry.listener_id.map(|id| ids[&id]); + match &mut entry.state { + EventHandlerPropertyState::Callback(id) => { + callbacks.insert(*id); + } + EventHandlerPropertyState::Uncompiled(handle) => { + *handle = handles[handle]; + } + EventHandlerPropertyState::Null => {} + } + } + for id in event_types.values_mut() { + *id = ids[id]; + } + if !listeners.is_empty() { + assert!(self.listeners.insert(new, listeners).is_none()); + } + if !handlers.is_empty() { + assert!(self.handler_properties.insert(new, handlers).is_none()); + } + if !event_types.is_empty() { + assert!( + self.event_type_registration_ids + .insert(new, event_types) + .is_none() + ); + } + } + callbacks + } +} + impl fmt::Debug for HostEventTargetRegistry { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("HostEventTargetRegistry") diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rs index 6e771654141..a9f3036c750 100644 --- a/moli-renderer-v8/src/native_bridge/abort.rs +++ b/moli-renderer-v8/src/native_bridge/abort.rs @@ -492,8 +492,21 @@ pub(crate) fn abort_signal<'s>( v8::tc_scope!(let scope, scope); if event::invoke_abort_algorithms(scope, signal, reason, dispatch.algorithms) { for linked in dispatch.linked_target_listeners { + let (host_ptr, target) = match linked.target { + EventTargetHandle::Node(handle) => { + let Some((owner, handle)) = unsafe { &*host_ptr } + .native_bridge() + .identity + .resolve_node_ownership(scope, host_ptr, handle) + else { + continue; + }; + (owner, EventTargetHandle::Node(handle)) + } + target => (host_ptr, target), + }; unsafe { &mut *host_ptr }.remove_registered_event_listener_by_id( - linked.target, + target, &linked.event_type, linked.callback_id, linked.capture, diff --git a/moli-renderer-v8/src/native_bridge/bridge/wrappers.rs b/moli-renderer-v8/src/native_bridge/bridge/wrappers.rs index 1c5e5b32c15..f2bc3ebd74b 100644 --- a/moli-renderer-v8/src/native_bridge/bridge/wrappers.rs +++ b/moli-renderer-v8/src/native_bridge/bridge/wrappers.rs @@ -65,23 +65,29 @@ impl NativeDomBridge { handle: BridgeHandle, identity: BridgeWrapperIdentity, ) -> Option> { + let current = scope.get_current_context(); let current_host = - crate::util::context_host_ptr_from_context_slot(scope.get_current_context())?; + crate::util::context_host_ptr_from_context_slot(current)?; let foreign_host = current_host != host_ptr; - if identity == BridgeWrapperIdentity::Canonical && foreign_host { - // Reflector IDs are local to a DOM bridge. Related Pages share - // an isolate, but must never consult one another's wrapper cache. - let host = unsafe { &*host_ptr }; - let dispatch_scope = crate::native_bridge::OwnerDispatchScope::Top; - let owner = host.current_window_execution_context_owner(dispatch_scope)?; - let context = host - .window_execution_context(scope, owner, dispatch_scope)? - .1; - let scope = &mut v8::ContextScope::new(scope, context); + let producer = if handle.node_handle().is_some() { + self.identity.node_owner_context(scope, host_ptr) + } else { + unsafe { &*host_ptr }.page_default_context(scope) + }; + if identity == BridgeWrapperIdentity::Canonical + && foreign_host + && let Some(producer) = producer + && super::super::identity::contexts_share_wrapper_world(current, producer) + { + // One-field wrappers resolve their native host from the creation + // context. Canonical wrappers retain their producer realm. + let scope = &mut v8::ContextScope::new(scope, producer); return self.materialize_bridge_wrapper(scope, host_ptr, handle, identity); } - let native_owner = if identity == BridgeWrapperIdentity::NewObject && foreign_host { - let producer = unsafe { &*host_ptr }.page_default_context(scope)?; + let native_owner = if foreign_host + && (identity == BridgeWrapperIdentity::NewObject || handle.node_handle().is_some()) + { + let producer = producer?; let scope = &mut v8::ContextScope::new(scope, producer); Some(v8::Global::new(scope, v8::Object::new(scope))) } else { @@ -96,9 +102,14 @@ impl NativeDomBridge { return Some(wrapper); } - let wrapper = self - .bindings - .instantiate_wrapper(scope, host_ptr, handle, reflector_id); + let wrapper = + self.bindings + .instantiate_wrapper(scope, host_ptr, handle.clone(), reflector_id); + if let Some(node) = handle.node_handle() { + self.identity + .node_ownership(scope, host_ptr, node) + .bind(scope, wrapper); + } if let Some(owner) = native_owner { let owner = v8::Local::new(scope, owner); crate::util::set_private_value( diff --git a/moli-renderer-v8/src/native_bridge/collections/builders.rs b/moli-renderer-v8/src/native_bridge/collections/builders.rs index 24df2c8e7de..6321920bcb0 100644 --- a/moli-renderer-v8/src/native_bridge/collections/builders.rs +++ b/moli-renderer-v8/src/native_bridge/collections/builders.rs @@ -339,6 +339,27 @@ pub(crate) fn build_static_handle_node_list_wrapper<'s>( host.native_bridge_mut().static_handle_collection_store() }; let collection_id = collections.borrow_mut().register(handles.to_vec()); + let anchors = v8::Array::new( + scope, + i32::try_from(handles.len()).expect("NodeList length fits V8"), + ); + anchors.set_prototype(scope, v8::null(scope).into()); + for (index, handle) in handles.iter().copied().enumerate() { + let ownership = unsafe { &mut *runtime_ptr } + .native_bridge_mut() + .identity + .node_ownership(scope, runtime_ptr, handle); + let anchor = ownership + .anchor(scope) + .expect("NodeList node has an owner realm"); + anchors.set_index(scope, index as u32, anchor.into()); + } + set_private_value( + scope, + wrapper, + "__moliStaticCollectionNodeOwners", + anchors.into(), + ); // Mutation records create short-lived snapshots frequently. Release the // native handle vector when its wrapper dies, without retaining the host. crate::v8_finalizer::track_context_owned_v8_finalizer(scope, wrapper, move || { @@ -403,6 +424,11 @@ pub(in crate::native_bridge) fn build_live_collection_wrapper<'s>( collection_id, descriptor.collection_kind, ); + unsafe { &mut *runtime_ptr } + .native_bridge_mut() + .identity + .node_ownership(scope, runtime_ptr, descriptor.root) + .bind(scope, wrapper); { let host = unsafe { &mut *runtime_ptr }; host.native_bridge_mut() diff --git a/moli-renderer-v8/src/native_bridge/collections/iteration.rs b/moli-renderer-v8/src/native_bridge/collections/iteration.rs index 39dbd83cc59..4299ef75ea5 100644 --- a/moli-renderer-v8/src/native_bridge/collections/iteration.rs +++ b/moli-renderer-v8/src/native_bridge/collections/iteration.rs @@ -38,7 +38,8 @@ pub(in crate::native_bridge::collections) fn collection_value_at<'s>( } if let Ok((runtime_ptr, collection_id)) = static_handle_collection_id_from_object(scope, object) { - let handle = static_handle_collection_handle_at(runtime_ptr, collection_id, index)?; + let (runtime_ptr, handle) = + static_handle_collection_handle_at(scope, runtime_ptr, collection_id, index)?; return Some(wrapped_handle_value(scope, runtime_ptr, handle).unwrap_or_else(|| { panic!( "failed to materialize handle-backed static collection handle `{handle:?}` at index `{index}`" diff --git a/moli-renderer-v8/src/native_bridge/collections/live_handlers.rs b/moli-renderer-v8/src/native_bridge/collections/live_handlers.rs index 07ea506ebaf..bde42c43894 100644 --- a/moli-renderer-v8/src/native_bridge/collections/live_handlers.rs +++ b/moli-renderer-v8/src/native_bridge/collections/live_handlers.rs @@ -398,8 +398,8 @@ pub(in crate::native_bridge::collections) fn static_handle_collection_indexed_ge let (runtime_ptr, collection_id) = static_handle_collection_id_from_object(scope, args.holder()) .expect("handle-backed static NodeList must retain its collection id"); - let Some(handle) = - static_handle_collection_handle_at(runtime_ptr, collection_id, index as usize) + let Some((runtime_ptr, handle)) = + static_handle_collection_handle_at(scope, runtime_ptr, collection_id, index as usize) else { return v8::Intercepted::kNo; }; @@ -467,8 +467,8 @@ pub(in crate::native_bridge::collections) fn static_handle_collection_indexed_de let (runtime_ptr, collection_id) = static_handle_collection_id_from_object(scope, args.holder()) .expect("handle-backed static NodeList must retain its collection id"); - let Some(handle) = - static_handle_collection_handle_at(runtime_ptr, collection_id, index as usize) + let Some((runtime_ptr, handle)) = + static_handle_collection_handle_at(scope, runtime_ptr, collection_id, index as usize) else { return v8::Intercepted::kNo; }; diff --git a/moli-renderer-v8/src/native_bridge/collections/shared.rs b/moli-renderer-v8/src/native_bridge/collections/shared.rs index 703c1bb4991..08b1a84cc30 100644 --- a/moli-renderer-v8/src/native_bridge/collections/shared.rs +++ b/moli-renderer-v8/src/native_bridge/collections/shared.rs @@ -33,12 +33,18 @@ pub(in crate::native_bridge::collections) fn live_collection_descriptor_from_obj ) -> std::result::Result<(*mut JsContextHost, LiveCollectionDescriptor), String> { let runtime_ptr = runtime_ptr_from_object(scope, object)?; let collection_id = object_collection_id(scope, object)?; - let descriptor = unsafe { &mut *runtime_ptr } + let mut descriptor = unsafe { &mut *runtime_ptr } .native_bridge_mut() .live_collection_descriptor(collection_id) .cloned() .ok_or_else(|| format!("missing live collection descriptor `{collection_id}`"))?; - Ok((runtime_ptr, descriptor)) + let (owner, root) = unsafe { &*runtime_ptr } + .native_bridge() + .identity + .resolve_node_ownership(scope, runtime_ptr, descriptor.root) + .ok_or_else(|| "live collection root has no owning realm".to_owned())?; + descriptor.root = root; + Ok((owner, descriptor)) } pub(in crate::native_bridge::collections) fn static_handle_collection_id_from_object<'s>( @@ -71,13 +77,18 @@ pub(in crate::native_bridge::collections) fn static_handle_collection_len( } pub(in crate::native_bridge::collections) fn static_handle_collection_handle_at( + scope: &mut v8::PinScope<'_, '_>, runtime_ptr: *mut JsContextHost, collection_id: u32, index: usize, -) -> Option { - unsafe { &mut *runtime_ptr } +) -> Option<(*mut JsContextHost, DomHandle)> { + let handle = unsafe { &mut *runtime_ptr } .native_bridge_mut() - .static_handle_collection_handle_at(collection_id, index) + .static_handle_collection_handle_at(collection_id, index)?; + unsafe { &*runtime_ptr } + .native_bridge() + .identity + .resolve_node_ownership(scope, runtime_ptr, handle) } pub(in crate::native_bridge::collections) fn object_collection_id( diff --git a/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs b/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs index 8e3f536b4c2..ea7d77c7e77 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs @@ -12,6 +12,29 @@ pub(super) struct CanvasResourceStore { } impl CanvasResourceStore { + pub(super) fn transfer_from( + &mut self, + source: &mut Self, + handles: &HashMap, + ) { + let mut changed = false; + for (&old, &new) in handles { + if let Some(pixels) = source.pixels_by_element.remove(&old) { + source.retained_bytes -= pixels.byte_len(); + self.retained_bytes = self + .retained_bytes + .checked_add(pixels.byte_len()) + .expect("retained canvas byte accounting fits usize"); + assert!(self.pixels_by_element.insert(new, pixels).is_none()); + changed = true; + } + } + if changed { + source.visual_generation.bump(); + self.visual_generation.bump(); + } + } + pub(super) fn new(visual_generation: VisualResourceGeneration) -> Self { Self { pixels_by_element: HashMap::new(), @@ -118,6 +141,37 @@ impl super::JsContextHost { mod tests { use super::*; + #[test] + fn ownership_transfer_preserves_canvas_pixels_and_both_hosts_accounting() { + let mut source = CanvasResourceStore::default(); + let mut target = CanvasResourceStore::default(); + let source_node = DomHandle::new(7); + let unmoved_source = DomHandle::new(8); + let target_node = DomHandle::new(12); + let unmoved_target = DomHandle::new(7); + assert!(source.replace(source_node, 1, 1, vec![1, 2, 3, 4])); + assert!(source.replace(unmoved_source, 1, 1, vec![5, 6, 7, 8])); + assert!(target.replace(unmoved_target, 1, 1, vec![9, 10, 11, 12])); + let retained = source.get(source_node).unwrap(); + target.transfer_from(&mut source, &HashMap::from([(source_node, target_node)])); + assert!(source.get(source_node).is_none()); + assert!(Arc::ptr_eq(&retained, &target.get(target_node).unwrap())); + assert_eq!(source.retained_bytes, 4); + assert_eq!(target.retained_bytes, 8); + assert_eq!(source.get(unmoved_source).unwrap().rgba, [5, 6, 7, 8]); + assert_eq!(target.get(unmoved_target).unwrap().rgba, [9, 10, 11, 12]); + source.transfer_from( + &mut target, + &HashMap::from([(target_node, DomHandle::new(20))]), + ); + assert!(Arc::ptr_eq( + &retained, + &source.get(DomHandle::new(20)).unwrap() + )); + assert_eq!(source.retained_bytes, 8); + assert_eq!(target.retained_bytes, 4); + } + #[test] fn replacing_a_canvas_resource_preserves_old_snapshot_arcs_and_exact_accounting() { let mut store = CanvasResourceStore::default(); diff --git a/moli-renderer-v8/src/native_bridge/context_host/event_callbacks.rs b/moli-renderer-v8/src/native_bridge/context_host/event_callbacks.rs index 41cb17ad283..36005506871 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/event_callbacks.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/event_callbacks.rs @@ -16,6 +16,7 @@ struct EventCallbackRecord { callback: WebIdlCallbackInterface, kind: EventCallbackKind, relevant_identity: Option, + registration_identity: Option, #[cfg(test)] incumbent_identity: Option, } @@ -97,17 +98,17 @@ impl PreparedEventCallback { #[derive(Default)] pub(super) struct EventCallbackRegistry { - next_id: u64, records: HashMap, } impl EventCallbackRegistry { fn allocate_id(&mut self) -> EventCallbackId { - self.next_id = self - .next_id - .checked_add(1) + use std::sync::atomic::{AtomicU64, Ordering}; + static NEXT_ID: AtomicU64 = AtomicU64::new(1); + let id = NEXT_ID + .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |id| id.checked_add(1)) .expect("event callback id overflow"); - EventCallbackId(self.next_id) + EventCallbackId(id) } fn take_owned_by(&mut self, owner: WindowExecutionContextOwner) -> HashSet { @@ -116,7 +117,7 @@ impl EventCallbackRegistry { .iter() .filter_map(|(id, record)| { record - .relevant_identity + .registration_identity .is_some_and(|identity| identity.owner() == owner) .then_some(*id) }) @@ -397,6 +398,7 @@ impl JsContextHost { callback, kind, relevant_identity, + registration_identity: relevant_identity, #[cfg(test)] incumbent_identity, }, @@ -481,7 +483,7 @@ impl JsContextHost { ) -> Option { let record = self.event_callbacks.records.get(&id)?; if record - .relevant_identity + .registration_identity .is_some_and(|identity| !self.window_execution_context_identity_is_current(identity)) { return None; @@ -489,10 +491,35 @@ impl JsContextHost { Some(PreparedEventCallback { callback: record.callback.prepare(scope), kind: record.kind, - relevant_identity: record.relevant_identity, + relevant_identity: record + .relevant_identity + .filter(|identity| self.window_execution_context_identity_is_current(*identity)), }) } + pub(in crate::native_bridge) fn transfer_node_event_callbacks_from( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + source: &mut Self, + callbacks: &HashSet, + owner: v8::Local<'_, v8::Context>, + ) { + let registration_identity = + self.window_execution_context_identity_for_v8_context(scope, owner); + for id in callbacks { + let mut record = source + .event_callbacks + .records + .remove(id) + .expect("native event registration has a callback record"); + // The target's lifetime moves; the callback's captured relevant and + // incumbent realms do not. Callback IDs are unique across hosts, + // so retained AbortSignal registrations continue to identify it. + record.registration_identity = registration_identity; + assert!(self.event_callbacks.records.insert(*id, record).is_none()); + } + } + pub(in crate::native_bridge::context_host) fn retire_event_callbacks_for_execution_context( &mut self, owner: WindowExecutionContextOwner, diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs index 50979f6a52d..c4d35fd5ec7 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -98,6 +98,7 @@ mod file_chooser; mod file_entry_file_callbacks; mod fixture_support; mod focus; +mod node_adoption; pub(crate) use focus::SequentialFocusStartingPoint; mod frame_document_ready_routes; mod hash_changes; diff --git a/moli-renderer-v8/src/native_bridge/context_host/node_adoption.rs b/moli-renderer-v8/src/native_bridge/context_host/node_adoption.rs new file mode 100644 index 00000000000..4a23be5e8bd --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/node_adoption.rs @@ -0,0 +1,73 @@ +use super::JsContextHost; +use crate::{ + custom_elements, document_runtime::DomHandle, + native_bridge::node_runtime_and_handle_from_object, +}; + +impl JsContextHost { + pub(in crate::native_bridge) fn adopt_node_from_host( + scope: &mut v8::PinScope<'_, '_>, + target: *mut Self, + document: DomHandle, + object: v8::Local<'_, v8::Object>, + ) -> Option { + let (source, root) = node_runtime_and_handle_from_object(scope, object).ok()?; + if source == target { + return Some(root); + } + let owner = unsafe { &*target } + .bridge + .identity + .node_owner_context(scope, target)?; + custom_elements::with_custom_element_reaction_scope(scope, source, |scope| { + let parent = unsafe { &*source }.dom_host().parent_node(root); + if let Some(parent) = parent + && !unsafe { &mut *source } + .remove_child_appending_to_current_reaction_queue(scope, source, parent, root) + { + return None; + } + // Removal may synchronously run focus/resource cleanup. Resolve the + // original object again rather than trusting a pre-callback ID. + let (current_source, current_root) = + node_runtime_and_handle_from_object(scope, object).ok()?; + if current_source != source || current_root != root { + return Self::adopt_node_from_host(scope, target, document, object); + } + let transfer = unsafe { &mut *target } + .dom_host_mut() + .transfer_detached_subtree_from( + document, + unsafe { &mut *source }.dom_host_mut(), + root, + ) + .ok()?; + let handles = transfer.handles(); + let target_host = unsafe { &mut *target }; + let source_host = unsafe { &mut *source }; + target_host.bridge.identity.transfer_node_ownership_from( + scope, + &mut source_host.bridge.identity, + source, + owner, + handles, + ); + for (&old, &new) in handles { + if let Some(style) = source_host.inline_style_declarations.remove(&old) { + assert!( + target_host + .inline_style_declarations + .insert(new, style) + .is_none() + ); + } + } + target_host + .canvas_resources + .transfer_from(&mut source_host.canvas_resources, handles); + let callbacks = target_host.transfer_native_event_targets_from(source_host, handles); + target_host.transfer_node_event_callbacks_from(scope, source_host, &callbacks, owner); + Some(transfer.root()) + }) + } +} diff --git a/moli-renderer-v8/src/native_bridge/document/detached_objects/state_tree.rs b/moli-renderer-v8/src/native_bridge/document/detached_objects/state_tree.rs index 4a896f6836e..1ec70772b49 100644 --- a/moli-renderer-v8/src/native_bridge/document/detached_objects/state_tree.rs +++ b/moli-renderer-v8/src/native_bridge/document/detached_objects/state_tree.rs @@ -301,6 +301,11 @@ pub(crate) fn detached_native_handle_for_runtime<'s>( ) -> Option { let node = node_backing_object(scope, node)?; let value = get_private_value(scope, node, DETACHED_NATIVE_HANDLE_SLOT)?; + if let Some((owner, handle)) = + crate::native_bridge::identity::resolve_object_node_ownership(scope, node) + { + return (owner == runtime_ptr).then_some(handle); + } let big = v8::Local::::try_from(value).ok()?; let (index, lossless) = big.u64_value(); if !lossless { @@ -666,6 +671,13 @@ pub(in crate::native_bridge) fn define_detached_native_handle( ) { let value = v8::BigInt::new_from_u64(scope, handle.index() as u64); set_private_value(scope, node, DETACHED_NATIVE_HANDLE_SLOT, value.into()); + if let Some(host) = context_host_ptr_from_global_bridge(scope) { + unsafe { &mut *host } + .native_bridge_mut() + .identity + .node_ownership(scope, host, handle) + .bind(scope, node); + } pair_detached_native_handle_with_wrapper(scope, node, handle); } diff --git a/moli-renderer-v8/src/native_bridge/helpers/identity.rs b/moli-renderer-v8/src/native_bridge/helpers/identity.rs index e4e5ca71fd1..3dcacb018e7 100644 --- a/moli-renderer-v8/src/native_bridge/helpers/identity.rs +++ b/moli-renderer-v8/src/native_bridge/helpers/identity.rs @@ -52,5 +52,13 @@ pub(in crate::native_bridge) fn bridge_handle_from_object( .native_bridge() .bridge_handle(reflector_id) .with_context(|| format!("no bridge identity for reflector id {}", reflector_id.raw()))?; + if let Some(node) = handle.node_handle() { + let (owner, node) = unsafe { &*runtime_ptr } + .native_bridge() + .identity + .resolve_node_ownership(scope, runtime_ptr, node) + .context("native node's owning realm has retired")?; + return Ok((owner, handle.with_node_handle(node))); + } Ok((runtime_ptr, handle)) } diff --git a/moli-renderer-v8/src/native_bridge/identity.rs b/moli-renderer-v8/src/native_bridge/identity.rs index 5fba974e45c..78b8023630a 100644 --- a/moli-renderer-v8/src/native_bridge/identity.rs +++ b/moli-renderer-v8/src/native_bridge/identity.rs @@ -17,6 +17,8 @@ use super::{JsContextHost, RuntimeObservableContextToken}; use dense_reflector_map::DenseReflectorMap; mod dense_reflector_map; +mod node_ownership; +pub(in crate::native_bridge) use node_ownership::resolve_object_node_ownership; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub(super) struct ReflectorId(u64); @@ -53,6 +55,30 @@ pub(super) enum BridgeHandle { ComputedStyle(DomHandle, Rc), } +impl BridgeHandle { + pub(super) fn node_handle(&self) -> Option { + match self { + Self::Window => None, + Self::Node(handle) + | Self::ClassList(handle, _) + | Self::Dataset(handle) + | Self::Style(handle) + | Self::ComputedStyle(handle, _) => Some(*handle), + } + } + + pub(super) fn with_node_handle(self, handle: DomHandle) -> Self { + match self { + Self::Window => Self::Window, + Self::Node(_) => Self::Node(handle), + Self::ClassList(_, kind) => Self::ClassList(handle, kind), + Self::Dataset(_) => Self::Dataset(handle), + Self::Style(_) => Self::Style(handle), + Self::ComputedStyle(_, descriptor) => Self::ComputedStyle(handle, descriptor), + } + } +} + #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub(crate) struct ComputedStyleDescriptor { pub(crate) pseudo: ComputedStylePseudoKey, @@ -642,6 +668,8 @@ pub(crate) fn clear_context_wrapper_cache_for_teardown( #[derive(Debug, Default)] pub(super) struct BridgeIdentityStore { reflector_handles: IndexSet, + node_ownership: HashMap>, + node_owner_realm: Option>, live_collections: LiveCollectionStore, static_handle_collections: Rc>, default_world_wrapper_cache: Rc>, diff --git a/moli-renderer-v8/src/native_bridge/identity/node_ownership.rs b/moli-renderer-v8/src/native_bridge/identity/node_ownership.rs new file mode 100644 index 00000000000..2e4247a54ad --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/identity/node_ownership.rs @@ -0,0 +1,304 @@ +use std::{cell::RefCell, rc::Rc}; + +use super::{BridgeIdentityStore, JsContextHost, ReflectorId}; +use crate::{document_runtime::DomHandle, util}; + +const ANCHOR_SLOT: &str = "__moliNativeNodeOwnership"; +const OWNER_SLOT: &str = "__moliNativeNodeCurrentOwner"; +const HANDLE_SLOT: &str = "__moliNativeNodeCurrentHandle"; + +pub(in crate::native_bridge) fn resolve_object_node_ownership( + scope: &mut v8::PinScope<'_, '_>, + object: v8::Local<'_, v8::Object>, +) -> Option<(*mut JsContextHost, DomHandle)> { + let object = v8::Local::new(scope, object); + let anchor = util::get_private_object(scope, object, ANCHOR_SLOT)?; + let handle = util::get_private_value(scope, anchor, HANDLE_SLOT)?; + let handle = v8::Local::::try_from(handle).ok()?; + let (handle, lossless) = handle.u64_value(); + let handle = lossless.then(|| usize::try_from(handle).ok()).flatten()?; + let owner = util::get_private_object(scope, anchor, OWNER_SLOT).unwrap_or(anchor); + let owner = owner.get_creation_context(scope)?; + Some(( + util::context_host_ptr_from_context_slot(owner)?, + DomHandle::new(handle), + )) +} + +/// Native location shared by every retained view of a node. The Rust record +/// has only weak V8 edges. Wrappers and collections trace the anchor, which in +/// turn traces the current owning Document realm through a private property. +/// Moving a node updates this one location without changing its JS identity, +/// prototype, or the host-local IDs stored in an older collection snapshot. +#[derive(Debug)] +pub(in crate::native_bridge) struct NodeOwnership { + location: RefCell, +} + +#[derive(Debug)] +struct NodeLocation { + handle: DomHandle, + owner: v8::Weak, + anchor: v8::Weak, +} + +impl NodeOwnership { + fn new( + scope: &mut v8::PinScope<'_, '_>, + owner: v8::Local<'_, v8::Context>, + handle: DomHandle, + ) -> Self { + let scope = &mut v8::ContextScope::new(scope, owner); + let anchor = util::new_null_prototype_object(scope); + let value = v8::BigInt::new_from_u64(scope, handle.index() as u64); + util::set_private_value(scope, anchor, HANDLE_SLOT, value.into()); + Self { + location: RefCell::new(NodeLocation { + handle, + owner: v8::Weak::new(scope, owner), + anchor: v8::Weak::new(scope, anchor), + }), + } + } + + pub(in crate::native_bridge) fn resolve( + &self, + scope: &mut v8::PinScope<'_, '_>, + ) -> Option<(*mut JsContextHost, DomHandle)> { + let location = self.location.borrow(); + let owner = location.owner.to_local(scope)?; + let host = util::context_host_ptr_from_context_slot(owner)?; + Some((host, location.handle)) + } + + pub(in crate::native_bridge) fn anchor<'s>( + &self, + scope: &mut v8::PinScope<'s, '_>, + ) -> Option> { + let mut location = self.location.borrow_mut(); + if let Some(anchor) = location.anchor.to_local(scope) { + return Some(anchor); + } + let owner = location.owner.to_local(scope)?; + let scope = &mut v8::ContextScope::new(scope, owner); + let anchor = util::new_null_prototype_object(scope); + let value = v8::BigInt::new_from_u64(scope, location.handle.index() as u64); + util::set_private_value(scope, anchor, HANDLE_SLOT, value.into()); + location.anchor = v8::Weak::new(scope, anchor); + Some(anchor) + } + + pub(in crate::native_bridge) fn bind( + &self, + scope: &mut v8::PinScope<'_, '_>, + object: v8::Local<'_, v8::Object>, + ) { + let anchor = self + .anchor(scope) + .expect("live native node has an owner realm"); + util::set_private_value(scope, object, ANCHOR_SLOT, anchor.into()); + } + + pub(in crate::native_bridge) fn retarget( + &self, + scope: &mut v8::PinScope<'_, '_>, + owner: v8::Local<'_, v8::Context>, + handle: DomHandle, + ) { + // A retained anchor can have been created in an earlier Page. Give it + // a V8-traced edge to the new owner before replacing the weak location. + let mut location = self.location.borrow_mut(); + if let Some(anchor) = location.anchor.to_local(scope) { + let scope = &mut v8::ContextScope::new(scope, owner); + let owner_anchor = util::new_null_prototype_object(scope); + util::set_private_value(scope, anchor, OWNER_SLOT, owner_anchor.into()); + let value = v8::BigInt::new_from_u64(scope, handle.index() as u64); + util::set_private_value(scope, anchor, HANDLE_SLOT, value.into()); + } + location.handle = handle; + location.owner = v8::Weak::new(scope, owner); + } +} + +impl BridgeIdentityStore { + pub(in crate::native_bridge) fn transfer_node_ownership_from( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + source: &mut Self, + source_host: *mut JsContextHost, + owner: v8::Local<'_, v8::Context>, + handles: &std::collections::HashMap, + ) { + // Capture existing canonical objects before retargeting. Their internal + // reflector ID still belongs to the original host; its shared location + // resolves to the new owner. No public getter or setter participates. + let wrappers = source + .reflector_handles + .iter() + .enumerate() + .filter_map(|(index, descriptor)| { + let old = descriptor.node_handle()?; + let new = *handles.get(&old)?; + let wrapper = source.cached_wrapper(scope, ReflectorId::from_index(index))?; + Some(( + descriptor.clone().with_node_handle(new), + v8::Global::new(scope, wrapper), + )) + }) + .collect::>(); + let collections = { + let cache = source.current_wrapper_cache(scope); + let cache = cache.borrow(); + let mut collections = Vec::new(); + for (descriptor, entry) in &cache.live_collection_wrappers { + if let Some(&root) = handles.get(&descriptor.root) + && let Some(wrapper) = entry.wrapper.to_local(scope) + { + let mut descriptor = descriptor.clone(); + *descriptor.resolution_cache.0.borrow_mut() = None; + descriptor.root = root; + collections.push((descriptor, v8::Global::new(scope, wrapper))); + } + } + for (descriptor, entry) in &cache.retired_live_collection_wrappers { + if let Some(&root) = handles.get(&descriptor.root) + && let Some(wrapper) = entry.to_local(scope) + { + let mut descriptor = descriptor.clone(); + *descriptor.resolution_cache.0.borrow_mut() = None; + descriptor.root = root; + collections.push((descriptor, v8::Global::new(scope, wrapper))); + } + } + collections + }; + for (&old, &new) in handles { + let ownership = source.node_ownership(scope, source_host, old); + ownership.retarget(scope, owner, new); + assert!( + self.node_ownership.insert(new, ownership).is_none(), + "transferred native IDs are never reused" + ); + } + for (descriptor, wrapper) in wrappers { + let id = self.reflector_id(&descriptor); + self.cache_wrapper(scope, id, v8::Local::new(scope, &wrapper)); + } + for (descriptor, wrapper) in collections { + self.cache_live_collection_wrapper(scope, descriptor, v8::Local::new(scope, &wrapper)); + } + // A retained descriptor not materialized in this world must also lose + // its source-host query cache, whose version can collide with the target. + for descriptor in source.live_collections.descriptors.values() { + if handles.contains_key(&descriptor.root) { + *descriptor.resolution_cache.0.borrow_mut() = None; + } + } + } + + pub(in crate::native_bridge) fn node_ownership( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + host: *mut JsContextHost, + handle: DomHandle, + ) -> Rc { + if let Some(ownership) = self.node_ownership.get(&handle) { + return ownership.clone(); + } + let owner = self + .node_owner_context(scope, host) + .expect("native node owner has a Document realm"); + self.node_owner_realm = Some(v8::Weak::new(scope, owner)); + let ownership = Rc::new(NodeOwnership::new(scope, owner, handle)); + self.node_ownership.insert(handle, ownership.clone()); + ownership + } + + pub(in crate::native_bridge) fn node_owner_context<'s>( + &self, + scope: &mut v8::PinScope<'s, '_>, + host: *mut JsContextHost, + ) -> Option> { + // Native ownership belongs to the Page, independent of which isolated + // world first materializes a wrapper. Keep only a weak realm reference + // for retained nodes after the Page clears its active default context. + unsafe { &*host } + .page_default_context(scope) + .or_else(|| { + self.node_owner_realm + .as_ref() + .and_then(|owner| owner.to_local(scope)) + }) + .or_else(|| { + let current = scope.get_current_context(); + (util::context_host_ptr_from_context_slot(current) == Some(host)).then_some(current) + }) + } + + pub(in crate::native_bridge) fn resolve_node_ownership( + &self, + scope: &mut v8::PinScope<'_, '_>, + host: *mut JsContextHost, + handle: DomHandle, + ) -> Option<(*mut JsContextHost, DomHandle)> { + match self.node_ownership.get(&handle) { + Some(ownership) => ownership.resolve(scope), + None => Some((host, handle)), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn retained_node_traces_its_current_owner_and_releases_previous_and_final_owners() { + crate::ensure_v8_for_test(); + let mut isolate = v8::Isolate::new(Default::default()); + let (ownership, wrapper, first_owner, current_owner) = { + let scope = std::pin::pin!(v8::HandleScope::new(&mut isolate)); + let scope = &mut scope.init(); + let original = v8::Context::new(scope, Default::default()); + let first = v8::Context::new(scope, Default::default()); + let current = v8::Context::new(scope, Default::default()); + let scope = &mut v8::ContextScope::new(scope, original); + let wrapper = util::new_null_prototype_object(scope); + let ownership = NodeOwnership::new(scope, original, DomHandle::new(5)); + ownership.bind(scope, wrapper); + ownership.retarget(scope, first, DomHandle::new(105)); + ownership.retarget(scope, current, DomHandle::new(205)); + assert_eq!(wrapper.get_creation_context(scope), Some(original)); + let anchor = util::get_private_object(scope, wrapper, ANCHOR_SLOT).unwrap(); + let handle = util::get_private_value(scope, anchor, HANDLE_SLOT).unwrap(); + assert_eq!( + v8::Local::::try_from(handle) + .unwrap() + .u64_value(), + (205, true) + ); + ( + ownership, + v8::Global::new(scope, wrapper), + v8::Weak::new(scope, first), + v8::Weak::new(scope, current), + ) + }; + isolate.low_memory_notification(); + assert!( + first_owner.is_empty(), + "retargeting must release the intermediate Document realm" + ); + assert!( + !current_owner.is_empty(), + "a retained wrapper traces its current native owner" + ); + drop(wrapper); + isolate.low_memory_notification(); + assert!( + current_owner.is_empty(), + "Rust ownership metadata must not root a released Document realm" + ); + drop(ownership); + } +} diff --git a/moli-renderer-v8/src/native_bridge/node.rs b/moli-renderer-v8/src/native_bridge/node.rs index ca42919c373..fd7161a2f1f 100644 --- a/moli-renderer-v8/src/native_bridge/node.rs +++ b/moli-renderer-v8/src/native_bridge/node.rs @@ -841,6 +841,9 @@ pub(crate) fn node_runtime_and_handle_from_object_or_detached<'s>( if let Ok(node) = node_runtime_and_handle_from_object(scope, object) { return Ok(node); } + if let Some(node) = super::identity::resolve_object_node_ownership(scope, object) { + return Ok(node); + } // Detached node indices are host-local too. Borrowed bindings and // structuredClone can run in another Page, so resolve the producer's // lifecycle-checked context instead of looking in the caller's arena. diff --git a/moli-renderer-v8/src/native_bridge/node/foreign/arg.rs b/moli-renderer-v8/src/native_bridge/node/foreign/arg.rs index c12849c7474..1064fa601df 100644 --- a/moli-renderer-v8/src/native_bridge/node/foreign/arg.rs +++ b/moli-renderer-v8/src/native_bridge/node/foreign/arg.rs @@ -196,8 +196,12 @@ pub(in crate::native_bridge) fn node_or_foreign_arg_handle( match resolve_node_argument(scope, runtime_ptr, value) { NodeArgumentResolution::SameRuntimeNative(handle) | NodeArgumentResolution::LiveDelegate(handle) => Some(handle), - NodeArgumentResolution::CrossRuntimeNative(object) - | NodeArgumentResolution::ForeignObject(object) => { + NodeArgumentResolution::CrossRuntimeNative(object) => { + let document = document_handle + .unwrap_or_else(|| unsafe { &*runtime_ptr }.dom_host().document_handle()); + JsContextHost::adopt_node_from_host(scope, runtime_ptr, document, object) + } + NodeArgumentResolution::ForeignObject(object) => { let document_handle = document_handle?; materialize_foreign_node_arg_handle(scope, runtime_ptr, document_handle, object) } @@ -248,8 +252,12 @@ pub(crate) fn node_or_foreign_arg_handle_allow_detached( let object = v8::Local::new(scope, object); materialize_detached_node_arg_handle(scope, runtime_ptr, document_handle, object) } - NodeArgumentResolution::CrossRuntimeNative(object) - | NodeArgumentResolution::ForeignObject(object) => { + NodeArgumentResolution::CrossRuntimeNative(object) => { + let document = document_handle + .unwrap_or_else(|| unsafe { &*runtime_ptr }.dom_host().document_handle()); + JsContextHost::adopt_node_from_host(scope, runtime_ptr, document, object) + } + NodeArgumentResolution::ForeignObject(object) => { let document_handle = document_handle?; materialize_foreign_node_arg_handle(scope, runtime_ptr, document_handle, object) } diff --git a/moli-renderer-v8/src/window_host.rs b/moli-renderer-v8/src/window_host.rs index 3b2b7108bed..3f8f7fe7ed1 100644 --- a/moli-renderer-v8/src/window_host.rs +++ b/moli-renderer-v8/src/window_host.rs @@ -304,6 +304,11 @@ fn register_dom_event_target_listener<'s>( window_receiver: Option, call: AddEventListenerArgs<'s>, ) { + let host_ptr = if window_receiver.is_none() { + native_event_target_host(scope, receiver).unwrap_or(host_ptr) + } else { + host_ptr + }; let host = unsafe { &mut *host_ptr }; let Some(listener) = call.listener else { return; @@ -432,6 +437,12 @@ pub(super) fn event_target_remove_event_listener_callback<'s>( else { return; }; + let host_ptr = if window_receiver.is_none() { + native_event_target_host(scope, args.this()).unwrap_or(host_ptr) + } else { + host_ptr + }; + let host = unsafe { &mut *host_ptr }; let Some(listener) = call.listener else { return; }; @@ -478,6 +489,7 @@ pub(super) fn event_target_dispatch_event_callback<'s>( rv.set_bool(false); return; }; + let host_ptr = native_event_target_host(scope, args.this()).unwrap_or(host_ptr); let host = unsafe { &mut *host_ptr }; let Ok(window_receiver) = capture_window_event_target_receiver(scope, args.this(), host) else { return; @@ -2264,6 +2276,17 @@ fn dom_handle_from_marker_value( .map(|value| crate::document_runtime::DomHandle::new(value as usize)) } +fn native_event_target_host<'s>( + scope: &mut v8::PinScope<'s, '_>, + receiver: v8::Local<'s, v8::Object>, +) -> Option<*mut JsContextHost> { + // A Node retains its function/prototype realm across adoption. Resolve its + // native owner after conversion, since an options getter can move it again. + crate::native_bridge::node_runtime_and_handle_from_object_or_detached(scope, receiver) + .ok() + .map(|(host, _)| host) +} + fn event_target_handle_from_this<'s>( scope: &mut v8::PinScope<'s, '_>, args: &v8::FunctionCallbackArguments<'s>,