mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
fix(workers): asynchronously intercept nested main scripts
This commit is contained in:
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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'}}
|
||||
));
|
||||
};
|
||||
Reference in New Issue
Block a user