diff --git a/moli-core/src/runtime/mod.rs b/moli-core/src/runtime/mod.rs index 4d28da69dd1..5bf5e74f359 100644 --- a/moli-core/src/runtime/mod.rs +++ b/moli-core/src/runtime/mod.rs @@ -311,6 +311,9 @@ impl Browser { config.debugger_enabled(), ); let browser_context_access = browser_context_owner.owner_access(); + browser_context_access + .runtime() + .bind_storage_bucket_store(partition.storage_bucket_store()); let resource_runtime = browser_context_access .current_browser_resource_runtime() .context("browser context resource owner unavailable")?; diff --git a/moli-protocol/src/conn/state/browser_context.rs b/moli-protocol/src/conn/state/browser_context.rs index 4a726eb1230..0ca8da51de5 100644 --- a/moli-protocol/src/conn/state/browser_context.rs +++ b/moli-protocol/src/conn/state/browser_context.rs @@ -516,6 +516,12 @@ impl BrowserContext { debugger_enabled: bool, ) -> Self { let storage_partition = BrowserContextStoragePartition::new(identity, partition); + let renderer_runtime_owner = + RendererBrowserContextRuntime::new_with_debugger_enabled(debugger_enabled); + renderer_runtime_owner + .owner_access() + .runtime() + .bind_storage_bucket_store(storage_partition.storage_bucket_store().clone()); Self { id, @@ -557,9 +563,7 @@ impl BrowserContext { http_cache_max_bytes, page_navigation_runtime_config: None, renderer_output_transport_sender: None, - renderer_runtime_owner: Some(RendererBrowserContextRuntime::new_with_debugger_enabled( - debugger_enabled, - )), + renderer_runtime_owner: Some(renderer_runtime_owner), } } diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/owner_wake_tests.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/owner_wake_tests.rs index aa34702cbfc..c90f50a0112 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/owner_wake_tests.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/owner_wake_tests.rs @@ -15,6 +15,15 @@ enum WorkerServices { InitializedAfterRegistration, } +#[test] +fn binding_partition_cache_storage_keeps_worker_services_deferred() { + let context = RendererBrowserContextRuntime::new(); + let store = crate::context_bootstrap::new_shared_storage_bucket_store(); + context.bind_storage_bucket_store(store); + assert!(!context.inner.service_worker_runtime.is_initialized()); + assert!(!context.inner.shared_worker_runtime.is_initialized()); +} + struct ReceiverWake; // A static Waker::noop() cannot witness whether the channel retains its owner. diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs index 465bed6065d..bbb79d6b43b 100644 --- a/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs +++ b/moli-renderer-v8/src/runtime/browser_context_runtime/service_worker_runtime.rs @@ -31,6 +31,7 @@ pub(super) struct LazyServiceWorkerRuntime { client_id_allocator: crate::service_worker_runtime::ServiceWorkerClientIdAllocator, browser_context_runtime_id: crate::runtime::RendererBrowserContextRuntimeId, output_transport: crate::runtime::RendererOutputTransportSenderSlot, + storage_bucket_store: Mutex>, } enum LazyServiceWorkerRuntimeState { @@ -88,6 +89,7 @@ impl LazyServiceWorkerRuntime { client_id_allocator: Default::default(), browser_context_runtime_id, output_transport, + storage_bucket_store: Mutex::new(None), } } @@ -126,6 +128,9 @@ impl LazyServiceWorkerRuntime { self.browser_context_runtime_id, self.output_transport.clone(), ); + if let Some(store) = self.storage_bucket_store.lock().clone() { + service.bind_storage_bucket_store(store); + } for sender in owner_wake_senders.into_senders() { service.add_owner_wake_sender(sender); } @@ -150,6 +155,17 @@ impl LazyServiceWorkerRuntime { service } + pub(super) fn bind_storage_bucket_store( + &self, + store: crate::context_bootstrap::SharedStorageBucketStore, + ) { + let state = self.state.lock(); + *self.storage_bucket_store.lock() = Some(store.clone()); + if let LazyServiceWorkerRuntimeState::Live(service) = &*state { + service.bind_storage_bucket_store(store); + } + } + pub(super) fn get(&self) -> Option { let state = self.state.lock(); let LazyServiceWorkerRuntimeState::Live(service) = &*state else { @@ -390,6 +406,17 @@ impl LazyServiceWorkerRuntime { } impl RendererBrowserContextRuntime { + /// Bind the partition's CacheStorage backend without initializing the + /// Service Worker registry or starting a restored worker. + pub fn bind_storage_bucket_store( + &self, + store: crate::context_bootstrap::SharedStorageBucketStore, + ) { + self.inner + .service_worker_runtime + .bind_storage_bucket_store(store); + } + #[cfg(feature = "devtools")] fn service_worker_runtime_for_existing_registration( &self, diff --git a/moli-renderer-v8/src/service_worker_runtime/service/registration_store.rs b/moli-renderer-v8/src/service_worker_runtime/service/registration_store.rs index 3cd790cb47a..5779793684e 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/registration_store.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/registration_store.rs @@ -25,6 +25,20 @@ pub(super) fn bump_registration_last_update_check_time_locked( } impl ServiceWorkerRuntimeService { + pub(crate) fn bind_storage_bucket_store( + &self, + store: crate::context_bootstrap::SharedStorageBucketStore, + ) { + let mut state = self.inner.state.lock(); + *self.inner.storage_bucket_store.lock() = Some(store.clone()); + for version in state.versions.values_mut() { + version + .launch_config + .storage_bucket_store + .get_or_insert_with(|| store.clone()); + } + } + pub(super) fn restore_stored_registration_for_queued_job_locked( &self, state: &mut ServiceWorkerRuntimeState, @@ -143,8 +157,11 @@ impl ServiceWorkerRuntimeService { &self, state: &mut ServiceWorkerRuntimeState, stored: ServiceWorkerStoredRegistration, - launch_config: ServiceWorkerVersionLaunchConfig, + mut launch_config: ServiceWorkerVersionLaunchConfig, ) -> Option { + if launch_config.storage_bucket_store.is_none() { + launch_config.storage_bucket_store = self.inner.storage_bucket_store.lock().clone(); + } let registration_key = ServiceWorkerRegistrationKey { scope_url: stored.scope_url.clone(), storage_key: stored.storage_key.clone(), diff --git a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/script_updates_and_storage.rs b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/script_updates_and_storage.rs index bfd95838a21..3681830dc00 100644 --- a/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/script_updates_and_storage.rs +++ b/moli-renderer-v8/src/service_worker_runtime/service/tests/extracted/script_updates_and_storage.rs @@ -449,6 +449,8 @@ fn resource_store_lazily_restores_registration_added_after_startup() { resource_store.clone(), test_worker_context_runtime(), ); + let cache_store = crate::context_bootstrap::new_shared_storage_bucket_store(); + observer_service.bind_storage_bucket_store(cache_store.clone()); assert_eq!( observer_service.diagnostics_snapshot().registration_count, 0 @@ -505,6 +507,14 @@ fn resource_store_lazily_restores_registration_added_after_startup() { .matching_registration_for_client(&document_url) .expect("matching client query should lazily restore later stored registration"); assert_eq!(restored.scope_url(), &scope_url); + { + let state = observer_service.inner.state.lock(); + let version = state.versions.values().next().unwrap(); + assert!(Arc::ptr_eq( + version.launch_config.storage_bucket_store.as_ref().unwrap(), + &cache_store, + )); + } assert_eq!( observer_service.diagnostics_snapshot().registration_count, 1 @@ -531,6 +541,67 @@ fn resource_store_lazily_restores_registration_added_after_startup() { assert_eq!(state.stored_registration_cache.len(), 1); } } + +#[test] +fn startup_restored_worker_launch_uses_partition_cache_storage() { + let resource_store = new_shared_service_worker_resource_store(); + let writer = new_service_worker_runtime_service_with_resource_store( + resource_store.clone(), + test_worker_context_runtime(), + ); + let registration_id = ServiceWorkerRegistrationId(1); + let version_id = ServiceWorkerVersionId(1); + let scope = url("https://example.test/app/"); + let script = scope.join("worker.js").unwrap(); + insert_registered_version( + &writer, + registration_id, + version_id, + script.clone(), + scope, + [], + ); + writer + .inner + .state + .lock() + .versions + .get_mut(&version_id) + .unwrap() + .main_script_resource = Some(test_script_resource(&script)); + assert!( + writer + .store_registration_resources_for_test(registration_id, version_id) + .unwrap() + ); + + let reader = new_service_worker_runtime_service_with_resource_store( + resource_store, + test_worker_context_runtime(), + ); + let cache_store = crate::context_bootstrap::new_shared_storage_bucket_store(); + reader.bind_storage_bucket_store(cache_store.clone()); + let state = reader.inner.state.lock(); + let version = state.versions.values().next().unwrap(); + let registration = state.registrations.get(&version.registration_id).unwrap(); + let owner = test_run_owner(version.id, &version.run); + let params = version.launch_config.to_launch_params( + version.registration_id, + &owner, + version.script_url.clone(), + registration.scope_url.clone(), + registration.storage_key.clone(), + version.script_kind, + ); + assert!(Arc::ptr_eq( + params.storage_bucket_store.as_ref().unwrap(), + &cache_store + )); + assert!(matches!( + version.running_state, + ServiceWorkerVersionRunningState::Stopped + )); +} #[test] fn resource_store_deletes_registration_on_unregistration_clear() { let resource_store = new_shared_service_worker_resource_store(); diff --git a/moli-renderer-v8/src/service_worker_runtime/state.rs b/moli-renderer-v8/src/service_worker_runtime/state.rs index a29f8936a57..9b00dfc18a5 100644 --- a/moli-renderer-v8/src/service_worker_runtime/state.rs +++ b/moli-renderer-v8/src/service_worker_runtime/state.rs @@ -154,6 +154,8 @@ pub(super) struct ServiceWorkerRuntimeInner { pub(super) resource_store: SharedServiceWorkerResourceStore, pub(super) restored_worker_context_runtime: RendererWorkerContextRuntime, pub(super) browser_resource_runtime: crate::network::BrowserResourceRuntimeBinding, + pub(super) storage_bucket_store: + Mutex>, #[cfg(test)] pub(super) target_output_test_rx: Mutex>, @@ -187,6 +189,7 @@ impl ServiceWorkerRuntimeInner { resource_store, restored_worker_context_runtime, browser_resource_runtime, + storage_bucket_store: Mutex::new(None), #[cfg(test)] target_output_test_rx: Mutex::new(None), }