From 175d45d1c1d2b9b08cd2f009c8473cde31ea9aff Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 18 Oct 2026 02:14:43 +0800 Subject: [PATCH] fix(worker): publish fetch and XHR resource timing Own Worker resource timing independently of CDP records and retain native response boundaries across streaming, failure, and cancellation. Keep completed byte counts and abort status when JavaScript delays transport delivery. Share native streaming IO between synchronous and asynchronous XHR, retire the previous Worker request on open(), and use the saved Worker origin throughout CORS, ORB, and response construction. Validation: cargo fmt; strict workspace all-targets all-features Clippy; 22463 nextest passes; 86 Worker integration checks; original HTTP/HTTPS Worker timing WPT timeouts become passes with no retained PASS losses. --- .../performance_runtime/fetch_timing.rs | 23 ++ .../network_host/controlled_resource/fetch.rs | 21 ++ .../controlled_resource/result.rs | 3 + .../src/network_host/xhr/bindings/open.rs | 1 + moli-renderer-v8/src/network_host/xhr/send.rs | 1 + .../src/worker/global_scope/fetch.rs | 44 ++- .../worker/global_scope/fetch/native_load.rs | 7 +- .../src/worker/global_scope/mod.rs | 3 + .../src/worker/global_scope/network_state.rs | 10 + .../worker/global_scope/resource_timing.rs | 289 ++++++++++++++++++ .../src/worker/global_scope/xhr.rs | 83 ++++- moli-renderer-v8/src/worker/mod.rs | 21 +- .../tests/performance_resource_timing.rs | 65 ++++ .../worker-network-resource-timing.js | 126 ++++++++ 14 files changed, 668 insertions(+), 29 deletions(-) create mode 100644 moli-renderer-v8/src/worker/global_scope/resource_timing.rs create mode 100644 moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js diff --git a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs index 4c65df1c52c..8616600333c 100644 --- a/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs +++ b/moli-renderer-v8/src/context_bootstrap/performance_runtime/fetch_timing.rs @@ -42,6 +42,29 @@ impl FetchResourceTiming { self.response_start_unix_millis.set(Some(self.now())); } + /// Use the transport's header boundary even when Worker JS delayed delivery. + pub(crate) fn response_started_at(&self, start: Option) { + self.response_start_unix_millis + .set(start.map(|instant| self.unix_millis(instant))); + } + + pub(crate) fn completed_at( + &self, + mut entry: ResourcePerformanceEntry, + end: std::time::Instant, + ) -> ResourcePerformanceEntry { + entry.end_unix_millis = Some(self.unix_millis(end)); + entry + } + + fn unix_millis(&self, instant: std::time::Instant) -> f64 { + self.start_unix_millis + + instant + .saturating_duration_since(self.started) + .as_secs_f64() + * 1000.0 + } + pub(crate) fn completed( &self, url: &Url, diff --git a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs index a063b96b1ab..675d332f582 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/fetch.rs @@ -33,6 +33,7 @@ pub(crate) struct ControlledFetchStream { pub(super) body_source_id: Option, response: Option>, delivered: usize, + timing: crate::worker::WorkerResourceTiming, } struct StreamedFetchResponse { @@ -65,6 +66,7 @@ impl ControlledFetchStream { request_url: Arc, load: crate::network::loads::ResourceLoadLease, resource_timing: FetchResourceTiming, + timing: crate::worker::WorkerResourceTiming, ) -> Self { Self { completion, @@ -80,6 +82,7 @@ impl ControlledFetchStream { body_source_id: None, response: None, delivered: 0, + timing, } } @@ -90,6 +93,7 @@ impl ControlledFetchStream { network_request_headers: Option>, body: ResourceInterceptionBody, ) -> Result<(), String> { + self.timing.observe_head(&head); super::super::validate_fetch_response_headers( &self.request_origin, &head, @@ -167,6 +171,7 @@ impl ControlledFetchStream { .expect("response precedes body") .handle; self.delivered += bytes.len(); + self.timing.observe_chunk(bytes.len()); self.interception .publish_network(ScriptNetworkOutputItem::SubresourceDataReceived( SubresourceDataReceived::new(handle, bytes.len(), bytes.len()), @@ -184,6 +189,7 @@ impl ControlledFetchStream { } pub(super) fn finish(&mut self, result: Result<(), String>) { + self.timing.complete(); let response = *self .response .take() @@ -235,6 +241,7 @@ impl super::ControlledResourceLoad { fetch_id: u32, resource_timing: FetchResourceTiming, integrity: String, + timing: crate::worker::WorkerResourceTiming, ) { // Network/CDP correlation follows redirects; Resource Timing names // the original request, including when interception rewrites its URL. @@ -259,6 +266,7 @@ impl super::ControlledResourceLoad { Arc::clone(&request_url), self.load.clone(), resource_timing.clone(), + timing.clone(), )); let result = self.run_inner((integrity.is_empty() && self.info.resource_type != crate::types::SubresourceResourceType::Font).then_some(&mut stream)).await; let result = self.normalize_cancellation(result); @@ -270,6 +278,7 @@ impl super::ControlledResourceLoad { stream.finish(result.map(|_| ())); self.load.finish(); self.publish_completed(); + let _ = completion.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); return; } let (mut result, headers) = match result { @@ -317,6 +326,17 @@ impl super::ControlledResourceLoad { result = Err(error); } } + if let Ok(delivered) = &result { + let head = delivered.response.head(); + timing.observe_head(&head); + timing.observe_chunk(delivered.response.body_bytes().len()); + if let Some(filter) = self.response_filter.clone() { + timing.select_response(&head, filter, delivered.response.body_bytes().len(), true); + } + } else { + timing.discard_response(); + } + timing.complete(); let mut record = super::result::XhrLoadResult::new(self.info.clone(), result, headers); if let Err(error) = &record.result { record.network_record = failure_record(&self.info, network_error(error)); @@ -380,6 +400,7 @@ impl super::ControlledResourceLoad { let _ = completion.send(WorkerFetchEvent::Completion(Box::new( crate::worker::WorkerFetchCompletion { fetch_id, result }, ))); + let _ = completion.send(WorkerFetchEvent::ResourceTiming { fetch_id, timing }); } } diff --git a/moli-renderer-v8/src/network_host/controlled_resource/result.rs b/moli-renderer-v8/src/network_host/controlled_resource/result.rs index b3e57a87f52..2f51eb7b507 100644 --- a/moli-renderer-v8/src/network_host/controlled_resource/result.rs +++ b/moli-renderer-v8/src/network_host/controlled_resource/result.rs @@ -111,6 +111,7 @@ pub(crate) fn start_buffered_xhr( cancel: FetchCancelHandle, preflight_headers: Vec<(String, String)>, control: Option, + on_completed: impl FnOnce(&XhrLoadResult) + Send + 'static, ) -> crossbeam_channel::Receiver> { let (tx, rx) = crossbeam_channel::bounded(1); load.task_runner().spawn(async move { @@ -148,6 +149,7 @@ pub(crate) fn start_buffered_xhr( XhrLoadResult::new(info, result.map(BufferedXhrResponse::from_response), None) } }; + on_completed(&completed); let _ = tx.send(Ok(completed)); }); rx @@ -216,6 +218,7 @@ mod tests { from_cache: false, cache_state: Default::default(), negotiated_http_version: None, + preload_state: Default::default(), }, body: ResourceInterceptionBody::from_complete(captured), }; diff --git a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs index a1012a6be09..1becfe8243b 100644 --- a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs +++ b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs @@ -81,6 +81,7 @@ pub(super) fn xhr_open_callback<'s>( } let previous_ready_state = xhr_ready_state(scope, xhr); terminate_window_xhr_fetch(scope, xhr); + crate::worker::try_worker_xhr_terminate_fetch(scope, xhr); super::super::delivery::clear_xhr_request_timers(scope, xhr); let open_generation = xhr_state_number_property(scope, xhr, XHR_OPEN_GENERATION_SLOT).unwrap_or(0.0); diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rs index ec14e608a46..a9040bcba6e 100644 --- a/moli-renderer-v8/src/network_host/xhr/send.rs +++ b/moli-renderer-v8/src/network_host/xhr/send.rs @@ -365,6 +365,7 @@ fn send_synchronous_network_xhr( cancel_handle.clone(), preflight_headers, control, + |_| {}, ); let result = match wait_for_synchronous_load( response_rx, diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index acae153efb1..0cb51aebdcf 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -95,6 +95,7 @@ pub(in crate::worker) fn record_worker_subresource_failure_with_handle( if let Some(output) = &state.interception_context { output.record_subresource_network(record); } + } fn worker_fetch_script_metadata( @@ -970,6 +971,21 @@ pub(super) fn start_worker_resource_fetch<'s>( return Some(rejected); } + let request_origin = worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque); + let timing = WorkerResourceTiming::new( + scope, + resolved_url.clone(), + request_origin, + WorkerTimingRequest::Fetch { + method: method.clone(), + mode: request_mode, + credentials: credentials_mode, + redirect: redirect_mode, + policy: policy_context, + font: kind == WorkerFetchKind::Font, + }, + ); + let report_only_violation = { let state_ref = state.borrow(); worker_content_security_policy_report_only_violation( @@ -1137,13 +1153,15 @@ pub(super) fn start_worker_resource_fetch<'s>( native_load::start( scope, &state, - native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face }, + native_load::NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing }, + document_url, signal_id, request_metadata, policy_context, ) } + } pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( @@ -1172,12 +1190,10 @@ pub(in crate::worker) fn reject_worker_fetches_for_signal<'s>( rejected }; for (_, pending) in rejected { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.abort(scope); pending.load.cancel(); if let Some(body_source_id) = pending.streaming_body_source_id { + error_pending_network_body_stream_with_reason( scope, body_source_id, @@ -1196,12 +1212,18 @@ pub(in crate::worker) fn drain_worker_fetch_completion( event: WorkerFetchEvent, ) { match event { + WorkerFetchEvent::ResourceTiming { fetch_id, timing } => { + if !state.borrow().pending_fetches.contains_key(&fetch_id) { + timing.publish(scope); + } + } WorkerFetchEvent::PolicyViolations(violations) => { for violation in violations { dispatch_worker_content_security_policy_violation_event_for_state( scope, state, &violation, ); } + } WorkerFetchEvent::Completion(completion) => { drain_worker_fetch_completion_result(scope, state, *completion) @@ -1273,10 +1295,7 @@ pub(in crate::worker) fn finish_worker_streaming_fetch( close_pending_network_body_stream(scope, finished.body_source_id); } Err(error_text) => { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.publish(scope); let reason = v8_string(scope, &error_text) .map(|message| v8::Exception::type_error(scope, message)) .unwrap_or_else(|| v8::undefined(scope).into()); @@ -1295,6 +1314,7 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( state: &Rc>, completion: WorkerFetchCompletion, ) { + let Some(pending) = state .borrow_mut() .pending_fetches @@ -1331,10 +1351,8 @@ pub(in crate::worker) fn drain_worker_fetch_completion_result( let _ = resolver.resolve(scope, response_obj.into()); } Err(message) => { - crate::context_bootstrap::record_resource_performance_entry( - scope, - pending.resource_timing.failed(&pending.request_url), - ); + pending.timing.reject(scope); + if let Some(message) = v8_string(scope, &message) { let _ = resolver.reject(scope, v8::Exception::type_error(scope, message)); } else { diff --git a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs index dbba6d1e0b1..9cad78531be 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch/native_load.rs @@ -4,6 +4,7 @@ pub(super) struct NativeWorkerFetchRequest<'s> { pub(super) request: Request, pub(super) blob_url_entry: Option, pub(super) kind: WorkerFetchKind, + pub(super) timing: WorkerResourceTiming, pub(super) font_face: Option>, } @@ -16,10 +17,11 @@ pub(super) fn start<'s>( metadata: ServiceWorkerFetchRequestMetadata, policy_context: SubresourcePolicyContext, ) -> Option> { - let NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face } = request; + let NativeWorkerFetchRequest { request, blob_url_entry, kind, font_face, timing } = request; let resolver = v8::PromiseResolver::new(scope)?; let promise = resolver.get_promise(scope); let cancel = FetchCancelHandle::new(); + timing.begin_transport(cancel.clone()); let load = state.borrow().loader.register_load( kind.resource_type().into(), if metadata.keepalive { @@ -66,6 +68,7 @@ pub(super) fn start<'s>( font_face: font_face.map(|face| v8::Global::new(scope, face)), resolver: v8::Global::new(scope, resolver), resource_timing: resource_timing.clone(), + timing: timing.clone(), signal_id, load: load.clone(), request_url: request.url.clone(), @@ -88,7 +91,7 @@ pub(super) fn start<'s>( .fetch_load(request, info, load, cancel, policy_context) .with_blob_url_entry(blob_url_entry) .with_service_worker(service_worker, service_worker_client, metadata) - .run_fetch(completion, fetch_id, resource_timing, integrity) + .run_fetch(completion, fetch_id, resource_timing, integrity, timing) .await; }); Some(promise) diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index f7cf479fefb..bbd8b6a747a 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -111,6 +111,7 @@ mod nested_workers; mod network_state; mod origin; mod performance; +mod resource_timing; mod service_worker_api; mod service_worker_results; mod state; @@ -203,6 +204,8 @@ use network_state::{merge_worker_request_headers, next_fetch_id, next_xhr_id, wo pub(crate) use origin::worker_global_origin; use origin::{WorkerGlobalOriginDeclaration, WorkerGlobalOriginPrototypeDeclaration}; use performance::monotonic_unix_epoch_millis; +pub(crate) use resource_timing::WorkerResourceTiming; +use resource_timing::WorkerTimingRequest; pub(super) use service_worker_results::{ PendingServiceWorkerClientFocus, PendingServiceWorkerClientNavigate, PendingServiceWorkerClientQuery, PendingServiceWorkerClientQueryType, diff --git a/moli-renderer-v8/src/worker/global_scope/network_state.rs b/moli-renderer-v8/src/worker/global_scope/network_state.rs index 0bc5110dced..039c5337ba2 100644 --- a/moli-renderer-v8/src/worker/global_scope/network_state.rs +++ b/moli-renderer-v8/src/worker/global_scope/network_state.rs @@ -3,6 +3,7 @@ use super::*; pub(in crate::worker) struct PendingWorkerFetch { + pub(super) timing: WorkerResourceTiming, pub(in crate::worker) kind: fetch::WorkerFetchKind, pub(in crate::worker) font_face: Option>, pub(in crate::worker) resolver: v8::Global, @@ -22,6 +23,10 @@ pub(crate) enum WorkerFetchEvent { StreamingStarted(WorkerFetchStreamingStarted), StreamingChunk(WorkerFetchStreamingChunk), StreamingFinished(WorkerFetchStreamingFinished), + ResourceTiming { + fetch_id: u32, + timing: WorkerResourceTiming, + }, } pub(crate) struct WorkerFetchCompletion { @@ -57,6 +62,7 @@ pub(crate) struct WorkerFetchResponse { } pub(in crate::worker) struct PendingWorkerXhr { + pub(super) timing: WorkerResourceTiming, pub(in crate::worker) xhr: v8::Global, pub(in crate::worker) credentials_mode: RequestCredentialsMode, @@ -116,6 +122,10 @@ pub(in crate::worker) struct WorkerWebSocketState { } pub(in crate::worker) enum WorkerXhrEvent { + ResourceTiming { + xhr_id: Option, + timing: WorkerResourceTiming, + }, Upload { xhr_id: u32, event: moli_fetch::UploadEvent, diff --git a/moli-renderer-v8/src/worker/global_scope/resource_timing.rs b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs new file mode 100644 index 00000000000..b3cb4e5f05f --- /dev/null +++ b/moli-renderer-v8/src/worker/global_scope/resource_timing.rs @@ -0,0 +1,289 @@ +//! Request-owned Resource Timing, independent of CDP capture and JS receivers. + +use parking_lot::Mutex; +use std::sync::Arc; +use std::time::Instant; + +use moli_fetch::{ + FetchCancelHandle, RequestCredentialsMode, RequestMode, RequestRedirectMode, ResponseHead, +}; +use moli_url::WebOrigin; +use url::Url; + +use crate::context_bootstrap::{FetchResourceTiming, ResourcePerformanceEntry}; +use crate::network_host::{ + FetchResponseRequest, validate_cors_response_chain, validate_fetch_response_headers, +}; +use crate::types::{AsyncSubresourceFetchResponseFilter, SubresourcePolicyContext}; + +pub(super) enum WorkerTimingRequest { + Fetch { + method: String, + mode: RequestMode, + credentials: RequestCredentialsMode, + redirect: RequestRedirectMode, + policy: SubresourcePolicyContext, + font: bool, + }, + Xhr { + credentials: RequestCredentialsMode, + }, +} + +impl WorkerTimingRequest { + fn filter( + &self, + origin: &WebOrigin, + head: &ResponseHead, + ) -> Option { + let (method, mode, credentials, redirect) = match self { + Self::Fetch { + method, + mode, + credentials, + redirect, + policy, + .. + } => { + validate_fetch_response_headers(origin, head, *mode, *credentials, *policy).ok()?; + (method.as_str(), *mode, *credentials, *redirect) + } + Self::Xhr { credentials } => { + validate_cors_response_chain(origin, head, *credentials).ok()?; + ( + "GET", + RequestMode::Cors, + *credentials, + RequestRedirectMode::Follow, + ) + } + }; + Some( + FetchResponseRequest { + method, + mode, + redirect_mode: redirect, + } + .network_response_filter(origin, head, credentials), + ) + } + + fn initiator_type(&self) -> &'static str { + match self { + Self::Fetch { font: true, .. } => "css", + Self::Fetch { font: false, .. } => "fetch", + Self::Xhr { .. } => "xmlhttprequest", + } + } +} + +/// IO owns observations; the Worker owner selects the response and publishes. +/// A terminal IO event also retains this owner after abort/open retires the +/// pending JS request, so an already completed response cannot lose its entry. +#[derive(Clone)] +pub(crate) struct WorkerResourceTiming(Arc); + +struct WorkerResourceTimingInner { + name: Url, + origin: WebOrigin, + request: WorkerTimingRequest, + state: Mutex, +} + +struct WorkerResourceTimingState { + clock: FetchResourceTiming, + transport: Option, + response: Option<(ResponseHead, AsyncSubresourceFetchResponseFilter)>, + body_size: usize, + completed_at: Option, + synthetic_response_start: Option, + awaiting_selection: bool, + aborted: bool, + reported: bool, +} + +impl WorkerResourceTiming { + pub(super) fn new( + scope: &mut v8::PinScope<'_, '_>, + name: Url, + origin: WebOrigin, + request: WorkerTimingRequest, + ) -> Self { + let clock = FetchResourceTiming::capture_for_initiator_type( + scope, + &origin, + request.initiator_type(), + ); + Self(Arc::new(WorkerResourceTimingInner { + name, + origin, + request, + state: Mutex::new(WorkerResourceTimingState { + clock, + transport: None, + response: None, + body_size: 0, + completed_at: None, + synthetic_response_start: None, + awaiting_selection: false, + aborted: false, + reported: false, + }), + })) + } + + pub(crate) fn origin(&self) -> &WebOrigin { + &self.0.origin + } + + pub(crate) fn begin_transport(&self, cancel: FetchCancelHandle) { + let mut state = self.0.state.lock(); + state.transport = Some(cancel); + state.response = None; + state.body_size = 0; + state.completed_at = None; + state.synthetic_response_start = None; + state.awaiting_selection = false; + state.aborted = false; + } + + pub(crate) fn observe_head(&self, head: &ResponseHead) { + let filter = self.0.request.filter(&self.0.origin, head); + let mut state = self.0.state.lock(); + state.response = filter.map(|filter| (head.clone(), filter)); + } + + pub(crate) fn observe_chunk(&self, size: usize) { + let mut state = self.0.state.lock(); + state.body_size = state.body_size.saturating_add(size); + } + + pub(crate) fn complete(&self) { + let mut state = self.0.state.lock(); + state.completed_at.get_or_insert_with(Instant::now); + } + + pub(crate) fn pause(&self) { + self.0.state.lock().awaiting_selection = true; + } + + pub(crate) fn discard_response(&self) { + let mut state = self.0.state.lock(); + state.transport = None; + state.response = None; + state.body_size = 0; + state.completed_at = Some(Instant::now()); + state.synthetic_response_start = None; + } + + pub(crate) fn begin_synthetic_response(&self) { + self.discard_response(); + let mut state = self.0.state.lock(); + state.synthetic_response_start = state.completed_at; + } + + pub(crate) fn select_response( + &self, + head: &ResponseHead, + filter: AsyncSubresourceFetchResponseFilter, + body_size: usize, + synthetic: bool, + ) { + let mut state = self.0.state.lock(); + if synthetic && state.synthetic_response_start.is_none() { + // A fulfilled/intercepted response is a new client handover. The + // transport that previously supplied a challenge is not its clock. + state.transport = None; + let now = Instant::now(); + state.synthetic_response_start = Some(now); + state.completed_at = Some(now); + } + state.response = Some((head.clone(), filter)); + state.body_size = body_size; + state.awaiting_selection = false; + } + + pub(crate) fn publish(&self, scope: &mut v8::PinScope<'_, '_>) { + self.publish_entry(scope, false, false); + } + + pub(crate) fn reject(&self, scope: &mut v8::PinScope<'_, '_>) { + self.publish_entry(scope, true, false); + } + + pub(crate) fn abort(&self, scope: &mut v8::PinScope<'_, '_>) { + { + let mut state = self.0.state.lock(); + state.aborted = true; + if !state.awaiting_selection + && state.transport.as_ref().is_some_and(|transport| { + transport.response_timing().response_end_at().is_some() + }) + { + // IO has committed its terminal but its Worker delivery may + // still be queued behind running JS. Let that event report. + return; + } + } + self.publish_entry(scope, false, true); + } + + fn publish_entry(&self, scope: &mut v8::PinScope<'_, '_>, rejected: bool, aborted: bool) { + if let Some(entry) = self.take_entry(rejected, aborted) { + crate::context_bootstrap::record_resource_performance_entry(scope, entry); + } + } + + fn take_entry(&self, rejected: bool, aborted: bool) -> Option { + let mut state = self.0.state.lock(); + if state.reported || !matches!(self.0.name.scheme(), "http" | "https") { + return None; + } + state.reported = true; + let aborted = aborted || state.aborted; + let native = state + .transport + .as_ref() + .map(FetchCancelHandle::response_timing); + let completed = !state.awaiting_selection + && native.is_some_and(|timing| timing.response_end_at().is_some()); + let end = if aborted && !completed { + Instant::now() + } else { + native + .and_then(|timing| timing.response_end_at()) + .or(state.completed_at) + .unwrap_or_else(Instant::now) + }; + let start = native + .and_then(|timing| timing.response_started_at()) + .or(state.synthetic_response_start); + state.clock.response_started_at(start); + let body_size = if aborted && !completed { + 0 + } else { + state.body_size + }; + let mode = match &self.0.request { + WorkerTimingRequest::Fetch { mode, .. } => *mode, + WorkerTimingRequest::Xhr { .. } => RequestMode::Cors, + }; + let entry = if !rejected && let Some((head, filter)) = &state.response { + let mut entry = state.clock.completed( + &self.0.name, + &self.0.origin, + mode, + head, + body_size, + Some(filter), + ); + if aborted { + entry.mark_aborted(completed); + } + entry + } else { + state.clock.failed(&self.0.name) + }; + Some(state.clock.completed_at(entry, end)) + } +} diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs index 1d30fcfeb61..3bbc8c27f4d 100644 --- a/moli-renderer-v8/src/worker/global_scope/xhr.rs +++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs @@ -8,6 +8,7 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; pub(in crate::worker) struct PreparedWorkerXhrSendRequest { pub(in crate::worker) use_cors_preflight: bool, + timing: WorkerResourceTiming, document_url: Url, resolved_url: Url, blob_url_entry: Option, @@ -227,6 +228,7 @@ pub(in crate::worker) fn worker_xhr_timeout_callback( let pending = state.borrow_mut().pending_xhrs.remove(&scheduled_xhr_id); if let Some(pending) = pending { + pending.timing.abort(scope); pending.load.cancel(); } apply_xhr_timeout(scope, xhr); @@ -406,6 +408,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( state.pending_xhrs.insert( xhr_id, PendingWorkerXhr { + timing: prepared.timing.clone(), xhr: v8::Global::new(scope, xhr), credentials_mode: prepared.credentials_mode, @@ -432,6 +435,8 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( let completion_tx = state.borrow().xhr_completion_tx.clone(); let info = worker_xhr_info(&prepared); let request = worker_xhr_request(&state.borrow(), &prepared); + let timing = prepared.timing.clone(); + timing.begin_transport(cancel_handle.clone()); load.task_runner().spawn(async move { let mut request = request; if let Some(body) = request.body.as_ref() { @@ -451,13 +456,22 @@ pub(crate) fn try_worker_xhr_send_callback<'s>( ) .run() .await; + if let Ok(response) = &completed.result { + timing.observe_head(&response.head()); + timing.observe_chunk(response.body_bytes().len()); + } else { + timing.discard_response(); + } + timing.complete(); let _ = completion_tx.send(WorkerXhrEvent::Completion(Box::new(WorkerXhrCompletion { xhr_id, local_request: None, csp_violations: completed.csp_violations, result: completed.result, }))); + let _ = completion_tx.send(WorkerXhrEvent::ResourceTiming { xhr_id: Some(xhr_id), timing }); }); + true } @@ -516,7 +530,9 @@ fn send_synchronous_worker_xhr( loader: crate::network::context::WorkerResourceLoader, control: ControlledXhrContext, ) { + let timing = prepared.timing.clone(); let request_url_text = prepared.resolved_url.to_string(); + let request = worker_xhr_request(&state.borrow(), &prepared); let cancel = state.borrow().network_cancel.child_for_subrequest(); let Some(load) = loader.register_load( @@ -524,6 +540,7 @@ fn send_synchronous_worker_xhr( ResourceLoadDisposition::Ordinary, Some(cancel.clone()), ) else { + timing.reject(scope); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError"); return; }; @@ -532,6 +549,10 @@ fn send_synchronous_worker_xhr( .as_ref() .map(|timeout| after(timeout.wait_delay)) .unwrap_or_else(never); + + timing.begin_transport(cancel.clone()); + let worker_timing = timing.clone(); + let completion_tx = state.borrow().xhr_completion_tx.clone(); let response_rx = start_buffered_xhr( request, worker_xhr_info(&prepared), @@ -539,16 +560,28 @@ fn send_synchronous_worker_xhr( cancel, prepared.request_headers.to_byte_strings(), Some(control), + move |completed| { + if let Ok(response) = &completed.result { + worker_timing.observe_head(&response.head()); + worker_timing.observe_chunk(response.body_bytes().len()); + } else { + worker_timing.discard_response(); + } + worker_timing.complete(); + let _ = completion_tx.send(WorkerXhrEvent::ResourceTiming { xhr_id: None, timing: worker_timing }); + }, ); let result = select! { recv(response_rx) -> result => result.unwrap_or_else(|_| Err("worker sync XHR resource task dropped response channel".into())), recv(timeout_rx) -> _ => { + timing.abort(scope); load.cancel(); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "TimeoutError"); return; } }; if state.borrow().network_cancel.is_cancelled() { + timing.abort(scope); return; } // The loader has already published the network result independently of JS. @@ -562,14 +595,17 @@ fn send_synchronous_worker_xhr( match result.map(|completion| completion.result) { Ok(Ok(mut response)) => { response.headers = filter_cors_exposed_response_headers( - &worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque), + timing.origin(), &response.head(), prepared.credentials_mode, ); + timing.publish(scope); apply_xhr_response(scope, xhr, response); } Ok(Err(_)) | Err(_) => { + timing.publish(scope); throw_synchronous_xhr_failure(scope, xhr, &request_url_text, "NetworkError") + } } } @@ -599,6 +635,17 @@ fn worker_xhr_open_generation_changed( pub(crate) fn try_worker_xhr_abort_callback( scope: &mut v8::PinScope<'_, '_>, xhr: v8::Local<'_, v8::Object>, +) -> bool { + if !try_worker_xhr_terminate_fetch(scope, xhr) { + return false; + } + crate::network_host::finish_xhr_abort(scope, xhr); + true +} + +pub(crate) fn try_worker_xhr_terminate_fetch( + scope: &mut v8::PinScope<'_, '_>, + xhr: v8::Local<'_, v8::Object>, ) -> bool { let Some(state) = get_worker_state(scope) else { return false; @@ -614,10 +661,10 @@ pub(crate) fn try_worker_xhr_abort_callback( None }; if let Some(pending) = pending { + pending.timing.abort(scope); pending.load.cancel(); } - crate::network_host::finish_xhr_abort(scope, xhr); true } @@ -627,6 +674,11 @@ pub(in crate::worker) fn drain_worker_xhr_event( event: WorkerXhrEvent, ) { match event { + WorkerXhrEvent::ResourceTiming { xhr_id, timing } => { + if xhr_id.is_none_or(|id| !state.borrow().pending_xhrs.contains_key(&id)) { + timing.publish(scope); + } + } WorkerXhrEvent::Upload { xhr_id, event } => { let xhr = { let state = state.borrow(); @@ -638,6 +690,7 @@ pub(in crate::worker) fn drain_worker_xhr_event( if !apply_xhr_upload_event(scope, xhr, u64::from(xhr_id), event) && let Some(pending) = state.borrow_mut().pending_xhrs.remove(&xhr_id) { + pending.timing.abort(scope); pending.load.cancel(); } } @@ -665,10 +718,12 @@ pub(in crate::worker) fn drain_worker_xhr_completion( || xhr_state_bool_property(scope, xhr, XHR_ABORTED_SLOT).unwrap_or(false) { if let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) { + pending.timing.abort(scope); pending.load.cancel(); } return; } + let Some(pending) = state.borrow_mut().pending_xhrs.remove(&completion.xhr_id) else { return; }; @@ -692,16 +747,26 @@ pub(in crate::worker) fn drain_worker_xhr_completion( } match completion.result { Ok(response) => { + if completion.local_request.is_some() { + pending.timing.observe_head(&response.head()); + pending.timing.observe_chunk(response.body_bytes().len()); + pending.timing.complete(); + } let (mut head, body) = response.into_body(); head.headers = filter_cors_exposed_response_headers( - state.borrow().request_origin(), + pending.timing.origin(), &head, pending.credentials_mode, pending.load.request_client().web_security_disabled(), ); + pending.timing.publish(scope); apply_xhr_response_body_source(scope, xhr, head, body); + + } + Err(_) => { + pending.timing.publish(scope); + apply_xhr_failure(scope, xhr); } - Err(_) => apply_xhr_failure(scope, xhr), } } @@ -730,7 +795,17 @@ pub(in crate::worker) fn prepare_worker_xhr_send_request<'s>( RequestCredentialsMode::SameOrigin }; + let request_origin = worker_global_origin(scope).unwrap_or(moli_url::WebOrigin::Opaque); + let timing = WorkerResourceTiming::new( + scope, + resolved_url.clone(), + request_origin, + WorkerTimingRequest::Xhr { + credentials: credentials_mode, + }, + ); Ok(PreparedWorkerXhrSendRequest { + timing, use_cors_preflight: capture_xhr_upload_listener_flag(scope, xhr), document_url, resolved_url, diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 24ca7be0ed3..b1fa998b195 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -17,6 +17,7 @@ mod codec_tasks; mod data_url; mod file_reading_tasks; mod global_scope; +pub(crate) use global_scope::WorkerResourceTiming; mod handle; mod inspector_task_runner; mod module_mime; @@ -58,17 +59,17 @@ pub(crate) use global_scope::{ register_worker_opfs_move_task, register_worker_opfs_task, register_worker_webcrypto_task, register_worker_websocket, reserve_nested_worker_context, send_worker_websocket_binary, send_worker_websocket_blob, send_worker_websocket_text, service_worker_runtime_identity, - start_worker_font_face_fetch, try_worker_xhr_abort_callback, try_worker_xhr_reschedule_timeout_after_timeout_change, - try_worker_xhr_send_callback, worker_allows_eval_code_generation_by_csp, + start_worker_font_face_fetch, try_worker_xhr_abort_callback, + try_worker_xhr_reschedule_timeout_after_timeout_change, try_worker_xhr_send_callback, + try_worker_xhr_terminate_fetch, worker_allows_eval_code_generation_by_csp, worker_allows_trusted_type_policy_name_by_csp, worker_allows_trusted_types_eval, - worker_allows_wasm_code_generation_by_csp, - worker_broadcast_channel_registry, worker_broadcast_channel_storage_key, - worker_broadcast_channel_wake_sender, worker_broadcast_channel_wrapper, - worker_content_security_policy_snapshot, worker_current_script_url, worker_global_is_closed, - worker_global_origin, worker_message_port_registry, worker_message_port_wake_sender, - worker_message_port_wrapper, worker_notification_permission_state, - worker_opfs_directory_iterator_registry, worker_opfs_handle_registry, - worker_realm_secure_context_available, worker_referrer_policy, + worker_allows_wasm_code_generation_by_csp, worker_broadcast_channel_registry, + worker_broadcast_channel_storage_key, worker_broadcast_channel_wake_sender, + worker_broadcast_channel_wrapper, worker_content_security_policy_snapshot, + worker_current_script_url, worker_global_is_closed, worker_global_origin, + worker_message_port_registry, worker_message_port_wake_sender, worker_message_port_wrapper, + worker_notification_permission_state, worker_opfs_directory_iterator_registry, + worker_opfs_handle_registry, worker_realm_secure_context_available, worker_referrer_policy, worker_service_worker_control_state, worker_storage_key, worker_storage_partition_identity, worker_termination_requested, worker_trusted_types_for_script_requirements, }; diff --git a/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs b/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs index 1d9a8a9f436..228a2c57a1e 100644 --- a/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs +++ b/moli-renderer-v8/src/worker/thread/tests/performance_resource_timing.rs @@ -58,6 +58,71 @@ fn import_resource_client() -> crate::network::ResourceRequestClientOwner { ResourceRequestClient::new(&config).unwrap() } +#[tokio::test] +async fn worker_fetch_and_xhr_publish_native_resource_timing() { + ensure_v8(); + let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let base = format!("http://{}", listener.local_addr().unwrap()); + let script_base = base.clone(); + let server = tokio::spawn(async move { + let mut connections = tokio::task::JoinSet::new(); + loop { + tokio::select! { + accepted = listener.accept() => { + let (mut stream, _) = accepted.unwrap(); + let script_base = script_base.clone(); + connections.spawn(async move { + let Ok(request) = read_http_request_head(&mut stream).await else { return }; + let target = request.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + if target.starts_with("/timing-redirect") { + let _ = stream.write_all(b"HTTP/1.1 302 Found\r\nLocation: /timing-data?redirected=1\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").await; + return; + } + let body = if target.starts_with("/timing-origin-import.js") { + format!("globalThis.__timingImportedFetch = fetch('{script_base}/timing-data?fromImportedScript=1').then(response => response.text()); globalThis.__timingImportedNoCorsFetch = fetch('{script_base}/timing-html?fromImportedScript=1', {{mode: 'no-cors'}}).then(response => response.text());") + } else { "/* worker transport body */".to_owned() }; + let status = if target.starts_with("/timing-404") { "404 Not Found" } else { "200 OK" }; + let cors = if target.starts_with("/timing-cors-deny") { "" } else { "Access-Control-Allow-Origin: *\r\n" }; + let tao = if target.contains("tao=1") { "Timing-Allow-Origin: *\r\n" } else { "" }; + let length = body.len() + if target.starts_with("/timing-broken") { 10 } else { 0 }; + let mime = if target.starts_with("/timing-html") { "text/html" } else { "text/javascript" }; + let head = format!("HTTP/1.1 {status}\r\nContent-Type: {mime}\r\n{cors}{tao}Cross-Origin-Resource-Policy: cross-origin\r\nCache-Control: no-store\r\nContent-Length: {length}\r\nConnection: close\r\n\r\n"); + if stream.write_all(head.as_bytes()).await.is_err() { return; } + if target.starts_with("/timing-delay") || target.starts_with("/timing-hang") { + tokio::time::sleep(Duration::from_millis(150)).await; + } + let _ = stream.write_all(body.as_bytes()).await; + }); + } + Some(result) = connections.join_next() => { result.unwrap(); } + } + } + }); + let source = format!( + r#"const probe = {}; + probe({}).then(result => {{ postMessage(result); close(); }}, + error => {{ postMessage({{error: String(error.stack || error)}}); close(); }});"#, + include_str!("../../../../tests/fixtures/worker-network-resource-timing.js"), + serde_json::to_string(&base).unwrap(), + ); + let mut worker = spawn_worker_with_request_client( + source, + format!("{base}/worker.js"), + import_resource_client(), + ); + let result: serde_json::Value = + serde_json::from_str(&recv_post_json(&mut worker).await).unwrap(); + let checks = result["checks"] + .as_array() + .unwrap_or_else(|| panic!("{result:#}")); + assert_eq!(checks.len(), 86, "{result:#}"); + let failures: Vec<_> = checks.iter().filter(|row| row["passed"] != true).collect(); + assert!(failures.is_empty(), "{failures:#?}\n{result:#}"); + assert!(timeout(TIMEOUT, worker.recv()).await.unwrap().is_none()); + server.abort(); + assert!(server.await.unwrap_err().is_cancelled()); +} + #[tokio::test] async fn worker_import_scripts_publish_native_resources_and_process_buffer_overflow() { ensure_v8(); diff --git a/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js b/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js new file mode 100644 index 00000000000..ccff5022e06 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/worker-network-resource-timing.js @@ -0,0 +1,126 @@ +async base => { + const checks=[],observations={}; const p=performance; const Entry=PerformanceResourceTiming; + const test=(name,callback)=>{try{if(!callback())throw Error('assertion failed');checks.push({name,passed:true});}catch(error){checks.push({name,passed:false,details:String(error)});}}; + const tick=()=>new Promise(resolve=>setTimeout(resolve,0)); + const rows=url=>p.getEntriesByName(url,'resource'); + // Opaque text() reads a null public body; its network terminal is a + // separate task. Observe that task instead of treating one timer as a barrier. + const waitForEntry=url=>rows(url).length?Promise.resolve():new Promise((resolve,reject)=>{ + const observer=new PerformanceObserver(list=>{ + if(list.getEntries().some(entry=>entry.name===url)){clearTimeout(timer);observer.disconnect();resolve();} + }); + observer.observe({type:'resource',buffered:true}); + const timer=setTimeout(()=>{observer.disconnect();reject(Error('Missing resource entry: '+url));},2000); + }); + const snapshot=url=>rows(url).map(e=>({name:e.name,initiatorType:e.initiatorType,startTime:e.startTime,duration:e.duration,responseStart:e.responseStart,responseEnd:e.responseEnd,responseStatus:e.responseStatus,transferSize:e.transferSize,encodedBodySize:e.encodedBodySize,decodedBodySize:e.decodedBodySize,nextHopProtocol:e.nextHopProtocol})); + const verify=(label,url,initiator,status)=>{ + const e=rows(url)[0]; observations[label]=snapshot(url); + test(label+': one entry by completion',()=>rows(url).length===1); + test(label+': native resource entry',()=>e instanceof Entry&&e.entryType==='resource'&&e.initiatorType===initiator); + test(label+': requested URL',()=>e.name===url); + test(label+': status',()=>e.responseStatus===status); + test(label+': monotonic timing',()=>e.startTime>=0&&e.duration>=0&&e.responseEnd>=e.startTime&&e.responseEnd<=p.now()+.1); + }; + for(const [label,path] of [['fetch','/timing-data#fragment'],['fetch 404','/timing-404'],['fetch redirect','/timing-redirect']]){ + p.clearResourceTimings();const url=base+path;const r=await fetch(url);await r.text();verify(label,url,'fetch',label==='fetch 404'?404:200); + } + p.clearResourceTimings();{ + const url=base+'/timing-delay';const response=await fetch(url);const clone=response.clone(); + test('streaming fetch waits for EOF',()=>rows(url).length===0); + await response.text();verify('streaming fetch',url,'fetch',200);await clone.text();test('cloned response does not duplicate timing',()=>rows(url).length===1); + } + const xhr=(url,sync)=>sync?new Promise((resolve,reject)=>{try{const x=new XMLHttpRequest();x.open('GET',url,false);x.send();resolve(x);}catch(e){reject(e);}}):new Promise((resolve,reject)=>{const x=new XMLHttpRequest();x.open('GET',url);x.onload=()=>resolve(x);x.onerror=()=>reject(Error('XHR error'));x.send();}); + for(const sync of [false,true]){ + p.clearResourceTimings();const url=base+'/timing-data?xhr='+sync;await xhr(url,sync);verify('XHR '+sync,url,'xmlhttprequest',200); + } + for(const tao of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?cors=1'+(tao?'&tao=1':'');await(await fetch(url)).text();verify('CORS '+tao,url,'fetch',200); + test('CORS '+tao+': readable body sizes',()=>rows(url)[0].decodedBodySize>0); + test('CORS '+tao+': TAO connection fields',()=>tao?rows(url)[0].responseStart>0&&rows(url)[0].transferSize>0:rows(url)[0].responseStart===0&&rows(url)[0].transferSize===0); + } + for(const tao of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?opaque=1'+(tao?'&tao=1':'');await(await fetch(url,{mode:'no-cors'})).text();await waitForEntry(url);observations['opaque '+tao]=snapshot(url); + } + for(const [label,path]of [['broken body','/timing-broken'],['CORS rejection','/timing-cors-deny']]){ + p.clearResourceTimings();const url=(label==='CORS rejection'?base.replace('127.0.0.1','localhost'):base)+path;try{await(await fetch(url)).text();}catch{}await tick();observations[label]=snapshot(url); + } + for(const afterHeaders of [false,true]){ + p.clearResourceTimings();const url=base+'/timing-hang?abort='+afterHeaders;const c=new AbortController();const promise=fetch(url,{signal:c.signal}); + if(afterHeaders){const r=await promise;c.abort();try{await r.text();}catch{}} + else{c.abort();try{await promise;}catch{}} + await tick();observations['abort '+afterHeaders]=snapshot(url); + } + p.clearResourceTimings();await(await fetch('data:text/plain,local')).text();await tick();observations.local=p.getEntriesByType('resource').map(e=>e.name); + const descriptor=Object.getOwnPropertyDescriptor(globalThis,'performance');const url=base+'/timing-data?shadow=1'; + try{Object.defineProperty(globalThis,'performance',{value:{},configurable:true});await(await fetch(url)).text();} + finally{if(descriptor)Object.defineProperty(globalThis,'performance',descriptor);else delete globalThis.performance;} + test('native Performance survives author shadowing',()=>rows(url).length===1); + + test('opaque body information remains hidden',()=>[false,true].every(tao=>{ + const entries=observations['opaque '+tao]; + return entries.length===1&&entries[0].responseStatus===0&&entries[0].encodedBodySize===0&&entries[0].decodedBodySize===0; + })); + test('broken body retains status and received bytes',()=>{ + const e=observations['broken body'][0];return e&&e.responseStatus===200&&e.encodedBodySize===27&&e.decodedBodySize===27; + }); + test('CORS rejection hides response metadata',()=>{ + const e=observations['CORS rejection'][0];return e&&e.responseStatus===0&&e.responseStart===0&&e.transferSize===0&&e.decodedBodySize===0; + }); + test('early abort reports one failed entry',()=>{ + const entries=observations['abort false'];const e=entries[0];return entries.length===1&&e.responseStatus===0&&e.responseStart===0&&e.transferSize===0; + }); + test('abort after headers retains allowed connection timing',()=>{ + const entries=observations['abort true'];const e=entries[0];return entries.length===1&&e.responseStatus===0&&e.responseStart>0&&e.transferSize===300&&e.decodedBodySize===0; + }); + test('data URL does not create a resource entry',()=>observations.local.length===0); + for(const sync of [false,true]){ + p.clearResourceTimings();const url=base.replace('127.0.0.1','localhost')+'/timing-data?corsXhr='+sync; + await xhr(url,sync);verify('CORS XHR '+sync,url,'xmlhttprequest',200); + test('CORS XHR '+sync+': readable sizes without TAO',()=>rows(url)[0].decodedBodySize===27&&rows(url)[0].transferSize===0); + p.clearResourceTimings();const broken=base+'/timing-broken?xhr='+sync; + try{await xhr(broken,sync);}catch{} + const entries=rows(broken);const e=entries[0];observations['broken XHR '+sync]=snapshot(broken); + test('broken XHR '+sync+': retains received bytes',()=>entries.length===1&&e.responseStatus===200&&e.decodedBodySize===27); + } + for(const kind of ['abort','timeout']){ + p.clearResourceTimings();const url=base+'/timing-hang?xhr='+kind;const x=new XMLHttpRequest(); + await new Promise(resolve=>{ + x.open('GET',url);x.onloadend=resolve;if(kind==='timeout')x.timeout=20; + x.send();if(kind==='abort')x.abort(); + }); + await tick();const entries=rows(url);const e=entries[0];observations['XHR '+kind]=snapshot(url); + test('XHR '+kind+': one failure before loadend',()=>entries.length===1&&e.responseStatus===0&&e.decodedBodySize===0); + } + p.clearResourceTimings();{ + const old=base+'/timing-hang?xhr=replaced';const url=base+'/timing-data?xhr=replacement';const x=new XMLHttpRequest();let aborts=0; + x.onabort=()=>aborts++; + await new Promise((resolve,reject)=>{ + x.open('GET',old);x.send();x.open('GET',url);x.onload=resolve;x.onerror=reject;x.send(); + }); + verify('reopened XHR',url,'xmlhttprequest',200);await tick();const entries=rows(old); + test('XHR open retires the old timing owner',()=>entries.length===1&&entries[0].responseStatus===0); + test('XHR open does not dispatch abort',()=>aborts===0); + } + p.clearResourceTimings();{ + const url=base+'/timing-data?fromImportedScript=1'; + importScripts(base.replace('127.0.0.1','localhost')+'/timing-origin-import.js'); + await globalThis.__timingImportedFetch; + verify('fetch from imported script',url,'fetch',200); + test('imported script keeps the Worker origin',()=>rows(url)[0].responseStart>0&&rows(url)[0].transferSize>0); + const body=await globalThis.__timingImportedNoCorsFetch; + const noCors=rows(base+'/timing-html?fromImportedScript=1'); + test('imported script no-cors HTML stays readable for its Worker origin',()=>body==='/* worker transport body */'); + test('imported script no-cors timing remains same-origin',()=>noCors.length===1&&noCors[0].responseStatus===200&&noCors[0].responseStart>0); + + } + p.clearResourceTimings();{ + const url=base+'/timing-delay?lateAbort=1';const controller=new AbortController(); + const response=await fetch(url,{signal:controller.signal}); + const blockStart=p.now();while(p.now()-blockStart<450){} + const blockEnd=p.now();controller.abort();try{await response.text();}catch{} + await waitForEntry(url);const entries=rows(url);const e=entries[0];observations.lateAbort=snapshot(url); + test('late JS abort preserves completed bytes and reports abort status',()=>entries.length===1&&e.responseStatus===0&&e.decodedBodySize===27); + test('response end precedes delayed Worker delivery',()=>e.responseEnd