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.
This commit is contained in:
ldm0
2026-11-01 04:03:38 +08:00
committed by Donough Liu
parent 18c379855a
commit f2c2b89266
4 changed files with 18 additions and 132 deletions
+2 -8
View File
@@ -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()));
+6 -66
View File
@@ -35,11 +35,7 @@ pub(super) struct SqliteBackend {
cache: Mutex<Cache>,
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<?3)";
fn origin_prefix_range(origin: &str) -> (String, String) {
@@ -356,56 +352,22 @@ impl SqliteBackend {
fn area_metadata_for_origin(
&self,
origin: &str,
) -> std::result::Result<BTreeMap<String, AreaMetadata>, WebStorageMutationError> {
) -> std::result::Result<BTreeMap<String, usize>, 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<usize, WebStorageMutationError> {
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<Area> {
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<Vec<String>, WebStorageMutationError> {
let prefix = web_storage_area_key_prefix_for_origin(origin);
let mut keys = self
.area_metadata_for_origin(origin)?
.into_keys()
.collect::<Vec<_>>();
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(
+10 -31
View File
@@ -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();
}
-27
View File
@@ -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<Vec<String>, 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<usize, WebStorageMutationError> {
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,