Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(events): keep shared event state in private V8 backing

ldm0929f73b148da
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/history_worlds.py b/moli-cdp-smoke/moli_cdp_smoke/groups/history_worlds.py
index 05ffdbeb4..808f7499e 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/groups/history_worlds.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/history_worlds.py
@@ -237,7 +237,69 @@ async def run_history_worlds_group(
await evaluate("FormData.prototype.set.call(probeData, 'value', 'updated')")
assert_equal(await evaluate("probeFormData.get('value')", isolated),
"updated", "FormData views remain live")
+ event_fields = []
+ for source, receiver in [(isolated, None), (None, isolated)]:
+ await evaluate("""
+ globalThis.eventFieldObservations = [];
+ navigation.addEventListener('backing-fields-probe', event => {
+ eventFieldObservations.push([event instanceof CustomEvent,
+ event.detail, event.type, event.target === navigation]);
+ event.preventDefault();
+ }, {once: true});
+ navigation.addEventListener('backing-toggle-probe', event => {
+ eventFieldObservations.push([event instanceof ToggleEvent,
+ event.oldState, event.newState, event.source === null,
+ event.target === navigation, event.expando === undefined]);
+ }, {once: true});
+ """, receiver)
+ source_facts = await evaluate("""
+ (() => {
+ let getterCalls = 0;
+ const original = new CustomEvent('backing-fields-probe', {detail: 7, cancelable: true});
+ Object.defineProperty(original, 'detail', {
+ get() { getterCalls++; return 99; }, configurable: true,
+ });
+ let sameObject = false;
+ navigation.addEventListener('backing-fields-probe', event => {
+ sameObject = event === original;
+ }, {once: true});
+ const dispatched = navigation.dispatchEvent(original);
+ const toggle = new ToggleEvent('backing-toggle-probe', {oldState: 'closed', newState: 'open'});
+ toggle.expando = 'source';
+ return [dispatched, sameObject, getterCalls, original.defaultPrevented,
+ navigation.dispatchEvent(toggle)];
+ })()
+ """, source)
+ observed = await evaluate("eventFieldObservations", receiver)
+ assert_equal(source_facts, [False, True, 0, True, True],
+ "internal fields preserve source identity and do not invoke shadow getters")
+ assert_equal(observed, [[True, 7, "backing-fields-probe", True],
+ [True, "closed", "open", True, True, True]],
+ "CustomEvent and ToggleEvent use internal fields in the receiving world")
+ event_fields.append({"source": source_facts, "receiver": observed})
+
+ dispatch_path = await evaluate("""
+ (() => {
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const shadow = host.attachShadow({mode: 'open'});
+ const one = document.createElement('button');
+ const two = document.createElement('button');
+ shadow.append(one, two);
+ let calls = 0, getterCalls = 0;
+ host.addEventListener('path-probe', () => calls++);
+ const event = new Event('path-probe', {bubbles: true, composed: true});
+ Object.defineProperty(event, 'relatedTarget', {get() { getterCalls++; return two; }});
+ one.dispatchEvent(event);
+ one.dispatchEvent(new FocusEvent('path-probe', {bubbles: true, composed: true, relatedTarget: two}));
+ host.remove();
+ return [calls, getterCalls];
+ })()
+ """)
+ assert_equal(dispatch_path, [1, 0], "dispatch uses internal relatedTarget, not author expandos")
+
record(results, "raw_cdp_history_world_boundaries", {
+ "event_fields": event_fields, "dispatch_path": dispatch_path,
"wrappers": wrappers, "changes": changes, "cancellation": cancellation,
"errors": errors, "state": state,
"signal_views": signal_views, "original_identity": original_identity,
diff --git a/moli-renderer-v8/src/content_security_policy.rs b/moli-renderer-v8/src/content_security_policy.rs
index 03d8be051..5c54e1619 100644
--- a/moli-renderer-v8/src/content_security_policy.rs
+++ b/moli-renderer-v8/src/content_security_policy.rs
@@ -234,10 +234,11 @@ pub(crate) fn create_security_policy_violation_event<'s>(
fields: &ContentSecurityPolicyViolationEventFields<'_>,
) -> Option<v8::Local<'s, v8::Object>> {
let declaration = security_policy_violation_event_declaration(scope, fields)?;
- let event = declaration.bind(scope).ok()?;
+ let event = crate::context_bootstrap::new_event_state(scope);
initialize_event_object(scope, event, "securitypolicyviolation", true, false);
+ declaration.initialize(scope, event).ok()?;
mark_event_trusted(scope, event);
- Some(event)
+ crate::context_bootstrap::new_event_wrapper(scope, event)
}
pub(crate) fn initialize_security_policy_violation_event<'s>(
@@ -245,6 +246,7 @@ pub(crate) fn initialize_security_policy_violation_event<'s>(
event: v8::Local<'s, v8::Object>,
fields: &ContentSecurityPolicyViolationEventFields<'_>,
) -> bool {
+ let event = crate::context_bootstrap::event_backing(scope, event);
security_policy_violation_event_declaration(scope, fields)
.and_then(|declaration| declaration.initialize(scope, event).ok())
.is_some()
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index 0caa1ee82..f617317f0 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -247,10 +247,11 @@ pub(crate) use self::css_stylesheet_runtime::{
pub(crate) use self::dom_rect::build_dom_rect_object;
pub(crate) use self::events::{
EVENT_DISPATCHING_SLOT, EVENT_PASSIVE_SLOT, EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT,
- EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, event_initialized,
- event_internal_bool_flag, event_is_dispatching, event_is_error_event, event_is_mouse_event,
- initialize_event_object, mark_event_trusted, set_event_composed_path, set_event_internal_flag,
- set_event_trusted,
+ EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, event_attribute, event_backing,
+ event_bool_attribute, event_initialized, event_internal_bool_flag, event_is_dispatching,
+ event_is_error_event, event_is_mouse_event, event_private_value, initialize_event_object,
+ initialize_event_wrapper, mark_event_trusted, new_event_state, new_event_wrapper,
+ set_event_composed_path, set_event_internal_flag, set_event_private_value, set_event_trusted,
};
pub(crate) use self::file_api::{
DataTransferStringCallbackTask, DataTransferStringCallbackTaskEffect,
diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs
index 64eabfae8..00aa56a8c 100644
--- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs
@@ -5,8 +5,7 @@ use super::storage::{
use super::*;
use crate::context_bootstrap::events::initialize_event_object;
use crate::util::{
- callback_data_index_value, callback_data_item, get_private_value, global_constructor_prototype,
- set_private_value,
+ callback_data_index_value, callback_data_item, get_private_value, set_private_value,
};
use crate::web_api_interfaces;
use crate::webidl;
@@ -166,8 +165,12 @@ fn font_face_set_load_event_fontfaces_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'s, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), FONT_FACE_SET_LOAD_EVENT_FONTFACES_SLOT)
- .unwrap_or_else(|| v8::undefined(scope).into());
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ args.this(),
+ FONT_FACE_SET_LOAD_EVENT_FONTFACES_SLOT,
+ )
+ .unwrap_or_else(|| v8::undefined(scope).into());
rv.set(value);
}
@@ -239,14 +242,11 @@ fn dispatched_font_face_set_load_event<'s>(
event_type: &str,
fontfaces: Option<v8::Local<'s, v8::Array>>,
) -> v8::Local<'s, v8::Object> {
- let event = v8::Object::new(scope);
+ let event = crate::context_bootstrap::new_event_state(scope);
initialize_event_object(scope, event, event_type, false, false);
web_api_interfaces::FontFaceSetLoadEvent::DESCRIPTOR
.initialize(scope, event)
.expect("font loading events should carry their native interface brand");
- if let Some(prototype) = global_constructor_prototype(scope, "FontFaceSetLoadEvent") {
- let _ = event.set_prototype(scope, prototype.into());
- }
let mut values = Vec::new();
if let Some(fontfaces) = fontfaces {
for index in 0..fontfaces.length() {
@@ -262,7 +262,7 @@ fn dispatched_font_face_set_load_event<'s>(
FONT_FACE_SET_LOAD_EVENT_FONTFACES_SLOT,
fontfaces.into(),
);
- event
+ crate::context_bootstrap::new_event_wrapper(scope, event).expect("FontFaceSetLoadEvent wrapper")
}
pub(super) fn dispatch_font_face_set_event<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/event_target_dispatch.rs b/moli-renderer-v8/src/context_bootstrap/event_target_dispatch.rs
index f1942bdab..bb1fc3995 100644
--- a/moli-renderer-v8/src/context_bootstrap/event_target_dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/event_target_dispatch.rs
@@ -29,7 +29,7 @@ pub(crate) fn prepare_script_dispatch<'s>(
// Retaining a target keeps synthetic dispatch available. Each listener's
// relevant realm is checked separately by CallbackInvoker before invocation.
set_event_trusted(scope, event, false);
- let event_type = event
+ let event_type = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "type").into())?
.to_string(scope)?
.to_rust_string_lossy(scope);
diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs
index 2b16ad880..e045fbe45 100644
--- a/moli-renderer-v8/src/context_bootstrap/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events.rs
@@ -7,6 +7,7 @@ mod init;
mod kind;
mod methods;
mod subclasses;
+mod wrappers;
const CLOSE_EVENT_WAS_CLEAN_SLOT: &str = "__moliCloseEventWasClean";
const CLOSE_EVENT_CODE_SLOT: &str = "__moliCloseEventCode";
@@ -70,6 +71,8 @@ pub(in crate::context_bootstrap) fn new_uninitialized_text_event<'s>(
if event.set_prototype(scope, prototype.into()) != Some(true) {
return None;
}
+ let wrapper = event;
+ let event = new_event_state(scope);
base::initialize_event_object(scope, event, "", false, false);
if !subclasses::initialize_text_event(scope, event, None) {
return None;
@@ -81,7 +84,9 @@ pub(in crate::context_bootstrap) fn new_uninitialized_text_event<'s>(
v8::Integer::new(scope, EventSubclassKind::TextEvent as i32).into(),
);
base::set_event_initialized(scope, event, false);
- Some(event)
+ web_api_interfaces::initialize(scope, event, "TextEvent").ok()?;
+ initialize_event_wrapper(scope, wrapper, event)?;
+ Some(wrapper)
}
pub(crate) fn construct_original_page_transition_event<'s>(
@@ -178,6 +183,7 @@ pub(in crate::context_bootstrap) fn define_storage_event_properties_utf16<'s>(
url: &str,
storage_area: Option<v8::Local<'s, v8::Value>>,
) {
+ let event = event_backing(scope, event);
let key_value = storage_event_nullable_string_value_utf16(scope, key);
let old_value = storage_event_nullable_string_value_utf16(scope, old_value);
let new_value = storage_event_nullable_string_value_utf16(scope, new_value);
@@ -224,18 +230,16 @@ fn storage_event_nullable_string_value_utf16<'s>(
pub(crate) use base::{
EVENT_DISPATCHING_SLOT, EVENT_PASSIVE_SLOT, EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT,
- EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, event_initialized,
- event_internal_bool_flag, event_is_dispatching, initialize_event_object, mark_event_trusted,
- set_event_composed_path, set_event_internal_flag, set_event_trusted,
-};
-pub(in crate::context_bootstrap) use base::{
- bind_event_attribute, bind_event_backing, event_backing, event_trusted,
+ EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, define_event_property, event_backing,
+ event_initialized, event_internal_bool_flag, event_is_dispatching, initialize_event_object,
+ mark_event_trusted, set_event_composed_path, set_event_internal_flag, set_event_trusted,
};
+
fn event_subclass_kind<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<EventSubclassKind> {
- get_private_value(scope, event, EVENT_SUBCLASS_KIND_SLOT)
+ crate::context_bootstrap::event_private_value(scope, event, EVENT_SUBCLASS_KIND_SLOT)
.and_then(|value| v8::Local::<v8::Integer>::try_from(value).ok())
.and_then(|value| i32::try_from(value.value()).ok())
.and_then(EventSubclassKind::from_i32)
@@ -303,10 +307,7 @@ fn event_related_target_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> v8::Local<'s, v8::Value> {
- event
- .get_own_property_descriptor(scope, v8str(scope, "relatedTarget").into())
- .and_then(|descriptor| v8::Local::<v8::Object>::try_from(descriptor).ok())
- .and_then(|descriptor| descriptor.get(scope, v8str(scope, "value").into()))
+ wrappers::event_attribute_in_wrapper(scope, event, "relatedTarget")
.unwrap_or_else(|| v8::null(scope).into())
}
@@ -381,8 +382,12 @@ pub(super) fn close_event_was_clean_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), CLOSE_EVENT_WAS_CLEAN_SLOT)
- .unwrap_or_else(|| v8::Boolean::new(scope, false).into());
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ args.this(),
+ CLOSE_EVENT_WAS_CLEAN_SLOT,
+ )
+ .unwrap_or_else(|| v8::Boolean::new(scope, false).into());
rv.set(value);
}
@@ -391,8 +396,9 @@ pub(super) fn close_event_code_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), CLOSE_EVENT_CODE_SLOT)
- .unwrap_or_else(|| v8::Number::new(scope, 0.0).into());
+ let value =
+ crate::context_bootstrap::event_private_value(scope, args.this(), CLOSE_EVENT_CODE_SLOT)
+ .unwrap_or_else(|| v8::Number::new(scope, 0.0).into());
rv.set(value);
}
@@ -401,8 +407,9 @@ pub(super) fn close_event_reason_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), CLOSE_EVENT_REASON_SLOT)
- .unwrap_or_else(|| v8str(scope, "").into());
+ let value =
+ crate::context_bootstrap::event_private_value(scope, args.this(), CLOSE_EVENT_REASON_SLOT)
+ .unwrap_or_else(|| v8str(scope, "").into());
rv.set(value);
}
@@ -411,9 +418,18 @@ pub(super) fn submit_event_submitter_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), SUBMIT_EVENT_SUBMITTER_SLOT)
- .unwrap_or_else(|| v8::null(scope).into());
- rv.set(value);
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ args.this(),
+ SUBMIT_EVENT_SUBMITTER_SLOT,
+ )
+ .unwrap_or_else(|| v8::null(scope).into());
+ let Some(context) = args.this().get_creation_context(scope) else {
+ return;
+ };
+ if let Some(value) = super::platform_object_worlds::in_realm(scope, value, context) {
+ rv.set(value);
+ }
}
pub(super) fn form_data_event_form_data_getter_function<'s>(
@@ -421,9 +437,18 @@ pub(super) fn form_data_event_form_data_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), FORM_DATA_EVENT_FORM_DATA_SLOT)
- .unwrap_or_else(|| v8::undefined(scope).into());
- rv.set(value);
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ args.this(),
+ FORM_DATA_EVENT_FORM_DATA_SLOT,
+ )
+ .unwrap_or_else(|| v8::undefined(scope).into());
+ let Some(context) = args.this().get_creation_context(scope) else {
+ return;
+ };
+ if let Some(value) = super::platform_object_worlds::in_realm(scope, value, context) {
+ rv.set(value);
+ }
}
pub(super) fn track_event_track_getter_function<'s>(
@@ -431,7 +456,13 @@ pub(super) fn track_event_track_getter_function<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value = get_private_value(scope, args.this(), TRACK_EVENT_TRACK_SLOT)
- .unwrap_or_else(|| v8::null(scope).into());
+ let value =
+ crate::context_bootstrap::event_private_value(scope, args.this(), TRACK_EVENT_TRACK_SLOT)
+ .unwrap_or_else(|| v8::null(scope).into());
rv.set(value);
}
+
+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,
+};
diff --git a/moli-renderer-v8/src/context_bootstrap/events/base.rs b/moli-renderer-v8/src/context_bootstrap/events/base.rs
index 5bbc941d8..3f5f86712 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/base.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/base.rs
@@ -15,9 +15,9 @@ const EVENT_INITIALIZED_SLOT: &str = "__moliEventInitialized";
const EVENT_TRUSTED_PRIVATE_SLOT: &str = "__moliEventTrusted";
const EVENT_TIMESTAMP_PRIVATE_SLOT: &str = "__moliEventTimeStamp";
const EVENT_IS_TRUSTED_GETTER_FUNCTION_SLOT: &str = "__moliEventIsTrustedGetterFunction";
-const EVENT_BACKING_SLOT: &str = "__moliEventBacking";
+pub(super) const EVENT_BACKING_SLOT: &str = "__moliEventBacking";
-pub(in crate::context_bootstrap) fn event_backing<'s>(
+pub(crate) fn event_backing<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'_, v8::Object>,
) -> v8::Local<'s, v8::Object> {
@@ -25,88 +25,6 @@ pub(in crate::context_bootstrap) fn event_backing<'s>(
crate::util::get_private_object(scope, event, EVENT_BACKING_SLOT).unwrap_or(event)
}
-/// A projected Event has its own prototype and expandos, but all its views
-/// observe the same dispatch, cancellation and propagation flags.
-pub(in crate::context_bootstrap) fn bind_event_backing<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- wrapper: v8::Local<'s, v8::Object>,
- event: v8::Local<'s, v8::Object>,
-) {
- set_private_value(scope, wrapper, EVENT_BACKING_SLOT, event.into());
- for property in [
- "type",
- "target",
- "srcElement",
- "currentTarget",
- "eventPhase",
- "bubbles",
- "cancelable",
- "defaultPrevented",
- "composed",
- "info",
- ] {
- if property == "info"
- && event.has_own_property(scope, v8str(scope, property).into()) != Some(true)
- {
- continue;
- }
- bind_event_attribute(scope, wrapper, property);
- }
-}
-
-pub(in crate::context_bootstrap) fn bind_event_attribute<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- wrapper: v8::Local<'s, v8::Object>,
- property: &'static str,
-) {
- let getter = v8::Function::builder(shared_event_attribute_getter)
- .data(v8str(scope, property).into())
- .build(scope)
- .expect("event attribute getter");
- crate::definitions::define_get_set_property(
- scope,
- wrapper,
- v8str(scope, property).into(),
- getter.into(),
- v8::undefined(scope).into(),
- v8::PropertyAttribute::NONE,
- "shared Event attribute",
- )
- .expect("shared Event attribute");
-}
-
-fn shared_event_attribute_getter<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- args: v8::FunctionCallbackArguments<'s>,
- mut rv: v8::ReturnValue<'_, v8::Value>,
-) {
- let wrapper = args.this();
- let property = args.data().to_rust_string_lossy(scope);
- let value = shared_event_attribute_value(scope, wrapper, &property);
- rv.set(value.unwrap_or_else(|| v8::undefined(scope).into()));
-}
-
-fn shared_event_attribute_value<'s>(
- scope: &mut v8::PinScope<'s, '_>,
- wrapper: v8::Local<'s, v8::Object>,
- property: &str,
-) -> Option<v8::Local<'s, v8::Value>> {
- let event = event_backing(scope, wrapper);
- let key = v8_string(scope, property)?;
- let value = event.get(scope, key.into())?;
- if matches!(property, "target" | "srcElement" | "currentTarget")
- && let Ok(target) = v8::Local::<v8::Object>::try_from(value)
- && let Some(context) = wrapper.get_creation_context(scope)
- {
- return Some(
- crate::context_bootstrap::shared_event_targets::target_in_realm(scope, target, context)
- .into(),
- );
- }
- let context = wrapper.get_creation_context(scope)?;
- super::super::navigation_event_worlds::attribute_in_realm(scope, property, value, context)
-}
-
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct InitializedEventHeaderDeclaration<'scope> {
@@ -194,12 +112,13 @@ pub(in crate::context_bootstrap) fn event_type_argument<'s>(
)
}
-pub(in crate::context_bootstrap) fn define_event_property(
+pub(crate) fn define_event_property(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
key: &'static str,
value: v8::Local<'_, v8::Value>,
) {
+ let event = event_backing(scope, event);
let _ = event.set(scope, v8str(scope, key).into(), value);
}
@@ -231,6 +150,7 @@ pub(in crate::context_bootstrap) fn set_event_initialized(
event: v8::Local<'_, v8::Object>,
initialized: bool,
) {
+ let event = event_backing(scope, event);
set_private_value(
scope,
event,
@@ -298,16 +218,28 @@ pub(crate) fn event_composed_path_value<'s>(
event: v8::Local<'s, v8::Object>,
) -> v8::Local<'s, v8::Value> {
let backing = event_backing(scope, event);
- if !backing.strict_equals(event.into()) {
- let target = event.get(scope, v8str(scope, "target").into());
- return if event_is_dispatching(scope, backing) {
- v8::Array::new_with_elements(scope, &target.into_iter().collect::<Vec<_>>()).into()
- } else {
- v8::Array::new(scope, 0).into()
- };
+ let path = get_private_value(scope, backing, EVENT_COMPOSED_PATH_SLOT)
+ .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok());
+ let context = event.get_creation_context(scope);
+ let mut values = Vec::new();
+ if let Some(path) = path {
+ for index in 0..path.length() {
+ if let Some(value) = path.get_index(scope, index) {
+ let value = if let (Ok(target), Some(context)) =
+ (v8::Local::<v8::Object>::try_from(value), context)
+ {
+ crate::context_bootstrap::shared_event_targets::target_in_realm(
+ scope, target, context,
+ )
+ .into()
+ } else {
+ value
+ };
+ values.push(value);
+ }
+ }
}
- get_private_value(scope, event, EVENT_COMPOSED_PATH_SLOT)
- .unwrap_or_else(|| v8::Array::new(scope, 0).into())
+ v8::Array::new_with_elements(scope, &values).into()
}
pub(crate) fn set_event_composed_path<'s>(
@@ -399,6 +331,7 @@ pub(crate) fn initialize_event_object<'s>(
bubbles: bool,
cancelable: bool,
) {
+ let event = event_backing(scope, event);
initialize_event_declaration(scope, event, event_type, bubbles, cancelable);
}
@@ -432,7 +365,7 @@ fn initialize_event_after_header<'s>(
.expect("initialized event tail declaration should initialize");
}
-fn define_event_is_trusted_accessor<'s>(
+pub(super) fn define_event_is_trusted_accessor<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
@@ -488,20 +421,9 @@ fn event_core_attribute_getter<'s>(
return;
}
- let backing = event_backing(scope, receiver);
- if !backing.strict_equals(receiver.into()) {
- let value = shared_event_attribute_value(scope, receiver, key);
- rv.set(value.unwrap_or_else(|| v8::undefined(scope).into()));
- return;
+ if let Some(value) = super::wrappers::event_attribute_in_wrapper(scope, receiver, key) {
+ rv.set(value);
}
-
- let key = v8str(scope, key);
- let value = receiver
- .get_own_property_descriptor(scope, key.into())
- .and_then(|descriptor| v8::Local::<v8::Object>::try_from(descriptor).ok())
- .and_then(|descriptor| descriptor.get(scope, v8str(scope, "value").into()))
- .unwrap_or_else(|| v8::undefined(scope).into());
- rv.set(value);
}
macro_rules! define_event_core_attribute_getter {
@@ -554,7 +476,8 @@ pub(in crate::context_bootstrap) fn event_constructor_callback<'s>(
return;
}
- let event = args.this();
+ let wrapper = args.this();
+ let event = new_event_state(scope);
let Some(event_type) = event_type_argument(scope, &args, "Event") else {
return;
};
@@ -568,5 +491,7 @@ pub(in crate::context_bootstrap) fn event_constructor_callback<'s>(
v8::Boolean::new(scope, composed).into(),
);
- rv.set(event.into());
+ if initialize_event_wrapper(scope, wrapper, event).is_some() {
+ rv.set(wrapper.into());
+ }
}
diff --git a/moli-renderer-v8/src/context_bootstrap/events/methods.rs b/moli-renderer-v8/src/context_bootstrap/events/methods.rs
index bef8e4cea..28bb0ddaa 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/methods.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/methods.rs
@@ -16,7 +16,7 @@ pub(in crate::context_bootstrap) fn event_prevent_default_callback<'s>(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = args.this();
- if !object_bool_property(scope, event, "cancelable").unwrap_or(false) {
+ if !crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable") {
return;
}
if event_internal_bool_flag(scope, event, EVENT_PASSIVE_SLOT) {
@@ -35,7 +35,7 @@ pub(in crate::context_bootstrap) fn event_return_value_getter_function<'s>(
return;
}
let default_prevented =
- object_bool_property(scope, args.this(), "defaultPrevented").unwrap_or(false);
+ crate::context_bootstrap::event_bool_attribute(scope, args.this(), "defaultPrevented");
rv.set(v8::Boolean::new(scope, !default_prevented).into());
}
@@ -50,7 +50,7 @@ pub(in crate::context_bootstrap) fn event_return_value_setter_function<'s>(
return;
}
if args.get(0).boolean_value(scope)
- || !object_bool_property(scope, event, "cancelable").unwrap_or(false)
+ || !crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable")
|| event_internal_bool_flag(scope, event, EVENT_PASSIVE_SLOT)
{
return;
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
index de0cb8a69..fad7a1ea6 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
@@ -20,3 +20,5 @@ pub(in crate::context_bootstrap) use data::{
pub(in crate::context_bootstrap) use pointer::{
pointer_event_get_coalesced_events_callback, pointer_event_get_predicted_events_callback,
};
+
+pub(in crate::context_bootstrap::events) use data::initialize_navigate_event_methods;
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs
index ad9220957..286de81d8 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/constructor.rs
@@ -29,7 +29,8 @@ fn event_subclass_constructor_callback<'s>(
return;
}
- let event = args.this();
+ let wrapper = args.this();
+ let event = new_event_state(scope);
let Some(event_type) = event_type_argument(scope, &args, kind.constructor_name()) else {
return;
};
@@ -177,7 +178,9 @@ fn event_subclass_constructor_callback<'s>(
EVENT_SUBCLASS_KIND_SLOT,
v8::Integer::new(scope, kind as i32).into(),
);
- rv.set(event.into());
+ if initialize_event_wrapper(scope, wrapper, event).is_some() {
+ rv.set(wrapper.into());
+ }
}
pub(in crate::context_bootstrap) fn build_event_subclass_template<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs
index 04b1c31cc..e9cb6ece7 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs
@@ -779,9 +779,7 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_navigate_even
.initialize(scope, event)
.expect("NavigateEvent init declaration should initialize");
define_navigate_event_internal_flag(scope, event, true);
- NavigateEventMethodsDeclaration::default()
- .initialize(scope, event)
- .expect("NavigateEvent methods declaration should initialize");
+
true
}
@@ -790,7 +788,7 @@ fn define_navigate_event_internal_flag(
event: v8::Local<'_, v8::Object>,
synthetic: bool,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_SYNTHETIC_SLOT,
@@ -803,7 +801,8 @@ fn navigate_event_private_value<'s>(
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
- get_private_value(scope, event, slot).filter(|value| !value.is_undefined())
+ crate::context_bootstrap::event_private_value(scope, event, slot)
+ .filter(|value| !value.is_undefined())
}
fn navigate_event_private_bool<'s>(
@@ -823,7 +822,12 @@ fn set_navigate_event_private_bool<'s>(
slot: &'static str,
value: bool,
) {
- set_private_value(scope, event, slot, v8::Boolean::new(scope, value).into());
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ slot,
+ v8::Boolean::new(scope, value).into(),
+ );
}
fn navigate_event_can_use_navigation_api<'s>(
@@ -831,7 +835,8 @@ fn navigate_event_can_use_navigation_api<'s>(
event: v8::Local<'s, v8::Object>,
) -> bool {
let synthetic = navigate_event_private_bool(scope, event, NAVIGATE_EVENT_SYNTHETIC_SLOT, true);
- let can_intercept = object_bool_property(scope, event, "canIntercept").unwrap_or(false);
+ let can_intercept =
+ crate::context_bootstrap::event_bool_attribute(scope, event, "canIntercept");
!synthetic && can_intercept
}
@@ -864,7 +869,7 @@ fn navigate_event_target_is_connected(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) -> bool {
- let Some(target) = event
+ let Some(target) = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "target").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
else {
@@ -890,7 +895,7 @@ fn navigate_event_can_intercept_now<'s>(
if !navigate_event_is_dispatching(scope, event) {
return false;
}
- if object_bool_property(scope, event, "defaultPrevented").unwrap_or(false) {
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "defaultPrevented") {
return false;
}
navigate_event_target_is_connected(scope, event)
@@ -928,7 +933,7 @@ fn navigate_event_intercept_callback<'s>(
return;
}
if options.precommit_handler.is_some()
- && !object_bool_property(scope, event, "cancelable").unwrap_or(false)
+ && !crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable")
{
navigate_event_throw_invalid_state(scope);
return;
@@ -1003,7 +1008,7 @@ fn install_navigate_event_precommit_transition<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) {
- if get_private_value(
+ if crate::context_bootstrap::event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_RESOLVER_SLOT,
@@ -1012,7 +1017,7 @@ fn install_navigate_event_precommit_transition<'s>(
{
return;
}
- let Some(navigation) = get_private_value(
+ let Some(navigation) = crate::context_bootstrap::event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_NAVIGATION_SLOT,
@@ -1020,22 +1025,28 @@ fn install_navigate_event_precommit_transition<'s>(
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok()) else {
return;
};
- let Some(from) = get_private_value(scope, event, NAVIGATE_EVENT_PRECOMMIT_TRANSITION_FROM_SLOT)
- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
- else {
+ let Some(from) = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ NAVIGATE_EVENT_PRECOMMIT_TRANSITION_FROM_SLOT,
+ )
+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok()) else {
return;
};
- let destination = get_private_value(
+ let destination = crate::context_bootstrap::event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_DESTINATION_SLOT,
)
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok());
- let navigation_type =
- get_private_value(scope, event, NAVIGATE_EVENT_PRECOMMIT_TRANSITION_TYPE_SLOT)
- .and_then(|value| value.to_string(scope))
- .map(|value| value.to_rust_string_lossy(scope))
- .unwrap_or_else(|| "push".to_owned());
+ let navigation_type = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ NAVIGATE_EVENT_PRECOMMIT_TRANSITION_TYPE_SLOT,
+ )
+ .and_then(|value| value.to_string(scope))
+ .map(|value| value.to_rust_string_lossy(scope))
+ .unwrap_or_else(|| "push".to_owned());
let navigation_type = match navigation_type.as_str() {
"replace" => "replace",
"reload" => "reload",
@@ -1047,7 +1058,7 @@ fn install_navigate_event_precommit_transition<'s>(
else {
return;
};
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_RESOLVER_SLOT,
@@ -1158,8 +1169,7 @@ fn precommit_controller_redirect_callback<'s>(
let Some(event) = precommit_controller_event(scope, args.data()) else {
return;
};
- let event = crate::context_bootstrap::events::event_backing(scope, event);
- let navigation_type = event
+ let navigation_type = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "navigationType").into())
.and_then(|value| value.to_string(scope))
.map(|value| value.to_rust_string_lossy(scope))
@@ -1168,7 +1178,7 @@ fn precommit_controller_redirect_callback<'s>(
navigate_event_throw_invalid_state(scope);
return;
}
- let Some(destination) = event
+ let Some(destination) = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "destination").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
else {
@@ -1254,7 +1264,7 @@ fn apply_precommit_redirect_options<'s>(
.map(|value| value.to_rust_string_lossy(scope))
.filter(|value| matches!(value.as_str(), "push" | "replace"))
{
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_REDIRECT_HISTORY_SLOT,
@@ -1273,7 +1283,6 @@ fn navigate_event_defer_page_swap_callback<'s>(
navigate_event_throw_synthetic_security_error(scope);
return;
};
- let event = crate::context_bootstrap::events::event_backing(scope, event);
if !navigate_event_can_use_navigation_api(scope, event) {
navigate_event_throw_synthetic_security_error(scope);
return;
@@ -1292,17 +1301,17 @@ fn navigate_event_scroll_callback<'s>(
navigate_event_throw_synthetic_security_error(scope);
return;
};
- let event = crate::context_bootstrap::events::event_backing(scope, event);
if !navigate_event_can_use_navigation_api(scope, event) {
navigate_event_throw_synthetic_security_error(scope);
return;
}
let intercepted =
navigate_event_private_bool(scope, event, NAVIGATE_EVENT_INTERCEPTED_SLOT, false);
- let default_prevented = object_bool_property(scope, event, "defaultPrevented").unwrap_or(false);
+ let default_prevented =
+ crate::context_bootstrap::event_bool_attribute(scope, event, "defaultPrevented");
let already_scrolled =
navigate_event_private_bool(scope, event, NAVIGATE_EVENT_SCROLL_CALLED_SLOT, false);
- let active = event
+ let active = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "target").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.is_some_and(|navigation| navigation_scroll_event_is_active(scope, navigation, event));
@@ -1316,7 +1325,7 @@ fn navigate_event_scroll_callback<'s>(
return;
}
set_navigate_event_private_bool(scope, event, NAVIGATE_EVENT_SCROLL_CALLED_SLOT, true);
- let Some(target_url) = event
+ let Some(target_url) = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "destination").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
.and_then(|destination| destination.get(scope, v8str(scope, "url").into()))
@@ -1348,19 +1357,24 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_close_event<'
let code = init_number_property(scope, init, "code", 0.0);
let reason = init_string_property(scope, init, "reason", "");
let reason_value = v8_string(scope, &reason).unwrap().into();
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
CLOSE_EVENT_WAS_CLEAN_SLOT,
v8::Boolean::new(scope, was_clean).into(),
);
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
CLOSE_EVENT_CODE_SLOT,
v8::Number::new(scope, code).into(),
);
- set_private_value(scope, event, CLOSE_EVENT_REASON_SLOT, reason_value);
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ CLOSE_EVENT_REASON_SLOT,
+ reason_value,
+ );
}
pub(in crate::context_bootstrap::events::subclasses) fn initialize_submit_event<'s>(
@@ -1371,7 +1385,12 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_submit_event<
let Some(submitter) = submit_event_submitter(scope, init) else {
return false;
};
- set_private_value(scope, event, SUBMIT_EVENT_SUBMITTER_SLOT, submitter);
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ SUBMIT_EVENT_SUBMITTER_SLOT,
+ submitter,
+ );
true
}
@@ -1408,7 +1427,12 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_form_data_eve
);
return false;
}
- set_private_value(scope, event, FORM_DATA_EVENT_FORM_DATA_SLOT, form_data);
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ FORM_DATA_EVENT_FORM_DATA_SLOT,
+ form_data,
+ );
true
}
@@ -1429,7 +1453,7 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_track_event<'
init: Option<v8::Local<'s, v8::Object>>,
) {
let track = init_value_property(scope, init, "track").unwrap_or_else(|| v8::null(scope).into());
- set_private_value(scope, event, TRACK_EVENT_TRACK_SLOT, track);
+ crate::context_bootstrap::set_event_private_value(scope, event, TRACK_EVENT_TRACK_SLOT, track);
}
pub(in crate::context_bootstrap::events::subclasses) fn initialize_interest_event<'s>(
@@ -1490,3 +1514,12 @@ fn submitter_is_html_element(
.node(handle)
.is_some_and(|node| node.is_element())
}
+
+pub(in crate::context_bootstrap::events) fn initialize_navigate_event_methods<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'s, v8::Object>,
+) {
+ NavigateEventMethodsDeclaration::default()
+ .initialize(scope, event)
+ .expect("NavigateEvent methods declaration should initialize");
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs
index ab0707706..d2d029bd1 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/pointer.rs
@@ -322,7 +322,7 @@ fn pointer_event_sequence_copy<'s>(
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> v8::Local<'s, v8::Array> {
- let Some(stored) = get_private_value(scope, event, slot)
+ let Some(stored) = crate::context_bootstrap::event_private_value(scope, event, slot)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
else {
return v8::Array::new(scope, 0);
diff --git a/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs
new file mode 100644
index 000000000..941a7fce5
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/events/wrappers.rs
@@ -0,0 +1,171 @@
+//! World-local Event wrappers over a private, V8-managed state object.
+//!
+//! The state is never passed to script. Keeping its JS values in the V8 heap
+//! lets the collector trace cycles such as wrapper -> state -> detail -> wrapper.
+//! Rust runs the dispatch algorithms; V8 owns the state and its lifetime.
+//! The world cache contains weak wrappers, not persistent roots for that graph.
+
+use super::*;
+use crate::context_bootstrap::{exposed_interfaces, world_wrappers};
+
+pub(crate) fn new_event_state<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Object> {
+ crate::util::new_null_prototype_object(scope)
+}
+
+/// Bind a fresh wrapper without invoking a public constructor or inspecting an
+/// author's properties. The original constructor's `this` remains its wrapper.
+pub(crate) fn initialize_event_wrapper<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ wrapper: v8::Local<'s, v8::Object>,
+ state: v8::Local<'s, v8::Object>,
+) -> Option<()> {
+ let interface = moli_webapi_declare::web_api_object_type(scope, state)?.name();
+ crate::web_api_interfaces::initialize(scope, wrapper, interface).ok()?;
+ set_private_value(
+ scope,
+ wrapper,
+ super::base::EVENT_BACKING_SLOT,
+ state.into(),
+ );
+ let names = state.get_own_property_names(
+ scope,
+ v8::GetPropertyNamesArgs {
+ property_filter: v8::PropertyFilter::ALL_PROPERTIES | v8::PropertyFilter::SKIP_SYMBOLS,
+ ..Default::default()
+ },
+ )?;
+ for index in 0..names.length() {
+ let property = names.get_index(scope, index)?;
+ if property.to_rust_string_lossy(scope) == "isTrusted" {
+ super::base::define_event_is_trusted_accessor(scope, wrapper);
+ } else {
+ let attributes = state.get_property_attributes(scope, property)?;
+ bind_attribute(scope, wrapper, property, attributes)?;
+ }
+ }
+ if interface == "NavigateEvent" {
+ super::subclasses::initialize_navigate_event_methods(scope, wrapper);
+ }
+ world_wrappers::insert(scope, state, wrapper);
+ Some(())
+}
+
+pub(crate) fn new_event_wrapper<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ state: v8::Local<'s, v8::Object>,
+) -> Option<v8::Local<'s, v8::Object>> {
+ let state = event_backing(scope, state);
+ let interface = moli_webapi_declare::web_api_object_type(scope, state)?.name();
+ let prototype =
+ exposed_interfaces::ensure_intrinsic_interface_prototype(scope, interface).ok()?;
+ let wrapper = v8::Object::new(scope);
+ if wrapper.set_prototype(scope, prototype.into()) != Some(true) {
+ return None;
+ }
+ initialize_event_wrapper(scope, wrapper, state)?;
+ Some(wrapper)
+}
+
+fn bind_attribute<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ wrapper: v8::Local<'s, v8::Object>,
+ property: v8::Local<'s, v8::Value>,
+ attributes: v8::PropertyAttribute,
+) -> Option<()> {
+ let name = v8::Local::<v8::Name>::try_from(property).ok()?;
+ let getter = v8::Function::builder(event_attribute_getter)
+ .data(property)
+ .build(scope)?;
+ let getter_name = format!("get {}", property.to_rust_string_lossy(scope));
+ getter.set_name(v8_string(scope, &getter_name)?);
+ let mut accessor_attributes = v8::PropertyAttribute::NONE;
+ if attributes.is_dont_enum() {
+ accessor_attributes = accessor_attributes | v8::PropertyAttribute::DONT_ENUM;
+ }
+ if attributes.is_dont_delete() {
+ accessor_attributes = accessor_attributes | v8::PropertyAttribute::DONT_DELETE;
+ }
+ crate::definitions::define_get_set_property(
+ scope,
+ wrapper,
+ name,
+ getter.into(),
+ v8::undefined(scope).into(),
+ accessor_attributes,
+ "Event attribute",
+ )
+ .ok()
+}
+
+fn event_attribute_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ if event_initialized(scope, args.this()).is_none() {
+ throw_type_error(scope, "Illegal invocation");
+ return;
+ }
+ let property = args.data().to_rust_string_lossy(scope);
+ if let Some(value) = event_attribute_in_wrapper(scope, args.this(), &property) {
+ rv.set(value);
+ }
+}
+
+pub(super) fn event_attribute_in_wrapper<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ wrapper: v8::Local<'s, v8::Object>,
+ property: &str,
+) -> Option<v8::Local<'s, v8::Value>> {
+ let value = event_attribute(scope, wrapper, property)?;
+ let context = wrapper.get_creation_context(scope)?;
+ if matches!(property, "target" | "srcElement" | "currentTarget")
+ && let Ok(target) = v8::Local::<v8::Object>::try_from(value)
+ {
+ return Some(
+ crate::context_bootstrap::shared_event_targets::target_in_realm(scope, target, context)
+ .into(),
+ );
+ }
+ crate::context_bootstrap::navigation_event_worlds::attribute_in_realm(
+ scope, property, value, context,
+ )
+}
+
+/// Engine reads must bypass the public wrapper, including own shadows and
+/// getters. Constructors initialize these fields on the private state directly.
+pub(crate) fn event_attribute<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'_, v8::Object>,
+ property: &str,
+) -> Option<v8::Local<'s, v8::Value>> {
+ let state = event_backing(scope, event);
+ state.get(scope, v8_string(scope, property)?.into())
+}
+
+pub(crate) fn event_bool_attribute<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'_, v8::Object>,
+ property: &str,
+) -> bool {
+ event_attribute(scope, event, property).is_some_and(|value| value.boolean_value(scope))
+}
+
+pub(crate) fn event_private_value<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'_, v8::Object>,
+ slot: &str,
+) -> Option<v8::Local<'s, v8::Value>> {
+ let state = event_backing(scope, event);
+ get_private_value(scope, state, slot)
+}
+
+pub(crate) fn set_event_private_value(
+ scope: &mut v8::PinScope<'_, '_>,
+ event: v8::Local<'_, v8::Object>,
+ slot: &str,
+ value: v8::Local<'_, v8::Value>,
+) {
+ let state = event_backing(scope, event);
+ set_private_value(scope, state, slot, value);
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/dispatch.rs
index 336dd7313..f60b5288a 100644
--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/dispatch.rs
@@ -68,7 +68,7 @@ pub(in crate::context_bootstrap::indexed_db) fn dispatch_idb_event_object<'s>(
clear_event_dispatch_fields(scope, event);
owner_scope.defer_restore(scope, previous_owner);
- !object_bool_property(scope, event, "defaultPrevented").unwrap_or(false)
+ !crate::context_bootstrap::event_bool_attribute(scope, event, "defaultPrevented")
}
fn idb_event_target_owner_scope<'s>(
diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs
index 36e1230b7..d0bb35658 100644
--- a/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs
+++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/event_target/version_change.rs
@@ -44,7 +44,8 @@ pub(in crate::context_bootstrap) fn idb_version_change_event_constructor_callbac
else {
return;
};
- let event = args.this();
+ let wrapper = args.this();
+ let event = events::new_event_state(scope);
events::initialize_event_object(scope, event, &parsed.event_type, false, false);
IdbVersionChangeEventFieldsDeclaration::new(
parsed.init.old_version,
@@ -52,7 +53,11 @@ pub(in crate::context_bootstrap) fn idb_version_change_event_constructor_callbac
)
.initialize(scope, event)
.expect("IDBVersionChangeEvent fields declaration should initialize");
- rv.set(event.into());
+ crate::web_api_interfaces::initialize(scope, event, "IDBVersionChangeEvent")
+ .expect("IDBVersionChangeEvent brand");
+ if events::initialize_event_wrapper(scope, wrapper, event).is_some() {
+ rv.set(wrapper.into());
+ }
}
pub(in crate::context_bootstrap::indexed_db) fn dispatch_version_change_event<'s>(
@@ -62,32 +67,19 @@ pub(in crate::context_bootstrap::indexed_db) fn dispatch_version_change_event<'s
old_version: u64,
new_version: Option<u64>,
) -> bool {
- let global = scope.get_current_context().global(scope);
- let Some(event_ctor) = global
- .get(scope, v8str(scope, "IDBVersionChangeEvent").into())
- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
- else {
- return dispatch_idb_named_event(scope, target, event_type, |scope, event| {
- IdbVersionChangeEventFieldsDeclaration::new(
- old_version,
- version_change_nullable_version_value(scope, new_version),
- )
- .initialize(scope, event)
- .expect("IDBVersionChangeEvent fallback fields declaration should initialize");
- });
- };
- let Some(event_type) = v8_string(scope, event_type) else {
- return true;
- };
- let Some(event) = event_ctor.new_instance(scope, &[event_type.into()]) else {
- return true;
- };
+ let state = events::new_event_state(scope);
+ events::initialize_event_object(scope, state, event_type, false, false);
IdbVersionChangeEventFieldsDeclaration::new(
old_version,
version_change_nullable_version_value(scope, new_version),
)
- .initialize(scope, event)
- .expect("IDBVersionChangeEvent dispatched fields declaration should initialize");
+ .initialize(scope, state)
+ .expect("IDBVersionChangeEvent state");
+ crate::web_api_interfaces::initialize(scope, state, "IDBVersionChangeEvent")
+ .expect("IDBVersionChangeEvent brand");
+ let Some(event) = events::new_event_wrapper(scope, state) else {
+ return true;
+ };
dispatch_idb_event_object(scope, target, event)
}
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries.rs b/moli-renderer-v8/src/context_bootstrap/media_queries.rs
index 486a77aa4..eae04beb0 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries.rs
@@ -26,6 +26,6 @@ pub(super) use self::events::{
use super::{
MEDIA_QUERY_LIST_LISTENERS_SLOT, SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT,
- SIMPLE_EVENT_TARGET_SLOT, object_bool_property, object_property_as_array,
- object_string_property_defined, v8_string, v8str,
+ SIMPLE_EVENT_TARGET_SLOT, object_property_as_array, object_string_property_defined, v8_string,
+ v8str,
};
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/event.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/event.rs
index 6307de47f..7bdfaaa9a 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/event.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/event.rs
@@ -1,6 +1,6 @@
use crate::{
context_bootstrap::events::{initialize_event_object, mark_event_trusted},
- util::{get_private_value, throw_type_error, v8str},
+ util::{throw_type_error, v8str},
web_api_interfaces, webidl,
};
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
@@ -98,7 +98,8 @@ fn constructor<'s>(
return;
}
};
- let event = args.this();
+ let wrapper = args.this();
+ let event = crate::context_bootstrap::new_event_state(scope);
initialize_event_object(scope, event, "", init.bubbles, init.cancelable);
let _ = event.set(scope, v8str(scope, "type").into(), event_type.into());
let _ = event.set(
@@ -109,7 +110,11 @@ fn constructor<'s>(
MediaQueryListEventState::new(init.media, init.matches)
.initialize(scope, event)
.expect("MediaQueryListEvent state should initialize");
- rv.set(event.into());
+ web_api_interfaces::initialize(scope, event, "MediaQueryListEvent")
+ .expect("MediaQueryListEvent brand");
+ if crate::context_bootstrap::initialize_event_wrapper(scope, wrapper, event).is_some() {
+ rv.set(wrapper.into());
+ }
}
pub(in crate::context_bootstrap) fn build_media_query_list_event_template<'s>(
@@ -132,12 +137,13 @@ pub(super) fn create_media_query_list_event<'s>(
matches: bool,
) -> v8::Local<'s, v8::Object> {
let media = v8::String::new(scope, media).expect("media query string");
- let event = MediaQueryListEventState::new(media, matches)
- .bind(scope)
- .expect("MediaQueryListEvent should bind");
+ let event = crate::context_bootstrap::new_event_state(scope);
initialize_event_object(scope, event, "change", false, false);
+ MediaQueryListEventState::new(media, matches)
+ .initialize(scope, event)
+ .expect("MediaQueryListEvent state");
mark_event_trusted(scope, event);
- event
+ crate::context_bootstrap::new_event_wrapper(scope, event).expect("MediaQueryListEvent wrapper")
}
fn media_getter<'s>(
@@ -145,7 +151,9 @@ fn media_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if let Some(value) = get_private_value(scope, args.this(), MEDIA_SLOT) {
+ if let Some(value) =
+ crate::context_bootstrap::event_private_value(scope, args.this(), MEDIA_SLOT)
+ {
rv.set(value);
}
}
@@ -155,7 +163,9 @@ fn matches_getter<'s>(
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- if let Some(value) = get_private_value(scope, args.this(), MATCHES_SLOT) {
+ if let Some(value) =
+ crate::context_bootstrap::event_private_value(scope, args.this(), MATCHES_SLOT)
+ {
rv.set(value);
}
}
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
index 13533417d..0d8899649 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events.rs
@@ -1,7 +1,7 @@
use super::{
MEDIA_QUERY_LIST_LISTENERS_SLOT, SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT,
- SIMPLE_EVENT_TARGET_SLOT, object_bool_property, object_property_as_array,
- object_string_property_defined, v8_string, v8str,
+ SIMPLE_EVENT_TARGET_SLOT, object_property_as_array, object_string_property_defined, v8_string,
+ v8str,
};
const SIMPLE_EVENT_TARGET_HANDLER_SLOT_FIELD: &str = "handlerSlot";
diff --git a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/dispatch.rs
index 29470ecff..c2154a383 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_queries/events/simple_event_target/dispatch.rs
@@ -134,7 +134,6 @@ pub(crate) fn dispatch_simple_event_target_event_collecting_errors<'s>(
scope,
target,
event,
- event_type,
listener.relevant_context(),
)
else {
@@ -172,7 +171,8 @@ pub(crate) fn dispatch_simple_event_target_event_collecting_errors<'s>(
}
crate::context_bootstrap::event_target_dispatch::finish_dispatch(scope, event);
- let default_prevented = object_bool_property(scope, event, "defaultPrevented").unwrap_or(false);
+ let default_prevented =
+ crate::context_bootstrap::event_bool_attribute(scope, event, "defaultPrevented");
SimpleEventDispatchResult {
uncanceled: !default_prevented,
dispatched,
@@ -351,7 +351,7 @@ fn apply_handler_return_value<'s>(
returned: v8::Local<'s, v8::Value>,
) {
if returned.is_false()
- && object_bool_property(scope, event, "cancelable").unwrap_or(false)
+ && crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable")
&& !event_internal_bool_flag(scope, event, EVENT_PASSIVE_SLOT)
{
set_event_default_prevented(scope, event);
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_callbacks/navigation.rs b/moli-renderer-v8/src/context_bootstrap/navigation_callbacks/navigation.rs
index f12f58c40..2e6422309 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_callbacks/navigation.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_callbacks/navigation.rs
@@ -1085,7 +1085,7 @@ fn precommit_transition_resolver_from_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::PromiseResolver>> {
- get_private_value(
+ crate::context_bootstrap::event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_RESOLVER_SLOT,
@@ -1230,9 +1230,7 @@ fn precommit_commit_fulfilled_callback<'s>(
proceed: true,
intercepted: true,
signal: data.signal,
- destination: data
- .event
- .get(scope, v8str(scope, "destination").into())
+ destination: crate::context_bootstrap::event_attribute(scope, data.event, "destination")
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok()),
redirected_url: None,
redirected_history: None,
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_event_worlds.rs b/moli-renderer-v8/src/context_bootstrap/navigation_event_worlds.rs
index c1a560624..f79b8443d 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_event_worlds.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_event_worlds.rs
@@ -2,28 +2,17 @@
//! internal control object, so page expandos cannot cross into another world.
use super::{events, history_runtime::native, shared_event_targets, world_wrappers};
-use crate::util::v8str;
pub(super) fn event_in_realm<'s>(
scope: &mut v8::PinScope<'s, '_>,
target: v8::Local<'s, v8::Object>,
event: v8::Local<'s, v8::Object>,
- event_type: &str,
context: v8::Local<'s, v8::Context>,
) -> Option<v8::Local<'s, v8::Object>> {
if !shared_event_targets::is_shared_target(scope, target) {
return Some(event);
}
let backing = events::event_backing(scope, event);
- // Register an author's original object in its world; foreign listeners
- // receive their own wrapper, even when the event is untrusted. A retained
- // UA view already belongs to the backing object's wrapper cache.
- if backing.strict_equals(event.into()) && !events::event_trusted(scope, event) {
- let creation = event.get_creation_context(scope)?;
- if world_wrappers::get(scope, backing, creation).is_none() {
- world_wrappers::insert(scope, backing, event);
- }
- }
let target = shared_event_targets::target_in_realm(scope, target, context);
// A callback in another same-world Document still receives the owning
// Window's wrapper. Its callback realm is entered separately by the invoker.
@@ -32,33 +21,7 @@ pub(super) fn event_in_realm<'s>(
return Some(wrapper);
}
let scope = &mut v8::ContextScope::new(scope, context);
- let init = crate::util::new_null_prototype_object(scope);
- // Native interface identity survives author prototype/constructor changes
- // and initEvent(). An event named "navigate" can still be an ordinary Event.
- let interface = moli_webapi_declare::web_api_object_type(scope, backing)?.name();
- let properties = init_properties(interface);
- for property in properties
- .iter()
- .copied()
- .chain(["bubbles", "cancelable", "composed"])
- {
- let value = backing.get(scope, v8str(scope, property).into())?;
- let value = attribute_in_realm(scope, property, value, context)?;
- let _ = init.set(scope, v8str(scope, property).into(), value);
- }
- let constructor =
- super::exposed_interfaces::ensure_intrinsic_interface_constructor(scope, interface).ok()?;
- let event_type = crate::util::v8_string(scope, event_type)?;
- let wrapper = constructor.new_instance(scope, &[event_type.into(), init.into()])?;
- for property in ["target", "srcElement"] {
- let _ = wrapper.set(scope, v8str(scope, property).into(), target.into());
- }
- events::bind_event_backing(scope, wrapper, backing);
- for property in properties {
- events::bind_event_attribute(scope, wrapper, property);
- }
- world_wrappers::insert(scope, backing, wrapper);
- Some(wrapper)
+ events::new_event_wrapper(scope, backing)
}
pub(super) fn attribute_in_realm<'s>(
@@ -83,147 +46,3 @@ pub(super) fn attribute_in_realm<'s>(
_ => Some(value),
}
}
-
-fn init_properties(interface: &str) -> Vec<&'static str> {
- let mut properties = Vec::new();
- if matches!(
- interface,
- "UIEvent"
- | "FocusEvent"
- | "TextEvent"
- | "CompositionEvent"
- | "MouseEvent"
- | "KeyboardEvent"
- | "WheelEvent"
- | "PointerEvent"
- | "TouchEvent"
- | "DragEvent"
- | "InputEvent"
- | "CapturedMouseEvent"
- ) {
- properties.extend(["view", "detail"]);
- }
- if matches!(
- interface,
- "MouseEvent" | "WheelEvent" | "PointerEvent" | "DragEvent" | "CapturedMouseEvent"
- ) {
- properties.extend([
- "screenX",
- "screenY",
- "clientX",
- "clientY",
- "ctrlKey",
- "shiftKey",
- "altKey",
- "metaKey",
- "button",
- "buttons",
- "relatedTarget",
- "movementX",
- "movementY",
- ]);
- }
- let own: &[&str] = match interface {
- "CustomEvent" => &["detail"],
- "FocusEvent" => &["relatedTarget"],
- "TextEvent" | "CompositionEvent" => &["data"],
- "KeyboardEvent" => &[
- "key",
- "code",
- "location",
- "ctrlKey",
- "shiftKey",
- "altKey",
- "metaKey",
- "repeat",
- "isComposing",
- "charCode",
- "keyCode",
- "which",
- ],
- "WheelEvent" => &["deltaX", "deltaY", "deltaZ", "deltaMode"],
- "PointerEvent" => &[
- "pointerId",
- "width",
- "height",
- "pressure",
- "tangentialPressure",
- "tiltX",
- "tiltY",
- "twist",
- "altitudeAngle",
- "azimuthAngle",
- "pointerType",
- "isPrimary",
- "persistentDeviceId",
- ],
- "TouchEvent" => &[
- "touches",
- "targetTouches",
- "changedTouches",
- "ctrlKey",
- "shiftKey",
- "altKey",
- "metaKey",
- ],
- "MessageEvent" => &["data", "origin", "lastEventId", "source", "ports"],
- "ErrorEvent" => &["message", "filename", "lineno", "colno", "error"],
- "PromiseRejectionEvent" => &["promise", "reason"],
- "NavigationCurrentEntryChangeEvent" => &["from", "navigationType"],
- "NavigateEvent" => &[
- "navigationType",
- "destination",
- "canIntercept",
- "userInitiated",
- "hashChange",
- "signal",
- "formData",
- "downloadRequest",
- "info",
- "sourceElement",
- "hasUAVisualTransition",
- ],
- "CloseEvent" => &["wasClean", "code", "reason"],
- "DragEvent" => &["dataTransfer"],
- "ClipboardEvent" => &["clipboardData"],
- "CapturedMouseEvent" => &["surfaceX", "surfaceY"],
- "SubmitEvent" => &["submitter"],
- "FormDataEvent" => &["formData"],
- "InputEvent" => &[
- "data",
- "isComposing",
- "inputType",
- "dataTransfer",
- "targetRanges",
- ],
- "PopStateEvent" => &["state", "hasUAVisualTransition"],
- "PageTransitionEvent" => &["persisted"],
- "CommandEvent" => &["command", "source"],
- "ToggleEvent" => &["oldState", "newState", "source"],
- "TrackEvent" => &["track"],
- "InterestEvent" => &["source"],
- "StorageEvent" => &["key", "oldValue", "newValue", "url", "storageArea"],
- "SecurityPolicyViolationEvent" => &[
- "documentURI",
- "referrer",
- "blockedURI",
- "violatedDirective",
- "effectiveDirective",
- "originalPolicy",
- "disposition",
- "sourceFile",
- "sample",
- "statusCode",
- "lineNumber",
- "columnNumber",
- ],
- "FontFaceSetLoadEvent" => &["fontfaces"],
- "ProgressEvent" => &["lengthComputable", "loaded", "total"],
- "HashChangeEvent" => &["oldURL", "newURL"],
- "AnimationEvent" => &["animationName", "elapsedTime", "pseudoElement"],
- "TransitionEvent" => &["propertyName", "elapsedTime", "pseudoElement"],
- _ => &[],
- };
- properties.extend_from_slice(own);
- properties
-}
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_events.rs b/moli-renderer-v8/src/context_bootstrap/navigation_events.rs
index 8ddd2382b..35cb2703a 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_events.rs
@@ -104,13 +104,6 @@ struct HashChangeEventStateDeclaration {
new_url: String,
}
-#[derive(WebApiObject)]
-#[webapi(plain)]
-struct PageTransitionEventStateDeclaration {
- #[webapi(data_property)]
- persisted: bool,
-}
-
#[derive(WebApiObject)]
#[webapi(plain)]
struct NavigateEventInitDeclaration<'scope> {
@@ -232,7 +225,7 @@ pub(super) fn mark_navigation_outcome_default_prevented<'s>(
let Some(event) = outcome.precommit_event else {
return;
};
- let _ = event.define_own_property(
+ let _ = crate::context_bootstrap::event_backing(scope, event).define_own_property(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -358,7 +351,11 @@ pub(in crate::context_bootstrap) fn navigation_scroll_event_is_active<'s>(
event: v8::Local<'s, v8::Object>,
) -> bool {
get_private_value(scope, navigation, NAVIGATION_ACTIVE_SCROLL_EVENT_SLOT)
- .is_some_and(|active| active.strict_equals(event.into()))
+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
+ .is_some_and(|active| {
+ let active = event_backing(scope, active);
+ active.strict_equals(event_backing(scope, event).into())
+ })
}
fn navigation_active_navigate_event<'s>(
@@ -477,7 +474,8 @@ fn navigate_event_private_value<'s>(
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> Option<v8::Local<'s, v8::Value>> {
- get_private_value(scope, event, slot).filter(|value| !value.is_undefined())
+ crate::context_bootstrap::event_private_value(scope, event, slot)
+ .filter(|value| !value.is_undefined())
}
fn navigate_event_private_bool<'s>(
@@ -497,7 +495,12 @@ fn set_navigate_event_private_bool<'s>(
slot: &'static str,
value: bool,
) {
- set_private_value(scope, event, slot, v8::Boolean::new(scope, value).into());
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ slot,
+ v8::Boolean::new(scope, value).into(),
+ );
}
fn install_precommit_transition_seed<'s>(
@@ -511,19 +514,19 @@ fn install_precommit_transition_seed<'s>(
let Some(from) = navigation_current_entry(scope, owner) else {
return;
};
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_NAVIGATION_SLOT,
navigation.into(),
);
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_FROM_SLOT,
from.into(),
);
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_DESTINATION_SLOT,
@@ -532,7 +535,7 @@ fn install_precommit_transition_seed<'s>(
let navigation_type = v8_string(scope, navigation_type)
.map(v8::Local::<v8::Value>::from)
.unwrap_or_else(|| v8::String::empty(scope).into());
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
NAVIGATE_EVENT_PRECOMMIT_TRANSITION_TYPE_SLOT,
@@ -554,8 +557,8 @@ pub(super) fn cancel_active_navigation_event<'s>(
.map(|value| value.to_rust_string_lossy(scope))
.unwrap_or_default();
clear_navigation_active_navigate_event(scope, navigation);
- if object_bool_property(scope, event, "cancelable").unwrap_or(false) {
- let _ = event.define_own_property(
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable") {
+ let _ = crate::context_bootstrap::event_backing(scope, event).define_own_property(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -563,7 +566,12 @@ pub(super) fn cancel_active_navigation_event<'s>(
);
}
let error = navigation_dom_exception(scope, "Navigation was canceled", "AbortError");
- set_private_value(scope, event, NAVIGATE_EVENT_ABORT_ERROR_SLOT, error);
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ NAVIGATE_EVENT_ABORT_ERROR_SLOT,
+ error,
+ );
if let Some(signal) = signal {
crate::native_bridge::abort::abort_signal(scope, signal, error);
}
@@ -577,17 +585,19 @@ pub(super) fn dispatch_popstate_event<'s>(
child_handle: Option<crate::document_runtime::DomHandle>,
state: v8::Local<'s, v8::Value>,
) {
- let global = scope.get_current_context().global(scope);
- let Some(event_ctor) = global
- .get(scope, v8str(scope, "Event").into())
- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
- else {
- return;
- };
- let Some(event) = event_ctor.new_instance(scope, &[v8str(scope, "popstate").into()]) else {
+ let event_state = new_event_state(scope);
+ initialize_event_object(scope, event_state, "popstate", false, false);
+ let _ = PopStateEventStateDeclaration::new(state).initialize(scope, event_state);
+ super::events::define_event_property(
+ scope,
+ event_state,
+ "hasUAVisualTransition",
+ v8::Boolean::new(scope, false).into(),
+ );
+ let _ = web_api_interfaces::initialize(scope, event_state, "PopStateEvent");
+ let Some(event) = new_event_wrapper(scope, event_state) else {
return;
};
- let _ = PopStateEventStateDeclaration::new(state).initialize(scope, event);
let runtime = unsafe { &mut *host_ptr };
if let Some(child_handle) = child_handle {
runtime.dispatch_child_window_event(scope, child_handle, "popstate", event);
@@ -607,14 +617,13 @@ pub(crate) fn construct_original_hash_change_event<'s>(
old_url: &str,
new_url: &str,
) -> Option<v8::Local<'s, v8::Object>> {
- let global = scope.get_current_context().global(scope);
- let event_ctor = global
- .get(scope, v8str(scope, "Event").into())
- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
- let event = event_ctor.new_instance(scope, &[v8str(scope, "hashchange").into()])?;
- let _ = HashChangeEventStateDeclaration::new(old_url.to_owned(), new_url.to_owned())
- .initialize(scope, event);
- Some(event)
+ let state = new_event_state(scope);
+ initialize_event_object(scope, state, "hashchange", false, false);
+ HashChangeEventStateDeclaration::new(old_url.to_owned(), new_url.to_owned())
+ .initialize(scope, state)
+ .ok()?;
+ web_api_interfaces::initialize(scope, state, "HashChangeEvent").ok()?;
+ new_event_wrapper(scope, state)
}
pub(crate) fn dispatch_beforeunload_for_runtime_owner<'s>(
@@ -641,10 +650,11 @@ pub(crate) fn dispatch_pagehide_for_runtime_owner<'s>(
scope: &mut v8::PinScope<'s, '_>,
owner: v8::Local<'s, v8::Object>,
) {
- let Some(event) = construct_original_event(scope, "pagehide") else {
+ let Some(event) =
+ super::events::construct_original_page_transition_event(scope, "pagehide", false)
+ else {
return;
};
- let _ = PageTransitionEventStateDeclaration::new(false).initialize(scope, event);
dispatch_unload_lifecycle_event_for_runtime_owner(scope, owner, "pagehide", event);
}
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_handler_callbacks.rs b/moli-renderer-v8/src/context_bootstrap/navigation_handler_callbacks.rs
index 90564d7ff..cfdc198b1 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_handler_callbacks.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_handler_callbacks.rs
@@ -19,10 +19,7 @@
use super::*;
use crate::{
- util::{
- context_host_ptr_from_global_bridge, get_private_value, serialize_v8_iter_array,
- set_private_value,
- },
+ util::{context_host_ptr_from_global_bridge, serialize_v8_iter_array, set_private_value},
window_webidl_callback::{
PreparedWindowWebIdlCallbackFunctionOutcome, V8TracedWindowWebIdlCallbackFunction,
},
@@ -56,12 +53,11 @@ pub(in crate::context_bootstrap) fn push_navigation_handler<'s>(
) -> Result<(), NavigationHandlerResidenceFailure> {
let callback = V8TracedWindowWebIdlCallbackFunction::new(scope, callback).into_object();
set_private_value(scope, callback, HANDLER_EVENT_VIEW_SLOT, event.into());
- let event = super::events::event_backing(scope, event);
- let handlers = get_private_value(scope, event, slot)
+ let handlers = crate::context_bootstrap::event_private_value(scope, event, slot)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
.unwrap_or_else(|| {
let handlers = v8::Array::new(scope, 0);
- set_private_value(scope, event, slot, handlers.into());
+ crate::context_bootstrap::set_event_private_value(scope, event, slot, handlers.into());
handlers
});
let result = navigation_handler_residence_write_result(handlers.set_index(
@@ -96,7 +92,7 @@ pub(in crate::context_bootstrap) fn navigation_handler_array_is_empty<'s>(
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> bool {
- get_private_value(scope, event, slot)
+ crate::context_bootstrap::event_private_value(scope, event, slot)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
.is_none_or(|handlers| handlers.length() == 0)
}
@@ -163,9 +159,14 @@ fn take_navigation_handler_array<'s>(
event: v8::Local<'s, v8::Object>,
slot: &'static str,
) -> Option<v8::Local<'s, v8::Array>> {
- let handlers = get_private_value(scope, event, slot)
+ let handlers = crate::context_bootstrap::event_private_value(scope, event, slot)
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())?;
- set_private_value(scope, event, slot, v8::undefined(scope).into());
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ slot,
+ v8::undefined(scope).into(),
+ );
(handlers.length() > 0).then_some(handlers)
}
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_lifecycle.rs b/moli-renderer-v8/src/context_bootstrap/navigation_lifecycle.rs
index c6b3ef543..1056180c2 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_lifecycle.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_lifecycle.rs
@@ -221,13 +221,21 @@ pub(super) fn perform_navigation_scroll_if_needed<'s>(
return;
}
if let Some(event) = active_event {
- if get_private_value(scope, event, NAVIGATE_EVENT_SCROLL_CALLED_SLOT)
- .is_some_and(|value| value.is_true())
+ if crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ NAVIGATE_EVENT_SCROLL_CALLED_SLOT,
+ )
+ .is_some_and(|value| value.is_true())
{
return;
}
- if get_private_value(scope, event, NAVIGATE_EVENT_SCROLL_AFTER_TRANSITION_SLOT)
- .is_some_and(|value| !value.is_true())
+ if crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ NAVIGATE_EVENT_SCROLL_AFTER_TRANSITION_SLOT,
+ )
+ .is_some_and(|value| !value.is_true())
{
return;
}
@@ -235,7 +243,11 @@ pub(super) fn perform_navigation_scroll_if_needed<'s>(
return;
};
let owner = super::navigation_window::runtime_window_owner(scope, navigation);
- if object_string_property(scope, event, "navigationType").as_deref() == Some("traverse")
+ if crate::context_bootstrap::event_attribute(scope, event, "navigationType")
+ .and_then(|value| value.to_string(scope))
+ .map(|value| value.to_rust_string_lossy(scope))
+ .as_deref()
+ == Some("traverse")
&& super::navigation_entry::restore_current_navigation_entry_scroll_position(
scope, owner,
)
diff --git a/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs b/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs
index dc7cbcf4e..cd2d6866c 100644
--- a/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs
+++ b/moli-renderer-v8/src/context_bootstrap/shared_worker_host.rs
@@ -799,7 +799,7 @@ fn dispatch_shared_worker_error_event<'s>(
&& let Some(returned) = callback_result
&& v8::Local::new(scope, &returned).boolean_value(scope)
{
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
diff --git a/moli-renderer-v8/src/context_bootstrap/streams/transferable/protocol.rs b/moli-renderer-v8/src/context_bootstrap/streams/transferable/protocol.rs
index 579cbf37e..a36da3670 100644
--- a/moli-renderer-v8/src/context_bootstrap/streams/transferable/protocol.rs
+++ b/moli-renderer-v8/src/context_bootstrap/streams/transferable/protocol.rs
@@ -20,7 +20,8 @@ pub(super) fn parts<'s>(
event: v8::Local<'s, v8::Value>,
) -> Option<(MessageKind, v8::Local<'s, v8::Value>)> {
let event = v8::Local::<v8::Object>::try_from(event).ok()?;
- let data = event.get(scope, v8str(scope, "data").into())?;
+ let data = crate::context_bootstrap::event_backing(scope, event)
+ .get(scope, v8str(scope, "data").into())?;
let envelope = v8::Local::<v8::Array>::try_from(data).ok()?;
let kind = MessageKind::try_from(envelope.get_index(scope, 0)?.uint32_value(scope)?).ok()?;
let value = envelope
diff --git a/moli-renderer-v8/src/context_bootstrap/touch_runtime.rs b/moli-renderer-v8/src/context_bootstrap/touch_runtime.rs
index 84ef94abf..c4ef7f813 100644
--- a/moli-renderer-v8/src/context_bootstrap/touch_runtime.rs
+++ b/moli-renderer-v8/src/context_bootstrap/touch_runtime.rs
@@ -255,7 +255,7 @@ fn touch_event_getter<'s>(
rv.set_undefined();
return;
};
- let receiver = args.this();
+ let receiver = crate::context_bootstrap::event_backing(scope, args.this());
match get_private_value(scope, receiver, slot) {
Some(value) => rv.set(value),
None => rv.set_undefined(),
diff --git a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs
index 665a65ba2..39009103a 100644
--- a/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs
+++ b/moli-renderer-v8/src/context_bootstrap/web_audio_runtime.rs
@@ -800,7 +800,11 @@ fn audio_worklet_worker_error_callback<'s>(
};
let message = v8::Local::<v8::Object>::try_from(args.get(0))
.ok()
- .and_then(|event| object_string_property(scope, event, "message"))
+ .and_then(|event| {
+ crate::context_bootstrap::event_attribute(scope, event, "message")
+ .and_then(|value| value.to_string(scope))
+ .map(|value| value.to_rust_string_lossy(scope))
+ })
.unwrap_or_else(|| "AudioWorklet module failed.".to_owned());
let error = error_value(scope, &message).unwrap_or_else(|| v8::undefined(scope).into());
fail_audio_worklet_module(scope, module_state, error);
diff --git a/moli-renderer-v8/src/context_bootstrap/window_events/error.rs b/moli-renderer-v8/src/context_bootstrap/window_events/error.rs
index 5c31fe3c5..d377efa61 100644
--- a/moli-renderer-v8/src/context_bootstrap/window_events/error.rs
+++ b/moli-renderer-v8/src/context_bootstrap/window_events/error.rs
@@ -20,16 +20,6 @@ struct ErrorEventInitDeclaration<'scope> {
error: v8::Local<'scope, v8::Value>,
}
-#[derive(WebApiObject)]
-#[webapi(plain, data_properties, enumerable)]
-struct ErrorEventDetailsDeclaration<'scope> {
- message: v8::Local<'scope, v8::Value>,
- filename: v8::Local<'scope, v8::Value>,
- lineno: u32,
- colno: u32,
- error: v8::Local<'scope, v8::Value>,
-}
-
const BODY_ONERROR_RESOLUTION_GUARD_SLOT: &str = "__moliBodyOnerrorResolutionGuard";
pub(super) fn ensure_window_reflecting_body_onerror_handler(scope: &mut v8::PinScope<'_, '_>) {
@@ -146,7 +136,6 @@ pub(crate) fn dispatch_window_error_event_with_details<'s>(
colno: u32,
error_value: Option<v8::Local<'s, v8::Value>>,
) -> std::result::Result<(), String> {
- let global = scope.get_current_context().global(scope);
ensure_window_reflecting_body_onerror_handler(scope);
let error_value = error_value.unwrap_or_else(|| v8::null(scope).into());
@@ -162,22 +151,12 @@ pub(crate) fn dispatch_window_error_event_with_details<'s>(
.expect("ErrorEvent init declaration should bind");
let event_type = v8str(scope, "error");
- let event = global
- .get(scope, v8str(scope, "ErrorEvent").into())
- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
- .and_then(|ctor| ctor.new_instance(scope, &[event_type.into(), init.into()]))
- .or_else(|| {
- let event_ctor = global
- .get(scope, v8str(scope, "Event").into())
- .and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())?;
- let event = event_ctor.new_instance(scope, &[event_type.into(), init.into()])?;
- let details =
- ErrorEventDetailsDeclaration::new(message, filename, lineno, colno, error_value);
- if details.initialize(scope, event).is_err() {
- return None;
- }
- Some(event)
- });
+ let event = super::super::exposed_interfaces::ensure_intrinsic_interface_constructor(
+ scope,
+ "ErrorEvent",
+ )
+ .ok()
+ .and_then(|ctor| ctor.new_instance(scope, &[event_type.into(), init.into()]));
let Some(event) = event else {
return Ok(());
};
@@ -192,9 +171,18 @@ pub(crate) fn dispatch_window_error_event_with_details<'s>(
}
runtime.dispatch_public_event(scope, host_ptr, EventTargetHandle::Window, event)?;
+ let global = scope.get_current_context().global(scope);
let global_value: v8::Local<'_, v8::Value> = global.into();
- let _ = event.set(scope, v8str(scope, "target").into(), global_value);
- let _ = event.set(scope, v8str(scope, "currentTarget").into(), global_value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "target").into(),
+ global_value,
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "currentTarget").into(),
+ global_value,
+ );
Ok(())
}
diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
index eaaeefab0..a891a0107 100644
--- a/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
+++ b/moli-renderer-v8/src/context_bootstrap/worker_host/dispatch.rs
@@ -271,7 +271,7 @@ pub(crate) fn dispatch_worker_error_event_with_kind<'s>(
&& let Some(returned) = callback_result
&& v8::Local::new(scope, &returned).boolean_value(scope)
{
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -287,7 +287,7 @@ pub(crate) fn dispatch_worker_error_event_with_kind<'s>(
crate::context_bootstrap::run_end_of_microtask_checkpoint_tasks(scope);
clear_event_dispatch_fields(scope, event);
- let default_prevented = event
+ let default_prevented = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "defaultPrevented").into())
.is_some_and(|value| value.boolean_value(scope));
!default_prevented
diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rs
index 2ac8970b2..726e1fba7 100644
--- a/moli-renderer-v8/src/document_runtime.rs
+++ b/moli-renderer-v8/src/document_runtime.rs
@@ -47,7 +47,7 @@ use super::{
stylesheet_blocking::{
DocumentBlockingStylesheetSignature, StylesheetBlockingState, StylesheetBlockingStatus,
},
- util::{object_string_property, v8str},
+ util::v8str,
};
#[cfg(test)]
use crate::dom::native::ShadowRootBindingSnapshot;
diff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rs
index d505b5057..f7622a7b3 100644
--- a/moli-renderer-v8/src/document_runtime/events.rs
+++ b/moli-renderer-v8/src/document_runtime/events.rs
@@ -450,7 +450,7 @@ impl DocumentRuntime {
event: v8::Local<'s, v8::Object>,
) -> std::result::Result<PublicEventDispatchResult, String> {
let event_type = public_event_type(scope, event);
- let composed = event
+ let composed = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "composed").into())
.is_some_and(|value| value.boolean_value(scope));
let mut path = if let Some(source_target) =
@@ -481,7 +481,7 @@ impl DocumentRuntime {
event: v8::Local<'s, v8::Object>,
) -> std::result::Result<PublicEventDispatchResult, String> {
let event_type = public_event_type(scope, event);
- let composed = event
+ let composed = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "composed").into())
.is_some_and(|value| value.boolean_value(scope));
let mut path = self.build_propagation_path(dispatch_target, composed);
@@ -687,7 +687,9 @@ fn public_event_type(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) -> Option<String> {
- object_string_property(scope, event, "type")
+ crate::context_bootstrap::event_attribute(scope, event, "type")
+ .and_then(|value| value.to_string(scope))
+ .map(|value| value.to_rust_string_lossy(scope))
}
fn trim_window_from_subresource_load_path(
@@ -711,7 +713,7 @@ fn source_target_for_reference_event(
host_ptr: *mut JsContextHost,
event: v8::Local<'_, v8::Object>,
) -> Option<EventTargetHandle> {
- let event_type = event
+ let event_type = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "type").into())?
.to_string(scope)?
.to_rust_string_lossy(scope);
@@ -720,7 +722,8 @@ fn source_target_for_reference_event(
"submit" => "submitter",
_ => return None,
};
- let source = event.get(scope, v8str(scope, source_property).into())?;
+ let source = crate::context_bootstrap::event_backing(scope, event)
+ .get(scope, v8str(scope, source_property).into())?;
if source.is_null_or_undefined() || !source.is_object() {
return None;
}
diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs
index d78334bed..138ac01ee 100644
--- a/moli-renderer-v8/src/document_runtime/security_policy.rs
+++ b/moli-renderer-v8/src/document_runtime/security_policy.rs
@@ -2134,9 +2134,21 @@ pub(crate) fn create_content_security_policy_violation_event<'s>(
&ContentSecurityPolicyViolationEventFields::from(violation),
)
.ok_or_else(|| anyhow::anyhow!("failed to create CSP violation event"))?;
- let _ = event.set(scope, v8str(scope, "target").into(), target);
- let _ = event.set(scope, v8str(scope, "srcElement").into(), target);
- let _ = event.set(scope, v8str(scope, "currentTarget").into(), current_target);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "target").into(),
+ target,
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "srcElement").into(),
+ target,
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "currentTarget").into(),
+ current_target,
+ );
Ok(event)
}
diff --git a/moli-renderer-v8/src/host/events.rs b/moli-renderer-v8/src/host/events.rs
index 0343f9a4c..f29ae2535 100644
--- a/moli-renderer-v8/src/host/events.rs
+++ b/moli-renderer-v8/src/host/events.rs
@@ -5,7 +5,7 @@ use crate::{
mark_event_trusted, set_event_composed_path,
},
dom_parser::DOM_PARSER_FOREIGN_NODE_SLOT,
- util::{get_private_object, get_private_value, serialize_v8_iter_array, set_private_value},
+ util::{get_private_object, get_private_value, serialize_v8_iter_array},
};
use moli_webapi_declare::WebApiObject;
use std::collections::HashSet;
@@ -292,19 +292,19 @@ fn invoke_event_handler_property<'s>(
&& event_type == "error"
&& event_is_error_event(scope, event)
{
- let message = event
+ let message = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "message").into())
.unwrap_or_else(|| v8::undefined(scope).into());
- let source = event
+ let source = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "filename").into())
.unwrap_or_else(|| v8::undefined(scope).into());
- let lineno = event
+ let lineno = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "lineno").into())
.unwrap_or_else(|| v8::Number::new(scope, 0.0).into());
- let colno = event
+ let colno = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "colno").into())
.unwrap_or_else(|| v8::Number::new(scope, 0.0).into());
- let error = event
+ let error = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "error").into())
.unwrap_or_else(|| v8::null(scope).into());
@@ -325,7 +325,7 @@ fn invoke_event_handler_property<'s>(
if let Some(returned) = returned {
let returned = v8::Local::new(scope, returned);
if returned.boolean_value(scope) {
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -362,7 +362,7 @@ fn invoke_event_handler_property<'s>(
if let Some(returned) = returned {
let returned = v8::Local::new(scope, returned);
if returned.is_boolean() && !returned.boolean_value(scope) {
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -1631,7 +1631,11 @@ pub(crate) fn dispatch_public_event_with_original_target<'s, 'i>(
set_event_internal_flag(scope, event, EVENT_STOP_IMMEDIATE_SLOT, false);
set_event_internal_flag(scope, event, EVENT_PASSIVE_SLOT, false);
let current_target_key = v8str(scope, "currentTarget");
- let _ = event.set(scope, current_target_key.into(), v8::null(scope).into());
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ current_target_key.into(),
+ v8::null(scope).into(),
+ );
clear_event_composed_path(scope, event);
Ok(PublicEventDispatchResult {
default_prevented: event_default_prevented(scope, event),
@@ -1690,7 +1694,11 @@ pub(crate) fn dispatch_host_event(
event_type,
event,
);
- let _ = event.set(scope, current_target_key.into(), v8::null(scope).into());
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ current_target_key.into(),
+ v8::null(scope).into(),
+ );
dispatch_result
}
@@ -1746,7 +1754,7 @@ fn set_event_current_target(
value: v8::Local<'_, v8::Value>,
) {
let key = v8str(scope, "currentTarget");
- let _ = event.set(scope, key.into(), value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(scope, key.into(), value);
}
fn set_event_target(
@@ -1755,14 +1763,18 @@ fn set_event_target(
value: v8::Local<'_, v8::Value>,
) {
let key = v8str(scope, "target");
- let _ = event.set(scope, key.into(), value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(scope, key.into(), value);
let src_element_key = v8str(scope, "srcElement");
- let _ = event.set(scope, src_element_key.into(), value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ src_element_key.into(),
+ value,
+ );
}
fn set_event_phase(scope: &mut v8::PinScope<'_, '_>, event: v8::Local<'_, v8::Object>, phase: u32) {
let key = v8str(scope, "eventPhase");
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
key.into(),
v8::Integer::new_from_unsigned(scope, phase).into(),
@@ -1775,7 +1787,12 @@ fn set_event_internal_flag(
key: &str,
value: bool,
) {
- set_private_value(scope, event, key, v8::Boolean::new(scope, value).into());
+ crate::context_bootstrap::set_event_private_value(
+ scope,
+ event,
+ key,
+ v8::Boolean::new(scope, value).into(),
+ );
}
fn event_internal_bool_flag<'s>(
@@ -1783,7 +1800,8 @@ fn event_internal_bool_flag<'s>(
event: v8::Local<'s, v8::Object>,
key: &str,
) -> bool {
- get_private_value(scope, event, key).is_some_and(|value| value.boolean_value(scope))
+ crate::context_bootstrap::event_private_value(scope, event, key)
+ .is_some_and(|value| value.boolean_value(scope))
}
pub(crate) fn event_dispatch_status<'s>(
@@ -1865,7 +1883,7 @@ fn normalize_public_event_record<'s>(
let target_key = v8str(scope, "target");
let current_target_key = v8str(scope, "currentTarget");
- let event_type_value = event
+ let event_type_value = crate::context_bootstrap::event_backing(scope, event)
.get(scope, type_key.into())
.ok_or_else(|| "Failed to execute 'dispatchEvent': event type is required.".to_owned())?;
if event_type_value.is_null_or_undefined() {
@@ -1876,12 +1894,25 @@ fn normalize_public_event_record<'s>(
.map(|value| value.to_rust_string_lossy(scope))
.unwrap_or_default();
- let target_value = event.get(scope, target_key.into());
+ let target_value =
+ crate::context_bootstrap::event_backing(scope, event).get(scope, target_key.into());
if target_value.is_none() || target_value.is_some_and(|value| value.is_null_or_undefined()) {
- let _ = event.set(scope, target_key.into(), default_target);
- let _ = event.set(scope, v8str(scope, "srcElement").into(), default_target);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ target_key.into(),
+ default_target,
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "srcElement").into(),
+ default_target,
+ );
}
- let _ = event.set(scope, current_target_key.into(), default_target);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ current_target_key.into(),
+ default_target,
+ );
// `dispatchEvent()` brand-checks the initialized Event private slot before
// reaching this function. Its methods and legacy accessors therefore come
// from the intrinsic Event prototype and must not be shadowed here.
@@ -1895,7 +1926,7 @@ fn event_default_prevented(
event: v8::Local<'_, v8::Object>,
) -> bool {
let default_prevented_key = v8str(scope, "defaultPrevented");
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, default_prevented_key.into())
.is_some_and(|value| value.boolean_value(scope))
}
@@ -1950,7 +1981,7 @@ fn event_target_receiver<'s>(
.unwrap_or_else(|| v8::undefined(scope).into()),
EventTargetHandle::Node(_) => {
let key = v8str(scope, "currentTarget");
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.unwrap_or_else(|| v8::undefined(scope).into())
}
@@ -1982,7 +2013,11 @@ fn set_event_related_target_for_current_target<'s>(
};
let related_target = retarget_event_target(host_ptr, original_related_target, current_target);
let related_value = event_target_value(scope, host_ptr, related_target)?;
- let _ = event.set(scope, v8str(scope, "relatedTarget").into(), related_value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "relatedTarget").into(),
+ related_value,
+ );
Ok(())
}
@@ -1998,7 +2033,11 @@ fn set_event_source_for_current_target<'s>(
};
let source = retarget_event_target(host_ptr, original_source_target, current_target);
let source_value = event_target_value(scope, host_ptr, source)?;
- let _ = event.set(scope, v8str(scope, "source").into(), source_value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "source").into(),
+ source_value,
+ );
Ok(())
}
@@ -2088,7 +2127,11 @@ fn set_event_post_dispatch_targets<'s>(
Some(related_target) => event_target_value(scope, host_ptr, related_target)?,
None => v8::null(scope).into(),
};
- let _ = event.set(scope, v8str(scope, "relatedTarget").into(), related_value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "relatedTarget").into(),
+ related_value,
+ );
}
Ok(())
@@ -2104,7 +2147,11 @@ fn set_event_post_dispatch_source<'s>(
return Ok(());
};
let source_value = event_target_value(scope, host_ptr, source_target)?;
- let _ = event.set(scope, v8str(scope, "source").into(), source_value);
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "source").into(),
+ source_value,
+ );
Ok(())
}
@@ -2145,7 +2192,8 @@ fn event_related_target_handle(
host_ptr: *mut JsContextHost,
event: v8::Local<'_, v8::Object>,
) -> Option<EventTargetHandle> {
- let value = event.get(scope, v8str(scope, "relatedTarget").into())?;
+ let value = crate::context_bootstrap::event_backing(scope, event)
+ .get(scope, v8str(scope, "relatedTarget").into())?;
if value.is_null_or_undefined() || !value.is_object() {
return None;
}
@@ -2165,7 +2213,8 @@ fn event_source_target_handle(
host_ptr: *mut JsContextHost,
event: v8::Local<'_, v8::Object>,
) -> Option<EventTargetHandle> {
- let value = event.get(scope, v8str(scope, "source").into())?;
+ let value = crate::context_bootstrap::event_backing(scope, event)
+ .get(scope, v8str(scope, "source").into())?;
if value.is_null_or_undefined() || !value.is_object() {
return None;
}
@@ -2341,7 +2390,7 @@ fn event_bool_property(
let Some(key) = v8_string(scope, key) else {
return false;
};
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.is_some_and(|value| value.boolean_value(scope))
}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_events.rs b/moli-renderer-v8/src/native_bridge/context_host/child_events.rs
index 491797016..b3965b631 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/child_events.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/child_events.rs
@@ -14,7 +14,7 @@ use crate::{
ACTIVE_CHILD_WINDOW_HANDLE_SLOT, EventCallbackId, PreparedEventCallback,
element::EventAttributeHandlerScope, element::compile_event_attribute_handler_for_owner,
},
- util::{get_private_value, object_bool_property, set_private_value, v8_string, v8str},
+ util::{get_private_value, set_private_value, v8_string, v8str},
};
use std::{collections::HashSet, convert::TryFrom};
@@ -494,8 +494,16 @@ impl JsContextHost {
} else {
window.into()
};
- let _ = event.set(scope, v8str(scope, "target").into(), target);
- let _ = event.set(scope, v8str(scope, "currentTarget").into(), window.into());
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "target").into(),
+ target,
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "currentTarget").into(),
+ window.into(),
+ );
if event_type == "load" {
install_child_body_load_attribute_handler_if_needed(scope, self, handle);
@@ -749,19 +757,19 @@ fn child_window_event_callback_arguments<'s>(
&& event_type == "error"
{
vec![
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "message").into())
.unwrap_or_else(|| v8::undefined(scope).into()),
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "filename").into())
.unwrap_or_else(|| v8::undefined(scope).into()),
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "lineno").into())
.unwrap_or_else(|| v8::Number::new(scope, 0.0).into()),
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "colno").into())
.unwrap_or_else(|| v8::Number::new(scope, 0.0).into()),
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "error").into())
.unwrap_or_else(|| v8::null(scope).into()),
]
@@ -785,8 +793,8 @@ fn apply_child_window_event_handler_return(
} else {
returned.is_boolean() && !returned.boolean_value(scope)
};
- if should_cancel && object_bool_property(scope, event, "cancelable").unwrap_or(false) {
- let _ = event.set(
+ if should_cancel && crate::context_bootstrap::event_bool_attribute(scope, event, "cancelable") {
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
diff --git a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
index 799adec42..e5f4b65a8 100644
--- a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
+++ b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs
@@ -7,7 +7,7 @@ use crate::dom::{
native::{Element, Node, SelectedFile},
};
use crate::util::{
- call_object_method, node_wrapper_from_handle, object_bool_property, object_number_property,
+ call_object_method, node_wrapper_from_handle, object_number_property,
object_property_as_object, utf16_len, v8_string, v8str,
};
use crate::{
@@ -144,7 +144,7 @@ fn event_default_prevented(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) -> bool {
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "defaultPrevented").into())
.is_some_and(|value| value.boolean_value(scope))
}
@@ -1266,9 +1266,15 @@ pub(crate) fn perform_click_default_action_for_dispatched_event(
if is_disabled_form_control(runtime, handle) {
return;
}
- let x = object_number_property(scope, event, "clientX").unwrap_or(0.0);
- let y = object_number_property(scope, event, "clientY").unwrap_or(0.0);
- let button = object_number_property(scope, event, "button").unwrap_or(0.0) as i32;
+ let x = crate::context_bootstrap::event_attribute(scope, event, "clientX")
+ .and_then(|value| value.number_value(scope))
+ .unwrap_or(0.0);
+ let y = crate::context_bootstrap::event_attribute(scope, event, "clientY")
+ .and_then(|value| value.number_value(scope))
+ .unwrap_or(0.0);
+ let button = crate::context_bootstrap::event_attribute(scope, event, "button")
+ .and_then(|value| value.number_value(scope))
+ .unwrap_or(0.0) as i32;
let modifiers = mouse_event_modifier_bits(scope, event);
let _ = perform_click_default_action(
scope,
@@ -1423,16 +1429,16 @@ fn mouse_event_modifier_bits(
event: v8::Local<'_, v8::Object>,
) -> u8 {
let mut modifiers = 0;
- if object_bool_property(scope, event, "altKey").unwrap_or(false) {
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "altKey") {
modifiers |= 1;
}
- if object_bool_property(scope, event, "ctrlKey").unwrap_or(false) {
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "ctrlKey") {
modifiers |= 2;
}
- if object_bool_property(scope, event, "metaKey").unwrap_or(false) {
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "metaKey") {
modifiers |= 4;
}
- if object_bool_property(scope, event, "shiftKey").unwrap_or(false) {
+ if crate::context_bootstrap::event_bool_attribute(scope, event, "shiftKey") {
modifiers |= 8;
}
modifiers
diff --git a/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs b/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
index c656eafdd..22de15d36 100644
--- a/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
+++ b/moli-renderer-v8/src/native_bridge/element/events/dispatch.rs
@@ -77,7 +77,7 @@ fn event_default_prevented(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) -> bool {
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "defaultPrevented").into())
.is_some_and(|value| value.boolean_value(scope))
}
diff --git a/moli-renderer-v8/src/native_bridge/element/focus.rs b/moli-renderer-v8/src/native_bridge/element/focus.rs
index 9a4a646c2..4a8c7e42d 100644
--- a/moli-renderer-v8/src/native_bridge/element/focus.rs
+++ b/moli-renderer-v8/src/native_bridge/element/focus.rs
@@ -1181,7 +1181,7 @@ fn event_boolean_property(
let Some(key) = v8_string(scope, name) else {
return false;
};
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.is_some_and(|value| value.boolean_value(scope))
}
@@ -1192,7 +1192,7 @@ fn event_string_property(
name: &str,
) -> Option<String> {
let key = v8_string(scope, name)?;
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.and_then(|value| v8::Local::<v8::String>::try_from(value).ok())
.map(|value| value.to_rust_string_lossy(scope))
diff --git a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
index b9d609bb0..e7943fec3 100644
--- a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
+++ b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs
@@ -433,7 +433,7 @@ pub(crate) fn align_event_constructor_function_realm_with_constructor<'s>(
};
event_constructor.set_name(v8str(scope, "Event"));
let _ = event_constructor.set(scope, v8str(scope, "prototype").into(), event_prototype);
- if !event
+ if !crate::context_bootstrap::event_backing(scope, event)
.define_own_property(
scope,
v8str(scope, "constructor").into(),
@@ -442,7 +442,7 @@ pub(crate) fn align_event_constructor_function_realm_with_constructor<'s>(
)
.unwrap_or(false)
{
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "constructor").into(),
event_constructor.into(),
diff --git a/moli-renderer-v8/src/network_host/xhr/bindings/progress_event.rs b/moli-renderer-v8/src/network_host/xhr/bindings/progress_event.rs
index 649b7ab56..0b7ff0267 100644
--- a/moli-renderer-v8/src/network_host/xhr/bindings/progress_event.rs
+++ b/moli-renderer-v8/src/network_host/xhr/bindings/progress_event.rs
@@ -1,5 +1,4 @@
use super::*;
-use crate::util::get_private_value;
use crate::web_api_interfaces;
use crate::webidl;
use moli_webapi_declare::WebApiObject;
@@ -72,7 +71,8 @@ pub(crate) fn progress_event_constructor_callback<'s>(
);
return;
}
- let obj = args.this();
+ let wrapper = args.this();
+ let obj = crate::context_bootstrap::new_event_state(scope);
let Some(parsed) = webidl::parse_args::<ProgressEventConstructorArgs>(scope, &args) else {
return;
};
@@ -90,7 +90,10 @@ pub(crate) fn progress_event_constructor_callback<'s>(
)
.initialize(scope, obj)
.expect("ProgressEvent state declaration should initialize");
- rv.set(obj.into());
+ web_api_interfaces::initialize(scope, obj, "ProgressEvent").expect("ProgressEvent brand");
+ if crate::context_bootstrap::initialize_event_wrapper(scope, wrapper, obj).is_some() {
+ rv.set(wrapper.into());
+ }
}
fn progress_event_slot_getter<'s>(
@@ -99,8 +102,8 @@ fn progress_event_slot_getter<'s>(
slot: &'static str,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
- let value =
- get_private_value(scope, receiver, slot).unwrap_or_else(|| v8::undefined(scope).into());
+ let value = crate::context_bootstrap::event_private_value(scope, receiver, slot)
+ .unwrap_or_else(|| v8::undefined(scope).into());
if value.is_undefined() {
throw_type_error(scope, "Illegal invocation");
return;
diff --git a/moli-renderer-v8/src/network_host/xhr/events/progress.rs b/moli-renderer-v8/src/network_host/xhr/events/progress.rs
index 46489067b..b233887fc 100644
--- a/moli-renderer-v8/src/network_host/xhr/events/progress.rs
+++ b/moli-renderer-v8/src/network_host/xhr/events/progress.rs
@@ -32,8 +32,9 @@ pub(crate) fn make_progress_event<'s>(
.bind(scope)
.expect("XHR progress event target declaration should bind"),
};
+ let state = crate::context_bootstrap::event_backing(scope, event);
ProgressEventTargetDeclaration::new(target, target)
- .initialize(scope, event)
+ .initialize(scope, state)
.expect("XHR progress event target declaration should initialize");
event
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/history_worlds.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/history_worlds.rs
index 289f840e5..ca9832efa 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/history_worlds.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/history_worlds.rs
@@ -1,5 +1,318 @@
use super::*;
+#[test]
+fn history_worlds_slot_backed_platform_fields_keep_local_wrappers() {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ vm.eval(r#"
+ if (!document.documentElement) document.appendChild(document.createElement('html'));
+ if (!document.body) document.documentElement.appendChild(document.createElement('body'));
+ document.body.innerHTML = '<button id="submitter"></button>';
+ globalThis.data = new FormData();
+ data.set('value', 'original');
+ data.pageOnly = true;
+ data.get = () => 'page override';
+ globalThis.formEvent = new FormDataEvent('form-probe', {formData: data});
+ globalThis.submitEvent = new SubmitEvent('submit-probe', {submitter: document.getElementById('submitter')});
+ submitEvent.submitter.pageOnly = true;
+ globalThis.getterCalls = 0;
+ Object.defineProperty(formEvent, 'formData', {get() { getterCalls++; throw new Error('shadow'); }});
+ Object.defineProperty(submitEvent, 'submitter', {get() { getterCalls++; throw new Error('shadow'); }});
+ 'ready'
+ "#).unwrap();
+ let isolated = vm.create_isolated_world("slot-fields", false).unwrap();
+ vm.eval_in_isolated_context(isolated, r#"
+ globalThis.facts = [];
+ navigation.addEventListener('form-probe', event => {
+ facts.push(event instanceof FormDataEvent, event.formData instanceof FormData,
+ event.formData.pageOnly === undefined, event.formData.get('value'));
+ event.formData.set('value', 'updated');
+ }, {once: true});
+ navigation.addEventListener('submit-probe', event => {
+ facts.push(event instanceof SubmitEvent, event.submitter instanceof HTMLButtonElement,
+ event.submitter === document.getElementById('submitter'), event.submitter.pageOnly === undefined);
+ }, {once: true});
+ 'ready'
+ "#).unwrap();
+ vm.eval("navigation.dispatchEvent(formEvent); navigation.dispatchEvent(submitEvent); 'sent'")
+ .unwrap();
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "JSON.stringify(facts)")
+ .unwrap(),
+ r#"[true,true,true,"original",true,true,true,true]"#
+ );
+ assert_eq!(
+ vm.eval("JSON.stringify([getterCalls, FormData.prototype.get.call(data, 'value')])")
+ .unwrap(),
+ r#"[0,"updated"]"#
+ );
+}
+
+#[test]
+fn history_worlds_event_backing_collects_cycles_and_releases_replaced_values() {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ vm.eval(
+ r#"
+ globalThis.payloadForGc = {value: 7};
+ globalThis.eventForGc = new CustomEvent('gc-probe', {detail: payloadForGc});
+ payloadForGc.event = eventForGc;
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ let isolated = vm.create_isolated_world("event-backing-gc", false).unwrap();
+ vm.eval_in_isolated_context(isolated, r#"
+ globalThis.foreignEventForGc = null;
+ navigation.addEventListener('gc-probe', event => { foreignEventForGc = event; }, {once: true});
+ 'ready'
+ "#).unwrap();
+ vm.eval("navigation.dispatchEvent(eventForGc); 'dispatched'")
+ .unwrap();
+ let context_ptr = &vm
+ .page_isolated_world_contexts
+ .context(isolated)
+ .unwrap()
+ .context as *const _;
+ let weak_values = vm
+ .with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
+ let global = scope.get_current_context().global(scope);
+ let event = global
+ .get(scope, crate::util::v8str(scope, "foreignEventForGc").into())
+ .unwrap();
+ let event = v8::Local::<v8::Object>::try_from(event).unwrap();
+ let payload = event
+ .get(scope, crate::util::v8str(scope, "detail").into())
+ .unwrap();
+ let payload = v8::Local::<v8::Object>::try_from(payload).unwrap();
+ Ok([v8::Weak::new(scope, event), v8::Weak::new(scope, payload)])
+ })
+ .unwrap();
+ // The foreign view owns the same private state after the source globals go away.
+ vm.eval("eventForGc = payloadForGc = null; 'released'")
+ .unwrap();
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "String(foreignEventForGc.detail.value)")
+ .unwrap(),
+ "7"
+ );
+ vm.eval_in_isolated_context(
+ isolated,
+ "foreignEventForGc.initCustomEvent('reused', false, false, '\\ud800'); 'replaced'",
+ )
+ .unwrap();
+ vm.renderer_document_isolate
+ .with_entered_renderer_document_isolate(|isolate| {
+ isolate.low_memory_notification();
+ Ok(())
+ })
+ .unwrap();
+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
+ assert!(weak_values[0].to_local(scope).is_some());
+ assert!(
+ weak_values[1].to_local(scope).is_none(),
+ "replacing a backing field must release the previous cyclic payload"
+ );
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "String(foreignEventForGc.detail.charCodeAt(0))")
+ .unwrap(),
+ "55296"
+ );
+ // Create a cycle again, then drop its final root. A native strong Global
+ // would keep this graph alive; the private V8 backing must not.
+ vm.eval_in_isolated_context(
+ isolated,
+ r#"
+ foreignEventForGc.initCustomEvent('cycle', false, false, {event: foreignEventForGc});
+ foreignEventForGc = null;
+ 'released'
+ "#,
+ )
+ .unwrap();
+ vm.renderer_document_isolate
+ .with_entered_renderer_document_isolate(|isolate| {
+ isolate.low_memory_notification();
+ Ok(())
+ })
+ .unwrap();
+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
+ assert!(
+ weak_values[0].to_local(scope).is_none(),
+ "event/backing/payload cycles must be collectible"
+ );
+ Ok(())
+ })
+ .unwrap();
+}
+
+#[test]
+fn history_worlds_toggle_events_share_fields_without_reconstructing_the_event() {
+ for isolated_source in [false, true] {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ let isolated = vm.create_isolated_world("toggle-fields", false).unwrap();
+ let listener = r#"
+ globalThis.facts = [];
+ navigation.addEventListener('toggle-probe', event => {
+ facts.push(event instanceof ToggleEvent, event instanceof Event,
+ event.oldState, event.newState, event.source === null,
+ event.target === navigation, event.currentTarget === navigation,
+ event.expando === undefined);
+ }, {once: true});
+ 'ready'
+ "#;
+ if isolated_source {
+ vm.eval(listener).unwrap();
+ } else {
+ vm.eval_in_isolated_context(isolated, listener).unwrap();
+ }
+ let dispatch = r#"
+ const original = new ToggleEvent('toggle-probe', {oldState: 'closed', newState: 'open'});
+ original.expando = 'source-only';
+ let sameObject = false;
+ navigation.addEventListener('toggle-probe', event => { sameObject = event === original; }, {once: true});
+ JSON.stringify([navigation.dispatchEvent(original), sameObject, original.oldState, original.newState])
+ "#;
+ let source = if isolated_source {
+ vm.eval_in_isolated_context(isolated, dispatch)
+ } else {
+ vm.eval(dispatch)
+ }
+ .unwrap();
+ assert_eq!(source, r#"[true,true,"closed","open"]"#);
+ let foreign = if isolated_source {
+ vm.eval("JSON.stringify(facts)")
+ } else {
+ vm.eval_in_isolated_context(isolated, "JSON.stringify(facts)")
+ }
+ .unwrap();
+ assert_eq!(
+ foreign,
+ r#"[true,true,"closed","open",true,true,true,true]"#
+ );
+ }
+}
+
+#[test]
+fn history_worlds_event_fields_ignore_public_shadows_and_getters() {
+ for isolated_source in [false, true] {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ let isolated = vm
+ .create_isolated_world("internal-event-fields", false)
+ .unwrap();
+ let listener = r#"
+ globalThis.facts = [];
+ globalThis.previousEvent = null;
+ navigation.addEventListener('field-probe', event => {
+ facts.push([event instanceof CustomEvent, event.detail, event.type,
+ event.cancelable, event.bubbles, event.target === navigation,
+ event.composedPath()[0] === navigation, event.expando === undefined]);
+ previousEvent = event;
+ event.preventDefault();
+ });
+ navigation.addEventListener('reinitialized', event => {
+ facts.push([event === previousEvent, event.detail, event.type,
+ event.target === navigation]);
+ });
+ 'ready'
+ "#;
+ if isolated_source {
+ vm.eval(listener).unwrap();
+ } else {
+ vm.eval_in_isolated_context(isolated, listener).unwrap();
+ }
+ let dispatch = r#"
+ globalThis.getterCalls = 0;
+ globalThis.sourceFacts = [];
+ for (const getter of [false, true]) {
+ const original = new CustomEvent('field-probe', {detail: 7, cancelable: true, bubbles: true});
+ original.expando = true;
+ Object.defineProperty(original, 'detail', getter
+ ? {get() { getterCalls++; return 99; }, configurable: true}
+ : {value: 99, configurable: true});
+ for (const property of ['type', 'cancelable', 'bubbles', 'target']) {
+ Object.defineProperty(original, property, {get() { getterCalls++; return 'shadow'; }, configurable: true});
+ }
+ let sameObject = false;
+ navigation.addEventListener('field-probe', event => { sameObject = event === original; }, {once: true});
+ sourceFacts.push(navigation.dispatchEvent(original), sameObject, original.defaultPrevented);
+ original.initCustomEvent('reinitialized', false, false, 9);
+ sourceFacts.push(navigation.dispatchEvent(original), original.defaultPrevented, getterCalls);
+ if (!getter) sourceFacts.push(original.detail);
+ }
+ JSON.stringify(sourceFacts)
+ "#;
+ let source = if isolated_source {
+ vm.eval_in_isolated_context(isolated, dispatch)
+ } else {
+ vm.eval(dispatch)
+ }
+ .unwrap();
+ assert_eq!(
+ source,
+ "[false,true,true,true,false,0,99,false,true,true,true,false,0]"
+ );
+ let foreign = if isolated_source {
+ vm.eval("JSON.stringify(facts)")
+ } else {
+ vm.eval_in_isolated_context(isolated, "JSON.stringify(facts)")
+ }
+ .unwrap();
+ assert_eq!(
+ foreign,
+ r#"[[true,7,"field-probe",true,true,true,true,true],[true,9,"reinitialized",true],[true,7,"field-probe",true,true,true,true,true],[true,9,"reinitialized",true]]"#
+ );
+ }
+}
+
+#[test]
+fn history_worlds_custom_event_detail_keeps_the_original_js_value() {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ vm.eval(
+ r#"
+ globalThis.payload = {value: 7};
+ globalThis.original = new CustomEvent('object-detail', {detail: payload});
+ Object.defineProperty(original, 'detail', {value: {value: 99}});
+ 'ready'
+ "#,
+ )
+ .unwrap();
+ let isolated = vm.create_isolated_world("object-detail", false).unwrap();
+ vm.eval_in_isolated_context(isolated, r#"
+ navigation.addEventListener('object-detail', event => { event.detail.value = 8; }, {once: true});
+ 'ready'
+ "#).unwrap();
+ assert_eq!(vm.eval("navigation.dispatchEvent(original); JSON.stringify([payload.value, original.detail.value])").unwrap(), "[8,99]");
+}
+
+#[test]
+fn history_worlds_event_prototype_getters_are_not_used_as_internal_state() {
+ let mut vm = new_storage_test_vm("https://example.com/base");
+ vm.eval(r#"
+ globalThis.getterCalls = 0;
+ Object.defineProperty(CustomEvent.prototype, 'detail', {get() { getterCalls++; return 99; }, configurable: true});
+ globalThis.original = new CustomEvent('prototype-probe', {detail: 7});
+ delete original.detail;
+ 'ready'
+ "#).unwrap();
+ let isolated = vm.create_isolated_world("prototype-fields", false).unwrap();
+ vm.eval_in_isolated_context(isolated, r#"
+ globalThis.detail = null;
+ navigation.addEventListener('prototype-probe', event => { detail = event.detail; }, {once: true});
+ 'ready'
+ "#).unwrap();
+ assert_eq!(
+ vm.eval("navigation.dispatchEvent(original); String(getterCalls)")
+ .unwrap(),
+ "0"
+ );
+ assert_eq!(
+ vm.eval_in_isolated_context(isolated, "String(detail)")
+ .unwrap(),
+ "7"
+ );
+}
+
#[test]
fn history_worlds_retained_page_event_does_not_retain_unobserved_foreign_views() {
let mut vm = new_storage_test_vm("https://example.com/base");
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs
index 9087c1900..43677af5d 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_xhr/shadow_dom.rs
@@ -169,14 +169,10 @@ fn detached_iframe_open_shadow_host_receives_related_target_events() {
});
}
- const event = new Event('x-related', {
+ const event = new FocusEvent('x-related', {
bubbles: true,
- composed: true
- });
- Object.defineProperty(event, 'relatedTarget', {
- value: two,
- writable: true,
- configurable: true
+ composed: true,
+ relatedTarget: two
});
one.dispatchEvent(event);
@@ -188,6 +184,34 @@ fn detached_iframe_open_shadow_host_receives_related_target_events() {
assert_eq!(result, "one:one:two:one,shadow|shadow:one:two:one,shadow");
}
+
+#[test]
+fn event_related_target_expando_does_not_change_the_dispatch_path() {
+ let mut vm = new_storage_test_vm("https://event-private-state.test/");
+ let result = vm
+ .eval(
+ r#"
+ if (!document.documentElement) document.appendChild(document.createElement('html'));
+ if (!document.body) document.documentElement.appendChild(document.createElement('body'));
+ const host = document.createElement('div');
+ document.body.appendChild(host);
+ const shadow = host.attachShadow({mode: 'open'});
+ const one = document.createElement('button');
+ const two = document.createElement('button');
+ shadow.append(one, two);
+ let calls = 0;
+ let getterCalls = 0;
+ host.addEventListener('probe', () => calls++);
+ const event = new Event('probe', {bubbles: true, composed: true});
+ Object.defineProperty(event, 'relatedTarget', {get() { getterCalls++; return two; }});
+ one.dispatchEvent(event);
+ JSON.stringify([calls, getterCalls])
+ "#,
+ )
+ .unwrap();
+ assert_eq!(result, "[1,0]");
+}
+
#[test]
fn detached_iframe_shadow_focus_events_retarget_and_trim_paths() {
let mut vm = new_storage_test_vm("https://detached-shadow-focus-events.test/");
diff --git a/moli-renderer-v8/src/window_host.rs b/moli-renderer-v8/src/window_host.rs
index 2eeb53dcf..1cadae126 100644
--- a/moli-renderer-v8/src/window_host.rs
+++ b/moli-renderer-v8/src/window_host.rs
@@ -41,9 +41,9 @@ use super::{
util::{
context_host_from_global_bridge, context_host_ptr_from_global_bridge,
context_host_ptr_from_window_object, define_non_enumerable_static_bool_property,
- get_private_value, object_bool_property, object_number_property,
- script_base_url_from_continuation_data, script_base_url_from_host_defined_options,
- set_private_value, throw_type_error, v8_string, v8str,
+ get_private_value, script_base_url_from_continuation_data,
+ script_base_url_from_host_defined_options, set_private_value, throw_type_error, v8_string,
+ v8str,
},
webidl,
};
@@ -382,7 +382,11 @@ pub(super) fn event_target_dispatch_event_callback<'s>(
if let Some(handle) = child_window_target {
let event_type = event_type.as_deref().unwrap_or_default();
host.dispatch_child_window_event(scope, handle, event_type, event);
- rv.set_bool(!object_bool_property(scope, event, "defaultPrevented").unwrap_or(false));
+ rv.set_bool(!crate::context_bootstrap::event_bool_attribute(
+ scope,
+ event,
+ "defaultPrevented",
+ ));
return;
}
let Some(target) = target else {
@@ -396,8 +400,8 @@ pub(super) fn event_target_dispatch_event_callback<'s>(
dispatched_click_activation_target(
host,
handle,
- object_bool_property(scope, event, "bubbles").unwrap_or(false),
- object_bool_property(scope, event, "composed").unwrap_or(false),
+ crate::context_bootstrap::event_bool_attribute(scope, event, "bubbles"),
+ crate::context_bootstrap::event_bool_attribute(scope, event, "composed"),
)
} else {
None
@@ -431,7 +435,7 @@ fn event_type_string(
scope: &mut v8::PinScope<'_, '_>,
event: v8::Local<'_, v8::Object>,
) -> Option<String> {
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "type").into())
.and_then(|value| value.to_string(scope))
.map(|value| value.to_rust_string_lossy(scope))
@@ -1292,10 +1296,14 @@ fn mouse_event_offset_getter(
event: v8::Local<'_, v8::Object>,
horizontal: bool,
) -> Option<f64> {
- let client_x = object_number_property(scope, event, "clientX").unwrap_or(0.0);
- let client_y = object_number_property(scope, event, "clientY").unwrap_or(0.0);
+ let client_x = crate::context_bootstrap::event_attribute(scope, event, "clientX")
+ .and_then(|value| value.number_value(scope))
+ .unwrap_or(0.0);
+ let client_y = crate::context_bootstrap::event_attribute(scope, event, "clientY")
+ .and_then(|value| value.number_value(scope))
+ .unwrap_or(0.0);
let coordinate = if horizontal { client_x } else { client_y };
- let Some(target) = event
+ let Some(target) = crate::context_bootstrap::event_backing(scope, event)
.get(scope, v8str(scope, "target").into())
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
else {
diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs
index 3f4951a5b..6770aab1e 100644
--- a/moli-renderer-v8/src/worker/thread/dispatch.rs
+++ b/moli-renderer-v8/src/worker/thread/dispatch.rs
@@ -625,7 +625,7 @@ pub(super) fn event_bool_property(
key: &str,
) -> bool {
let key = v8::String::new(scope, key).unwrap();
- event
+ crate::context_bootstrap::event_backing(scope, event)
.get(scope, key.into())
.is_some_and(|value| value.is_true())
}
@@ -651,15 +651,27 @@ fn set_event_dispatch_fields<'s>(
event: v8::Local<'s, v8::Object>,
) {
mark_event_trusted(scope, event);
- let _ = event.set(scope, v8str(scope, "target").into(), target.into());
- let _ = event.set(scope, v8str(scope, "srcElement").into(), target.into());
- let _ = event.set(scope, v8str(scope, "currentTarget").into(), target.into());
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "target").into(),
+ target.into(),
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "srcElement").into(),
+ target.into(),
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
+ scope,
+ v8str(scope, "currentTarget").into(),
+ target.into(),
+ );
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "eventPhase").into(),
v8::Integer::new_from_unsigned(scope, 2).into(),
);
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
EVENT_DISPATCHING_SLOT,
@@ -668,17 +680,17 @@ fn set_event_dispatch_fields<'s>(
}
fn clear_event_dispatch_fields(scope: &mut v8::PinScope<'_, '_>, event: v8::Local<'_, v8::Object>) {
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "currentTarget").into(),
v8::null(scope).into(),
);
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "eventPhase").into(),
v8::Integer::new_from_unsigned(scope, 0).into(),
);
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
EVENT_DISPATCHING_SLOT,
@@ -692,7 +704,7 @@ fn worker_event_prevent_default_callback(
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let event = args.this();
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -1048,7 +1060,7 @@ pub(super) fn dispatch_worker_error_event<'s>(
) {
Ok(returned) => {
if v8::Local::new(scope, &returned).is_true() {
- let _ = event.set(
+ let _ = crate::context_bootstrap::event_backing(scope, event).set(
scope,
v8str(scope, "defaultPrevented").into(),
v8::Boolean::new(scope, true).into(),
@@ -2311,7 +2323,7 @@ fn set_service_worker_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT,
@@ -2323,7 +2335,11 @@ fn service_worker_lifecycle_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_LIFECYCLE_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2333,7 +2349,7 @@ fn set_service_worker_fetch_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_FETCH_EVENT_ID_SLOT,
@@ -2345,7 +2361,11 @@ fn service_worker_fetch_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_FETCH_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_FETCH_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2355,7 +2375,7 @@ fn set_service_worker_message_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT,
@@ -2367,7 +2387,11 @@ fn service_worker_message_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_MESSAGE_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2377,7 +2401,7 @@ fn set_service_worker_notification_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT,
@@ -2389,7 +2413,11 @@ fn service_worker_notification_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_NOTIFICATION_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2399,7 +2427,7 @@ fn set_service_worker_push_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_PUSH_EVENT_ID_SLOT,
@@ -2411,7 +2439,11 @@ fn service_worker_push_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_PUSH_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_PUSH_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2421,7 +2453,7 @@ fn set_service_worker_sync_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_SYNC_EVENT_ID_SLOT,
@@ -2433,7 +2465,11 @@ fn service_worker_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_SYNC_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_SYNC_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}
@@ -2443,7 +2479,7 @@ fn set_service_worker_periodic_sync_event_id<'s>(
event: v8::Local<'s, v8::Object>,
event_id: ServiceWorkerEventId,
) {
- set_private_value(
+ crate::context_bootstrap::set_event_private_value(
scope,
event,
SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT,
@@ -2455,7 +2491,11 @@ fn service_worker_periodic_sync_event_id<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
) -> Option<ServiceWorkerEventId> {
- let value = get_private_value(scope, event, SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT)?;
+ let value = crate::context_bootstrap::event_private_value(
+ scope,
+ event,
+ SERVICE_WORKER_PERIODIC_SYNC_EVENT_ID_SLOT,
+ )?;
let id = service_worker_event_id_value(scope, value)?;
Some(ServiceWorkerEventId::from_u64_for_worker(id))
}