fix(service-worker): implement FetchEvent construction and native prototypes

Expose FetchEvent in service workers with required Request validation, ordered
WebIDL dictionary conversion, lossless DOMStrings and the specified Promise
defaults. Store its readonly attributes in native slots.

Use the same saved intrinsic prototype and state for native fetch dispatch,
including trusted cancelable Event state. Native dispatch remains independent
of author replacements of the public FetchEvent constructor. Cover constructor
validation, synthetic dispatch and the native respondWith path.
This commit is contained in:
ldm0
2026-11-13 02:10:40 +08:00
parent 22f81b8293
commit d89413df5e
8 changed files with 398 additions and 23 deletions
+1 -1
View File
@@ -382,7 +382,7 @@ pub(crate) use self::events::{
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,
initialize_event_object, initialize_event_wrapper,
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,
set_event_private_value, set_event_source_value, set_event_trusted,
@@ -164,6 +164,7 @@ pub(in crate::worker) fn install_worker_global_scope<'s>(
crate::worker::thread::WorkerGlobalKind::Service { .. }
) {
install_service_worker_extendable_event_constructors(scope, global)?;
install_service_worker_fetch_event_constructor(scope, global)?;
}
crate::context_bootstrap::initialize_worker_performance_realm_state(scope, global)?;
let subtle_crypto_available = secure_context;
@@ -0,0 +1,232 @@
//! FetchEvent construction and the state shared with native fetch dispatch.
use super::*;
use crate::webidl;
const FETCH_EVENT_PROTOTYPE_SLOT: &str = "__moliFetchEventPrototype";
const REQUEST_SLOT: &str = "__moliFetchEventRequest";
const PRELOAD_RESPONSE_SLOT: &str = "__moliFetchEventPreloadResponse";
const CLIENT_ID_SLOT: &str = "__moliFetchEventClientId";
const RESULTING_CLIENT_ID_SLOT: &str = "__moliFetchEventResultingClientId";
const REPLACES_CLIENT_ID_SLOT: &str = "__moliFetchEventReplacesClientId";
const HANDLED_SLOT: &str = "__moliFetchEventHandled";
#[derive(WebApiFunctionTemplate)]
#[webapi(
interface = web_api_interfaces::FetchEvent,
constructor_callback = fetch_event_constructor_callback,
constructor_length = 2,
readonly_prototype,
receiver = web_api_interfaces::FetchEvent::is_instance
)]
struct FetchEventTemplateDeclaration {
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, REQUEST_SLOT))]
request: (),
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, PRELOAD_RESPONSE_SLOT))]
preload_response: (),
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, CLIENT_ID_SLOT))]
client_id: (),
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, RESULTING_CLIENT_ID_SLOT))]
resulting_client_id: (),
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, REPLACES_CLIENT_ID_SLOT))]
replaces_client_id: (),
#[webapi(accessor_property, enumerable, getter = fetch_event_attribute_getter, data = v8str(scope, HANDLED_SLOT))]
handled: (),
#[webapi(method = "respondWith", enumerable, callback = fetch_event_respond_with_callback, length = 1)]
respond_with: (),
}
#[derive(WebApiObject)]
#[webapi(plain)]
struct FetchEventConstructorGlobalDeclaration<'scope> {
#[webapi(data_property = "FetchEvent")]
fetch_event: v8::Local<'scope, v8::Function>,
}
#[derive(webidl::WebIdlDictionary)]
struct FetchEventBaseInit {
#[webidl(default = false)]
bubbles: bool,
#[webidl(default = false)]
cancelable: bool,
#[webidl(default = false)]
composed: bool,
}
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "FetchEventInit")]
struct FetchEventInit<'s> {
#[webidl(inherit)]
base: FetchEventBaseInit,
#[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")]
client_id: webidl::DomString16,
#[webidl(converter = "raw")]
handled: Option<v8::Local<'s, v8::Promise>>,
#[webidl(converter = "raw")]
preload_response: Option<v8::Local<'s, v8::Promise>>,
#[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")]
replaces_client_id: webidl::DomString16,
#[webidl(required, interface = web_api_interfaces::Request)]
request: v8::Local<'s, v8::Object>,
#[webidl(default = webidl::DomString16(Vec::new()), converter = "raw")]
resulting_client_id: webidl::DomString16,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "FetchEvent")]
struct FetchEventConstructorArgs<'s> {
#[webidl(required, converter = "raw")]
event_type: webidl::DomString16,
#[webidl(required, dictionary)]
init: FetchEventInit<'s>,
}
#[derive(WebApiObject)]
#[webapi(interface = web_api_interfaces::FetchEvent, prototype = "Object")]
struct FetchEventStateDeclaration<'scope> {
#[webapi(slot = REQUEST_SLOT)]
request: v8::Local<'scope, v8::Object>,
#[webapi(slot = PRELOAD_RESPONSE_SLOT)]
preload_response: v8::Local<'scope, v8::Promise>,
#[webapi(slot = CLIENT_ID_SLOT)]
client_id: v8::Local<'scope, v8::String>,
#[webapi(slot = RESULTING_CLIENT_ID_SLOT)]
resulting_client_id: v8::Local<'scope, v8::String>,
#[webapi(slot = REPLACES_CLIENT_ID_SLOT)]
replaces_client_id: v8::Local<'scope, v8::String>,
#[webapi(slot = HANDLED_SLOT)]
handled: v8::Local<'scope, v8::Promise>,
}
pub(super) fn install_service_worker_fetch_event_constructor<'s>(
scope: &mut v8::PinScope<'s, '_>,
global: v8::Local<'s, v8::Object>,
) -> Result<()> {
let template = FetchEventTemplateDeclaration::build(scope);
let constructor = template
.get_function(scope)
.ok_or_else(|| anyhow!("failed to build FetchEvent constructor"))?;
let prototype = constructor_prototype(scope, constructor, "FetchEvent")?;
set_worker_to_string_tag(scope, prototype, "FetchEvent");
let parent = global_constructor_object(scope, "ExtendableEvent")
.ok_or_else(|| anyhow!("missing ExtendableEvent constructor"))?;
let parent_prototype = global_constructor_prototype(scope, "ExtendableEvent")
.ok_or_else(|| anyhow!("missing ExtendableEvent prototype"))?;
let _ = constructor.set_prototype(scope, parent.into());
let _ = prototype.set_prototype(scope, parent_prototype.into());
// Native dispatch must not consult an author-replaced constructor/getter.
set_private_value(scope, global, FETCH_EVENT_PROTOTYPE_SLOT, prototype.into());
FetchEventConstructorGlobalDeclaration::new(constructor)
.initialize(scope, global)
.map_err(Into::into)
}
fn fetch_event_constructor_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'s, v8::Value>,
) {
if !args.is_construct_call() {
throw_type_error(scope, "FetchEvent requires the 'new' operator.");
return;
}
let Some(parsed) = webidl::parse_args::<FetchEventConstructorArgs>(scope, &args) else {
return;
};
let init = parsed.init;
let event_type =
v8::String::new_from_two_byte(scope, &parsed.event_type.0, v8::NewStringType::Normal)
.expect("FetchEvent type");
let state = crate::context_bootstrap::new_event_state(scope);
crate::context_bootstrap::initialize_event_object_with_type(
scope,
state,
event_type,
init.base.bubbles,
init.base.cancelable,
);
let _ = state.set(
scope,
v8str(scope, "composed").into(),
v8::Boolean::new(scope, init.base.composed).into(),
);
let event = args.this();
if crate::context_bootstrap::initialize_event_wrapper(scope, event, state).is_none() {
return;
}
let preload_response = init.preload_response.unwrap_or_else(|| {
let resolver = v8::PromiseResolver::new(scope).expect("FetchEvent preload promise");
let _ = resolver.resolve(scope, v8::undefined(scope).into());
resolver.get_promise(scope)
});
let handled = init.handled.unwrap_or_else(|| {
v8::PromiseResolver::new(scope)
.expect("FetchEvent handled promise")
.get_promise(scope)
});
let string = |scope: &mut v8::PinScope<'s, '_>, value: webidl::DomString16| {
v8::String::new_from_two_byte(scope, &value.0, v8::NewStringType::Normal)
.expect("FetchEvent client ID")
};
FetchEventStateDeclaration::new(
init.request,
preload_response,
string(scope, init.client_id),
string(scope, init.resulting_client_id),
string(scope, init.replaces_client_id),
handled,
)
.initialize(scope, event)
.expect("FetchEvent state");
rv.set(event.into());
}
fn fetch_event_attribute_getter<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'s, v8::Value>,
) {
let slot = args.data().to_rust_string_lossy(scope);
if let Some(value) = get_private_value(scope, args.this(), &slot) {
rv.set(value);
}
}
fn fetch_event_respond_with_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
rv: v8::ReturnValue<'s, v8::Value>,
) {
if args.length() == 0 {
throw_type_error(scope, "FetchEvent.respondWith requires an argument.");
return;
}
crate::worker::thread::service_worker_respond_with_callback(scope, args, rv);
}
pub(in crate::worker) fn initialize_native_fetch_event<'s>(
scope: &mut v8::PinScope<'s, '_>,
event: v8::Local<'s, v8::Object>,
request: v8::Local<'s, v8::Object>,
handled: v8::Local<'s, v8::Promise>,
preload_response: v8::Local<'s, v8::Promise>,
ids: &crate::service_worker_runtime::ServiceWorkerFetchEventClientIds,
) {
let global = scope.get_current_context().global(scope);
let prototype = get_private_value(scope, global, FETCH_EVENT_PROTOTYPE_SLOT)
.expect("Service Worker FetchEvent prototype");
assert_eq!(event.set_prototype(scope, prototype), Some(true));
crate::context_bootstrap::initialize_event_object(scope, event, "fetch", false, true);
crate::context_bootstrap::mark_event_trusted(scope, event);
FetchEventStateDeclaration::new(
request,
preload_response,
v8::String::new(scope, &ids.client_id).unwrap_or_else(|| v8::String::empty(scope)),
v8::String::new(scope, &ids.resulting_client_id)
.unwrap_or_else(|| v8::String::empty(scope)),
v8::String::empty(scope),
handled,
)
.initialize(scope, event)
.expect("native FetchEvent state");
}
@@ -195,12 +195,15 @@ pub(super) use content_security_policy::{
use event_handlers::install_worker_global_event_handler_accessors;
pub(super) use event_handlers::service_worker_fetch_handler_type;
use extendable_events::install_service_worker_extendable_event_constructors;
mod fetch_events;
pub(super) use extendable_events::{
PendingServiceWorkerFetchEvent, PendingServiceWorkerLifecycleEvent,
PendingServiceWorkerMessageEvent, PendingServiceWorkerNavigationPreload,
PendingServiceWorkerNotificationEvent, PendingServiceWorkerPeriodicSyncEvent,
PendingServiceWorkerPushEvent, PendingServiceWorkerSyncEvent,
};
pub(in crate::worker) use fetch_events::initialize_native_fetch_event;
use fetch_events::install_service_worker_fetch_event_constructor;
pub(super) use import_scripts::{
WORKER_EXCEPTION_COLUMN_SLOT, WORKER_EXCEPTION_LINE_SLOT, WORKER_EXCEPTION_SOURCE_SLOT,
};
+12 -22
View File
@@ -131,16 +131,6 @@ struct ServiceWorkerFetchEventDeclaration<'scope> {
#[webapi(data_property, enumerable)]
default_prevented: bool,
#[webapi(data_property, enumerable)]
handled: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
preload_response: v8::Local<'scope, v8::Promise>,
#[webapi(data_property, enumerable)]
request: v8::Local<'scope, v8::Object>,
#[webapi(data_property, enumerable)]
client_id: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
resulting_client_id: v8::Local<'scope, v8::String>,
#[webapi(data_property, enumerable)]
is_reload: bool,
#[webapi(method, enumerable, callback = worker_event_prevent_default_callback)]
prevent_default: (),
@@ -1361,25 +1351,25 @@ fn new_service_worker_fetch_event<'s>(
handled: v8::Local<'s, v8::Promise>,
preload_response: v8::Local<'s, v8::Promise>,
) -> v8::Local<'s, v8::Object> {
let client_id = v8::String::new(scope, &event.client_ids.client_id)
.unwrap_or_else(|| v8::String::empty(scope));
let resulting_client_id = v8::String::new(scope, &event.client_ids.resulting_client_id)
.unwrap_or_else(|| v8::String::empty(scope));
ServiceWorkerFetchEventDeclaration {
let object = ServiceWorkerFetchEventDeclaration {
r#type: v8::String::new(scope, "fetch").unwrap(),
default_prevented: false,
handled,
preload_response,
request,
client_id,
resulting_client_id,
is_reload: event.request.is_reload,
prevent_default: (),
wait_until: (),
respond_with: (),
}
.bind(scope)
.expect("service worker fetch event declaration should bind")
.expect("service worker fetch event declaration should bind");
super::super::global_scope::initialize_native_fetch_event(
scope,
object,
request,
handled,
preload_response,
&event.client_ids,
);
object
}
fn new_service_worker_preload_response_promise<'s>(
@@ -2408,7 +2398,7 @@ fn service_worker_wait_until_settled_for_event(
}
}
fn service_worker_respond_with_callback<'s>(
pub(in crate::worker) fn service_worker_respond_with_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
@@ -46,6 +46,7 @@ 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;
use super::bitmap_tasks::WorkerBitmapTasks;
use super::canvas_blob_tasks::WorkerCanvasBlobTasks;
@@ -1,5 +1,62 @@
use super::*;
#[tokio::test]
async fn service_worker_fetch_event_constructor_preserves_webidl_state_and_dispatch() {
ensure_v8();
let source = format!(
"{}\nself.onmessage = event => event.waitUntil(runFetchEventConstructorChecks());",
include_str!("../../../../../tests/fixtures/fetch-event-constructor.js")
);
let mut handle = spawn_service_worker_for_test(&source);
let completion = dispatch_service_worker_message_event_for_test(
&mut handle,
31,
serialize_test_string("go"),
)
.await;
assert_eq!(completion.result, Ok(()));
handle.terminate_and_join();
}
#[tokio::test]
async fn native_fetch_event_preserves_its_intrinsic_prototype_and_readonly_request() {
ensure_v8();
let mut handle = spawn_service_worker_for_test(
r#"
const OriginalFetchEvent = FetchEvent;
const requestGetter = Object.getOwnPropertyDescriptor(FetchEvent.prototype, 'request').get;
Object.defineProperty(self, 'FetchEvent', {get() { throw Error('author FetchEvent getter'); }, configurable: true});
self.onfetch = event => {
const request = event.request;
const report = {
instance: event instanceof OriginalFetchEvent,
extendable: event instanceof ExtendableEvent,
event: event instanceof Event,
prototype: Object.getPrototypeOf(event) === OriginalFetchEvent.prototype,
request: requestGetter.call(event) === request,
ownRequest: Object.hasOwn(event, 'request'),
readonly: Reflect.set(event, 'request', null) === false,
url: event.request.url,
handled: event.handled === event.handled,
preload: event.preloadResponse === event.preloadResponse,
trusted: event.isTrusted,
cancelable: event.cancelable
};
OriginalFetchEvent.prototype.respondWith.call(event, new Response(JSON.stringify(report)));
};
"#,
);
let completion = dispatch_service_worker_fetch_event_for_test(&mut handle, 32).await;
let ServiceWorkerFetchResult::Response(response) = completion.result else {
panic!("expected native FetchEvent response");
};
assert_eq!(
String::from_utf8(response.body).unwrap(),
r#"{"instance":true,"extendable":true,"event":true,"prototype":true,"request":true,"ownRequest":false,"readonly":true,"url":"https://example.test/app/data.txt","handled":true,"preload":true,"trusted":true,"cancelable":true}"#
);
handle.terminate_and_join();
}
#[tokio::test]
async fn service_worker_fetch_event_uses_supplied_document_client_id_snapshots() {
ensure_v8();
@@ -0,0 +1,91 @@
async function runFetchEventConstructorChecks() {
const assert = (condition, message) => { if (!condition) throw Error(message); };
const thrown = callback => {
try { callback(); } catch (error) { return error; }
throw Error('expected exception');
};
const C = FetchEvent, P = Promise, R = Request;
const request = new R('https://example.test/input', {method: 'POST', body: 'body'});
const event = new C('\ud800\0\udfff', {request});
assert(C.name === 'FetchEvent' && C.length === 2, 'constructor metadata');
assert(Object.getPrototypeOf(C) === ExtendableEvent, 'constructor parent');
assert(Object.getPrototypeOf(C.prototype) === ExtendableEvent.prototype, 'prototype parent');
assert(event instanceof C && event instanceof ExtendableEvent && event instanceof Event, 'inheritance');
assert(Object.prototype.toString.call(event) === '[object FetchEvent]', 'toStringTag');
assert(event.type === '\ud800\0\udfff' && !event.bubbles && !event.cancelable && !event.composed, 'default Event state');
assert(event.isTrusted === false && event.request === request && !request.bodyUsed, 'request identity without consumption');
assert(event.clientId === '' && event.resultingClientId === '' && event.replacesClientId === '', 'default IDs');
assert(event.preloadResponse === event.preloadResponse && await event.preloadResponse === undefined, 'default preload');
assert(event.handled === event.handled && event.handled instanceof P, 'handled identity');
let handledSettled = false;
event.handled.then(() => { handledSettled = true; }, () => { handledSettled = true; });
await 0; await 0;
assert(!handledSettled, 'default handled stays pending');
for (const name of ['request', 'preloadResponse', 'clientId', 'resultingClientId', 'replacesClientId', 'handled']) {
const descriptor = Object.getOwnPropertyDescriptor(C.prototype, name);
assert(descriptor && typeof descriptor.get === 'function' && descriptor.set === undefined && descriptor.enumerable && descriptor.configurable, 'readonly descriptor ' + name);
assert(!Object.hasOwn(event, name), 'state is not an own public data property ' + name);
assert(thrown(() => descriptor.get.call({})) instanceof TypeError, 'receiver brand ' + name);
assert(thrown(() => descriptor.get.call(Object.create(C.prototype))) instanceof TypeError, 'forged receiver ' + name);
assert(Reflect.set(event, name, null) === false, 'readonly assignment ' + name);
}
assert(C.prototype.respondWith.length === 1, 'respondWith arity');
for (const callback of [() => C('fetch', {request}), () => new C(), () => new C('fetch'), () => new C('fetch', {}), () => new C('fetch', {request: null}), () => new C('fetch', {request: {}}), () => new C('fetch', {request: Object.create(R.prototype)}), () => new C('fetch', 1)]) {
assert(thrown(callback) instanceof TypeError, 'constructor validation');
}
assert(thrown(() => event.respondWith()) instanceof TypeError, 'required method argument');
for (const callback of [() => event.respondWith(new Response('synthetic')), () => event.waitUntil(P.resolve())]) {
const error = thrown(callback);
assert(error instanceof DOMException && error.name === 'InvalidStateError', 'synthetic lifetime guard');
}
const marker = {}, log = [];
const thenable = name => ({get then() {
log.push(name + '.then');
return resolve => { log.push(name + '.resolve'); resolve(marker); };
}});
const init = {};
const values = {bubbles: true, cancelable: true, composed: true,
clientId: '\udfff\0client', handled: thenable('handled'), preloadResponse: thenable('preload'),
replacesClientId: null, request, resultingClientId: 123};
for (const name of Object.keys(values)) Object.defineProperty(init, name, {get() { log.push(name); return values[name]; }});
const custom = new C({toString() { log.push('type'); return 'custom'; }}, Object.create(init));
assert(log.join() === 'type,bubbles,cancelable,composed,clientId,handled,handled.then,preloadResponse,preload.then,replacesClientId,request,resultingClientId', 'dictionary and promise conversion order: ' + log);
assert(custom.bubbles && custom.cancelable && custom.composed && !custom.defaultPrevented, 'explicit Event flags');
custom.preventDefault();
assert(custom.defaultPrevented, 'Event.preventDefault uses native Event state');
assert(custom.clientId === '\udfff\0client' && custom.resultingClientId === '123' && custom.replacesClientId === 'null', 'lossless DOMString conversion');
assert(await custom.handled === marker && await custom.preloadResponse === marker, 'promise assimilation preserves values');
const sentinel = {}, reads = [];
const error = thrown(() => new C('bad', {
get clientId() { reads.push('clientId'); throw sentinel; },
get request() { reads.push('request'); return request; }
}));
assert(error === sentinel && reads.join() === 'clientId', 'getter exceptions keep identity and stop conversion');
reads.length = 0;
assert(thrown(() => new C('bad', {request: null, get resultingClientId() { reads.push('late'); return ''; }})) instanceof TypeError && !reads.length, 'invalid required member stops later getters');
assert(thrown(() => new C('bad', {request, clientId: Symbol()})) instanceof TypeError, 'DOMString rejects symbols');
const rejected = new C('rejected', {request, preloadResponse: {get then() {throw sentinel;}}});
let rejection;
try { await rejected.preloadResponse; } catch (error) { rejection = error; }
assert(rejection === sentinel, 'then getter exception becomes promise rejection');
class Subclass extends C {}
const subclass = new Subclass('subclass', {request});
assert(Object.getPrototypeOf(subclass) === Subclass.prototype && subclass instanceof C && subclass.request === request, 'newTarget prototype');
let received = null;
const dispatched = new C('constructor-dispatch', {request, cancelable: true});
self.addEventListener('constructor-dispatch', event => { received = event; event.preventDefault(); }, {once: true});
assert(self.dispatchEvent(dispatched) === false && received === dispatched && dispatched.defaultPrevented && !dispatched.isTrusted, 'synthetic EventTarget dispatch');
const requestDescriptor = Object.getOwnPropertyDescriptor(self, 'Request');
const promiseDescriptor = Object.getOwnPropertyDescriptor(self, 'Promise');
try {
Object.defineProperty(self, 'Request', {configurable: true, get() {throw Error('public Request getter');}});
Object.defineProperty(self, 'Promise', {configurable: true, get() {throw Error('public Promise getter');}});
const poisoned = new C('intrinsics', {request, handled: 42, preloadResponse: 'preload'});
assert(poisoned.request === request && poisoned.handled instanceof P && poisoned.preloadResponse instanceof P, 'intrinsic promise and Request brand');
assert(await poisoned.handled === 42 && await poisoned.preloadResponse === 'preload', 'non-promise values');
} finally {
Object.defineProperty(self, 'Request', requestDescriptor);
Object.defineProperty(self, 'Promise', promiseDescriptor);
}
return {passed: true, legacyIsReload: event.isReload === undefined ? 'absent' : event.isReload};
}