From d89413df5e39c3594a941ead037e52594f7a82d4 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 13 Nov 2026 02:10:40 +0800 Subject: [PATCH] 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. --- moli-renderer-v8/src/context_bootstrap.rs | 2 +- .../src/worker/global_scope/bootstrap.rs | 1 + .../src/worker/global_scope/fetch_events.rs | 232 ++++++++++++++++++ .../src/worker/global_scope/mod.rs | 3 + .../src/worker/thread/dispatch.rs | 34 +-- moli-renderer-v8/src/worker/thread/mod.rs | 1 + .../lifecycle/fetch_events_and_messages.rs | 57 +++++ .../tests/fixtures/fetch-event-constructor.js | 91 +++++++ 8 files changed, 398 insertions(+), 23 deletions(-) create mode 100644 moli-renderer-v8/src/worker/global_scope/fetch_events.rs create mode 100644 moli-renderer-v8/tests/fixtures/fetch-event-constructor.js diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 6e6183f7255..a7c3f84c79f 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -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, diff --git a/moli-renderer-v8/src/worker/global_scope/bootstrap.rs b/moli-renderer-v8/src/worker/global_scope/bootstrap.rs index 6ce5e0300a3..d636a8ad830 100644 --- a/moli-renderer-v8/src/worker/global_scope/bootstrap.rs +++ b/moli-renderer-v8/src/worker/global_scope/bootstrap.rs @@ -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; diff --git a/moli-renderer-v8/src/worker/global_scope/fetch_events.rs b/moli-renderer-v8/src/worker/global_scope/fetch_events.rs new file mode 100644 index 00000000000..badc10e090a --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/fetch_events.rs @@ -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>, + #[webidl(converter = "raw")] + preload_response: Option>, + #[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::(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"); +} diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index feddf18df9c..00cb641843b 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -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, }; diff --git a/moli-renderer-v8/src/worker/thread/dispatch.rs b/moli-renderer-v8/src/worker/thread/dispatch.rs index edc95ce79ba..34aef088721 100644 --- a/moli-renderer-v8/src/worker/thread/dispatch.rs +++ b/moli-renderer-v8/src/worker/thread/dispatch.rs @@ -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>, diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index 79bdf6fd774..f8efd7b0fb5 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -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; diff --git a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs index 53f48975793..7bef6e09e5f 100644 --- a/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs +++ b/moli-renderer-v8/src/worker/thread/tests/lifecycle/fetch_events_and_messages.rs @@ -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(); diff --git a/moli-renderer-v8/tests/fixtures/fetch-event-constructor.js b/moli-renderer-v8/tests/fixtures/fetch-event-constructor.js new file mode 100644 index 00000000000..fc055ca6496 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/fetch-event-constructor.js @@ -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}; +}