From 03214ca7bf4f79d4eaca342ae68cb8b63fa84125 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sun, 1 Nov 2026 09:31:58 +0800 Subject: [PATCH] fix(storage): reconcile WPT state with SQLite partitions --- moli-cookie-db/src/lib.rs | 4 +- moli-cookie-db/src/tests.rs | 74 +++++++++++++++++ .../misc/extracted/popup_window.rs | 7 +- .../storage_events_across_pages.rs | 23 ++++- .../script_vm/tests/fetch_credentialless.rs | 2 + .../src/script_vm/tests/sqlite_web_storage.rs | 28 ++++++- .../thread/tests/network/credentialless.rs | 3 +- moli-web-storage/src/events.rs | 83 +++++++++++++++++++ 8 files changed, 212 insertions(+), 12 deletions(-) diff --git a/moli-cookie-db/src/lib.rs b/moli-cookie-db/src/lib.rs index 3d713a71440..f117f89d6a2 100644 --- a/moli-cookie-db/src/lib.rs +++ b/moli-cookie-db/src/lib.rs @@ -35,7 +35,7 @@ impl From<&StoredCookie> for Key { } } enum Change { - Put(StoredCookie), + Put(Box), Delete, } #[derive(Default)] @@ -48,7 +48,7 @@ impl Batch { match change { StoredCookieMutation::Upsert { cookie } => Self { clear: false, - changes: BTreeMap::from([(Key::from(&cookie), Change::Put(cookie))]), + changes: BTreeMap::from([(Key::from(&cookie), Change::Put(Box::new(cookie)))]), }, StoredCookieMutation::Delete(key) => Self { clear: false, diff --git a/moli-cookie-db/src/tests.rs b/moli-cookie-db/src/tests.rs index 11d3e9e7047..f3692245e97 100644 --- a/moli-cookie-db/src/tests.rs +++ b/moli-cookie-db/src/tests.rs @@ -485,3 +485,77 @@ fn version_one_cookie_database_migrates_without_granting_a_new_cookie_age() { ); owner.close().unwrap(); } + +#[test] +fn version_one_cookie_rows_migrate_with_unknown_creation_time() { + let root = tempfile::tempdir().unwrap(); + let path = root.path().join("cookies.sqlite"); + let connection = Connection::open(&path).unwrap(); + connection.execute_batch("CREATE TABLE cookies( + partition_key BLOB NOT NULL,domain TEXT NOT NULL,path TEXT NOT NULL,name TEXT NOT NULL,value TEXT NOT NULL, + host_only INTEGER NOT NULL,secure INTEGER NOT NULL,http_only INTEGER NOT NULL, + expires_seconds INTEGER,expires_nanos INTEGER,same_site INTEGER NOT NULL,priority INTEGER, + source_scheme INTEGER NOT NULL,source_port INTEGER NOT NULL, + creation_index BLOB NOT NULL,last_access_index BLOB NOT NULL, + PRIMARY KEY(partition_key,domain,path,name)) WITHOUT ROWID;").unwrap(); + connection + .pragma_update(None, "application_id", codec::APPLICATION_ID) + .unwrap(); + connection.pragma_update(None, "user_version", 1).unwrap(); + connection.execute("INSERT INTO cookies VALUES (?1,'cookie.test','/','legacy','value',1,1,0,NULL,NULL,0,NULL,2,443,?2,?3)", + params![vec![0_u8],7_u64.to_be_bytes().as_slice(),11_u64.to_be_bytes().as_slice()]).unwrap(); + drop(connection); + let mut expected = cookie("legacy"); + expected.creation_index = 7; + expected.last_access_index = 11; + let runtime = Runtime::new().unwrap(); + for _ in 0..2 { + let (store, owner) = + CookieDatabase::open(path.clone(), OpenMode::Existing, runtime.handle()).unwrap(); + assert_eq!(store.lock().unwrap().cookies(), vec![expected.clone()]); + assert_eq!( + owner.owner.client().query(codec::read).unwrap(), + vec![expected.clone()] + ); + owner.close().unwrap(); + } + let connection = Connection::open(&path).unwrap(); + assert_eq!( + connection + .pragma_query_value(None, "user_version", |row| row.get::<_, i32>(0)) + .unwrap(), + 2 + ); + let timestamp: Option = connection + .query_row("SELECT creation_unix_micros FROM cookies", [], |row| { + row.get(0) + }) + .unwrap(); + assert_eq!(timestamp, None); +} + +#[test] +fn invalid_persisted_cookie_creation_time_does_not_become_an_empty_jar() { + let root = tempfile::tempdir().unwrap(); + let path = root.path().join("cookies.sqlite"); + let runtime = Runtime::new().unwrap(); + let (store, owner) = open(root.path(), &runtime); + put(&store, cookie("invalid-age")); + owner.close().unwrap(); + drop(owner); + drop(store); + let connection = Connection::open(&path).unwrap(); + connection + .execute( + "UPDATE cookies SET creation_unix_micros=?1", + ["invalid timestamp"], + ) + .unwrap(); + drop(connection); + let (store, owner) = + CookieDatabase::deferred(path, OpenMode::Existing, runtime.handle()).unwrap(); + let first = store.lock().unwrap_err().to_string(); + assert!(first.contains("creation_unix_micros"), "{first}"); + assert_eq!(store.lock().unwrap_err().to_string(), first); + owner.close().unwrap(); +} diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/popup_window.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/popup_window.rs index cbae0b0304d..ca03f0ce342 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/popup_window.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/popup_window.rs @@ -172,11 +172,8 @@ async fn retained_popup_storage_managers_use_bound_popup_owner() { let host = vm.context_host_weak_for_test().upgrade().unwrap(); let store = host.borrow().storage_bucket_store(); let service = store.lock().storage_service(); - let key = moli_storage_key::MoliStorageKey::first_party_from_url( - &url::Url::parse("https://popup-storage-owner-child.test").unwrap(), - None, - ) - .serialized_storage_key(); + let key = moli_storage_key::MoliStorageKey::first_party_from_url(&popup_url, None) + .serialized_storage_key(); let locator = moli_storage_service::StorageBucketLocator::default_bucket(key); let bucket_key = moli_storage_service::StorageService::opfs_bucket_key(&locator).unwrap(); let root = service.ensure_opfs_root(&locator).unwrap(); diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/storage_events_across_pages.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_events_across_pages.rs index 0a65417e013..14c91ab0d83 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/storage_events_across_pages.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/storage_events_across_pages.rs @@ -38,8 +38,29 @@ async fn drain_storage( #[tokio::test] async fn local_storage_events_cross_pages_with_matching_origin_and_partition() { + assert_local_storage_events_cross_pages(crate::RendererWebStorageHandles::ephemeral()).await; +} + +#[tokio::test] +async fn sqlite_local_storage_events_cross_pages_with_matching_origin_and_partition() { + let directory = tempfile::tempdir().unwrap(); + let runtime = moli_sqlite::Runtime::new().unwrap(); + let (local, owner) = moli_web_storage::new_sqlite_web_storage_store( + directory.path().join("localstorage.sqlite"), + moli_sqlite::OpenMode::Create, + runtime.handle(), + ) + .unwrap(); + assert_local_storage_events_cross_pages(crate::RendererWebStorageHandles::new( + local, + crate::new_shared_web_storage_store(), + )) + .await; + owner.close().unwrap(); +} + +async fn assert_local_storage_events_cross_pages(storage: crate::RendererWebStorageHandles) { let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); - let storage = crate::RendererWebStorageHandles::ephemeral(); let other_storage = crate::RendererWebStorageHandles::new( storage.local_storage(), crate::new_shared_web_storage_store(), diff --git a/moli-renderer-v8/src/script_vm/tests/fetch_credentialless.rs b/moli-renderer-v8/src/script_vm/tests/fetch_credentialless.rs index 98cd8ff023d..33b91064b28 100644 --- a/moli-renderer-v8/src/script_vm/tests/fetch_credentialless.rs +++ b/moli-renderer-v8/src/script_vm/tests/fetch_credentialless.rs @@ -97,6 +97,7 @@ async fn window_fetch_credentialless_credentials_follow_redirect_taint() { .cookie_store(); cookies .lock() + .unwrap() .set_document_cookie(&same.base_url(), "seed=1; Path=/; SameSite=Lax"); // The same probe exercises Request metadata and redirects in Window and Worker realms. vm.eval(&format!( @@ -169,6 +170,7 @@ async fn window_fetch_credentialless_credentials_follow_redirect_taint() { } let actual_cookies = cookies .lock() + .unwrap() .cookies() .into_iter() .map(|cookie| cookie.name) diff --git a/moli-renderer-v8/src/script_vm/tests/sqlite_web_storage.rs b/moli-renderer-v8/src/script_vm/tests/sqlite_web_storage.rs index 1392fd33c98..f5028befec3 100644 --- a/moli-renderer-v8/src/script_vm/tests/sqlite_web_storage.rs +++ b/moli-renderer-v8/src/script_vm/tests/sqlite_web_storage.rs @@ -139,7 +139,7 @@ fn sqlite_areas_follow_window_lifetime_without_storage_wrapper_finalizers() { .unwrap(); let handles = crate::RendererWebStorageHandles::new(local, crate::new_shared_web_storage_store()); - let mut vm = new_storage_test_vm("https://window-storage-lifetime.test/"); + let mut vm = new_storage_page_task_executor_test_vm("https://window-storage-lifetime.test/"); vm.set_web_storage_handles(&handles); let host = vm.context_host_weak_for_test().upgrade().unwrap(); assert_eq!(host.borrow().local_storage_area_count_for_test(), 0); @@ -157,14 +157,36 @@ fn sqlite_areas_follow_window_lifetime_without_storage_wrapper_finalizers() { vm.eval("globalThis.storagePopup = open('about:blank'); globalThis.retainedPopupStorage = storagePopup.localStorage; retainedPopupStorage.getItem('key');").unwrap(); assert_eq!(host.borrow().local_storage_area_count_for_test(), 2); vm.eval("storagePopup.close()").unwrap(); + assert_eq!( + host.borrow().local_storage_area_count_for_test(), + 2, + "close() queues definite Window closure on the DOM-manipulation source" + ); + assert_eq!( + vm.eval_after_selected_page_tasks( + "String(storagePopup.closed && storagePopup.opener === null)" + ) + .unwrap(), + "true" + ); assert_eq!( host.borrow().local_storage_area_count_for_test(), 1, "a closed Window releases its area even while its Storage wrapper is retained" ); - vm.eval("globalThis.storageFrame = document.createElement('iframe'); document.body.appendChild(storageFrame);").unwrap(); - materialize_single_child_default_realm_for_test(&mut vm, "storage lifetime child"); + assert_eq!( + vm.eval("globalThis.storageFrame = document.createElement('iframe'); document.body.appendChild(storageFrame); String(storageFrame.contentWindow !== null)").unwrap(), + "true" + ); + assert_eq!( + vm.eval_after_selected_page_tasks( + "String(storageFrame.contentDocument.defaultView === storageFrame.contentWindow)" + ) + .unwrap(), + "true" + ); + assert_eq!(vm.live_child_default_runtime_realm_inventory().len(), 1); vm.eval("globalThis.retainedChildStorage = storageFrame.contentWindow.localStorage; retainedChildStorage.getItem('key');").unwrap(); assert_eq!(host.borrow().local_storage_area_count_for_test(), 2); vm.eval("storageFrame.remove()").unwrap(); diff --git a/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs index fa9c8fc6b5d..8c826af6b37 100644 --- a/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs +++ b/moli-renderer-v8/src/worker/thread/tests/network/credentialless.rs @@ -91,7 +91,7 @@ async fn check_worker_credentialless_fetch(intercept: bool) { 7, )); let cookie_store = moli_cookie_jar::new_shared_browser_cookie_store(); - cookie_store.lock().set_document_cookie( + cookie_store.lock().unwrap().set_document_cookie( &url::Url::parse(&same_origin).unwrap(), "seed=1; Path=/; SameSite=Lax", ); @@ -201,6 +201,7 @@ async fn check_worker_credentialless_fetch(intercept: bool) { } let actual_cookies = cookie_store .lock() + .unwrap() .cookies() .into_iter() .map(|cookie| cookie.name) diff --git a/moli-web-storage/src/events.rs b/moli-web-storage/src/events.rs index e295705e4a5..d996ef1bf2d 100644 --- a/moli-web-storage/src/events.rs +++ b/moli-web-storage/src/events.rs @@ -141,3 +141,86 @@ impl WebStorageStore { queued } } + +#[cfg(test)] +mod tests { + use super::*; + + #[derive(Default)] + struct Recipient { + events: Mutex>, + register: Mutex, Arc)>>, + closed: bool, + } + + impl WebStorageEventSink for Recipient { + fn queue_storage_event( + &self, + _source: &WebStorageEventSource, + _origin: &str, + _area_key: &str, + data: &WebStorageEventData, + ) -> WebStorageEventDelivery { + self.events.lock().push(data.clone()); + if self.closed { + return WebStorageEventDelivery::Closed; + } + if let Some((store, recipient)) = self.register.lock().take() { + store.upgrade().unwrap().register_event_recipient(recipient); + } + WebStorageEventDelivery::Queued + } + } + + #[test] + fn event_recipients_are_weak_and_delivery_can_register_a_future_recipient() { + let store = new_shared_web_storage_store(); + let future = Arc::new(Recipient::default()); + let first = Arc::new(Recipient { + register: Mutex::new(Some((Arc::downgrade(&store), future.clone()))), + ..Default::default() + }); + let closed = Arc::new(Recipient { + closed: true, + ..Default::default() + }); + let expired = Arc::new(Recipient::default()); + let weak = Arc::downgrade(&expired); + store.register_event_recipient(first.clone()); + store.register_event_recipient(closed.clone()); + store.register_event_recipient(expired.clone()); + drop(expired); + assert!(weak.upgrade().is_none()); + let identity = Arc::new(()); + let source = WebStorageEventSource::new(identity.clone()); + assert_eq!(source, WebStorageEventSource::new(identity)); + let data = WebStorageEventData::new( + "https://source.test/".into(), + false, + Some(vec![0xd800]), + None, + Some(vec![0xdc00]), + ); + assert_eq!( + store.queue_remote_storage_events(&source, "https://source.test", "area", &data), + 1 + ); + assert!(future.events.lock().is_empty()); + assert_eq!( + store.queue_remote_storage_events(&source, "https://source.test", "area", &data), + 2 + ); + assert_eq!(*first.events.lock(), vec![data.clone(), data.clone()]); + assert_eq!(*future.events.lock(), vec![data.clone()]); + assert_eq!(*closed.events.lock(), vec![data]); + drop(first); + drop(future); + assert_eq!(store.event_recipients.lock().len(), 2); + let data = WebStorageEventData::new(String::new(), false, None, None, None); + assert_eq!( + store.queue_remote_storage_events(&source, "https://source.test", "area", &data), + 0 + ); + assert!(store.event_recipients.lock().is_empty()); + } +}