Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(events): project shared native aliases into listener realms

ldm003232f517ad1
diff --git a/moli-renderer-v8/src/context_bootstrap/abort_signal_events.rs b/moli-renderer-v8/src/context_bootstrap/abort_signal_events.rs
index 6590c5d55..fa2d9fca7 100644
--- a/moli-renderer-v8/src/context_bootstrap/abort_signal_events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/abort_signal_events.rs
@@ -1,6 +1,6 @@
use super::{
construct_original_event, dispatch_simple_event_target_event, initialize_simple_event_target,
- simple_object_event_set_handler,
+ shared_event_targets::resolve_event_target, simple_object_event_set_handler,
};
use crate::util::{get_private_value, set_private_value};
@@ -33,8 +33,11 @@ pub(crate) fn onabort_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
+ let Some(signal) = resolve_event_target(scope, args.this()) else {
+ return;
+ };
rv.set(
- get_private_value(scope, args.this(), ONABORT_SLOT)
+ get_private_value(scope, signal.handler_owner, ONABORT_SLOT)
.unwrap_or_else(|| v8::null(scope).into()),
);
}
@@ -44,6 +47,14 @@ pub(crate) fn onabort_setter<'s>(
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
- let signal = args.this();
- simple_object_event_set_handler(scope, signal, "abort", ONABORT_SLOT, args.get(0));
+ let Some(signal) = resolve_event_target(scope, args.this()) else {
+ return;
+ };
+ simple_object_event_set_handler(
+ scope,
+ signal.handler_owner,
+ "abort",
+ ONABORT_SLOT,
+ args.get(0),
+ );
}
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 6ae54a707..0592774b9 100644
--- a/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
+++ b/moli-renderer-v8/src/context_bootstrap/shared_event_targets.rs
@@ -63,6 +63,9 @@ pub(super) fn is_shared_target<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
) -> bool {
+ let Some(target) = native_target(scope, target) else {
+ return false;
+ };
get_private_object(scope, target, OWNER).is_some()
}
@@ -112,8 +115,12 @@ pub(super) fn target_in_realm<'s>(
if let Some(node) = node_target_in_realm(scope, target, context) {
return node;
}
+ let receiver = target;
+ let target = native_target(scope, target).unwrap_or(target);
let Some(owner) = get_private_object(scope, target, OWNER) else {
- return target;
+ // Ordinary native aliases retain their own public identity. Shared
+ // platform objects instead project the native receiver's world wrapper.
+ return receiver;
};
if crate::web_api_interfaces::AbortSignal::is_instance(scope, owner) {
return super::platform_object_worlds::in_realm(scope, owner.into(), context)
@@ -236,9 +243,9 @@ fn handler_getter<'s>(
) {
let index = args.data().int32_value(scope).unwrap_or(-1) as usize;
if let Some((slot, _)) = HANDLERS.get(index) {
- rv.set(
- get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::null(scope).into()),
- );
+ let target = resolve_event_target(scope, args.this())
+ .map_or(args.this(), |target| target.handler_owner);
+ rv.set(get_private_value(scope, target, slot).unwrap_or_else(|| v8::null(scope).into()));
}
}
@@ -251,6 +258,7 @@ fn handler_setter<'s>(
let Some((slot, event_type)) = HANDLERS.get(index) else {
return;
};
- let target = args.this();
+ let target =
+ resolve_event_target(scope, args.this()).map_or(args.this(), |target| target.handler_owner);
media_queries::simple_object_event_set_handler(scope, target, event_type, slot, args.get(0));
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs
index 88f46df28..0d543fbff 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/event_target_prototype.rs
@@ -192,3 +192,141 @@ fn event_target_prototype_methods_separate_listener_owner_from_dispatch_target()
"[1,0]"
);
}
+
+#[test]
+fn event_target_native_aliases_preserve_shared_world_targets_and_handler_state() {
+ let mut vm = new_storage_test_vm("https://event-target-native-worlds.test/");
+ vm.eval(
+ r#"
+ navigation.addEventListener('navigate', event => {
+ globalThis.mainSignal = event.signal;
+ }, {once: true});
+ "#,
+ )
+ .unwrap();
+ let isolated = vm
+ .create_isolated_world("native-target-identities", false)
+ .unwrap();
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"
+ navigation.addEventListener('navigate', event => {
+ globalThis.worldSignal = event.signal;
+ }, {once: true});
+ "#,
+ )
+ .unwrap();
+ vm.eval(
+ r#"
+ history.pushState({}, '', '#capture-signal');
+ globalThis.aliasTraps = 0;
+ const makeAlias = target => new Proxy(target, {
+ get() {aliasTraps++; throw new Error('get trap');},
+ getPrototypeOf() {aliasTraps++; throw new Error('prototype trap');}
+ });
+ globalThis.navigationAlias = makeAlias(navigation);
+ globalThis.signalAlias = makeAlias(mainSignal);
+ true;
+ "#,
+ )
+ .unwrap();
+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {
+ let global = scope.get_current_context().global(scope);
+ for name in ["navigationAlias", "signalAlias"] {
+ let value = global
+ .get(scope, crate::util::v8str(scope, name).into())
+ .unwrap();
+ let proxy = v8::Local::<v8::Proxy>::try_from(value).unwrap();
+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();
+ }
+ Ok(())
+ })
+ .unwrap();
+ vm.eval(r#"
+ globalThis.mainFacts = [];
+ globalThis.mainSpecs = [
+ [navigation, navigationAlias, 'navigate', 'onnavigate',
+ Object.getOwnPropertyDescriptor(navigation, 'onnavigate')],
+ [mainSignal, signalAlias, 'abort', 'onabort',
+ Object.getOwnPropertyDescriptor(AbortSignal.prototype, 'onabort')],
+ ];
+ globalThis.mainHandlers = mainSpecs.map(([target, alias, type, slot, descriptor]) => {
+ const handler = function(event) {
+ mainFacts.push([this === target, event.target === target,
+ event.currentTarget === target, event instanceof CustomEvent, event.pageOnly === 42]);
+ };
+ descriptor.set.call(alias, handler);
+ if (descriptor.get.call(alias) !== handler || descriptor.get.call(target) !== handler)
+ throw Error(type + ': alias handler owner');
+ return handler;
+ });
+ true;
+ "#).unwrap();
+ vm.eval_in_isolated_context(isolated, r#"
+ globalThis.worldFacts = [];
+ globalThis.worldEvents = [];
+ globalThis.worldSpecs = [[navigation, 'navigate', 'onnavigate'], [worldSignal, 'abort', 'onabort']];
+ globalThis.worldHandlers = worldSpecs.map(([target, type, slot]) => {
+ const record = function(event) {
+ worldEvents.push(event);
+ worldFacts.push([this === target, event.target === target, event.currentTarget === target,
+ event.composedPath()[0] === target, event instanceof CustomEvent,
+ event.pageOnly === undefined, event.detail === 7]);
+ };
+ target[slot] = record;
+ target.addEventListener(type, function(event) {
+ record.call(this, event);
+ event.preventDefault();
+ }, {once: true});
+ return record;
+ });
+ true;
+ "#).unwrap();
+ assert_eq!(vm.eval(r#"JSON.stringify(mainSpecs.map(([target, alias, type]) => {
+ const event = new CustomEvent(type, {detail: 7, cancelable: true});
+ event.pageOnly = 42;
+ return [EventTarget.prototype.dispatchEvent.call(alias, event), event.defaultPrevented,
+ event.target === target, event.currentTarget === null, event.composedPath().length === 0];
+ }))"#).unwrap(), "[[false,true,true,true,true],[false,true,true,true,true]]");
+ assert_eq!(vm.eval_in_isolated_context(isolated, r#"String(
+ worldFacts.length === 4 && worldFacts.every(row => row.every(Boolean)) &&
+ worldEvents.every(event => event.defaultPrevented && event.currentTarget === null &&
+ event.composedPath().length === 0) && worldSpecs.every(([target, type, slot], index) => {
+ if (target[slot] !== worldHandlers[index]) return false;
+ target[slot] = null;
+ return target[slot] === null;
+ })
+ )"#).unwrap(), "true");
+ assert_eq!(vm.eval(r#"String(mainSpecs.every(([target, alias, type, slot, descriptor], index) => {
+ if (descriptor.get.call(alias) !== mainHandlers[index] || target[slot] !== mainHandlers[index])
+ return false;
+ const event = new CustomEvent(type, {detail: 7, cancelable: true});
+ event.pageOnly = 42;
+ return EventTarget.prototype.dispatchEvent.call(alias, event) && !event.defaultPrevented;
+ }) && mainFacts.length === 4 && mainFacts.every(row => row.every(Boolean)) && aliasTraps === 0)"#).unwrap(), "true");
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "String(worldFacts.length === 4)")
+ .unwrap(),
+ "true"
+ );
+ assert_eq!(
+ vm.eval(
+ r#"(() => {
+ if (!document.documentElement) document.appendChild(document.createElement('html'));
+ if (!document.body) document.documentElement.appendChild(document.createElement('body'));
+ const frame = document.body.appendChild(document.createElement('iframe'));
+ const facts = [];
+ const listener = frame.contentWindow.Function('expected', 'facts', `return function(event) {
+ facts.push(this === expected, event.target === expected,
+ event.currentTarget === expected, event.composedPath()[0] === expected);
+ }`)(navigation, facts);
+ navigation.addEventListener('foreign-probe', listener, {once: true});
+ EventTarget.prototype.dispatchEvent.call(navigationAlias, new Event('foreign-probe'));
+ frame.remove();
+ return JSON.stringify(facts);
+ })()"#
+ )
+ .unwrap(),
+ "[true,true,true,true]"
+ );
+}