mirror of
https://github.com/lexmount/moli.git
synced 2026-11-18 16:08:37 +00:00
fix(service-worker): share native ExtendableEvent waitUntil handling
Source-commit: a86a76838a
This commit is contained in:
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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');
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user