diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs index 25a5b2c1f1e..e8018d6a804 100644 --- a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs +++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs @@ -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( diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_results.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_results.rs new file mode 100644 index 00000000000..195179c49e7 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator/cache_results.rs @@ -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> { + 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> { + 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> { + let status_text = v8_string(scope, status_text)?; + let init = CachedResponseInitDeclaration::new(status as u32, status_text) + .bind(scope) + .ok()?; + without_prototype(scope, init) +} diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.js b/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.js new file mode 100644 index 00000000000..2679fb87fcf --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.js @@ -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 (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; +})() diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.rs new file mode 100644 index 00000000000..c16c509708f --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/cache_results.rs @@ -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::()); + 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(), + "[]" + ); +} diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs index e6b4b8756e8..70a8aac7d21 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs @@ -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;