fix(service-worker): share native waitUntil lifetime handling

Connect ExtendableEvent.prototype.waitUntil to native pending-event state.
Validate receiver and required Promise arguments before checking event trust
and activity, and apply current WebIDL Promise wrapping to own and inherited
calls. Reject script-redispatched events using the private trusted flag.
This commit is contained in:
ldm0
2026-11-13 04:18:25 +08:00
parent 48640c3bf7
commit a86a76838a
9 changed files with 250 additions and 63 deletions
+1 -1
View File
@@ -381,7 +381,7 @@ pub(crate) use self::events::{
clear_event_composed_path, construct_original_error_event, construct_original_message_event,
error_event_handler_arguments, 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, event_source_retargets_on_access,
event_is_mouse_event, event_private_value, event_source_retargets_on_access, event_trusted,
initialize_event_object, initialize_event_object_with_type, initialize_event_wrapper,
initialize_native_security_policy_violation_event, mark_agent_submit_event, mark_event_trusted,
new_event_state, new_event_wrapper, set_event_composed_path, set_event_internal_flag,
@@ -311,9 +311,9 @@ pub(crate) use base::{
EVENT_DISPATCHING_SLOT, EVENT_MOUSE_POSITIONLESS_SLOT, EVENT_PASSIVE_SLOT,
EVENT_STOP_IMMEDIATE_PROPAGATION_SLOT, 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, initialize_event_object_with_type,
mark_event_trusted, reinitialize_event_object, set_event_composed_path,
set_event_internal_flag, set_event_trusted,
event_is_dispatching, event_trusted, initialize_event_object,
initialize_event_object_with_type, mark_event_trusted, reinitialize_event_object,
set_event_composed_path, set_event_internal_flag, set_event_trusted,
};
fn event_subclass_kind<'s>(
@@ -264,7 +264,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 {
@@ -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: (),
}
@@ -550,16 +550,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);
}
+36 -19
View File
@@ -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: (),
}
@@ -134,7 +134,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: (),
@@ -159,7 +159,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: (),
}
@@ -210,7 +210,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: (),
}
@@ -227,7 +227,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: (),
}
@@ -259,7 +259,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: (),
}
@@ -276,7 +276,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: (),
}
@@ -1899,12 +1899,37 @@ 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)]
promise: v8::Local<'s, v8::Promise>,
}
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::<ServiceWorkerWaitUntilArgs>(scope, &args) else {
return;
};
// 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);
@@ -2083,12 +2108,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, parsed.promise, on_fulfilled, on_rejected) {
service_worker_wait_until_settled_for_event(scope, event_id, event_kind, false);
}
}
@@ -2112,9 +2132,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 {
@@ -2128,9 +2148,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;
};
+3 -1
View File
@@ -46,7 +46,9 @@ mod isolate;
mod runtime_inspector;
pub(crate) use dispatch::dispatch_current_worker_callback_exception;
pub(in crate::worker) use dispatch::service_worker_respond_with_callback;
pub(in crate::worker) use dispatch::{
service_worker_respond_with_callback, service_worker_wait_until_callback,
};
use super::bitmap_tasks::WorkerBitmapTasks;
use super::canvas_blob_tasks::WorkerCanvasBlobTasks;
@@ -1,5 +1,118 @@
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);
onfetch = event => {
if (captured) return;
captured = event;
let finish;
event.waitUntil(new Promise(resolve => finish = resolve));
event.respondWith(new Response('captured'));
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);
};
onmessage = event => event.waitUntil(redispatchChecked);
"#,
);
let completion = dispatch_service_worker_fetch_event_for_test(&mut handle, 85).await;
let ServiceWorkerFetchResult::Response(response) = completion.result else {
panic!("expected captured native fetch response");
};
assert_eq!(response.body, b"captured");
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_event_constructor_preserves_webidl_state_and_dispatch() {
ensure_v8();
@@ -1539,7 +1539,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#"
@@ -1549,6 +1550,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 {
@@ -1576,7 +1579,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();
}
@@ -1737,33 +1740,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]
@@ -0,0 +1,44 @@
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'),
new FetchEvent('synthetic', {request: new Request('https://example.test/')})
]) {
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');
}
}
}