diff --git a/moli-renderer-v8/src/context_bootstrap/indexed_db/core/clone.rs b/moli-renderer-v8/src/context_bootstrap/indexed_db/core/clone.rs index 89216dc9883..c8b1c0f712e 100644 --- a/moli-renderer-v8/src/context_bootstrap/indexed_db/core/clone.rs +++ b/moli-renderer-v8/src/context_bootstrap/indexed_db/core/clone.rs @@ -1,4 +1,9 @@ use super::*; +use crate::structured_clone::{ + HOST_OBJECT_TAG_DOM_EXCEPTION, HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR, + read_dom_exception_payload, read_quota_exceeded_error_payload, write_dom_exception_payload, + write_quota_exceeded_error_payload, +}; use crate::{ context_bootstrap::{ FileSystemHandleDurablePayload, build_file_system_handle_from_durable_payload, @@ -51,6 +56,16 @@ impl v8::ValueSerializerImpl for IndexedDbStructuredCloneSerializer { serializer: &dyn v8::ValueSerializerHelper, ) -> Option { match moli_webapi_declare::web_api_object_type(scope, object).map(|kind| kind.name()) { + Some("DOMException") + if write_dom_exception_payload(scope, object, serializer).is_some() => + { + return Some(true); + } + Some("QuotaExceededError") + if write_quota_exceeded_error_payload(scope, object, serializer).is_some() => + { + return Some(true); + } Some("EncodedVideoChunk") => { let exception = dom_exception_value( scope, @@ -180,6 +195,10 @@ impl v8::ValueDeserializerImpl for IndexedDbStructuredCloneDeserializer { return None; } match tag { + HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer), + HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => { + read_quota_exceeded_error_payload(scope, deserializer) + } HOST_OBJECT_TAG_IMAGE_DATA => read_image_data_payload(scope, deserializer), HOST_OBJECT_TAG_CRYPTO_KEY => { read_crypto_key_payload(scope, deserializer).or_else(|| { diff --git a/moli-renderer-v8/src/script_vm/tests/indexed_db.rs b/moli-renderer-v8/src/script_vm/tests/indexed_db.rs index e1a2ef3db1c..d23ebd68392 100644 --- a/moli-renderer-v8/src/script_vm/tests/indexed_db.rs +++ b/moli-renderer-v8/src/script_vm/tests/indexed_db.rs @@ -6595,3 +6595,101 @@ navigator.storageBuckets.open('limited', {quota: 16}).then(bucket => { r#"["abort:QuotaExceededError:0:0:true","open-error:AbortError:true","deleted"]"# ); } + +#[test] +fn indexed_db_roundtrips_native_exception_data_without_author_access() { + let mut vm = new_storage_page_task_executor_test_vm("https://indexeddb-exception-data.test/"); + vm.eval(&format!( + "{}\nglobalThis.exceptionPayloadResult = 'pending'; indexedDBExceptionPayloadProbe(globalThis).then(result => {{ exceptionPayloadResult = JSON.stringify(result); }}, error => {{ exceptionPayloadResult = JSON.stringify({{error: error.name + ':' + error.message}}); }});", + include_str!("../../../tests/fixtures/indexeddb-exception-payloads.js"), + )) + .expect("IndexedDB exception data probe should schedule"); + let result = vm + .eval_after_selected_page_tasks("String(exceptionPayloadResult)") + .expect("IndexedDB exception data probe should complete"); + let result: serde_json::Value = serde_json::from_str(&result).unwrap(); + assert_eq!(result["failures"], serde_json::json!([]), "{result}"); + assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}"); +} + +#[test] +fn indexed_db_native_exception_data_survives_profile_restart() { + let root = indexed_db_test_root("exception-data-profile-restart"); + let page_url = "https://indexeddb-exception-profile.test/"; + for phase in ["write", "read"] { + let manager = crate::new_indexed_db_manager(Some(root.clone())) + .expect("durable IndexedDB manager should initialize"); + let mut vm = new_storage_page_task_executor_test_vm(page_url); + vm.set_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager))); + vm.eval(&format!("globalThis.exceptionPayloadPhase = {phase:?};")) + .unwrap(); + vm.eval( + r#" +globalThis.exceptionPayloadRestart = 'pending'; +(async () => { + const request = value => new Promise((resolve, reject) => { + value.onsuccess = () => resolve(value.result); + value.onerror = () => reject(value.error); + }); + const done = tx => new Promise((resolve, reject) => { + tx.oncomplete = resolve; tx.onabort = () => reject(tx.error); + }); + const open = indexedDB.open('durable-exceptions', 1); + open.onupgradeneeded = () => open.result.createObjectStore('values'); + const db = await request(open); + try { + if (exceptionPayloadPhase === 'write') { + const error = new DOMException('stored\u0000\ud83d\ude00', 'AbortError'); + const quota = new QuotaExceededError('full', {quota:0, requested:12.5}); + const value = {error, alias:error, quota}; value.self = value; + const tx = db.transaction('values','readwrite'), complete = done(tx); + tx.objectStore('values').put(value, 'record'); await complete; + exceptionPayloadRestart = 'stored'; + } else { + const tx = db.transaction('values'), complete = done(tx); + const value = await request(tx.objectStore('values').get('record')); + await complete; + exceptionPayloadRestart = JSON.stringify([ + value.self === value, value.error === value.alias, + Object.getPrototypeOf(value.error) === DOMException.prototype, + value.error.name, value.error.message, value.error.code, + Object.getPrototypeOf(value.quota) === QuotaExceededError.prototype, + value.quota.name, value.quota.message, value.quota.code, + value.quota.quota, value.quota.requested, + !Object.hasOwn(value.error,'stack'), !Object.hasOwn(value.quota,'stack') + ]); + } + } finally { db.close(); } +})().catch(error => { exceptionPayloadRestart = error.name+':'+error.message; }); +"#, + ) + .expect("durable exception data workflow should schedule"); + let result = vm + .eval_after_selected_page_tasks("String(exceptionPayloadRestart)") + .expect("durable exception data workflow should complete"); + if phase == "write" { + assert_eq!(result, "stored"); + } else { + assert_eq!( + serde_json::from_str::(&result).unwrap(), + serde_json::json!([ + true, + true, + true, + "AbortError", + "stored\0😀", + 20, + true, + "QuotaExceededError", + "full", + 22, + 0, + 12.5, + true, + true + ]) + ); + } + } + let _ = std::fs::remove_dir_all(root); +} diff --git a/moli-renderer-v8/src/structured_clone.rs b/moli-renderer-v8/src/structured_clone.rs index 1a492f19528..5a3de29f19e 100644 --- a/moli-renderer-v8/src/structured_clone.rs +++ b/moli-renderer-v8/src/structured_clone.rs @@ -43,9 +43,9 @@ pub(crate) const HOST_OBJECT_TAG_IMAGE_DATA: u32 = 2; pub(crate) const HOST_OBJECT_TAG_CRYPTO_KEY: u32 = 3; const HOST_OBJECT_TAG_READABLE_STREAM: u32 = 4; pub(crate) const HOST_OBJECT_TAG_BLOB: u32 = 5; -const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6; +pub(crate) const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6; pub(crate) const HOST_OBJECT_TAG_FILE_SYSTEM_HANDLE: u32 = 7; -const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8; +pub(crate) const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8; const HOST_OBJECT_TAG_WRITABLE_STREAM: u32 = 9; const HOST_OBJECT_TAG_TRANSFORM_STREAM: u32 = 10; const HOST_OBJECT_TAG_ENCODED_VIDEO_CHUNK: u32 = 13; @@ -532,24 +532,15 @@ impl v8::ValueSerializerImpl for WireSerializer { return Some(true); } } - Some("QuotaExceededError") => { - if let Some((message, quota, requested)) = - quota_exceeded_error_clone_fields(scope, object) - { - serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR); - write_string(serializer, &message); - write_optional_double(serializer, quota); - write_optional_double(serializer, requested); - return Some(true); - } + Some("QuotaExceededError") + if write_quota_exceeded_error_payload(scope, object, serializer).is_some() => + { + return Some(true); } - Some("DOMException") => { - if let Some((message, name)) = dom_exception_clone_fields(scope, object) { - serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION); - write_string(serializer, &message); - write_string(serializer, &name); - return Some(true); - } + Some("DOMException") + if write_dom_exception_payload(scope, object, serializer).is_some() => + { + return Some(true); } _ => {} } @@ -783,18 +774,9 @@ impl v8::ValueDeserializerImpl for WireDeserializer { None }) } - HOST_OBJECT_TAG_DOM_EXCEPTION => { - let message = read_string(deserializer)?; - let name = read_string(deserializer)?; - Some(build_dom_exception_object(scope, &message, &name)) - } + HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer), HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => { - let message = read_string(deserializer)?; - let quota = read_optional_double(deserializer)?; - let requested = read_optional_double(deserializer)?; - Some(build_quota_exceeded_error_object( - scope, &message, quota, requested, - )) + read_quota_exceeded_error_payload(scope, deserializer) } _ => { throw_data_clone_exception(scope, "Unsupported structured clone host object."); @@ -989,6 +971,52 @@ pub(crate) fn read_crypto_key_payload<'s>( ) } +pub(crate) fn write_dom_exception_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + object: v8::Local<'s, v8::Object>, + serializer: &dyn v8::ValueSerializerHelper, +) -> Option<()> { + let (message, name) = dom_exception_clone_fields(scope, object)?; + serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION); + write_string(serializer, &message); + write_string(serializer, &name); + Some(()) +} + +pub(crate) fn read_dom_exception_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + deserializer: &dyn v8::ValueDeserializerHelper, +) -> Option> { + let message = read_string(deserializer)?; + let name = read_string(deserializer)?; + Some(build_dom_exception_object(scope, &message, &name)) +} + +pub(crate) fn write_quota_exceeded_error_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + object: v8::Local<'s, v8::Object>, + serializer: &dyn v8::ValueSerializerHelper, +) -> Option<()> { + let (message, quota, requested) = quota_exceeded_error_clone_fields(scope, object)?; + serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR); + write_string(serializer, &message); + write_optional_double(serializer, quota); + write_optional_double(serializer, requested); + Some(()) +} + +pub(crate) fn read_quota_exceeded_error_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + deserializer: &dyn v8::ValueDeserializerHelper, +) -> Option> { + let message = read_string(deserializer)?; + let quota = read_optional_double(deserializer)?; + let requested = read_optional_double(deserializer)?; + Some(build_quota_exceeded_error_object( + scope, &message, quota, requested, + )) +} + fn write_string(serializer: &dyn v8::ValueSerializerHelper, value: &str) { write_raw_vec(serializer, value.as_bytes()); } diff --git a/moli-renderer-v8/src/worker/thread/tests/indexed_db.rs b/moli-renderer-v8/src/worker/thread/tests/indexed_db.rs index c2164d1af3d..e718c5ef100 100644 --- a/moli-renderer-v8/src/worker/thread/tests/indexed_db.rs +++ b/moli-renderer-v8/src/worker/thread/tests/indexed_db.rs @@ -60,3 +60,67 @@ async fn indexed_db_global_attribute_preserves_receivers_and_identity_across_wor }); } } + +#[tokio::test] +async fn indexed_db_preserves_native_exception_data_across_worker_kinds() { + ensure_v8(); + let manager = crate::new_indexed_db_manager(None).unwrap(); + let storage_key = moli_storage_key::MoliStorageKey::new( + "https://indexeddb-exception-data.test".to_owned(), + "https://indexeddb-exception-data.test".to_owned(), + None, + moli_storage_key::StoragePartitionRelation::FirstParty, + ); + for (kind, script_kind) in [ + ( + WorkerGlobalKind::Dedicated { + name: String::new(), + }, + WorkerScriptKind::Classic, + ), + ( + WorkerGlobalKind::Dedicated { + name: String::new(), + }, + WorkerScriptKind::Module, + ), + ( + WorkerGlobalKind::Shared { + name: "exceptions".to_owned(), + storage_key, + }, + WorkerScriptKind::Classic, + ), + ( + WorkerGlobalKind::Service { + registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1), + version_id: ServiceWorkerVersionId::from_u64_for_test(1), + scope_url: url::Url::parse("https://indexeddb-exception-data.test/").unwrap(), + }, + WorkerScriptKind::Classic, + ), + ] { + let source = format!( + "{}\nindexedDBExceptionPayloadProbe(globalThis).then(result => console.log(JSON.stringify(result)), error => console.log(JSON.stringify({{error: error.name + ':' + error.message}})));", + include_str!("../../../../tests/fixtures/indexeddb-exception-payloads.js"), + ); + let mut handle = spawn_test_worker_with_options( + WorkerSpawnOptions::new( + source, + "https://indexeddb-exception-data.test/worker.js".to_owned(), + ) + .with_global_kind(kind) + .with_script_kind(script_kind) + .with_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager))), + ); + let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap(); + handle.terminate_and_join(); + let WorkerToParentMessage::Console(console) = message else { + panic!("expected the completed exception data probe, got {message:?}"); + }; + let result: serde_json::Value = + serde_json::from_str(console.message.strip_prefix("log: ").unwrap()).unwrap(); + assert_eq!(result["failures"], serde_json::json!([]), "{result}"); + assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}"); + } +} diff --git a/moli-renderer-v8/tests/fixtures/indexeddb-exception-payloads.js b/moli-renderer-v8/tests/fixtures/indexeddb-exception-payloads.js new file mode 100644 index 00000000000..9202e19b7d7 --- /dev/null +++ b/moli-renderer-v8/tests/fixtures/indexeddb-exception-payloads.js @@ -0,0 +1,124 @@ +async function indexedDBExceptionPayloadProbe(global) { + const rows = [], failures = []; + const check = (name, pass) => { + rows.push({name, pass: !!pass}); + if (!pass) failures.push(name); + }; + const request = value => new Promise((resolve, reject) => { + value.onsuccess = () => resolve(value.result); + value.onerror = () => reject(value.error); + }); + const completion = tx => new Promise((resolve, reject) => { + tx.oncomplete = resolve; + tx.onabort = () => reject(tx.error || new Error('transaction aborted')); + }); + const DOM = global.DOMException, Quota = global.QuotaExceededError; + const domDescriptor = Object.getOwnPropertyDescriptor(global, 'DOMException'); + const quotaDescriptor = Object.getOwnPropertyDescriptor(global, 'QuotaExceededError'); + const message = 'stored\u0000\ud83d\ude00'; + class Derived extends DOM {} + let native; + try { global.structuredClone(() => {}); } catch (error) { native = error; } + const cases = [ + {label:'abort', error:new DOM(message, 'AbortError'), ctor:DOM, name:'AbortError', message, code:20}, + {label:'default', error:new DOM(), ctor:DOM, name:'Error', message:'', code:0}, + {label:'custom', error:new DOM(message, 'CustomError'), ctor:DOM, name:'CustomError', message, code:0}, + {label:'base-quota-name', error:new DOM(message, 'QuotaExceededError'), ctor:DOM, name:'QuotaExceededError', message, code:22}, + {label:'subclass', error:new Derived(message, 'NotFoundError'), ctor:DOM, name:'NotFoundError', message, code:8}, + {label:'native', error:native, ctor:DOM, name:'DataCloneError', message:native.message, code:25}, + ...[ + ['empty', {}], ['quota', {quota:10}], ['requested', {requested:12}], + ['zero', {quota:0, requested:0}], ['fraction', {quota:10.25, requested:12.5}] + ].map(([label, options]) => ({label:'quota-'+label, error:new Quota(message, options), + ctor:Quota, name:'QuotaExceededError', message, code:22, + quota:options.quota ?? null, requested:options.requested ?? null})) + ]; + check('native API exception retains its diagnostic stack', typeof native.stack === 'string'); + const ordinary = new TypeError('ordinary', {cause:cases[0].error}); + const ordinaryStack = ordinary.stack; + let authorReads = 0; + const poison = () => { ++authorReads; throw new Error('author getter must not run'); }; + for (const entry of cases) { + Object.setPrototypeOf(entry.error, null); + for (const name of ['message', 'name', 'code', 'quota', 'requested', 'stack', 'expando']) { + Object.defineProperty(entry.error, name, {enumerable:true, get:poison}); + } + } + const value = {kind:'original', errors:cases.map(entry => entry.error), ordinary}; + value.alias = value.errors[0]; value.self = value; + value.map = new Map([[value.errors[0], value.errors[1]]]); + value.set = new Set([value.errors[0]]); + const inspect = (label, copy) => { + check(label+': fresh graph with cycles and aliases', copy !== value && copy.self === copy && copy.alias === copy.errors[0]); + check(label+': Map and Set preserve native-object identity', copy.map.get(copy.errors[0]) === copy.errors[1] && copy.set.has(copy.errors[0])); + check(label+': ordinary Error keeps prototype, cause and stack', Object.getPrototypeOf(copy.ordinary) === TypeError.prototype && copy.ordinary.cause === copy.errors[0] && copy.ordinary.stack === ordinaryStack); + check(label+': exception count', copy.errors.length === cases.length); + for (let i=0; i open.result.createObjectStore('values').createIndex('kind','kind'); + db = await request(open); + const tx = db.transaction('values','readwrite'), done = completion(tx), store = tx.objectStore('values'); + for (const entry of cases) { + let error; + try { store.put(new Proxy(entry.error, {}), 'proxy-'+entry.label); } catch (caught) { error = caught; } + check(entry.label+': author Proxy rejected', error instanceof DOM && error.name === 'DataCloneError'); + } + let serialized = true; + try { store.add(value,'add'); store.put(value,'put'); } catch (error) { + serialized = false; + check('native exception data can be stored: '+error.name, false); + } + await done; + check('native exception records accepted', serialized); + if (serialized) { + Object.defineProperty(global,'DOMException',{configurable:true,get:poison}); + Object.defineProperty(global,'QuotaExceededError',{configurable:true,get:poison}); + const read = db.transaction('values'); + const readDone = completion(read), values = read.objectStore('values'); + const one = request(values.get('add')); + const many = request(values.getAll()); + const indexed = request(values.index('kind').get('original')); + const [copy, copies, indexCopy] = await Promise.all([one,many,indexed]); + await readDone; + inspect('get',copy); + check('getAll returns both records',copies.length === 2); + for (let i=0;i { + cursor.onerror=() => reject(cursor.error); + cursor.onsuccess=() => { + const change=cursor.result.update(value); + change.onsuccess=resolve; change.onerror=() => reject(change.error); + }; + }); + await changed; await updateDone; + db.close(); db=await request(global.indexedDB.open(dbName)); + const reopened=db.transaction('values'), reopenedDone=completion(reopened); + const saved=await request(reopened.objectStore('values').index('kind').get('updated')); + await reopenedDone; + inspect('cursor.update after reopening',saved); + } + check('native data serialization never reads author getters',authorReads === 0); + } catch(error) { + check('probe completes without '+error.name+': '+error.message,false); + } finally { + Object.defineProperty(global,'DOMException',domDescriptor); + Object.defineProperty(global,'QuotaExceededError',quotaDescriptor); + if (db) db.close(); + await request(global.indexedDB.deleteDatabase(dbName)); + } + return {rows,failures}; +}