fix(cache): return native query results in the owner realm

This commit is contained in:
ldm0
2026-11-21 20:03:30 +08:00
parent dfbfaac8de
commit cc982c36d6
5 changed files with 241 additions and 23 deletions
@@ -32,6 +32,7 @@ use crate::webidl;
mod bucket_maintenance;
mod cache_add;
mod cache_query;
mod cache_results;
use moli_storage_service::StorageBucketCacheName;
mod legacy_storage_quota;
pub(in crate::context_bootstrap) use bucket_maintenance::settle_storage_bucket_operation;
@@ -1239,6 +1240,8 @@ fn storage_bucket_cache_storage_open_callback<'s>(
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
return;
};
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) =
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "open")
else {
@@ -1281,17 +1284,21 @@ fn storage_bucket_cache_storage_match_callback<'s>(
let options = parsed.options;
let request = parsed.request.expect("required RequestInfo was converted");
let query = storage_bucket_cache_query(request, &options);
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) =
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "match")
else {
return;
};
let matched = with_storage_bucket_store_entry(scope, |store| {
let cache_names = match parsed.cache_name.as_ref() {
Some(cache_name) => vec![cache_name.clone()],
None => store.cache_names_for_identity(&handle.identity)?,
};
let cache_names = store.cache_names_for_identity(&handle.identity)?;
for cache_name in cache_names {
if let Some(expected) = parsed.cache_name.as_ref()
&& expected != &cache_name
{
continue;
}
if let Some(response) = store
.match_cache_entries_for_identity(&handle.identity, &cache_name, &query)?
.into_iter()
@@ -1339,6 +1346,8 @@ fn storage_bucket_cache_storage_has_callback<'s>(
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
return;
};
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) =
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "has")
else {
@@ -1370,6 +1379,8 @@ fn storage_bucket_cache_storage_keys_callback<'s>(
else {
return;
};
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) =
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "keys")
else {
@@ -1412,6 +1423,8 @@ fn storage_bucket_cache_storage_delete_callback<'s>(
let Some(cache_name) = cache_query::name_argument(scope, &args, resolver) else {
return;
};
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) =
storage_bucket_cache_storage_live_handle(scope, args.this(), resolver, "delete")
else {
@@ -1748,6 +1761,8 @@ fn storage_bucket_cache_match_callback<'s>(
let options = parsed.options;
let request = parsed.request.expect("required RequestInfo was converted");
let query = storage_bucket_cache_query(request, &options);
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "match")
else {
return;
@@ -1802,6 +1817,8 @@ fn storage_bucket_cache_match_all_callback<'s>(
let options = parsed.options;
let request = parsed.request;
let query = request.map(|request| storage_bucket_cache_query(request, &options));
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "matchAll")
else {
return;
@@ -1842,6 +1859,14 @@ fn storage_bucket_cache_match_all_callback<'s>(
return;
}
}
let Some(responses) = cache_results::freeze_array(scope, responses) else {
reject_type_error(
scope,
resolver,
"Cache.matchAll failed to freeze its result.",
);
return;
};
let _ = resolver.resolve(scope, responses.into());
}
Some(None) => reject_storage_bucket_unknown_error(scope, resolver, "cache.matchAll"),
@@ -1872,6 +1897,8 @@ fn storage_bucket_cache_keys_callback<'s>(
let options = parsed.options;
let request = parsed.request;
let query = request.map(|request| storage_bucket_cache_query(request, &options));
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "keys")
else {
return;
@@ -1922,6 +1949,8 @@ fn storage_bucket_cache_delete_callback<'s>(
let options = parsed.options;
let request = parsed.request.expect("required RequestInfo was converted");
let query = storage_bucket_cache_query(request, &options);
let (owner, resolver) = cache_results::owner_resolver(scope, args.this(), resolver, &mut rv);
let scope = &mut v8::ContextScope::new(scope, owner);
let Some(handle) = storage_bucket_cache_live_handle(scope, args.this(), resolver, "delete")
else {
return;
@@ -2618,25 +2647,7 @@ fn cache_entries_to_request_array<'s>(
return None;
}
}
Some(requests)
}
fn headers_entries_to_init_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
entries: &[(String, String)],
) -> v8::Local<'s, v8::Array> {
let array = v8::Array::new(scope, entries.len() as i32);
for (index, (name, value)) in entries.iter().enumerate() {
let pair = v8::Array::new(scope, 2);
if let Some(name) = v8_string(scope, name) {
let _ = pair.set_index(scope, 0, name.into());
}
if let Some(value) = v8_string(scope, value) {
let _ = pair.set_index(scope, 1, value.into());
}
let _ = array.set_index(scope, index as u32, pair.into());
}
array
cache_results::freeze_array(scope, requests)
}
fn cache_entry_usage_bytes(
@@ -0,0 +1,63 @@
//! Result construction runs in the receiver's realm after WebIDL conversion.
use super::*;
use moli_webapi_declare::WebApiObject;
pub(super) fn owner_resolver<'s>(
scope: &mut v8::PinScope<'s, '_>,
receiver: v8::Local<'s, v8::Object>,
callee_resolver: v8::Local<'s, v8::PromiseResolver>,
rv: &mut v8::ReturnValue<'_, v8::Value>,
) -> (
v8::Local<'s, v8::Context>,
v8::Local<'s, v8::PromiseResolver>,
) {
let target = moli_webapi_declare::web_api_object_target(scope, receiver)
.expect("branded Cache receiver has native identity");
let owner = target
.get_creation_context(scope)
.expect("Cache receiver has an owner realm");
if owner == scope.get_current_context() {
return (owner, callee_resolver);
}
let scope = &mut v8::ContextScope::new(scope, owner);
let resolver = v8::PromiseResolver::new(scope).expect("Cache result Promise should allocate");
rv.set(resolver.get_promise(scope).into());
(owner, resolver)
}
pub(super) fn freeze_array<'s>(
scope: &mut v8::PinScope<'s, '_>,
array: v8::Local<'s, v8::Array>,
) -> Option<v8::Local<'s, v8::Array>> {
array
.set_integrity_level(scope, v8::IntegrityLevel::Frozen)?
.then_some(array)
}
#[derive(WebApiObject)]
#[webapi(plain, data_properties, enumerable)]
struct CachedResponseInitDeclaration<'s> {
status: u32,
status_text: v8::Local<'s, v8::String>,
}
fn without_prototype<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
) -> Option<v8::Local<'s, v8::Object>> {
object
.set_prototype(scope, v8::null(scope).into())?
.then_some(object)
}
pub(super) fn response_init<'s>(
scope: &mut v8::PinScope<'s, '_>,
status: u16,
status_text: &str,
) -> Option<v8::Local<'s, v8::Object>> {
let status_text = v8_string(scope, status_text)?;
let init = CachedResponseInitDeclaration::new(status as u32, status_text)
.bind(scope)
.ok()?;
without_prototype(scope, init)
}
@@ -0,0 +1,120 @@
(async () => {
const checks = [];
async function check(name, test) {
try { checks.push({name, passed: (await test()) === true}); }
catch (error) { checks.push({name, passed:false, error:String(error)}); }
}
const names = ['cache-order-z','cache-order-a','cache-order-Z','cache-order-',
'cache-order-\ud800','cache-order-\ufffd','cache-order-\0','cache-order-😀'];
const list = async () => (await caches.keys()).filter(name => names.includes(name));
const same = (a,b) => JSON.stringify(a) === JSON.stringify(b);
const handles = [];
try {
await Promise.all(names.map(name => caches.delete(name)));
handles.push(...await Promise.all(names.map(name => caches.open(name))));
await check('names follow creation order', async () => same(await list(),names));
await caches.open(names[2]);
await check('reopen preserves position', async () => same(await list(),names));
for (let i=0;i<names.length;i++) await handles[i].put('/ordering',new Response(names[i]));
await check('storage match selects oldest cache', async () => (await (await caches.match('/ordering')).text()) === names[0]);
await check('storage explicit name selects chosen cache', async () => (await (await caches.match('/ordering',{cacheName:names[1]})).text()) === names[1]);
await check('delete existing cache', async () => await caches.delete(names[1]));
await check('delete preserves survivor order', async () => same(await list(),names.filter((_,i)=>i!==1)));
const recreated = await caches.open(names[1]);
await check('recreated name goes last', async () => same(await list(),[...names.filter((_,i)=>i!==1),names[1]]));
await check('recreated cache is empty', async () => (await recreated.keys()).length===0);
await check('deleted handle keeps contents', async () => await (await handles[1].match('/ordering')).text()===names[1]);
await caches.delete(names[0]);
await check('storage match follows next surviving cache', async () => await (await caches.match('/ordering')).text()===names[2]);
await check('missing named match does not create cache', async () => {
const before=await list();const missing='cache-order-absent';await caches.delete(missing);
return await caches.match('/ordering',{cacheName:missing})===undefined && !(await caches.has(missing)) && same(await list(),before);
});
await check('storage keys returns fresh mutable array', async () => {
const a=await caches.keys(),b=await caches.keys();a.push('local-only');return a!==b && !Object.isFrozen(a) && !(await caches.has('local-only'));
});
const cache=await caches.open('cache-results');
await cache.put('/first',new Response('first',{headers:{'x-value':'1'}}));
await cache.put('/second',new Response('second',{headers:{'x-value':'2'}}));
for (const method of ['keys','matchAll']) {
for (const request of [undefined,'/first','/missing']) {
const label=method+'/'+String(request),a=await cache[method](request),b=await cache[method](request);
await check(label+'/frozen array', () => Array.isArray(a)&&Object.isFrozen(a));
await check(label+'/immutable length and entries', async () => {
const value=await cache[method](request),old=value.length;
return !Reflect.set(value,'length',old+1)&&!Reflect.set(value,'0',null)&&value.length===old;
});
await check(label+'/fresh result and elements', () => a!==b&&(a.length===0||a[0]!==b[0]));
await check(label+'/shallow freeze', () => {if(!a.length)return true;a[0].marker=42;return a[0].marker===42&&!Object.isFrozen(a[0]);});
if (a.length) for (const mutation of ['append','set','delete']) {
await check(label+'/immutable headers '+mutation, () => {
let error;try{a[0].headers[mutation]('x-value','changed');}catch(e){error=e;}return error instanceof TypeError;
});
}
}
await check(method+'/internal headers ignore author iterator', async () => {
const descriptor=Object.getOwnPropertyDescriptor(Array.prototype,Symbol.iterator);let reads=0;
Object.defineProperty(Array.prototype,Symbol.iterator,{configurable:true,get(){reads++;throw 42;}});
try{return (await cache[method]()).length===2&&reads===0;}finally{Object.defineProperty(Array.prototype,Symbol.iterator,descriptor);}
});
const ctor=method==='keys'?'Request':'Response',descriptor=Object.getOwnPropertyDescriptor(globalThis,ctor);
await check(method+'/intrinsic constructor', async () => {
let calls=0;Object.defineProperty(globalThis,ctor,{configurable:true,get(){calls++;throw 42;}});
try{return (await cache[method]()).length===2&&calls===0;}finally{Object.defineProperty(globalThis,ctor,descriptor);}
});
}
await check('keys ignores inherited RequestInit getters',async()=>{
const descriptor=Object.getOwnPropertyDescriptor(Object.prototype,'mode');let reads=0;
Object.defineProperty(Object.prototype,'mode',{configurable:true,get(){reads++;throw 42;}});
try{return (await cache.keys()).length===2&&reads===0;}finally{if(descriptor)Object.defineProperty(Object.prototype,'mode',descriptor);else delete Object.prototype.mode;}
});
if(typeof document!=='undefined') {
const frame=document.createElement('iframe');document.body.append(frame);const child=frame.contentWindow;
try {
const childCache=await child.caches.open('cache-results');
for(const [ownerLabel,owner,receiver] of [['main',globalThis,cache],['child',child,childCache]]) {
for(const [calleeLabel,callee] of [['main',globalThis],['child',child]]) {
for(const method of ['keys','matchAll']) {
const label='realm/'+ownerLabel+'/'+calleeLabel+'/'+method;
const promise=callee.Cache.prototype[method].call(receiver),a=await promise;
const C=method==='keys'?owner.Request:owner.Response;
await check(label+'/promise',()=>Object.getPrototypeOf(promise)===owner.Promise.prototype);
await check(label+'/array',()=>Object.getPrototypeOf(a)===owner.Array.prototype);
await check(label+'/elements',()=>a.length===2&&a.every(value=>Object.getPrototypeOf(value)===C.prototype));
await check(label+'/frozen',()=>Object.isFrozen(a));
await check(label+'/invalid URL callee rejection',async()=>{
const p=callee.Cache.prototype[method].call(receiver,'http://[');let error;
try{await p;}catch(e){error=e;}
return Object.getPrototypeOf(p)===callee.Promise.prototype&&error instanceof callee.TypeError;
});
await check(label+'/getter callee rejection',async()=>{
const reason={};const p=callee.Cache.prototype[method].call(receiver,'/first',{get ignoreMethod(){throw reason;}});let error;
try{await p;}catch(e){error=e;}
return Object.getPrototypeOf(p)===callee.Promise.prototype&&error===reason;
});
}
await check('realm/'+ownerLabel+'/'+calleeLabel+'/match',async()=>{
const value=await callee.Cache.prototype.match.call(receiver,'/first');return Object.getPrototypeOf(value)===owner.Response.prototype;
});
for(const method of ['keys','match','open','has','delete']) {
const input=method==='match'?'/first':method==='delete'?'cache-order-absent':'cache-results';
const promise=callee.CacheStorage.prototype[method].call(owner.caches,input),value=await promise;
const label='storage-realm/'+ownerLabel+'/'+calleeLabel+'/'+method;
await check(label+'/promise',()=>Object.getPrototypeOf(promise)===owner.Promise.prototype);
await check(label+'/value',()=>{
if(method==='keys')return Object.getPrototypeOf(value)===owner.Array.prototype&&!Object.isFrozen(value);
if(method==='match')return Object.getPrototypeOf(value)===owner.Response.prototype;
if(method==='open')return Object.getPrototypeOf(value)===owner.Cache.prototype;
return typeof value==='boolean';
});
}
}
}
}finally{frame.remove();}
}
} finally {
await Promise.all([...names,'cache-results','cache-order-absent'].map(name=>caches.delete(name)));
}
globalThis.__uiEventResults={checks,total:checks.length,passed:checks.filter(row=>row.passed).length,complete:true};
return true;
})()
@@ -0,0 +1,23 @@
use super::*;
#[tokio::test(flavor = "current_thread")]
async fn cache_queries_preserve_creation_order_owner_realm_and_immutable_results() {
let loader = static_http_loader(std::iter::empty::<String>());
let mut vm =
new_storage_page_task_executor_test_vm_with_loader("https://cache-results.test/", &loader);
vm.exec(include_str!("cache_results.js"), None).unwrap();
advance_page_task_executor_until_eval_equals(
&mut vm,
&loader,
"String(globalThis.__uiEventResults?.complete===true)",
"true",
"cache-query-results-fixture",
)
.await;
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "145");
assert_eq!(
vm.eval("JSON.stringify(__uiEventResults.checks.filter(row=>!row.passed))")
.unwrap(),
"[]"
);
}
@@ -16,6 +16,7 @@ mod broadcast_channel;
mod cache_add;
mod cache_query;
mod cache_query_init;
mod cache_results;
mod chrome;
#[cfg(feature = "devtools")]
mod click_targets;