Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(renderer): project events across Realms of the same Window

ldm0e1f2169f6852
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index cd55429f3..8891569b5 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -280,7 +280,7 @@ pub(crate) use self::events::{
event_is_mouse_event, event_private_value, initialize_event_object, initialize_event_wrapper,
mark_agent_submit_event, mark_event_trusted, new_event_state, new_event_wrapper,
set_event_composed_path, set_event_internal_flag, set_event_private_value, set_event_trusted,
- submit_event_submitter_value,
+ submit_event_submitter_value, window_event_callback_values,
};
pub(crate) use self::file_api::{
DataTransferStringCallbackTask, DataTransferStringCallbackTaskEffect,
diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs
index d09f6f0ee..20029ef31 100644
--- a/moli-renderer-v8/src/context_bootstrap/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events.rs
@@ -497,7 +497,7 @@ pub(super) fn track_event_track_getter_function<'s>(
pub(crate) use wrappers::{
event_attribute, event_bool_attribute, event_private_value, initialize_event_wrapper,
- new_event_state, new_event_wrapper, set_event_private_value,
+ new_event_state, new_event_wrapper, set_event_private_value, window_event_callback_values,
};
pub(in crate::context_bootstrap) use message::message_event_init_callback;
diff --git a/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs
index 917d2caeb..234413262 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs
@@ -153,6 +153,38 @@ pub(crate) fn new_event_wrapper<'s>(
Some(wrapper)
}
+/// Project another Realm of the same live Window through the existing weak
+/// Event cache. The dispatch state stays shared and same-world identity stays
+/// intact. Foreign-Window callbacks retain their existing behavior: resolving
+/// an isolated world of another target Window requires an alias/world resolver
+/// that this path does not yet provide.
+pub(crate) fn window_event_callback_values<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Value>,
+ event: v8::Local<'s, v8::Object>,
+ context: v8::Local<'s, v8::Context>,
+) -> Option<(v8::Local<'s, v8::Value>, v8::Local<'s, v8::Object>)> {
+ let Ok(target) = v8::Local::<v8::Object>::try_from(receiver) else {
+ return Some((receiver, event));
+ };
+ let Some(target) =
+ super::super::shared_event_targets::window_target_in_realm(scope, target, context)
+ else {
+ return Some((receiver, event));
+ };
+ if world_wrappers::belongs_to_world(scope, event, context) {
+ return Some((target.into(), event));
+ }
+ let backing = event_backing(scope, event);
+ let wrapper = if let Some(wrapper) = world_wrappers::get(scope, backing, context) {
+ wrapper
+ } else {
+ let scope = &mut v8::ContextScope::new(scope, context);
+ new_event_wrapper(scope, backing)?
+ };
+ Some((target.into(), wrapper))
+}
+
fn bind_attribute<'s>(
scope: &mut v8::PinScope<'s, '_>,
getters: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
index b048e80e3..2a696f2a9 100644
--- a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
+++ b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
@@ -60,6 +60,9 @@ pub(super) fn target_in_realm<'s>(
target: v8::Local<'s, v8::Object>,
context: v8::Local<'s, v8::Context>,
) -> v8::Local<'s, v8::Object> {
+ if let Some(window) = window_target_in_realm(scope, target, context) {
+ return window;
+ }
let Some(owner) = get_private_object(scope, target, OWNER) else {
return target;
};
@@ -85,6 +88,37 @@ pub(super) fn target_in_realm<'s>(
.unwrap_or(target)
}
+/// Only another Realm of this exact live Window can replace a real global.
+/// Cross-Document aliases keep their existing behavior. In particular, the
+/// current parent/top alias path has no target-Window isolated-world resolver;
+/// this helper must not manufacture one by returning the callback global.
+pub(super) fn window_target_in_realm<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ target: v8::Local<'s, v8::Object>,
+ context: v8::Local<'s, v8::Context>,
+) -> Option<v8::Local<'s, v8::Object>> {
+ let target_context = target.get_creation_context(scope)?;
+ if !target.strict_equals(target_context.global(scope).into()) {
+ return None;
+ }
+ let host_ptr = crate::util::context_host_ptr_from_context_slot(target_context)?;
+ if crate::util::context_host_ptr_from_context_slot(context) != Some(host_ptr) {
+ return None;
+ }
+ let host = unsafe { &*host_ptr };
+ let target_identity =
+ host.window_execution_context_identity_for_access_check(target_context)?;
+ let destination_identity = host.window_execution_context_identity_for_access_check(context)?;
+ if target_identity.owner() != destination_identity.owner()
+ || target_identity.dispatch_scope() != destination_identity.dispatch_scope()
+ || !host.window_execution_context_identity_is_current(target_identity)
+ || !host.window_execution_context_identity_is_current(destination_identity)
+ {
+ return None;
+ }
+ Some(context.global(scope))
+}
+
pub(super) fn install_handlers<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/host/events.rs b/moli-renderer-v8/src/host/events.rs
index cc42aa084..a938f4059 100644
--- a/moli-renderer-v8/src/host/events.rs
+++ b/moli-renderer-v8/src/host/events.rs
@@ -155,6 +155,23 @@ pub(crate) fn invoke_prepared_event_callback<'s>(
arguments: &[v8::Local<'s, v8::Value>],
) -> Option<v8::Global<v8::Value>> {
let receiver = event_target_receiver(scope, host_ptr, target, event);
+ let has_event_argument = arguments.len() == 1 && arguments[0].strict_equals(event.into());
+ let (receiver, event) = if matches!(
+ target,
+ EventTargetHandle::Window | EventTargetHandle::ChildWindow(_)
+ ) {
+ let context = callback.relevant_context(scope);
+ crate::context_bootstrap::window_event_callback_values(scope, receiver, event, context)?
+ } else {
+ (receiver, event)
+ };
+ // Window.onerror's five arguments are JS values, not an Event conversion.
+ let event_arguments = [event.into()];
+ let arguments = if has_event_argument {
+ &event_arguments
+ } else {
+ arguments
+ };
let _dom_debugger_pause = unsafe { &*host_ptr }
.schedule_dom_debugger_event_listener_pause_for_target(event_type, target);
invoke_prepared_event_callback_with_receiver(
diff --git a/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs b/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs
index 43ee7ba06..52fc6a15b 100644
--- a/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs
+++ b/moli-renderer-v8/src/script_vm/tests/window_execution_context.rs
@@ -574,3 +574,287 @@ fn borrowed_fetch_uses_receiver_realm_and_keeps_reaction_realm_independent() {
.abort_subresource_fetch(keepalive_id)
);
}
+
+#[tokio::test(flavor = "current_thread")]
+async fn window_event_callbacks_project_same_window_realms_in_both_layout_modes() {
+ for policy in [
+ moli_page_types::LayoutPolicy::Mock,
+ moli_page_types::LayoutPolicy::OnDemand,
+ ] {
+ let mut vm = new_storage_test_vm("https://window-event-realms.test/");
+ vm.set_layout_policy(policy);
+ vm.eval(
+ r#"
+ globalThis.defaultFacts = [];
+ globalThis.original = null;
+ addEventListener('window-realm-probe', function(event) {
+ defaultFacts.push([
+ this === window, event === original, event instanceof Event,
+ event.target === window, event.currentTarget === window,
+ event.composedPath()[0] === window, window.event === event
+ ]);
+ });
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ let isolated = vm
+ .create_isolated_world("window-event-listeners", false)
+ .unwrap();
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"
+ globalThis.isolatedFacts = [];
+ globalThis.savedEvent = null;
+ addEventListener('window-realm-probe', function(event) {
+ savedEvent = event;
+ isolatedFacts.push([
+ this === window, event instanceof Event,
+ event.target === window, event.currentTarget === window,
+ event.composedPath()[0] === window, window.event === event,
+ event.defaultOnly === undefined
+ ]);
+ event.preventDefault();
+ });
+ const objectListener = {
+ handleEvent(event) {
+ isolatedFacts.push([
+ this === objectListener, event === savedEvent,
+ event.defaultPrevented, event.currentTarget === window
+ ]);
+ }
+ };
+ addEventListener('window-realm-probe', objectListener);
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ let builds = vm.layout_pass_observability_for_test().1;
+ assert_eq!(
+ vm.eval(
+ r#"
+ original = new Event('window-realm-probe', {cancelable: true});
+ original.defaultOnly = 'default';
+ JSON.stringify([
+ dispatchEvent(original), original.defaultPrevented,
+ original.currentTarget === null, original.composedPath().length === 0
+ ])
+ "#
+ )
+ .unwrap(),
+ "[false,true,true,true]",
+ "{policy:?}"
+ );
+ assert_eq!(
+ vm.eval("JSON.stringify(defaultFacts)").unwrap(),
+ "[[true,true,true,true,true,true,true]]",
+ "{policy:?}"
+ );
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "JSON.stringify(isolatedFacts)")
+ .unwrap(),
+ "[[true,true,true,true,true,true,true],[true,true,true,true]]",
+ "{policy:?}"
+ );
+ assert_eq!(vm.eval_in_isolated_context(isolated,
+ "JSON.stringify([savedEvent.currentTarget === null, savedEvent.composedPath().length === 0, savedEvent.defaultPrevented])"
+ ).unwrap(), "[true,true,true]", "{policy:?}");
+ assert_eq!(
+ vm.layout_pass_observability_for_test().1,
+ builds,
+ "event Realm conversion must not request layout: {policy:?}"
+ );
+
+ vm.destroy_isolated_world_context(isolated);
+ assert_eq!(vm.eval(r#"
+ original = new Event('window-realm-probe', {cancelable: true});
+ JSON.stringify([dispatchEvent(original), original.defaultPrevented, defaultFacts.length])
+ "#).unwrap(), "[true,false,2]", "retired isolated listeners: {policy:?}");
+ assert_eq!(
+ vm.layout_pass_observability_for_test().1,
+ builds,
+ "Realm retirement and dispatch must not request layout: {policy:?}"
+ );
+ }
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn borrowed_default_world_window_callback_keeps_target_window_and_event_identity() {
+ for policy in [
+ moli_page_types::LayoutPolicy::Mock,
+ moli_page_types::LayoutPolicy::OnDemand,
+ ] {
+ let mut vm = new_storage_test_vm("https://borrowed-window-event.test/");
+ vm.set_layout_policy(policy);
+ vm.eval(
+ r#"
+ globalThis.frame = document.createElement('iframe');
+ (document.body || document.documentElement || document).appendChild(frame);
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ materialize_single_child_default_realm_for_test(&mut vm, "borrowed Window callback");
+ vm.eval(
+ r#"
+ globalThis.borrowedFacts = [];
+ globalThis.original = null;
+ const child = frame.contentWindow;
+ addEventListener('borrowed-window-probe', child.Function('event', `
+ parent.borrowedFacts.push([
+ this === parent, this !== window, event === parent.original,
+ event.target === parent, event.currentTarget === parent,
+ event.composedPath()[0] === parent,
+ event instanceof parent.Event, !(event instanceof Event),
+ window.event === event
+ ]);
+ `));
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ let builds = vm.layout_pass_observability_for_test().1;
+ assert_eq!(
+ vm.eval(
+ r#"
+ original = new Event('borrowed-window-probe');
+ dispatchEvent(original);
+ JSON.stringify(borrowedFacts)
+ "#
+ )
+ .unwrap(),
+ "[[true,true,true,true,true,true,true,true,true]]",
+ "{policy:?}"
+ );
+ assert_eq!(
+ vm.layout_pass_observability_for_test().1,
+ builds,
+ "borrowed callback must not obtain geometry to resolve its Window: {policy:?}"
+ );
+ }
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn native_window_error_events_preserve_type_and_onerror_arguments_in_isolated_worlds() {
+ for policy in [
+ moli_page_types::LayoutPolicy::Mock,
+ moli_page_types::LayoutPolicy::OnDemand,
+ ] {
+ let mut vm = new_storage_test_vm("https://window-error-event-realms.test/");
+ vm.set_layout_policy(policy);
+ vm.eval("globalThis.defaultErrorEvent = null;").unwrap();
+ let isolated = vm
+ .create_isolated_world("window-error-listeners", false)
+ .unwrap();
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"
+ globalThis.errorFacts = {listener: [], handler: []};
+ globalThis.savedErrorEvent = null;
+ globalThis.handlerEvent = null;
+ globalThis.handlerError = null;
+ globalThis.handlerEventIsErrorEvent = false;
+ globalThis.onErrorCallback = function(message, source, line, column, error) {
+ handlerEvent = window.event;
+ handlerError = error;
+ handlerEventIsErrorEvent = handlerEvent instanceof ErrorEvent;
+ errorFacts.handler.push([
+ this === window, arguments.length === 5,
+ message.includes('native-window-error'), typeof source === 'string',
+ Number.isFinite(line), Number.isFinite(column),
+ error === handlerEvent.error, window.event === handlerEvent
+ ]);
+ return true;
+ };
+ "#,
+ )
+ .unwrap();
+ let context_ptr = {
+ let world = vm
+ .page_isolated_world_contexts
+ .context(isolated)
+ .expect("isolated error listener world should be tracked");
+ &world.context as *const _
+ };
+ let onerror_callback = vm
+ .with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _host_ptr| {
+ let global = scope.get_current_context().global(scope);
+ let key = v8::String::new(scope, "onErrorCallback").unwrap();
+ let callback = global.get(scope, key.into()).unwrap();
+ let callback = v8::Local::<v8::Function>::try_from(callback)
+ .expect("isolated onerror callback should be callable");
+ Ok(v8::Global::new(scope, callback))
+ })
+ .unwrap();
+ // Top-level onerror is stored on the target Window's global. Install
+ // the borrowed function through that Window's public setter while
+ // preserving the function's isolated relevant Realm.
+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _host_ptr| {
+ let global = scope.get_current_context().global(scope);
+ let key = v8::String::new(scope, "onerror").unwrap();
+ let callback = v8::Local::new(scope, &onerror_callback);
+ assert_eq!(global.set(scope, key.into(), callback.into()), Some(true));
+ let installed = global.get(scope, key.into()).unwrap();
+ assert!(
+ installed.strict_equals(callback.into()),
+ "the target Window must expose the exact borrowed onerror callback"
+ );
+ Ok(())
+ })
+ .unwrap();
+ drop(onerror_callback);
+ vm.eval("addEventListener('error', event => { defaultErrorEvent = event; });")
+ .unwrap();
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"
+ addEventListener('error', function(event) {
+ savedErrorEvent = event;
+ errorFacts.listener.push([
+ this === window, event instanceof ErrorEvent, event instanceof Event,
+ event.isTrusted, event.target === window, event.currentTarget === window,
+ event.composedPath()[0] === window,
+ event.error.message === 'native-window-error'
+ ]);
+ });
+ "#,
+ )
+ .unwrap();
+ let builds = vm.layout_pass_observability_for_test().1;
+ assert_eq!(
+ vm.eval(
+ r#"
+ reportError(new Error('native-window-error'));
+ JSON.stringify([
+ defaultErrorEvent instanceof ErrorEvent,
+ defaultErrorEvent.isTrusted,
+ defaultErrorEvent.defaultPrevented
+ ])
+ "#,
+ )
+ .unwrap(),
+ "[true,true,true]",
+ "{policy:?}"
+ );
+ assert_eq!(
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"JSON.stringify({
+ listener: errorFacts.listener,
+ handler: errorFacts.handler,
+ handlerEventIsErrorEvent,
+ sameEvent: handlerEvent === savedErrorEvent,
+ sameError: handlerError === savedErrorEvent.error
+ })"#,
+ )
+ .unwrap(),
+ r#"{"listener":[[true,true,true,true,true,true,true,true]],"handler":[[true,true,true,true,true,true,true,true]],"handlerEventIsErrorEvent":true,"sameEvent":true,"sameError":true}"#,
+ "native ErrorEvent projection must preserve its subclass and the five onerror arguments: {policy:?}"
+ );
+ assert_eq!(
+ vm.layout_pass_observability_for_test().1,
+ builds,
+ "native exception reporting must not request layout: {policy:?}"
+ );
+ }
+}