From fcd013ebe7fb8a336f0cb20a5fc276b66fef19b3 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Wed, 11 Nov 2026 23:35:43 +0800 Subject: [PATCH] fix(workers): asynchronously intercept nested main scripts --- moli-renderer-v8/src/context_bootstrap.rs | 4 +- .../worker_host/constructor.rs | 580 +++++++++++++----- .../src/context_bootstrap/worker_host/mod.rs | 4 + .../src/runtime/page_vm/tests/worker.rs | 2 + .../tests/worker/nested_worker_main_script.rs | 190 ++++++ .../service/client_registry.rs | 19 + .../src/worker/global_scope/mod.rs | 7 +- .../src/worker/global_scope/nested_workers.rs | 97 ++- moli-renderer-v8/src/worker/handle.rs | 2 + moli-renderer-v8/src/worker/mod.rs | 25 +- moli-renderer-v8/src/worker/thread/mod.rs | 9 + .../fixtures/nested-worker-main-client.js | 64 ++ .../fixtures/nested-worker-main-parent.js | 29 + .../tests/fixtures/nested-worker-main-sw.js | 37 ++ 14 files changed, 878 insertions(+), 191 deletions(-) create mode 100644 moli-renderer-v8/src/runtime/page_vm/tests/worker/nested_worker_main_script.rs create mode 100644 moli-renderer-v8/tests/fixtures/nested-worker-main-client.js create mode 100644 moli-renderer-v8/tests/fixtures/nested-worker-main-parent.js create mode 100644 moli-renderer-v8/tests/fixtures/nested-worker-main-sw.js diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 0c75a7be00b..987ebbd2505 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -657,9 +657,9 @@ pub(crate) use self::window_lazy_surface::{ use self::window_runtime::global_caches_getter_callback; pub(crate) use self::window_template::install_window_own_template_bindings; pub(crate) use self::worker_host::{ + NestedWorkerScriptLoad, NestedWorkerScriptLoadCompletion, complete_nested_worker_script_load, dispatch_worker_error_event_with_kind, dispatch_worker_event, - flush_pending_worker_messages_for_listener, - worker_has_message_delivery_listener, + flush_pending_worker_messages_for_listener, worker_has_message_delivery_listener, }; pub(crate) use self::worker_location_runtime::install_worker_location_runtime_state; pub(super) use super::{ diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs index 6cf78528569..87771a239ea 100644 --- a/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs +++ b/moli-renderer-v8/src/context_bootstrap/worker_host/constructor.rs @@ -547,23 +547,29 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( ); return; } - let loaded = match materialize_nested_worker_script_source( - scope, - &resolved_url, - &nested_context, - worker_options.worker_type, - worker_options.credentials_mode.0, - ) { - Ok(source) => source, + let loaded = match materialize_nested_worker_local_script(&resolved_url, &nested_context) { + Ok(Some(source)) => source, + Ok(None) => { + start_nested_worker_script_load( + scope, + worker, + nested_context, + resolved_url, + worker_options, + ); + return; + } Err(message) => { - nested_context.worker_context_runtime.emit_diagnostic(|source| { - crate::DiagnosticEvent::script_load_failure( - source, - resolved_url.as_str(), - resolved_url.as_str(), - &message, - ) - }); + nested_context + .worker_context_runtime + .emit_diagnostic(|source| { + crate::DiagnosticEvent::script_load_failure( + source, + resolved_url.as_str(), + resolved_url.as_str(), + &message, + ) + }); queue_nested_worker_script_load_error( scope, worker, @@ -574,117 +580,31 @@ pub(in crate::context_bootstrap) fn worker_constructor_callback<'s>( return; } }; - let loaded_url = Url::parse(&loaded.script_url).expect("native Worker script URL"); - if !crate::context_bootstrap::check_dedicated_worker_embedder_policy( - scope, - nested_context.policy_context, - loaded.policy_context.cross_origin_embedder_policy, - &nested_context.base_url, - &loaded_url, - ) { - queue_nested_worker_script_load_error( - scope, - worker, - &nested_context, - &resolved_url, - "Worker script was blocked by Cross-Origin-Embedder-Policy.".to_owned(), - ); - return; - } - let mut network_policy = nested_context.network_policy.clone(); - let secure_context = Url::parse(&loaded.script_url) - .ok() - .is_some_and(|script_url| { - nested_context - .network_policy - .secure_context - .resolve(&script_url) - }); - network_policy.secure_context = WorkerSecureContextPolicy::Inherited(secure_context); - let reserved_service_worker_client_id = + let secure_context = nested_context + .network_policy + .secure_context + .resolve(&resolved_url); + let reserved_client = reserve_nested_inherited_service_worker_worker_client_for_local_script( &resolved_url, &nested_context, secure_context, - ); - let mut worker_policy_context = loaded.policy_context; - if resolved_url.scheme() == "data" { - worker_policy_context.cross_origin_isolated = false; - } - let options = WorkerSpawnOptions::new_with_request_client( - loaded.source, - loaded.script_url, - nested_context.loader.request_client().clone(), - ) - .with_interception_context(nested_context.interception_context.clone()) - .with_resource_task_runner(nested_context.loader.task_runner()) - .with_content_security_policy_snapshot(loaded.content_security_policy) - .with_referrer_policy(loaded.referrer_policy) - .with_script_kind(worker_options.worker_type) - .with_module_credentials_mode(worker_options.credentials_mode.0) - .with_module_static_import_initiator_url(nested_context.base_url.clone()) - .with_module_static_import_content_security_policies( - nested_context.module_static_import_content_security_policies, - ) - .with_network_policy(network_policy) - .with_policy_context(worker_policy_context) - .with_shared_memory_agent_cluster(Some(nested_context.shared_memory_agent_cluster.clone())) - .with_worker_context_runtime(nested_context.worker_context_runtime.clone()) - .with_global_kind(WorkerGlobalKind::Dedicated { - name: worker_options.name.clone(), - }) - .with_storage_key_top_level_site(Some(nested_context.storage_key_top_level_site.clone())) - .with_creator_storage_key(nested_context.creator_storage_key.clone()) - .with_creator_message_security(Some(nested_context.creator_message_security.clone())) - .with_indexed_db_manager(nested_context.indexed_db_manager.clone()) - .with_storage_bucket_store(nested_context.storage_bucket_store.clone()); - let options = if let Some(runtime) = nested_context.service_worker_runtime.clone() { - options.with_service_worker_runtime(runtime) - } else { - options - }; - let options = if let Some(client_id) = reserved_service_worker_client_id { - options.with_reserved_service_worker_client_id(client_id) - } else { - options - }; - let mut worker_handle = spawn_worker_with_options(options); - if let Some(mut rx) = worker_handle.take_receiver() { - let wake_tx = nested_context.wake_tx; - let closed_owner_error_tx = nested_context.closed_owner_error_tx; - let worker_id = nested_context.worker_id; - let _ = std::thread::Builder::new() - .name(format!("nested-worker-pump:{worker_id}")) - .spawn(move || { - while let Some(message) = rx.blocking_recv() { - if let Err(error) = - wake_tx.send(crate::worker::WorkerMessage::NestedWorkerEvent { - worker_id, - message: Box::new(message), - }) - && let Some(parent_tx) = &closed_owner_error_tx - { - crate::worker::forward_nested_worker_error_after_owner_close( - error.0, parent_tx, - ); - } - } - }); - } - let registered = crate::worker::register_nested_worker_handle( - scope, - nested_context.worker_id, - worker_handle, - ); - debug_assert!( - registered, - "reserved nested Worker must own its native handle" - ); - set_private_value( + ) + .map(|client_id| ReservedNestedWorkerClient { + runtime: nested_context + .service_worker_runtime + .clone() + .expect("reserved client runtime"), + client_id: Some(client_id), + }); + spawn_nested_worker_from_loaded_script( scope, worker, - WORKER_ID_SLOT, - v8::Number::new(scope, nested_context.worker_id.as_u64() as f64).into(), + nested_context, + resolved_url, + worker_options, + loaded, + reserved_client, ); } else { #[cfg(not(test))] @@ -859,6 +779,321 @@ pub(in crate::context_bootstrap) fn document_query_encoding_override( .filter(|encoding| *encoding != encoding_rs::UTF_8) } +struct ReservedNestedWorkerClient { + runtime: crate::service_worker_runtime::ServiceWorkerRuntimeService, + client_id: Option, +} + +impl Drop for ReservedNestedWorkerClient { + fn drop(&mut self) { + if let Some(client_id) = self.client_id.take() { + self.runtime.unregister_client(client_id); + } + } +} + +pub(crate) struct NestedWorkerScriptLoad { + context: NestedWorkerContext, + script_url: Url, + options: WorkerOptionsMembers, + reserved_client: Option, +} + +pub(crate) struct NestedWorkerScriptLoadCompletion { + worker_id: DedicatedWorkerId, + result: Result, + timing: crate::context_bootstrap::ResourcePerformanceEntry, +} + +impl std::fmt::Debug for NestedWorkerScriptLoadCompletion { + fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter + .debug_struct("NestedWorkerScriptLoadCompletion") + .field("worker_id", &self.worker_id) + .field("loaded", &self.result.is_ok()) + .finish_non_exhaustive() + } +} + +fn start_nested_worker_script_load( + scope: &mut v8::PinScope<'_, '_>, + worker: v8::Local<'_, v8::Object>, + context: NestedWorkerContext, + script_url: Url, + options: WorkerOptionsMembers, +) { + let cancel = moli_fetch::FetchCancelHandle::new(); + set_private_value( + scope, + worker, + WORKER_ID_SLOT, + v8::Number::new(scope, context.worker_id.as_u64() as f64).into(), + ); + let Some(lease) = context.loader.register_load( + crate::network::loads::ResourceLoadKind::Script, + crate::network::loads::ResourceLoadDisposition::Ordinary, + Some(cancel.clone()), + ) else { + queue_nested_worker_script_load_error( + scope, + worker, + &context, + &script_url, + "Worker creator is no longer active.".to_owned(), + ); + return; + }; + let secure_context = context.network_policy.secure_context.resolve(&script_url); + let reserved_client = context + .service_worker_runtime + .as_ref() + .map(|runtime| ReservedNestedWorkerClient { + runtime: runtime.clone(), + client_id: Some(runtime.register_reserved_worker_client_with_storage_key( + script_url.clone(), + context.creator_storage_key.serialized_storage_key(), + ServiceWorkerClientType::DedicatedWorker, + secure_context, + )), + }) + // Network-only loads register their final response URL when the + // global starts. Controlled requests need a reserved identity for + // FetchEvent.resultingClientId before their script can run. + .filter(|client| { + client + .runtime + .matching_controller_for_client(client.client_id.expect("reserved worker client")) + .is_some() + }); + let reserved_client_id = reserved_client.as_ref().and_then(|client| client.client_id); + let Some(origin) = crate::worker::worker_global_origin(scope) else { + lease.finish(); + queue_nested_worker_script_load_error( + scope, + worker, + &context, + &script_url, + "Worker creator settings are unavailable.".to_owned(), + ); + return; + }; + let timing = crate::context_bootstrap::FetchResourceTiming::capture_for_initiator_type( + scope, + &origin, + match options.worker_type { + WorkerScriptKind::Classic => "other", + WorkerScriptKind::Module => "script", + }, + ); + let script_kind = options.worker_type; + let credentials = options.credentials_mode.0; + if !crate::worker::begin_nested_worker_script_load( + scope, + context.worker_id, + cancel.clone(), + NestedWorkerScriptLoad { + context: context.clone(), + script_url: script_url.clone(), + options, + reserved_client, + }, + ) { + return; + } + let runner = lease.task_runner(); + runner.spawn(async move { + let request_client = lease.request_client(); + let response = tokio::select! { + biased; + _ = cancel.cancelled() => Err(moli_fetch::NET_ERR_ABORTED_ERROR_TEXT.to_owned()), + result = fetch_nested_worker_main_script(&script_url, &context, &origin, script_kind, credentials, reserved_client_id, cancel.clone(), &request_client) => result, + }; + let completed = std::time::Instant::now(); + let head = response.as_ref().ok().map(|response| response.head()); + let entry = timing.complete_worker_script_fetch( + &worker_script_resource_url(&script_url), &origin, + head.as_ref().zip(response.as_ref().ok().map(|response| response.body_bytes().len())), + cancel.response_timing(), completed, + ); + let result = response.and_then(|response| loaded_nested_worker_script_from_response(response, &script_url, &context)); + lease.finish(); + let wake_tx = context.wake_tx.clone(); + let _ = wake_tx.send(crate::worker::WorkerMessage::NestedWorkerScriptLoaded(Box::new(NestedWorkerScriptLoadCompletion { + worker_id: context.worker_id, result, timing: entry, + }))); + }); +} + +pub(crate) fn complete_nested_worker_script_load( + scope: &mut v8::PinScope<'_, '_>, + completion: NestedWorkerScriptLoadCompletion, +) { + let NestedWorkerScriptLoadCompletion { + worker_id, + result, + timing, + } = completion; + let Some(worker) = crate::worker::nested_worker_wrapper(scope, worker_id) else { + return; + }; + let Some(NestedWorkerScriptLoad { + context, + script_url, + options, + reserved_client, + }) = crate::worker::take_nested_worker_script_load(scope, worker_id) + else { + return; + }; + crate::context_bootstrap::record_resource_performance_entry(scope, timing); + match result { + Ok(loaded) => spawn_nested_worker_from_loaded_script( + scope, + worker, + context, + script_url, + options, + loaded, + reserved_client, + ), + Err(message) => { + queue_nested_worker_script_load_error(scope, worker, &context, &script_url, message) + } + } +} + +fn spawn_nested_worker_from_loaded_script( + scope: &mut v8::PinScope<'_, '_>, + worker: v8::Local<'_, v8::Object>, + nested_context: NestedWorkerContext, + resolved_url: Url, + worker_options: WorkerOptionsMembers, + loaded: LoadedNestedWorkerScript, + mut reserved_client: Option, +) { + let loaded_url = Url::parse(&loaded.script_url).expect("native Worker script URL"); + if !crate::context_bootstrap::check_dedicated_worker_embedder_policy( + scope, + nested_context.policy_context, + loaded.policy_context.cross_origin_embedder_policy, + &nested_context.base_url, + &loaded_url, + ) { + queue_nested_worker_script_load_error( + scope, + worker, + &nested_context, + &resolved_url, + "Worker script was blocked by Cross-Origin-Embedder-Policy.".to_owned(), + ); + return; + } + if let Some(client) = reserved_client.as_ref() + && !client.runtime.update_reserved_worker_client_creation_url( + client.client_id.expect("reserved worker client"), + loaded_url.clone(), + ) + { + queue_nested_worker_script_load_error( + scope, + worker, + &nested_context, + &resolved_url, + "Worker client is no longer available.".to_owned(), + ); + return; + } + let mut network_policy = nested_context.network_policy.clone(); + let secure_context = nested_context + .network_policy + .secure_context + .resolve(&loaded_url); + network_policy.secure_context = WorkerSecureContextPolicy::Inherited(secure_context); + let mut worker_policy_context = loaded.policy_context; + if resolved_url.scheme() == "data" { + worker_policy_context.cross_origin_isolated = false; + } + let options = WorkerSpawnOptions::new_with_request_client( + loaded.source, + loaded.script_url, + nested_context.loader.request_client().clone(), + ) + .with_interception_context(nested_context.interception_context.clone()) + .with_resource_task_runner(nested_context.loader.task_runner()) + .with_content_security_policy_snapshot(loaded.content_security_policy) + .with_referrer_policy(loaded.referrer_policy) + .with_script_kind(worker_options.worker_type) + .with_module_credentials_mode(worker_options.credentials_mode.0) + .with_module_static_import_initiator_url(nested_context.base_url.clone()) + .with_module_static_import_content_security_policies( + nested_context.module_static_import_content_security_policies, + ) + .with_network_policy(network_policy) + .with_policy_context(worker_policy_context) + .with_shared_memory_agent_cluster(Some(nested_context.shared_memory_agent_cluster.clone())) + .with_worker_context_runtime(nested_context.worker_context_runtime.clone()) + .with_global_kind(WorkerGlobalKind::Dedicated { + name: worker_options.name.clone(), + }) + .with_storage_key_top_level_site(Some(nested_context.storage_key_top_level_site.clone())) + .with_creator_storage_key(nested_context.creator_storage_key.clone()) + .with_creator_message_security(Some(nested_context.creator_message_security.clone())) + .with_indexed_db_manager(nested_context.indexed_db_manager.clone()) + .with_storage_bucket_store(nested_context.storage_bucket_store.clone()); + let options = if let Some(runtime) = nested_context.service_worker_runtime.clone() { + options.with_service_worker_runtime(runtime) + } else { + options + }; + let options = + if let Some(client_id) = reserved_client.as_ref().and_then(|client| client.client_id) { + options.with_reserved_service_worker_client_id(client_id) + } else { + options + }; + let mut worker_handle = spawn_worker_with_options(options); + if let Some(client) = reserved_client.as_mut() { + client.client_id = None; + } + if let Some(mut rx) = worker_handle.take_receiver() { + let wake_tx = nested_context.wake_tx.clone(); + let closed_owner_error_tx = nested_context.closed_owner_error_tx; + let worker_id = nested_context.worker_id; + let _ = std::thread::Builder::new() + .name(format!("nested-worker-pump:{worker_id}")) + .spawn(move || { + while let Some(message) = rx.blocking_recv() { + if let Err(error) = + wake_tx.send(crate::worker::WorkerMessage::NestedWorkerEvent { + worker_id, + message: Box::new(message), + }) + && let Some(parent_tx) = &closed_owner_error_tx + { + crate::worker::forward_nested_worker_error_after_owner_close( + error.0, parent_tx, + ); + } + } + }); + } + let registered = crate::worker::register_nested_worker_handle( + scope, + nested_context.worker_id, + worker_handle, + ); + debug_assert!( + registered, + "reserved nested Worker must own its native handle" + ); + set_private_value( + scope, + worker, + WORKER_ID_SLOT, + v8::Number::new(scope, nested_context.worker_id.as_u64() as f64).into(), + ); +} + fn queue_nested_worker_script_load_error( scope: &mut v8::PinScope<'_, '_>, worker: v8::Local<'_, v8::Object>, @@ -866,6 +1101,7 @@ fn queue_nested_worker_script_load_error( script_url: &Url, message: String, ) { + crate::worker::fail_nested_worker_script_load(scope, context.worker_id); let _ = context .wake_tx .send(crate::worker::WorkerMessage::NestedWorkerEvent { @@ -948,13 +1184,10 @@ struct LoadedNestedWorkerScript { policy_context: crate::types::SubresourcePolicyContext, } -fn materialize_nested_worker_script_source( - scope: &mut v8::PinScope<'_, '_>, +fn materialize_nested_worker_local_script( script_url: &Url, context: &NestedWorkerContext, - script_kind: WorkerScriptKind, - module_credentials_mode: moli_fetch::RequestCredentialsMode, -) -> Result { +) -> Result, String> { let blob_policy = (script_url.scheme() == "blob") .then(|| crate::blob::object_url_policy(script_url.as_str())); let blob_access_key = crate::blob::ObjectUrlAccessKey::new( @@ -971,18 +1204,28 @@ fn materialize_nested_worker_script_source( context.referrer_policy.clone(), ) }; - return Ok(LoadedNestedWorkerScript { + return Ok(Some(LoadedNestedWorkerScript { script_url: script_url.to_string(), source, content_security_policy, referrer_policy, policy_context: context.policy_context, - }); + })); } - let loader = context.loader.clone(); + Ok(None) +} + +async fn fetch_nested_worker_main_script( + script_url: &Url, + context: &NestedWorkerContext, + origin: &moli_url::WebOrigin, + script_kind: WorkerScriptKind, + module_credentials_mode: moli_fetch::RequestCredentialsMode, + reserved_client_id: Option, + cancel: moli_fetch::FetchCancelHandle, + request_client: &crate::network::ResourceRequestClient, +) -> Result { let resource_url = worker_script_resource_url(script_url); - let origin = crate::worker::worker_global_origin(scope) - .ok_or_else(|| "Nested Worker creator settings are unavailable".to_owned())?; let request = moli_fetch::Request::new("GET", resource_url.as_str(), None, vec![]) .map_err(|error| error.to_string())? .with_request_mode(moli_fetch::RequestMode::SameOrigin) @@ -999,42 +1242,41 @@ fn materialize_nested_worker_script_source( document_referrer_policy: context.referrer_policy.clone(), ..Default::default() }); - let timing = crate::context_bootstrap::FetchResourceTiming::capture_for_initiator_type( - scope, - &origin, - match script_kind { - WorkerScriptKind::Classic => "other", - WorkerScriptKind::Module => "script", - }, - ); - let cancel = moli_fetch::FetchCancelHandle::new(); - let response = loader - .request_client() - .fetch_text_for_worker_blocking_boundary_with_cancel(request, cancel.clone()); - let completed = std::time::Instant::now(); - let head = response.as_ref().ok().map(|response| response.head()); - let entry = timing.complete_worker_script_fetch( - &resource_url, - &origin, - head.as_ref().zip( - response - .as_ref() - .ok() - .map(|response| response.body_bytes().len()), - ), - cancel.response_timing(), - completed, - ); - crate::context_bootstrap::record_resource_performance_entry(scope, entry); - let response = response - .map_err(|error| format!("Failed to load worker script `{resource_url}`: {error}"))?; - if !loader.request_client().web_security_disabled() { - crate::worker::ensure_worker_script_redirect_chain_same_origin( - &context.base_url, - &response.redirect_chain, - &response.final_url, - ) - .map_err(|message| format!("Failed to construct 'Worker': {message}"))?; + if let (Some(runtime), Some(client_id)) = (&context.service_worker_runtime, reserved_client_id) + && let Some(response) = runtime + .fetch_main_resource_for_worker_client( + client_id, + context.service_worker_client_id, + &request, + request_client, + context.loader.task_runner(), + crate::service_worker_runtime::ServiceWorkerRequestDestination::Worker, + cancel.clone(), + ) + .await? + { + return Ok(response); + } + request_client + .fetch_text_stream_with_cancel(request, cancel) + .await + .map(crate::protocol_types::NavigationResponse::from) + .map_err(|error| format!("Failed to load worker script `{resource_url}`: {error}")) +} + +fn loaded_nested_worker_script_from_response( + response: crate::protocol_types::NavigationResponse, + script_url: &Url, + context: &NestedWorkerContext, +) -> Result { + let head = response.head(); + if !context.loader.request_client().web_security_disabled() { + crate::worker::ensure_worker_script_redirect_chain_same_origin( + &context.base_url, + &head.redirect_chain, + &response.final_url, + ) + .map_err(|message| format!("Failed to construct 'Worker': {message}"))?; } moli_fetch::ensure_http_status_success(response.final_url.as_str(), response.status, false) .map_err(|error| error.to_string())?; @@ -1043,7 +1285,7 @@ fn materialize_nested_worker_script_source( &response.headers, response.body_bytes(), )?; - let (head, body) = response.into_text_parts(); + let source = response.body_text().to_owned(); let policy_context = crate::worker::dedicated_worker_policy_context_from_headers( &head.headers, context.policy_context, @@ -1070,7 +1312,7 @@ fn materialize_nested_worker_script_source( final_url.set_fragment(script_url.fragment()); Ok(LoadedNestedWorkerScript { script_url: final_url.to_string(), - source: body, + source, content_security_policy: policy, referrer_policy, policy_context, diff --git a/moli-renderer-v8/src/context_bootstrap/worker_host/mod.rs b/moli-renderer-v8/src/context_bootstrap/worker_host/mod.rs index e471ebb43eb..a5259d2f9ae 100644 --- a/moli-renderer-v8/src/context_bootstrap/worker_host/mod.rs +++ b/moli-renderer-v8/src/context_bootstrap/worker_host/mod.rs @@ -28,6 +28,10 @@ mod constructor; mod dispatch; mod methods; +pub(crate) use constructor::{ + NestedWorkerScriptLoad, NestedWorkerScriptLoadCompletion, complete_nested_worker_script_load, +}; + pub(in crate::context_bootstrap) use constructor::{ document_query_encoding_override, is_cross_origin_http_worker_script, materialize_worker_script_source, resolve_worker_script_url, throw_worker_dom_exception, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs index 44b5d6a08c0..d166f6c8ca3 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker.rs @@ -2518,3 +2518,5 @@ async fn local_worker_content_security_policy_preserves_self_and_blocks_cross_or } }).await; } + +mod nested_worker_main_script; diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/worker/nested_worker_main_script.rs b/moli-renderer-v8/src/runtime/page_vm/tests/worker/nested_worker_main_script.rs new file mode 100644 index 00000000000..60b87a69df6 --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/worker/nested_worker_main_script.rs @@ -0,0 +1,190 @@ +use super::*; + +const CLIENT: &str = include_str!("../../../../../tests/fixtures/nested-worker-main-client.js"); +const PARENT: &str = include_str!("../../../../../tests/fixtures/nested-worker-main-parent.js"); +const SERVICE_WORKER: &str = include_str!("../../../../../tests/fixtures/nested-worker-main-sw.js"); +const CHILD: &str = r#"postMessage({kind:'child',source:'network',scriptURL:location.href,gateReleased:typeof releasedByClient==='boolean'?releasedByClient:null});onmessage=e=>postMessage({kind:'echo',value:e.data.value,bytes:Array.from(new Uint8Array(e.data.bytes))});if(new URL(location.href).searchParams.get('route')==='rewritten')fetch('/child/probe').then(r=>r.json()).then(data=>postMessage({kind:'probe',data}));"#; + +async fn check_nested_worker_main_script(mode: &'static str) { + run_page_vm_async_test(async move { + let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap(); + listener.set_nonblocking(true).unwrap(); + let address = listener.local_addr().unwrap(); + let origin = format!("http://{address}"); + let server_origin = origin.clone(); + let (requests, mut received) = tokio::sync::mpsc::unbounded_channel(); + let (stop, mut stopped) = tokio::sync::oneshot::channel::<()>(); + let server = std::thread::spawn(move || { + tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap().block_on(async move { + let listener = TcpListener::from_std(listener).unwrap(); + let gates = std::sync::Arc::new(parking_lot::Mutex::new(std::collections::HashMap::>::new())); + let started = std::sync::Arc::new(parking_lot::Mutex::new(std::collections::HashSet::::new())); + let mut connections = tokio::task::JoinSet::new(); + loop { + let accepted = tokio::select! { + result = listener.accept() => result.ok(), + _ = &mut stopped => None, + _ = tokio::time::sleep(Duration::from_secs(30)) => None, + }; + let Some((mut stream, _)) = accepted else { break }; + let server_origin = server_origin.clone(); + let requests = requests.clone(); + let gates = gates.clone(); + let started = started.clone(); + connections.spawn(async move { + let head = read_http_request_head(&mut stream).await.unwrap(); + let path = head.lines().next().unwrap().split_whitespace().nth(1).unwrap(); + let url = Url::parse(&format!("{server_origin}{path}")).unwrap(); + requests.send(path.to_owned()).unwrap(); + let case = url.query_pairs().find(|(key, _)| key == "case").map(|(_, value)| value.into_owned()).unwrap_or_default(); + let route = url.query_pairs().find(|(key, _)| key == "route").map(|(_, value)| value.into_owned()).unwrap_or_default(); + let mut status = "200 OK"; + let mut extra = String::new(); + let mut content_type = "text/javascript"; + let body = match url.path() { + "/sw.js" => { extra = "Service-Worker-Allowed: /\r\n".to_owned(); SERVICE_WORKER.to_owned() } + "/outer/dedicated.js" => format!("{PARENT}\nconnect(self);"), + "/outer/shared.js" => format!("{PARENT}\nonconnect=e=>connect(e.ports[0]);"), + "/child/script.js" => CHILD.to_owned(), + "/final/script.js" => CHILD.to_owned(), + "/redirect/script.js" => { + status = "302 Found"; + extra = format!("Location: /final/script.js?{}\r\n", url.query().unwrap()); + String::new() + } + "/slow/script.js" => { + let gate = gates.lock().entry(case.clone()).or_default().clone(); + started.lock().insert(case); + let released = tokio::time::timeout(Duration::from_secs(10), gate.notified()).await.is_ok(); + format!("const releasedByClient = {released};\n{CHILD}") + } + "/release" => { gates.lock().entry(case).or_default().notify_one(); "released".to_owned() } + "/started" => if started.lock().contains(&case) { "yes" } else { "no" }.to_owned(), + "/failure/script.js" => { + match route.as_str() { + "status" => status = "503 Service Unavailable", + "mime" => content_type = "text/plain", + "syntax" => {}, + "redirect" => { status = "302 Found"; extra = format!("Location: http://localhost:{}/redirected.js\r\n", address.port()); } + _ => unreachable!(), + } + if route == "syntax" { "function {".to_owned() } else { CHILD.to_owned() } + } + "/barrier" => "barrier".to_owned(), + other => panic!("unexpected request: {other}"), + }; + let response = format!("HTTP/1.1 {status}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\nCache-Control: no-store\r\n{extra}\r\n{body}", body.len()); + let _ = stream.write_all(response.as_bytes()).await; + }); + } + connections.abort_all(); + while connections.join_next().await.is_some() {} + }); + }); + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).unwrap(); + let mut hooks = PageVmRuntimeHooks::standalone_without_owner_reservation_for_test(); + hooks.resource_task_runner = Some(loader.resource_task_runner()); + let document_url = Url::parse(&format!("{origin}/app/page.html")).unwrap(); + let mut page = test_page_vm_with_loader_document_url_and_hooks(&loader, Vec::new(), document_url, hooks); + page.retain_standalone_request_client_owner_for_test(loader); + let local = page.local_executor.clone(); + local.run(async move { + page.vm_mut().eval(&format!("const MODE = {};\n{CLIENT}", serde_json::to_string(mode).unwrap()))?; + drive_service_worker_page_vm_until_done_with_explicit_producer_admission(&mut page, "String(nestedResult !== null || nestedError !== null)", "nested main script fetching must preserve asynchronous startup, native SW clients and cancellation", |page| { page.runtime_hooks.browser_context_runtime.drain_shared_worker_service_lane(); }).await?; + assert_eq!(page.vm_mut().eval("String(nestedError)")?, "null"); + let result: serde_json::Value = serde_json::from_str(&page.vm_mut().eval("JSON.stringify(nestedResult)")?)?; + assert_eq!(result["windowControlled"], false); + let rows = result["rows"].as_array().unwrap(); + assert_eq!(rows.len(), if mode == "lifecycle" { 20 } else { 4 }); + for row in rows { + let events = row["events"].as_array().unwrap(); + let route = row["route"].as_str().unwrap(); + let event = |kind| events.iter().find(|event| event["kind"] == kind); + assert_eq!(event("transferred").unwrap()["byteLength"], 0); + if mode == "lifecycle" { + assert!(event("child").is_none(), "{row}"); + assert!(event("echo").is_none(), "{row}"); + if route == "terminate" { + assert_eq!(row["releaseReason"], "terminated"); + assert!(event("child-error").is_none(), "{row}"); + } else { assert_eq!(event("child-error").unwrap()["eventType"], "error"); } + continue; + } + let child = event("child").unwrap(); + let echo = event("echo").unwrap(); + assert_eq!(echo["value"], "queued-before-load"); + assert_eq!(echo["bytes"], serde_json::json!([13, 21, 34])); + if mode == "nonblocking" { + assert_eq!(row["releaseReason"], "pong", "{row}"); + assert_eq!(child["gateReleased"], true, "{row}"); + assert_eq!(child["source"], "network"); + continue; + } + if matches!(mode, "redirect" | "rewritten") { + let final_url = format!("{origin}/final/script.js?case={}&route={mode}", row["id"].as_str().unwrap()); + assert_eq!(child["scriptURL"], final_url); + let clients = result["clients"].as_array().unwrap(); + let target = clients.iter().find(|client| client["url"] == final_url).unwrap(); + assert_eq!(target["type"], "worker"); + if mode == "rewritten" { + let requests = result["mainRequests"].as_array().unwrap(); + let request_url = format!("{origin}/child/script.js?case={}&route=rewritten", row["id"].as_str().unwrap()); + let main = requests.iter().find(|request| request["url"] == request_url).unwrap(); + assert_eq!(main["resultingClientId"], target["id"]); + assert_eq!(event("probe").unwrap()["data"]["clientId"], target["id"]); + assert_eq!(event("probe").unwrap()["data"]["source"], "serviceworker"); + } + continue; + } + assert_eq!(child["source"], "serviceworker", "{row}"); + let meta = &child["meta"]; + let clients = result["clients"].as_array().unwrap(); + let creator_url = format!("{origin}/outer/{}.js?case={}", row["parentKind"].as_str().unwrap(), row["id"].as_str().unwrap()); + let child_url = format!("{origin}/child/script.js?case={}&route=intercept", row["id"].as_str().unwrap()); + let creator = clients.iter().find(|client| client["url"] == creator_url).unwrap(); + let target = clients.iter().find(|client| client["url"] == child_url).unwrap(); + assert_eq!(meta["clientId"], creator["id"]); + assert_eq!(meta["resultingClientId"], target["id"]); + assert_ne!(creator["id"], target["id"]); + assert_eq!(meta["destination"], "worker"); + assert_eq!(meta["mode"], "same-origin"); + assert_eq!(meta["credentials"], if row["type"] == "module" { "include" } else { "same-origin" }); + assert_eq!(meta["referrer"], creator_url); + } + anyhow::Ok(()) + }).await.unwrap(); + let _ = stop.send(()); + server.join().unwrap(); + let mut observed = Vec::new(); + while let Ok(request) = received.try_recv() { observed.push(request); } + if mode == "intercept" { + assert!(!observed.iter().any(|path| path.starts_with("/child/")), "{observed:?}"); + } + assert!(!observed.iter().any(|path| path.starts_with("/redirected.js")), "{observed:?}"); + }).await; +} + +#[tokio::test] +async fn nested_worker_main_script_interception_preserves_native_client_identity() { + check_nested_worker_main_script("intercept").await; +} + +#[tokio::test] +async fn nested_worker_constructor_does_not_block_creator_tasks() { + check_nested_worker_main_script("nonblocking").await; +} + +#[tokio::test] +async fn nested_worker_pending_main_load_termination_and_failures() { + check_nested_worker_main_script("lifecycle").await; +} + +#[tokio::test] +async fn nested_worker_main_script_redirect_preserves_client_url() { + check_nested_worker_main_script("redirect").await; +} + +#[tokio::test] +async fn nested_worker_main_response_url_preserves_client_id_and_controller() { + check_nested_worker_main_script("rewritten").await; +} diff --git a/moli-renderer-v8/src/service_worker_runtime/service/client_registry.rs b/moli-renderer-v8/src/service_worker_runtime/service/client_registry.rs index 128f0681edb..c35a481eddd 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/client_registry.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/client_registry.rs @@ -334,6 +334,25 @@ impl ServiceWorkerRuntimeService { Some(client_id) } + /// The response URL becomes the worker's creation URL. Its controller is + /// still the one selected for the main request, including a SW response + /// whose URL lies outside that registration's scope. + pub(crate) fn update_reserved_worker_client_creation_url( + &self, + client_id: ServiceWorkerClientId, + script_url: Url, + ) -> bool { + let mut state = self.inner.state.lock(); + let Some(client) = state.live_clients.get_mut(&client_id) else { + return false; + }; + if !matches!(client.endpoint, ServiceWorkerClientEndpoint::PendingWorker) { + return false; + } + client.creation_url = script_url; + true + } + pub(crate) fn activate_reserved_worker_client( &self, client_id: ServiceWorkerClientId, diff --git a/moli-renderer-v8/src/worker/global_scope/mod.rs b/moli-renderer-v8/src/worker/global_scope/mod.rs index 757b5a1d71e..6a0d5dcf8e9 100644 --- a/moli-renderer-v8/src/worker/global_scope/mod.rs +++ b/moli-renderer-v8/src/worker/global_scope/mod.rs @@ -202,8 +202,11 @@ pub(crate) use messaging::{ worker_message_port_wake_sender, worker_message_port_wrapper, }; pub(crate) use nested_workers::{ - NestedWorkerContext, check_and_queue_nested_worker_constructor_csp, forward_nested_worker_error_after_owner_close, queue_nested_worker_task, - register_nested_worker_handle, reserve_nested_worker_context, terminate_nested_worker, + NestedWorkerContext, begin_nested_worker_script_load, + check_and_queue_nested_worker_constructor_csp, fail_nested_worker_script_load, + forward_nested_worker_error_after_owner_close, nested_worker_wrapper, queue_nested_worker_task, + register_nested_worker_handle, reserve_nested_worker_context, take_nested_worker_script_load, + terminate_nested_worker, }; pub(super) use nested_workers::{dispatch_nested_worker_event, retire_nested_workers}; pub(super) use network_state::{ diff --git a/moli-renderer-v8/src/worker/global_scope/nested_workers.rs b/moli-renderer-v8/src/worker/global_scope/nested_workers.rs index d9bcf8cf83e..a8716500989 100644 --- a/moli-renderer-v8/src/worker/global_scope/nested_workers.rs +++ b/moli-renderer-v8/src/worker/global_scope/nested_workers.rs @@ -11,8 +11,20 @@ use super::*; pub(in crate::worker) struct NestedWorker { wrapper: v8::Global, handle: Option, + script_load_cancel: Option, + script_load: Option, + pending_tasks: std::collections::VecDeque, } +impl Drop for NestedWorker { + fn drop(&mut self) { + if let Some(cancel) = self.script_load_cancel.take() { + cancel.cancel(); + } + } +} + +#[derive(Clone)] pub(crate) struct NestedWorkerContext { pub(crate) interception_context: Option, @@ -58,6 +70,9 @@ pub(crate) fn reserve_nested_worker_context( NestedWorker { wrapper: v8::Global::new(scope, worker), handle: None, + script_load_cancel: None, + script_load: None, + pending_tasks: Default::default(), }, ); Some(NestedWorkerContext { @@ -117,10 +132,76 @@ pub(crate) fn register_nested_worker_handle( if worker.handle.is_some() { return false; } + worker.script_load_cancel = None; + for task in worker.pending_tasks.drain(..) { + handle.queue_task(task); + } worker.handle = Some(handle); true } +pub(crate) fn begin_nested_worker_script_load( + scope: &mut v8::PinScope<'_, '_>, + worker_id: DedicatedWorkerId, + cancel: moli_fetch::FetchCancelHandle, + load: crate::context_bootstrap::NestedWorkerScriptLoad, +) -> bool { + let Some(state) = get_worker_state(scope) else { + return false; + }; + let mut state = state.borrow_mut(); + let Some(worker) = state.nested_workers.get_mut(&worker_id) else { + return false; + }; + worker.script_load_cancel = Some(cancel); + worker.script_load = Some(load); + true +} + +pub(crate) fn take_nested_worker_script_load( + scope: &mut v8::PinScope<'_, '_>, + worker_id: DedicatedWorkerId, +) -> Option { + let state = get_worker_state(scope)?; + state + .borrow_mut() + .nested_workers + .get_mut(&worker_id)? + .script_load + .take() +} + +pub(crate) fn nested_worker_wrapper<'s>( + scope: &mut v8::PinScope<'s, '_>, + worker_id: DedicatedWorkerId, +) -> Option> { + let state = get_worker_state(scope)?; + let state = state.borrow(); + let worker = state.nested_workers.get(&worker_id)?; + Some(v8::Local::new(scope, &worker.wrapper)) +} + +pub(crate) fn fail_nested_worker_script_load( + scope: &mut v8::PinScope<'_, '_>, + worker_id: DedicatedWorkerId, +) { + let Some(state) = get_worker_state(scope) else { + return; + }; + let mut state = state.borrow_mut(); + let Some(worker) = state.nested_workers.get_mut(&worker_id) else { + return; + }; + if let Some(cancel) = worker.script_load_cancel.take() { + cancel.cancel(); + } + let tasks = std::mem::take(&mut worker.pending_tasks); + let load = worker.script_load.take(); + drop(state); + drop(tasks); + drop(load); +} + pub(crate) fn queue_nested_worker_task( scope: &mut v8::PinScope<'_, '_>, worker_id: DedicatedWorkerId, @@ -129,15 +210,17 @@ pub(crate) fn queue_nested_worker_task( let Some(state) = get_worker_state(scope) else { return false; }; - let state = state.borrow(); - let Some(handle) = state - .nested_workers - .get(&worker_id) - .and_then(|worker| worker.handle.as_ref()) - else { + let mut state = state.borrow_mut(); + let Some(worker) = state.nested_workers.get_mut(&worker_id) else { return false; }; - handle.queue_task(task); + if let Some(handle) = worker.handle.as_ref() { + handle.queue_task(task); + } else if worker.script_load_cancel.is_some() { + worker.pending_tasks.push_back(task); + } else { + return false; + } true } diff --git a/moli-renderer-v8/src/worker/handle.rs b/moli-renderer-v8/src/worker/handle.rs index 74f1562730d..86e125e7837 100644 --- a/moli-renderer-v8/src/worker/handle.rs +++ b/moli-renderer-v8/src/worker/handle.rs @@ -216,6 +216,8 @@ pub(crate) enum WorkerMessage { worker_id: DedicatedWorkerId, message: Box, }, + /// Finish a nested main-script fetch on its creator's event loop. + NestedWorkerScriptLoaded(Box), #[cfg(feature = "devtools")] /// Owner-thread dispatch or fallback for one queued Inspector task. RunInspectorTask(WorkerInspectorTaskMode), diff --git a/moli-renderer-v8/src/worker/mod.rs b/moli-renderer-v8/src/worker/mod.rs index 80a712c20f9..77a729ef690 100644 --- a/moli-renderer-v8/src/worker/mod.rs +++ b/moli-renderer-v8/src/worker/mod.rs @@ -57,19 +57,22 @@ pub(crate) use global_scope::{ check_worker_websocket_csp, check_worker_webtransport_csp, close_worker_websocket, + begin_nested_worker_script_load, + dispatch_worker_trusted_types_sink_violation_event, ensure_worker_opfs_directory_iterator_registry, ensure_worker_opfs_handle_registry, - fetch_native_request, forget_worker_broadcast_channel_wrapper, - forget_worker_message_port_wrapper, forward_nested_worker_error_after_owner_close, get_worker_state, - install_service_worker_interface_template_bindings, queue_nested_worker_task, - queue_worker_browser_timeout, queue_worker_font_task, register_nested_worker_handle, - register_worker_blob_read_task, register_worker_broadcast_channel_wrapper, - register_worker_message_port_wrapper, register_worker_opfs_iterator_task, - 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, - set_worker_websocket_stream_abort_registration, start_worker_event_source_request, - start_worker_font_face_fetch, take_worker_websocket_stream_abort_registration, + fail_nested_worker_script_load, fetch_native_request, forget_worker_broadcast_channel_wrapper, + forget_worker_message_port_wrapper, forward_nested_worker_error_after_owner_close, + get_worker_state, install_service_worker_interface_template_bindings, nested_worker_wrapper, + queue_nested_worker_task, queue_worker_browser_timeout, queue_worker_font_task, + register_nested_worker_handle, register_worker_blob_read_task, + register_worker_broadcast_channel_wrapper, register_worker_message_port_wrapper, + register_worker_opfs_iterator_task, 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, set_worker_websocket_stream_abort_registration, + start_worker_event_source_request, start_worker_font_face_fetch, + take_nested_worker_script_load, take_worker_websocket_stream_abort_registration, terminate_nested_worker, 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, diff --git a/moli-renderer-v8/src/worker/thread/mod.rs b/moli-renderer-v8/src/worker/thread/mod.rs index b751923d9ed..69045f6245b 100644 --- a/moli-renderer-v8/src/worker/thread/mod.rs +++ b/moli-renderer-v8/src/worker/thread/mod.rs @@ -3372,6 +3372,15 @@ async fn worker_main( perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope); drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx); } + WorkerLoopWake::Message(Some(WorkerMessage::NestedWorkerScriptLoaded(completion))) => { + let scope = pin!(v8::HandleScope::new(worker_isolate.worker_isolate_mut())); + let scope = &mut scope.init(); + let ctx = v8::Local::new(scope, &context); + let scope = &mut v8::ContextScope::new(scope, ctx); + crate::context_bootstrap::complete_nested_worker_script_load(scope, *completion); + perform_worker_microtask_checkpoint_and_report_pending_promise_rejections(scope); + drain_worker_dynamic_module_imports(scope, &state, &module_graph_fetch_tx); + } WorkerLoopWake::Message(Some(WorkerMessage::NestedWorkerEvent { worker_id, message, diff --git a/moli-renderer-v8/tests/fixtures/nested-worker-main-client.js b/moli-renderer-v8/tests/fixtures/nested-worker-main-client.js new file mode 100644 index 00000000000..a4cb6cfc30f --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/nested-worker-main-client.js @@ -0,0 +1,64 @@ +globalThis.nestedResult = null; +globalThis.nestedError = null; +globalThis.nestedParents = []; +(async () => { + let registration; + if (['intercept', 'redirect', 'rewritten'].includes(MODE)) { + registration = await navigator.serviceWorker.register('/sw.js', {scope: '/child/'}); + const worker = registration.installing || registration.waiting || registration.active; + if (worker.state !== 'activated') { + await new Promise(resolve => worker.addEventListener('statechange', () => { + if (worker.state === 'activated') resolve(); + })); + } + } + const rows = []; + const routes = MODE === 'lifecycle' ? ['status', 'mime', 'syntax', 'redirect', 'terminate'] : [MODE]; + for (const route of routes) for (const parentKind of ['dedicated', 'shared']) for (const type of ['classic', 'module']) { + const id = route + '-' + parentKind + '-' + type; + const parentPath = '/outer/' + parentKind + '.js?case=' + id; + const parent = parentKind === 'shared' ? new SharedWorker(parentPath) : new Worker(parentPath); + nestedParents.push(parent); + const port = parentKind === 'shared' ? parent.port : parent; + const events = []; + let releaseReason = null, releasePromise = null; + function release(reason) { + if (releaseReason !== null) return; + releaseReason = reason; + releasePromise = fetch('/release?case=' + id); + } + const completed = new Promise((resolve, reject) => { + parent.onerror = event => reject(new Error(event.message || 'Parent Worker failed')); + port.onmessage = event => { + events.push(event.data); + if (route === 'nonblocking' && event.data.kind === 'before-new') port.postMessage('ping'); + if (route === 'nonblocking' && event.data.kind === 'pong') release('pong'); + if (event.data.kind === 'terminated') { release('terminated'); resolve(); } + if (event.data.kind === 'child-error' || (events.some(e => e.kind === 'child') && events.some(e => e.kind === 'echo') && (route !== 'rewritten' || events.some(e => e.kind === 'probe')))) resolve(); + }; + }); + if (port.start) port.start(); + const directory = MODE === 'lifecycle' && route !== 'terminate' ? 'failure' : ['intercept', 'rewritten'].includes(route) ? 'child' : route === 'redirect' ? 'redirect' : 'slow'; + port.postMessage({url: '/' + directory + '/script.js?case=' + id + '&route=' + route, type}); + if (route === 'terminate') { + while ((await (await fetch('/started?case=' + id)).text()) !== 'yes') await new Promise(resolve => setTimeout(resolve, 0)); + port.postMessage('terminate'); + } + await completed; + if (releasePromise) await releasePromise; + rows.push({id, route, parentKind, type, events, releaseReason}); + } + let clients = [], mainRequests = []; + if (registration) { + const channel = new MessageChannel(); + const listed = new Promise(resolve => channel.port1.onmessage = event => resolve(event.data)); + registration.active.postMessage('list', [channel.port2]); + const result = await listed; + clients = result.clients; + mainRequests = result.requests; + } + // Give any incorrectly surviving child an actual networking turn after its + // held HTTP response has been released. + await fetch('/barrier'); + nestedResult = {rows, clients, mainRequests, windowControlled: !!navigator.serviceWorker.controller}; +})().catch(error => nestedError = String(error)); diff --git a/moli-renderer-v8/tests/fixtures/nested-worker-main-parent.js b/moli-renderer-v8/tests/fixtures/nested-worker-main-parent.js new file mode 100644 index 00000000000..27a61a8097f --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/nested-worker-main-parent.js @@ -0,0 +1,29 @@ +function connect(port) { + let child; + port.onmessage = event => { + if (event.data === 'ping') { + port.postMessage({kind: 'pong'}); + return; + } + if (event.data === 'terminate') { + child.terminate(); + port.postMessage({kind: 'terminated'}); + return; + } + port.postMessage({kind: 'before-new'}); + child = new Worker(event.data.url, { + type: event.data.type, + credentials: event.data.type === 'module' ? 'include' : 'omit', + }); + port.postMessage({kind: 'after-new'}); + child.onmessage = event => port.postMessage(event.data); + child.onerror = event => { + event.preventDefault(); + port.postMessage({kind: 'child-error', eventType: event.type}); + }; + const bytes = new Uint8Array([13, 21, 34]); + child.postMessage({value: 'queued-before-load', bytes: bytes.buffer}, [bytes.buffer]); + port.postMessage({kind: 'transferred', byteLength: bytes.byteLength}); + }; + if (port.start) port.start(); +} diff --git a/moli-renderer-v8/tests/fixtures/nested-worker-main-sw.js b/moli-renderer-v8/tests/fixtures/nested-worker-main-sw.js new file mode 100644 index 00000000000..43e15d03294 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/nested-worker-main-sw.js @@ -0,0 +1,37 @@ +self.oninstall = event => event.waitUntil(self.skipWaiting()); +self.onactivate = event => event.waitUntil(self.clients.claim()); +const requests = []; +self.onmessage = event => event.waitUntil( + self.clients.matchAll({type: 'all', includeUncontrolled: true}).then(clients => { + event.ports[0].postMessage({clients: clients.map(client => ({ + id: client.id, url: client.url, type: client.type, + })), requests}); + }) +); +self.onfetch = event => { + const url = new URL(event.request.url); + if (url.pathname === '/child/probe') { + event.respondWith(Response.json({clientId: event.clientId, source: 'serviceworker'})); + return; + } + if (url.pathname !== '/child/script.js') return; + const meta = { + clientId: event.clientId, + resultingClientId: event.resultingClientId, + destination: event.request.destination, + mode: event.request.mode, + credentials: event.request.credentials, + referrer: event.request.referrer, + url: event.request.url, + }; + requests.push(meta); + if (url.searchParams.get('route') === 'rewritten') { + event.respondWith(fetch('/final/script.js' + url.search)); + return; + } + event.respondWith(new Response( + 'postMessage({kind:"child",source:"serviceworker",meta:' + JSON.stringify(meta) + '});' + + 'onmessage=e=>postMessage({kind:"echo",value:e.data.value,bytes:Array.from(new Uint8Array(e.data.bytes))});', + {headers: {'Content-Type': 'text/javascript'}} + )); +};