From 00cf929e2ce7dc6504f8a79ca2716255949ff8d9 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 13 Nov 2026 19:57:01 +0800 Subject: [PATCH] fix(service-worker): share native ExtendableEvent waitUntil handling Source-commit: a86a76838ab --- moli-renderer-v8/src/context_bootstrap.rs | 2 + .../src/context_bootstrap/events.rs | 2 + .../src/context_bootstrap/events/base.rs | 2 +- .../worker/global_scope/extendable_events.rs | 15 +-- .../src/worker/thread/dispatch.rs | 62 +++++++--- moli-renderer-v8/src/worker/thread/mod.rs | 2 + .../lifecycle/fetch_events_and_messages.rs | 117 ++++++++++++++++++ .../lifecycle/worker_and_fetch_lifecycle.rs | 72 +++++++---- .../fixtures/extendable-event-wait-until.js | 43 +++++++ 9 files changed, 259 insertions(+), 58 deletions(-) create mode 100644 moli-renderer-v8/tests/fixtures/extendable-event-wait-until.js diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 8f4a52edbe1..cccbef49144 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -1202,3 +1202,5 @@ pub(crate) fn set_event_private_bool<'s>( v8::Boolean::new(scope, value).into(), ); } + +pub(crate) use self::events::event_trusted; diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs index c1107787d1e..39e6c55880b 100644 --- a/moli-renderer-v8/src/context_bootstrap/events.rs +++ b/moli-renderer-v8/src/context_bootstrap/events.rs @@ -515,3 +515,5 @@ pub(crate) use subclasses::construct_original_error_event; mod ui_properties; pub(in crate::context_bootstrap) use ui_properties::ui_event_which_getter_function; + +pub(crate) use self::base::event_trusted; diff --git a/moli-renderer-v8/src/context_bootstrap/events/base.rs b/moli-renderer-v8/src/context_bootstrap/events/base.rs index d63096d8d62..0c3fcf14184 100644 --- a/moli-renderer-v8/src/context_bootstrap/events/base.rs +++ b/moli-renderer-v8/src/context_bootstrap/events/base.rs @@ -258,7 +258,7 @@ fn event_is_trusted_getter_function<'s>( rv.set(v8::Boolean::new(scope, trusted).into()); } -pub(in crate::context_bootstrap) fn event_trusted<'s>( +pub(crate) fn event_trusted<'s>( scope: &mut v8::PinScope<'s, '_>, event: v8::Local<'s, v8::Object>, ) -> bool { diff --git a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs index 46b1e6b057b..9ded212dbfd 100644 --- a/moli-renderer-v8/src/worker/global_scope/extendable_events.rs +++ b/moli-renderer-v8/src/worker/global_scope/extendable_events.rs @@ -9,7 +9,7 @@ use super::*; constructor_length = 1 )] struct ExtendableEventTemplateDeclaration { - #[webapi(method = "waitUntil", callback = extendable_event_wait_until_callback, length = 1)] + #[webapi(method = "waitUntil", callback = super::super::thread::service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -565,16 +565,3 @@ fn frozen_empty_worker_array<'s>(scope: &mut v8::PinScope<'s, '_>) -> v8::Local< let _ = array.set_integrity_level(scope, v8::IntegrityLevel::Frozen); array } - -fn extendable_event_wait_until_callback<'s>( - scope: &mut v8::PinScope<'s, '_>, - _args: v8::FunctionCallbackArguments<'s>, - _rv: v8::ReturnValue<'_, v8::Value>, -) { - let exception = worker_dom_exception_value( - scope, - "ExtendableEvent.waitUntil() was called outside an active event dispatch.", - "InvalidStateError", - ); - scope.throw_exception(exception); -} diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs index a634a7d82d9..279d7026772 100644 --- a/moli-renderer-v8/src/worker/thread/dispatch.rs +++ b/moli-renderer-v8/src/worker/thread/dispatch.rs @@ -117,7 +117,7 @@ struct ServiceWorkerLifecycleEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -144,7 +144,7 @@ struct ServiceWorkerFetchEventDeclaration<'scope> { is_reload: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), #[webapi(method, enumerable, callback = service_worker_respond_with_callback)] respond_with: (), @@ -169,7 +169,7 @@ struct ServiceWorkerMessageEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -220,7 +220,7 @@ struct ServiceWorkerNotificationEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -237,7 +237,7 @@ struct ServiceWorkerPushEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -269,7 +269,7 @@ struct ServiceWorkerSyncEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -286,7 +286,7 @@ struct ServiceWorkerPeriodicSyncEventDeclaration<'scope> { default_prevented: bool, #[webapi(method, enumerable, callback = worker_event_prevent_default_callback)] prevent_default: (), - #[webapi(method, enumerable, callback = service_worker_wait_until_callback)] + #[webapi(method, enumerable, callback = service_worker_wait_until_callback, length = 1)] wait_until: (), } @@ -1895,12 +1895,44 @@ fn service_worker_event_id_value( lossless.then_some(id) } -fn service_worker_wait_until_callback<'s>( +#[derive(crate::webidl::WebIdlArgs)] +#[webidl(prefix = "ExtendableEvent.waitUntil")] +struct ServiceWorkerWaitUntilArgs<'s> { + #[webidl(required, converter = "raw")] + promise: v8::Local<'s, v8::Value>, +} + +pub(in crate::worker) fn service_worker_wait_until_callback<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, _rv: v8::ReturnValue<'_, v8::Value>, ) { let event = args.this(); + if !web_api_interfaces::ExtendableEvent::is_instance(scope, event) { + throw_type_error( + scope, + "ExtendableEvent.waitUntil called on an incompatible receiver.", + ); + return; + } + // Convert the required Promise before the method's active-event check. + // Web IDL creates a new intrinsic capability and observes the input's then. + let Some(parsed) = crate::webidl::parse_args::(scope, &args) else { + return; + }; + let Some(resolver) = v8::PromiseResolver::new(scope) else { + return; + }; + if resolver.resolve(scope, parsed.promise) != Some(true) { + return; + } + let promise = resolver.get_promise(scope); + // Script redispatch clears trust even while the original native event + // still has pending lifetime promises. Its private dispatch ID is not enough. + if !crate::context_bootstrap::event_trusted(scope, event) { + throw_service_worker_wait_until_invalid_state(scope); + return; + } let lifecycle_event_id = service_worker_lifecycle_event_id(scope, event); let fetch_event_id = service_worker_fetch_event_id(scope, event); let message_event_id = service_worker_message_event_id(scope, event); @@ -2079,12 +2111,7 @@ fn service_worker_wait_until_callback<'s>( throw_service_worker_wait_until_invalid_state(scope); return; } - if !promise_resolve_then2_after_wait_until_microtask( - scope, - args.get(0), - on_fulfilled, - on_rejected, - ) { + if !promise_then2_after_wait_until_microtask(scope, promise, on_fulfilled, on_rejected) { service_worker_wait_until_settled_for_event(scope, event_id, event_kind, false); } } @@ -2108,9 +2135,9 @@ fn promise_resolve_then2<'s>( promise.then2(scope, on_fulfilled, on_rejected) } -fn promise_resolve_then2_after_wait_until_microtask<'s>( +fn promise_then2_after_wait_until_microtask<'s>( scope: &mut v8::PinScope<'s, '_>, - value: v8::Local<'s, v8::Value>, + promise: v8::Local<'s, v8::Promise>, on_fulfilled: v8::Local<'s, v8::Function>, on_rejected: v8::Local<'s, v8::Function>, ) -> bool { @@ -2124,9 +2151,6 @@ fn promise_resolve_then2_after_wait_until_microtask<'s>( else { return false; }; - let Some(promise) = promise_resolve_value(scope, value) else { - return false; - }; let Some(wait_until_promise) = promise.then2(scope, extra_fulfilled, extra_rejected) else { return false; }; diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index 1559e9b8d80..0854566cfa7 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -3582,3 +3582,5 @@ fn evaluate_classic_worker_bootstrap_script( #[cfg(test)] mod tests; + +pub(in crate::worker) use self::dispatch::service_worker_wait_until_callback; diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs index 46fcf18f267..5e727d128ca 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs @@ -1,5 +1,122 @@ use super::*; +#[tokio::test] +async fn service_worker_wait_until_prototype_uses_native_dispatch_and_webidl_arguments() { + ensure_v8(); + let source = format!( + "{}\n{}", + include_str!("../../../../../tests/fixtures/extendable-event-wait-until.js"), + r#" + for (const type of ['install', 'activate', 'message']) { + addEventListener(type, checkExtendableEventWaitUntil); + } + onfetch = event => { + checkExtendableEventWaitUntil(event); + event.respondWith(new Response('checked')); + }; + "# + ); + let mut handle = spawn_service_worker_for_test(&source); + for (kind, id) in [ + (ServiceWorkerLifecycleEventKind::Install, 80), + (ServiceWorkerLifecycleEventKind::Activate, 81), + ] { + let completion = + dispatch_service_worker_lifecycle_event_for_test(&mut handle, kind, id).await; + assert_eq!(completion.result, Ok(())); + } + let completion = dispatch_service_worker_message_event_for_test( + &mut handle, + 82, + serialize_test_string("go"), + ) + .await; + assert_eq!(completion.result, Ok(())); + let completion = dispatch_service_worker_fetch_event_for_test(&mut handle, 83).await; + let ServiceWorkerFetchResult::Response(response) = completion.result else { + panic!("expected response after borrowed waitUntil checks"); + }; + assert_eq!(response.body, b"checked"); + handle.terminate_and_join(); +} + +#[tokio::test] +async fn service_worker_wait_until_rejects_script_redispatched_native_events() { + ensure_v8(); + let mut handle = spawn_service_worker_for_test( + r#" + let captured; + let checked; + const redispatchChecked = new Promise(resolve => checked = resolve); + onmessage = event => { + if (event === captured) return; + if (captured) { + event.waitUntil(redispatchChecked); + return; + } + captured = event; + let finish; + event.waitUntil(new Promise(resolve => finish = resolve)); + setTimeout(() => { + self.dispatchEvent(event); + if (event.isTrusted) throw Error('script redispatch must clear trust'); + let reads = 0; + const value = {get then() { reads++; return undefined; }}; + for (const method of [event.waitUntil, ExtendableEvent.prototype.waitUntil]) { + let caught; + try { method.call(event, value); } catch (error) { caught = error; } + if (!(caught instanceof DOMException) || caught.name !== 'InvalidStateError') { + throw Error('redispatched waitUntil must reject: ' + caught); + } + } + if (reads !== 2) throw Error('Promise arguments must be converted before trust check'); + checked(); + finish(); + }, 0); + }; + "#, + ); + let completion = dispatch_service_worker_message_event_for_test( + &mut handle, + 85, + serialize_test_string("capture"), + ) + .await; + assert_eq!(completion.result, Ok(())); + let completion = dispatch_service_worker_message_event_for_test( + &mut handle, + 86, + serialize_test_string("verify"), + ) + .await; + assert_eq!(completion.result, Ok(())); + handle.terminate_and_join(); +} + +#[tokio::test] +async fn service_worker_wait_until_prototype_rejection_fails_native_install() { + ensure_v8(); + let mut handle = spawn_service_worker_for_test( + r#" + oninstall = event => { + ExtendableEvent.prototype.waitUntil.call(event, + new Promise((resolve, reject) => setTimeout(() => reject('install rejected'), 0))); + }; + "#, + ); + let completion = dispatch_service_worker_lifecycle_event_for_test( + &mut handle, + ServiceWorkerLifecycleEventKind::Install, + 84, + ) + .await; + assert_eq!( + completion.result, + Err("service worker waitUntil promise rejected".to_owned()) + ); + handle.terminate_and_join(); +} + #[tokio::test] async fn service_worker_fetch_handler_throw_without_respond_with_still_falls_back() { ensure_v8(); diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_and_fetch_lifecycle.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_and_fetch_lifecycle.rs index 129de3eb53c..65e2468b383 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_and_fetch_lifecycle.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/worker_and_fetch_lifecycle.rs @@ -1522,7 +1522,8 @@ async fn service_worker_message_wait_until_same_turn_after_pending_promise_settl } #[tokio::test] -async fn service_worker_message_wait_until_extra_microtask_after_pending_promise_settles_throws() { +async fn service_worker_message_wait_until_original_promise_microtask_keeps_wrapped_lifetime_active() + { ensure_v8(); let mut handle = spawn_service_worker_for_test( r#" @@ -1532,6 +1533,8 @@ async fn service_worker_message_wait_until_extra_microtask_after_pending_promise resolveFirst = resolve; }); event.waitUntil(first); + // Web IDL wraps first in a new Promise. This original Promise's + // reaction and its microtask run before the wrapped lifetime settles. first.then(() => Promise.resolve().then(() => { let result = "unset"; try { @@ -1559,7 +1562,7 @@ async fn service_worker_message_wait_until_extra_microtask_after_pending_promise ServiceWorkerEventId::from_u64_for_worker(68) ); assert_eq!(completion.result, Ok(())); - assert_eq!(console, "log: extra-turn:InvalidStateError:true"); + assert_eq!(console, "log: extra-turn:OK"); handle.terminate_and_join(); } @@ -1720,33 +1723,54 @@ async fn service_worker_wait_until_uses_native_promise_adoption() { } #[tokio::test] -async fn service_worker_wait_until_uses_native_promise_reactions() { +async fn service_worker_wait_until_wraps_native_promises_before_registering_lifetime() { ensure_v8(); - let mut handle = spawn_service_worker_for_test( - r#" + for borrowed in [false, true] { + let source = format!( + "const borrowed = {borrowed};{}", + r#" self.addEventListener("install", event => { - const promise = new Promise(resolve => resolve("ok")); - promise.then = () => { - throw new Error("patched promise.then should not run"); - }; - event.waitUntil(promise); + const IntrinsicPromise = Promise; + const promise = IntrinsicPromise.resolve("ok"); + let reads = 0, calls = 0; + Object.defineProperty(promise, 'constructor', { + get() { throw Error('Promise constructor should not be read'); } + }); + Object.defineProperty(promise, 'then', {get() { + reads++; + return function(resolve) { + if (this !== promise) throw Error('incorrect then receiver'); + calls++; + resolve('assimilated'); + }; + }}); + self.Promise = function() { throw Error('author Promise constructor'); }; + const method = borrowed ? ExtendableEvent.prototype.waitUntil : event.waitUntil; + method.call(event, promise); + if (reads !== 1 || calls !== 0) throw Error('incorrect synchronous Promise conversion'); + method.call(event, new IntrinsicPromise(resolve => setTimeout(() => { + if (reads !== 1 || calls !== 1) throw Error('incorrect asynchronous Promise adoption'); + resolve(); + }, 0))); }); - "#, - ); + "# + ); + let mut handle = spawn_service_worker_for_test(&source); - let completion = dispatch_service_worker_lifecycle_event_for_test( - &mut handle, - ServiceWorkerLifecycleEventKind::Install, - 11, - ) - .await; + let completion = dispatch_service_worker_lifecycle_event_for_test( + &mut handle, + ServiceWorkerLifecycleEventKind::Install, + 11, + ) + .await; - assert_eq!( - completion.event_id, - ServiceWorkerEventId::from_u64_for_worker(11) - ); - assert_eq!(completion.result, Ok(())); - handle.terminate_and_join(); + assert_eq!( + completion.event_id, + ServiceWorkerEventId::from_u64_for_worker(11) + ); + assert_eq!(completion.result, Ok(())); + handle.terminate_and_join(); + } } #[tokio::test] diff --git a/moli-renderer-v8/tests/fixtures/extendable-event-wait-until.js b/moli-renderer-v8/tests/fixtures/extendable-event-wait-until.js new file mode 100644 index 00000000000..0258ce40ed6 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/extendable-event-wait-until.js @@ -0,0 +1,43 @@ +function checkExtendableEventWaitUntil(event) { + const waitUntil = ExtendableEvent.prototype.waitUntil; + const assert = (condition, message) => { + if (!condition) throw Error(message); + }; + const throws = (callback, expected, message) => { + let caught; + try { callback(); } catch (error) { caught = error; } + assert(caught?.name === expected, message + ': ' + caught); + }; + let reads = 0, traps = 0; + const value = {get then() { reads++; return undefined; }}; + const proxyHandler = new Proxy({}, { + get() { traps++; throw Error('author Proxy trap'); } + }); + const revoked = Proxy.revocable(event, {}); + revoked.revoke(); + for (const receiver of [ + {}, Object.create(ExtendableEvent.prototype), new Event('plain'), + new Proxy(event, proxyHandler), revoked.proxy + ]) { + throws(() => waitUntil.call(receiver, value), 'TypeError', 'invalid receiver'); + } + assert(reads === 0 && traps === 0, 'brand checks precede conversion and do not invoke traps'); + for (const synthetic of [ + new ExtendableEvent('synthetic'), + new ExtendableMessageEvent('synthetic') + ]) { + throws(() => waitUntil.call(synthetic), 'TypeError', 'required argument'); + const before = reads; + throws(() => waitUntil.call(synthetic, value), 'InvalidStateError', 'untrusted event'); + assert(reads === before + 1, 'Promise conversion precedes inactive-event check'); + } + for (const method of [waitUntil, event.waitUntil]) { + throws(() => method.call(event), 'TypeError', 'native event required argument'); + const before = reads; + assert(method.call(event, value) === undefined, 'native event returns undefined'); + assert(reads === before + 1, 'native event converts thenables once'); + for (const scalar of [undefined, null, 1, 'value', Symbol('value')]) { + assert(method.call(event, scalar) === undefined, 'Promise accepts scalar values'); + } + } +}