mirror of
https://github.com/lexmount/moli.git
synced 2026-11-18 16:08:37 +00:00
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:
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
@@ -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');
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user