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}; +}