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

Source-commit: a86a76838a
This commit is contained in:
ldm0
2026-11-13 22:49:06 +08:00
committed by Donough Liu
parent efbeb470e5
commit 00cf929e2c
9 changed files with 259 additions and 58 deletions
@@ -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;
@@ -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;
@@ -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 {
@@ -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);
}
+43 -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: (),
}
@@ -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::<ServiceWorkerWaitUntilArgs>(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;
};
@@ -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;
@@ -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();
@@ -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]
@@ -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');
}
}
}