From 153d9e993a3c9f4800a592480eb035f45c554e63 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Thu, 8 Oct 2026 23:31:10 +0800 Subject: [PATCH] fix(dom): preserve native ownership across Page adoption Move native subtrees while retaining wrappers, collections, styles, canvas resources, and event registrations. Resolve borrowed EventTarget methods through the native node owner and retain callback realms across adoption. Add real CDP Page regressions for repeated adoption, native receiver validation, retained views, and closed producer realms. Validated with workspace fmt, all-target/all-feature Clippy, and 32-thread nextest (21695 passed, 16 skipped). --- .../protocol_server/tests/cdp_dynamic_page.rs | 1 + .../cdp_dynamic_page/native_node_adoption.rs | 302 +++++++++++++++++ .../src/document_runtime/dom_facade.rs | 9 + moli-renderer-v8/src/host/events.rs | 65 ++++ moli-renderer-v8/src/native_bridge/abort.rs | 15 +- .../src/native_bridge/bridge/wrappers.rs | 43 ++- .../src/native_bridge/collections/builders.rs | 26 ++ .../native_bridge/collections/iteration.rs | 3 +- .../collections/live_handlers.rs | 8 +- .../src/native_bridge/collections/shared.rs | 21 +- .../context_host/canvas_resources.rs | 54 ++++ .../context_host/event_callbacks.rs | 43 ++- .../src/native_bridge/context_host/mod.rs | 1 + .../context_host/node_adoption.rs | 73 +++++ .../document/detached_objects/state_tree.rs | 12 + .../src/native_bridge/helpers/identity.rs | 8 + .../src/native_bridge/identity.rs | 28 ++ .../native_bridge/identity/node_ownership.rs | 304 ++++++++++++++++++ moli-renderer-v8/src/native_bridge/node.rs | 3 + .../src/native_bridge/node/foreign/arg.rs | 16 +- moli-renderer-v8/src/window_host.rs | 23 ++ 21 files changed, 1019 insertions(+), 39 deletions(-) create mode 100644 moli-protocol-server/src/protocol_server/tests/cdp_dynamic_page/native_node_adoption.rs create mode 100644 moli-renderer-v8/src/native_bridge/context_host/node_adoption.rs create mode 100644 moli-renderer-v8/src/native_bridge/identity/node_ownership.rs 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>,