fix(workers): asynchronously intercept nested main scripts

This commit is contained in:
ldm0
2026-11-20 22:48:02 +08:00
parent c64405ab73
commit fcd013ebe7
14 changed files with 878 additions and 191 deletions
+2 -2
View File
@@ -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::{
@@ -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<ServiceWorkerClientId>,
}
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<ReservedNestedWorkerClient>,
}
pub(crate) struct NestedWorkerScriptLoadCompletion {
worker_id: DedicatedWorkerId,
result: Result<LoadedNestedWorkerScript, String>,
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<ReservedNestedWorkerClient>,
) {
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<LoadedNestedWorkerScript, String> {
) -> Result<Option<LoadedNestedWorkerScript>, 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<ServiceWorkerClientId>,
cancel: moli_fetch::FetchCancelHandle,
request_client: &crate::network::ResourceRequestClient,
) -> Result<crate::protocol_types::NavigationResponse, String> {
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<LoadedNestedWorkerScript, String> {
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,
@@ -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,
@@ -2518,3 +2518,5 @@ async fn local_worker_content_security_policy_preserves_self_and_blocks_cross_or
}
}).await;
}
mod nested_worker_main_script;
@@ -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::<String, std::sync::Arc<tokio::sync::Notify>>::new()));
let started = std::sync::Arc::new(parking_lot::Mutex::new(std::collections::HashSet::<String>::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;
}
@@ -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,
@@ -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::{
@@ -11,8 +11,20 @@ use super::*;
pub(in crate::worker) struct NestedWorker {
wrapper: v8::Global<v8::Object>,
handle: Option<crate::worker::WorkerHandle>,
script_load_cancel: Option<moli_fetch::FetchCancelHandle>,
script_load: Option<crate::context_bootstrap::NestedWorkerScriptLoad>,
pending_tasks: std::collections::VecDeque<crate::worker::WorkerMessage>,
}
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<crate::network::interception_output::ResourceInterceptionContext>,
@@ -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<crate::context_bootstrap::NestedWorkerScriptLoad> {
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<v8::Local<'s, v8::Object>> {
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
}
+2
View File
@@ -216,6 +216,8 @@ pub(crate) enum WorkerMessage {
worker_id: DedicatedWorkerId,
message: Box<WorkerToParentMessage>,
},
/// Finish a nested main-script fetch on its creator's event loop.
NestedWorkerScriptLoaded(Box<crate::context_bootstrap::NestedWorkerScriptLoadCompletion>),
#[cfg(feature = "devtools")]
/// Owner-thread dispatch or fallback for one queued Inspector task.
RunInspectorTask(WorkerInspectorTaskMode),
+14 -11
View File
@@ -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,
@@ -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,
@@ -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));
@@ -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();
}
@@ -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'}}
));
};