Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(service-worker): initialize ExtendableEvent dispatch state

ldm02201528e08c9
diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs
index 4424efd90..130021e73 100644
--- a/moli-renderer-v8/src/worker/global_scope/mod.rs
+++ b/moli-renderer-v8/src/worker/global_scope/mod.rs
@@ -860,36 +860,9 @@ struct WorkerNavigationPreloadStateDeclaration {
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::ExtendableEvent, prototype = "Object")]
-struct InitializedExtendableEventStateDeclaration<'scope> {
- #[webapi(data_property = "type", enumerable)]
- event_type: String,
-
- #[webapi(data_property, enumerable)]
- bubbles: bool,
-
- #[webapi(data_property, enumerable)]
- cancelable: bool,
-
+struct ExtendableEventStateDeclaration {
#[webapi(data_property, enumerable)]
composed: bool,
-
- #[webapi(data_property = "defaultPrevented", enumerable)]
- default_prevented: bool,
-
- #[webapi(data_property, enumerable)]
- target: v8::Local<'scope, v8::Value>,
-
- #[webapi(data_property = "currentTarget", enumerable)]
- current_target: v8::Local<'scope, v8::Value>,
-
- #[webapi(data_property = "eventPhase", enumerable)]
- event_phase: i32,
-
- #[webapi(data_property = "isTrusted", enumerable)]
- is_trusted: bool,
-
- #[webapi(data_property = "timeStamp", enumerable)]
- time_stamp: f64,
}
#[derive(WebApiObject)]
@@ -5834,24 +5807,14 @@ fn initialize_extendable_event_object<'s>(
cancelable: bool,
composed: bool,
) {
- let timestamp_ms = SystemTime::now()
- .duration_since(UNIX_EPOCH)
- .map(|duration| duration.as_secs_f64() * 1000.0)
- .unwrap_or(0.0);
- let null_value: v8::Local<'_, v8::Value> = v8::null(scope).into();
- let _ = InitializedExtendableEventStateDeclaration::new(
- event_type.to_owned(),
- bubbles,
- cancelable,
- composed,
- false,
- null_value,
- null_value,
- 0,
- false,
- timestamp_ms,
- )
- .initialize(scope, event);
+ // EventTarget dispatch and inherited Event methods require the base
+ // event's internal state, in addition to its visible properties.
+ crate::context_bootstrap::initialize_event_object(
+ scope, event, event_type, bubbles, cancelable,
+ );
+ ExtendableEventStateDeclaration::new(composed)
+ .initialize(scope, event)
+ .expect("extendable event state should initialize");
}
fn extendable_message_event_data<'s>(
diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
index 859b33d1d..3e07ab6cf 100644
--- a/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle.rs
@@ -3549,6 +3549,67 @@ async fn service_worker_extendable_message_event_constructor_surface() {
handle.terminate_and_join();
}
+#[tokio::test]
+async fn service_worker_script_created_extendable_events_support_dispatch() {
+ ensure_v8();
+ let mut handle = spawn_service_worker_for_test(
+ r#"
+ self.addEventListener("message", () => {
+ for (const Constructor of [ExtendableEvent, ExtendableMessageEvent]) {
+ const event = new Constructor(Constructor.name, {
+ bubbles: true, cancelable: true, composed: true
+ });
+ let calls = 0;
+ self.addEventListener(Constructor.name, received => {
+ calls++;
+ if (received !== event || received.isTrusted ||
+ received.target !== self || received.currentTarget !== self ||
+ received.eventPhase !== Event.AT_TARGET ||
+ received.composedPath()[0] !== self) {
+ throw new Error("incorrect dispatched event state");
+ }
+ for (const action of [
+ () => self.dispatchEvent(received),
+ () => received.waitUntil(Promise.resolve())
+ ]) {
+ let errorName;
+ try { action(); } catch (error) { errorName = error.name; }
+ if (errorName !== "InvalidStateError") {
+ throw new Error("expected InvalidStateError, got " + errorName);
+ }
+ }
+ received.preventDefault();
+ });
+ for (let attempt = 1; attempt <= 2; attempt++) {
+ const result = self.dispatchEvent(event);
+ if (result !== false || calls !== attempt || !event.defaultPrevented ||
+ !event.bubbles || !event.composed || event.isTrusted ||
+ event.currentTarget !== null || event.eventPhase !== Event.NONE ||
+ event.composedPath().length !== 0) {
+ throw new Error("incorrect completed event state");
+ }
+ }
+ }
+ let fakeError;
+ try { self.dispatchEvent({type: "fake"}); }
+ catch (error) { fakeError = error.name; }
+ if (fakeError !== "TypeError") {
+ throw new Error("dispatchEvent accepted a non-Event");
+ }
+ });
+ "#,
+ );
+
+ let completion = dispatch_service_worker_message_event_for_test(
+ &mut handle,
+ 30,
+ serialize_test_string("go"),
+ )
+ .await;
+ assert_eq!(completion.result, Ok(()));
+ handle.terminate_and_join();
+}
+
#[tokio::test]
async fn service_worker_message_event_source_uses_client_snapshot() {
ensure_v8();