From f2c2b89266aca2cb6f05690bdf7dc03472f5b428 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 31 Oct 2026 21:05:30 +0800 Subject: [PATCH] refactor(storage): remove unused origin Web Storage usage aggregation Remove the origin-wide Web Storage quota API and its unused SQLite key listing. CDP and navigator quota queries already exclude Web Storage. Retain single-area metadata reads and the indexed entry-count query needed for cold origin clears. --- moli-web-storage/src/lib.rs | 10 +--- moli-web-storage/src/sqlite.rs | 72 +++------------------------- moli-web-storage/src/sqlite/tests.rs | 41 ++++------------ moli-web-storage/src/store.rs | 27 ----------- 4 files changed, 18 insertions(+), 132 deletions(-) diff --git a/moli-web-storage/src/lib.rs b/moli-web-storage/src/lib.rs index 312f53fdf81..91481942f9e 100644 --- a/moli-web-storage/src/lib.rs +++ b/moli-web-storage/src/lib.rs @@ -867,7 +867,7 @@ mod tests { } #[test] - fn origin_area_usage_and_clear_include_partitioned_area_keys() { + fn origin_clear_includes_partitioned_area_keys() { let origin = "https://cdn.example.test"; let first_party = first_party_area_key(origin); let top_a = web_storage_partitioned_area_key(origin, "https://top-a.example.test"); @@ -883,18 +883,12 @@ mod tests { assert!(store.set_item(&sibling, "s", "dddd")); assert_eq!(store.usage_bytes(&first_party), 1); - assert_eq!(store.usage_bytes_for_origin_areas(origin), 6); - assert_eq!( - store.usage_bytes_for_origin_areas("https://sibling.example.test"), - 4 - ); store.clear_origin(&first_party); - assert_eq!(store.usage_bytes_for_origin_areas(origin), 5); assert_eq!(store.get_item(&top_a, "a"), Some("bb".to_owned())); store.clear_origin_areas(origin); - assert_eq!(store.usage_bytes_for_origin_areas(origin), 0); + assert_eq!(store.get_item(&first_party, "fp"), None); assert_eq!(store.get_item(&top_a, "a"), None); assert_eq!(store.get_item(&top_b, "b"), None); assert_eq!(store.get_item(&sibling, "s"), Some("dddd".to_owned())); diff --git a/moli-web-storage/src/sqlite.rs b/moli-web-storage/src/sqlite.rs index fd85cd8e0b2..ca5dec6899c 100644 --- a/moli-web-storage/src/sqlite.rs +++ b/moli-web-storage/src/sqlite.rs @@ -35,11 +35,7 @@ pub(super) struct SqliteBackend { cache: Mutex, pub(super) namespace: parking_lot::RwLock<()>, } -struct AreaMetadata { - usage: usize, - entries: usize, -} -const ORIGIN_METADATA_SQL: &str = "SELECT storage_key,usage_bytes,entry_count FROM areas +const ORIGIN_METADATA_SQL: &str = "SELECT storage_key,entry_count FROM areas WHERE storage_key=?1 OR (storage_key>=?2 AND storage_key (String, String) { @@ -356,56 +352,22 @@ impl SqliteBackend { fn area_metadata_for_origin( &self, origin: &str, - ) -> std::result::Result, WebStorageMutationError> { + ) -> std::result::Result, WebStorageMutationError> { let (prefix, upper) = origin_prefix_range(origin); let origin = origin.to_owned(); Ok(self.client.query(move |connection| { let mut statement = connection.prepare_cached(ORIGIN_METADATA_SQL)?; statement .query_map(params![origin, prefix, upper], |row| { - Ok(( - row.get::<_, String>(0)?, - row.get::<_, i64>(1)?, - row.get::<_, i64>(2)?, - )) + Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?)) })? .map(|row| { - let (key, usage, entries) = row?; - Ok(( - key, - AreaMetadata { - usage: usize::try_from(usage).map_err(WritebackError::new)?, - entries: usize::try_from(entries).map_err(WritebackError::new)?, - }, - )) + let (key, entries) = row?; + Ok((key, usize::try_from(entries).map_err(WritebackError::new)?)) }) .collect() })?) } - pub(super) fn usage_bytes_for_origin_areas( - &self, - origin: &str, - ) -> std::result::Result { - let _namespace = self.namespace.write(); - // Pin live areas before querying SQL: a concurrent acknowledgement can - // otherwise release the last copy of a newer logical value. - let live = self.live_areas_for_origin(origin); - let mut metadata = self.area_metadata_for_origin(origin)?; - for (key, area) in live { - if let Some(state) = &*area.state.lock() { - metadata.insert( - key, - AreaMetadata { - usage: state.size, - entries: state.values.len(), - }, - ); - } - } - Ok(metadata - .values() - .fold(0usize, |sum, area| sum.saturating_add(area.usage))) - } fn area(&self, origin: &str) -> Arc { let mut cache = self.cache.lock(); if let Some(area) = cache.areas.get(origin).and_then(Weak::upgrade) { @@ -533,7 +495,7 @@ impl SqliteBackend { let nonempty = state .as_ref() .map(|data| !data.values.is_empty()) - .unwrap_or_else(|| metadata.get(key).is_some_and(|area| area.entries > 0)); + .unwrap_or_else(|| metadata.get(key).is_some_and(|entries| *entries > 0)); if !nonempty { continue; } @@ -563,28 +525,6 @@ impl SqliteBackend { } Ok(changed) } - pub(super) fn area_keys_for_origin( - &self, - origin: &str, - ) -> std::result::Result, WebStorageMutationError> { - let prefix = web_storage_area_key_prefix_for_origin(origin); - let mut keys = self - .area_metadata_for_origin(origin)? - .into_keys() - .collect::>(); - keys.extend( - self.cache - .lock() - .areas - .iter() - .filter(|(_, area)| area.strong_count() != 0) - .map(|(key, _)| key.clone()), - ); - keys.retain(|key| key == origin || key.starts_with(&prefix)); - keys.sort(); - keys.dedup(); - Ok(keys) - } } impl WebStorageStore { pub fn lease_area( diff --git a/moli-web-storage/src/sqlite/tests.rs b/moli-web-storage/src/sqlite/tests.rs index ef5e1d2147c..979f6a7a784 100644 --- a/moli-web-storage/src/sqlite/tests.rs +++ b/moli-web-storage/src/sqlite/tests.rs @@ -441,45 +441,24 @@ fn origin_clear_includes_cold_partitioned_areas_and_preserves_other_origins() { } #[test] -fn usage_queries_read_cold_metadata_and_overlay_uncommitted_area_sizes() { +fn single_area_usage_reads_cold_metadata_and_current_dirty_size() { let root = tempfile::tempdir().unwrap(); let runtime = Runtime::new().unwrap(); let (store, owner) = open(root.path(), &runtime); - let origin = "https://usage.test"; - let first = web_storage_partitioned_area_key(origin, origin); - let other = web_storage_partitioned_area_key(origin, "https://other.test"); - let fresh = web_storage_partitioned_area_key(origin, "https://new.test"); - let sibling = web_storage_partitioned_area_key("https://usage.test.sibling", origin); - for key in [origin, &first, &other, &sibling] { - store.try_set_item(key, "key", "old").unwrap(); - } + let key = web_storage_partitioned_area_key("https://usage.test", "https://usage.test"); + store.try_set_item(&key, "key", "old").unwrap(); owner.flush().unwrap(); assert_eq!(resident(&store), 0); - let cold = store.lease_area(&first).unwrap().unwrap(); - assert!(cold.area.state.lock().is_none()); - assert_eq!(store.try_usage_bytes(&first).unwrap(), 3); - assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 9); + let cold = store.lease_area(&key).unwrap().unwrap(); + assert_eq!(store.try_usage_bytes(&key).unwrap(), 3); assert!( cold.area.state.lock().is_none(), - "usage must not materialize entries" - ); - - store.try_set_item(&other, "key", "changed").unwrap(); - store.try_set_item(&fresh, "new", "fresh").unwrap(); - store.try_clear(origin).unwrap(); - // The known single area reads its uncommitted value; the origin query - // overlays both newly created and modified maps, including pending clear. - assert_eq!(store.try_usage_bytes(&other).unwrap(), 7); - assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 15); - assert!(cold.area.state.lock().is_none()); - owner.flush().unwrap(); - assert_eq!(store.try_usage_bytes_for_origin_areas(origin).unwrap(), 15); - assert_eq!( - store - .try_usage_bytes_for_origin_areas("https://usage.test.sibling") - .unwrap(), - 3 + "usage must not load entries" ); + store.try_set_item(&key, "key", "changed").unwrap(); + assert_eq!(store.try_usage_bytes(&key).unwrap(), 7); + store.try_clear(&key).unwrap(); + assert_eq!(store.try_usage_bytes(&key).unwrap(), 0); drop(cold); owner.close().unwrap(); } diff --git a/moli-web-storage/src/store.rs b/moli-web-storage/src/store.rs index 4dd330bb475..41020da28bd 100644 --- a/moli-web-storage/src/store.rs +++ b/moli-web-storage/src/store.rs @@ -414,33 +414,6 @@ impl WebStorageStore { pub fn usage_bytes(&self, origin: &str) -> usize { self.try_usage_bytes(origin).unwrap_or(0) } - fn area_keys_for_origin( - &self, - origin: &str, - ) -> std::result::Result, WebStorageMutationError> { - match &self.backend { - WebStorageBackend::Memory(memory) => Ok(memory.lock().area_keys_for_origin(origin)), - WebStorageBackend::Json(json) => Ok(json.lock().memory.area_keys_for_origin(origin)), - WebStorageBackend::Sqlite(sqlite) => sqlite.area_keys_for_origin(origin), - } - } - pub fn try_usage_bytes_for_origin_areas( - &self, - origin: &str, - ) -> std::result::Result { - if let WebStorageBackend::Sqlite(sqlite) = &self.backend { - return sqlite.usage_bytes_for_origin_areas(origin); - } - self.area_keys_for_origin(origin)? - .iter() - .try_fold(0usize, |sum, key| { - self.try_usage_bytes(key) - .map(|usage| sum.saturating_add(usage)) - }) - } - pub fn usage_bytes_for_origin_areas(&self, origin: &str) -> usize { - self.try_usage_bytes_for_origin_areas(origin).unwrap_or(0) - } pub fn try_clear_origin_areas( &self, origin: &str,