Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(clipboard): share byte snapshots across page realms
ldm0cff592798372
diff --git a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/clipboard.rs b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/clipboard.rsindex 70a05da40..99bb906f4 100644--- a/moli-renderer-v8/src/context_bootstrap/navigator_runtime/clipboard.rs+++ b/moli-renderer-v8/src/context_bootstrap/navigator_runtime/clipboard.rs@@ -2,14 +2,12 @@ use super::super::{SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT, SIMPLE_EVENT_TARGEuse crate::web_api_interfaces;use crate::{blob,- util::{get_private_value, set_private_value, throw_type_error, v8_string},+ util::{context_host_ptr_from_context_slot, get_private_value, throw_type_error, v8_string},webidl,};use anyhow::{Result, anyhow};use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};-const CLIPBOARD_ITEMS_SLOT: &str = "__moliClipboardItems";-const CLIPBOARD_TEXT_SLOT: &str = "__moliClipboardText";const CLIPBOARD_EVENT_LISTENERS_SLOT: &str = "__moliClipboardEventListeners";const CLIPBOARD_ITEM_DATA_SLOT: &str = "__moliClipboardItemData";@@ -25,12 +23,6 @@ struct ClipboardObjectDeclaration {#[webapi(slot = SIMPLE_EVENT_TARGET_ORDERED_HANDLERS_SLOT, init = true)]ordered_handlers: (),-- #[webapi(slot = CLIPBOARD_ITEMS_SLOT, init = "undefined")]- items: (),-- #[webapi(slot = CLIPBOARD_TEXT_SLOT, init = "")]- text: (),}#[derive(Default, WebApiFunctionTemplate)]@@ -558,6 +550,9 @@ fn clipboard_read_callback<'s>(return;}};+ let Some(runtime) = clipboard_browser_context(scope, args.this()) else {+ return;+ };if let Some(formats) = parsed.formats.unsanitized {let invalid = formats.len() > 1 || formats.iter().any(|format| format != "text/html");if invalid {@@ -570,7 +565,14 @@ fn clipboard_read_callback<'s>(return;}}- let items = copy_clipboard_items(scope, args.this());+ if reject_denied_clipboard_access(scope, args.this(), "clipboard-read", &mut rv) {+ return;+ }+ let Some(items) = copy_clipboard_items(scope, &runtime) else {+ let reason = type_error_value(scope, "Failed to read clipboard data.");+ set_rejected_promise(scope, &mut rv, reason);+ return;+ };set_resolved_promise(scope, &mut rv, items.into());}@@ -584,23 +586,17 @@ fn clipboard_read_text_callback<'s>(set_rejected_promise(scope, &mut rv, reason);return;}- if let Some(text) =- get_private_value(scope, args.this(), CLIPBOARD_TEXT_SLOT).filter(|value| value.is_string())- {- set_resolved_promise(scope, &mut rv, text);+ let Some(runtime) = clipboard_browser_context(scope, args.this()) else {+ return;+ };+ if reject_denied_clipboard_access(scope, args.this(), "clipboard-read", &mut rv) {return;}- let text_promise = first_clipboard_item(scope, args.this())- .and_then(|item| clipboard_item_data_promise(scope, item, "text/plain"))- .and_then(|promise| {- let converter = v8::Function::builder(clipboard_blob_to_text_callback).build(scope)?;- promise.then(scope, converter)- });- if let Some(promise) = text_promise {- rv.set(promise.into());- } else {- let empty = v8::String::empty(scope);- set_resolved_promise(scope, &mut rv, empty.into());+ let bytes = runtime+ .clipboard_data_for_type("text/plain")+ .unwrap_or_default();+ if let Some(text) = v8_string(scope, &String::from_utf8_lossy(&bytes)) {+ set_resolved_promise(scope, &mut rv, text.into());}}@@ -621,6 +617,9 @@ fn clipboard_write_callback<'s>(return;}};+ if clipboard_browser_context(scope, args.this()).is_none() {+ return;+ }if parsed.data.len() != 1 {let reason = super::super::new_dom_exception_value(scope,@@ -630,15 +629,22 @@ fn clipboard_write_callback<'s>(set_rejected_promise(scope, &mut rv, reason);return;}+ if reject_denied_clipboard_access(scope, args.this(), "clipboard-write", &mut rv) {+ return;+ }let item = parsed.data[0];let Some(validation) = clipboard_item_write_validation_promise(scope, item) else {let reason = type_error_value(scope, "Failed to validate ClipboardItem data.");set_rejected_promise(scope, &mut rv, reason);return;};- let callback_data = v8::Array::new(scope, 2);+ let Some(resolver) = v8::PromiseResolver::new(scope) else {+ return;+ };+ let callback_data = v8::Array::new(scope, 3);let _ = callback_data.set_index(scope, 0, args.this().into());let _ = callback_data.set_index(scope, 1, item.into());+ let _ = callback_data.set_index(scope, 2, resolver.into());let Some(store_callback) = v8::Function::builder(clipboard_store_validated_item_callback).data(callback_data.into()).build(scope)@@ -647,12 +653,23 @@ fn clipboard_write_callback<'s>(set_rejected_promise(scope, &mut rv, reason);return;};- let Some(promise) = validation.then(scope, store_callback) else {+ let Some(reject_callback) = v8::Function::builder(clipboard_write_rejected_callback)+ .data(callback_data.into())+ .build(scope)+ else {let reason = type_error_value(scope, "Failed to write ClipboardItem data.");set_rejected_promise(scope, &mut rv, reason);return;};- rv.set(promise.into());+ if validation+ .then2(scope, store_callback, reject_callback)+ .is_none()+ {+ let reason = type_error_value(scope, "Failed to write ClipboardItem data.");+ set_rejected_promise(scope, &mut rv, reason);+ return;+ }+ rv.set(resolver.get_promise(scope).into());}fn clipboard_write_text_callback<'s>(@@ -672,40 +689,14 @@ fn clipboard_write_text_callback<'s>(return;}};- let Some(text) = v8_string(scope, &parsed.data) else {- rv.set_undefined();- return;- };- let Some(promise) = resolved_promise(scope, text.into()) else {- rv.set_undefined();- return;- };- let Some(item) = build_clipboard_item(scope, vec![("text/plain".to_owned(), promise)]) else {- rv.set_undefined();+ let Some(runtime) = clipboard_browser_context(scope, args.this()) else {return;};- store_clipboard_item(scope, args.this(), item);- set_private_value(scope, args.this(), CLIPBOARD_TEXT_SLOT, text.into());- set_resolved_promise(scope, &mut rv, v8::undefined(scope).into());-}--fn clipboard_blob_to_text_callback<'s>(- scope: &mut v8::PinScope<'s, '_>,- args: v8::FunctionCallbackArguments<'s>,- mut rv: v8::ReturnValue<'_, v8::Value>,-) {- let Ok(blob) = v8::Local::<v8::Object>::try_from(args.get(0)) else {- throw_type_error(scope, "Clipboard text data is not a Blob.");+ if reject_denied_clipboard_access(scope, args.this(), "clipboard-write", &mut rv) {return;- };- let Some(bytes) = blob::blob_bytes_from_object(scope, blob) else {- throw_type_error(scope, "Clipboard text data is not a Blob.");- return;- };- let text = String::from_utf8_lossy(&bytes);- if let Some(value) = v8_string(scope, &text) {- rv.set(value.into());}+ runtime.set_clipboard_data(vec![("text/plain".to_owned(), parsed.data.into_bytes())]);+ set_resolved_promise(scope, &mut rv, v8::undefined(scope).into());}fn clipboard_item_write_validation_promise<'s>(@@ -723,7 +714,11 @@ fn clipboard_item_write_validation_promise<'s>(custom_format_count += 1;}let raw = clipboard_item_raw_data_promise(scope, item, &mime_type)?;- entries.push((key, raw));+ let normalized = clipboard_item_data_promise(scope, item, &mime_type)?;+ let validation_data = v8::Array::new(scope, 2);+ let _ = validation_data.set_index(scope, 0, key);+ let _ = validation_data.set_index(scope, 1, normalized.into());+ entries.push((validation_data, raw));}if custom_format_count > 100 {let reason = super::super::new_dom_exception_value(@@ -748,9 +743,9 @@ fn clipboard_item_write_validation_promise<'s>();let _ = state.set_index(scope, 2, v8::Boolean::new(scope, false).into());- for (key, raw) in entries {+ for (validation_data, raw) in entries {let validator = v8::Function::builder(clipboard_validate_write_entry_callback)- .data(key)+ .data(validation_data.into()).build(scope)?;let validated = raw.then(scope, validator)?;let on_fulfilled = v8::Function::builder(clipboard_validation_fulfilled_callback)@@ -767,11 +762,15 @@ fn clipboard_item_write_validation_promise<'s>(fn clipboard_validate_write_entry_callback<'s>(scope: &mut v8::PinScope<'s, '_>,args: v8::FunctionCallbackArguments<'s>,- _rv: v8::ReturnValue<'_, v8::Value>,+ mut rv: v8::ReturnValue<'_, v8::Value>,) {- let mime_type = args- .data()- .to_string(scope)+ let Ok(data) = v8::Local::<v8::Array>::try_from(args.data()) else {+ throw_type_error(scope, "Failed to validate ClipboardItem data.");+ return;+ };+ let mime_type = data+ .get_index(scope, 0)+ .and_then(|value| value.to_string(scope)).map(|value| value.to_rust_string_lossy(scope)).unwrap_or_default();if !clipboard_item_type_supported(&mime_type) {@@ -782,6 +781,11 @@ fn clipboard_validate_write_entry_callback<'s>();return;}+ // Await the representation's normalization as well as its raw type+ // validation before committing a byte snapshot to the shared clipboard.+ if let Some(normalized) = data.get_index(scope, 1) {+ rv.set(normalized);+ }let value = args.get(0);let Ok(object) = v8::Local::<v8::Object>::try_from(value) else {if mime_type == "image/png" {@@ -875,27 +879,62 @@ fn clipboard_store_validated_item_callback<'s>(args: v8::FunctionCallbackArguments<'s>,_rv: v8::ReturnValue<'_, v8::Value>,) {- let Ok(data) = v8::Local::<v8::Array>::try_from(args.data()) else {- throw_type_error(scope, "Failed to write ClipboardItem data.");+ let Some((clipboard, item, resolver)) = clipboard_write_callback_state(scope, args.data())+ else {return;};- let clipboard = data- .get_index(scope, 0)- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok());- let item = data- .get_index(scope, 1)- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok());- let (Some(clipboard), Some(item)) = (clipboard, item) else {- throw_type_error(scope, "Failed to write ClipboardItem data.");+ // Like Chromium's ScriptPromiseResolver, do not settle a write after its+ // realm is retired. Each live write still commits independently.+ let Some(runtime) = clipboard_browser_context(scope, clipboard) else {return;};- store_clipboard_item(scope, clipboard, item);- set_private_value(- scope,- clipboard,- CLIPBOARD_TEXT_SLOT,- v8::undefined(scope).into(),- );+ if clipboard_permission_denied(scope, clipboard, "clipboard-write") {+ let reason = super::super::new_dom_exception_value(+ scope,+ "Clipboard write permission denied.",+ "NotAllowedError",+ );+ let _ = resolver.reject(scope, reason);+ return;+ }+ let Some(data) = clipboard_item_bytes(scope, item) else {+ let reason = type_error_value(scope, "Failed to read validated ClipboardItem data.");+ let _ = resolver.reject(scope, reason);+ return;+ };+ runtime.set_clipboard_data(data);+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+}++fn clipboard_write_rejected_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((clipboard, _item, resolver)) = clipboard_write_callback_state(scope, args.data())+ else {+ return;+ };+ if clipboard_browser_context(scope, clipboard).is_some() {+ let _ = resolver.reject(scope, args.get(0));+ }+}++fn clipboard_write_callback_state<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ value: v8::Local<'s, v8::Value>,+) -> Option<(+ v8::Local<'s, v8::Object>,+ v8::Local<'s, v8::Object>,+ v8::Local<'s, v8::PromiseResolver>,+)> {+ let data = v8::Local::<v8::Array>::try_from(value).ok()?;+ let clipboard = v8::Local::<v8::Object>::try_from(data.get_index(scope, 0)?).ok()?;+ let item = v8::Local::<v8::Object>::try_from(data.get_index(scope, 1)?).ok()?;+ let resolver = v8::Local::<v8::Object>::try_from(data.get_index(scope, 2)?).ok()?;+ // This callback data is created only by clipboard_write_callback.+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };+ Some((clipboard, item, resolver))}fn throw_dom_exception(scope: &mut v8::PinScope<'_, '_>, message: &str, name: &str) {@@ -903,37 +942,104 @@ fn throw_dom_exception(scope: &mut v8::PinScope<'_, '_>, message: &str, name: &sscope.throw_exception(exception);}-fn store_clipboard_item<'s>(+fn clipboard_permission_denied<'s>(scope: &mut v8::PinScope<'s, '_>,clipboard: v8::Local<'s, v8::Object>,- item: v8::Local<'s, v8::Object>,-) {- let items = v8::Array::new(scope, 1);- let _ = items.set_index(scope, 0, item.into());- let _ = items.set_integrity_level(scope, v8::IntegrityLevel::Frozen);- set_private_value(scope, clipboard, CLIPBOARD_ITEMS_SLOT, items.into());+ permission: &str,+) -> bool {+ let Some(context) = clipboard.get_creation_context(scope) else {+ return true;+ };+ let Some(host_ptr) = context_host_ptr_from_context_slot(context) else {+ return true;+ };+ let scope = &mut v8::ContextScope::new(scope, context);+ let host = unsafe { &mut *host_ptr };+ let embedding_origin = moli_url::origin_ascii_serialization(host.document_url());+ let Some(requesting_origin) = host+ .current_runtime_window_execution_context_identity(scope)+ .and_then(|identity| host.storage_context_for_window_execution_context_identity(identity))+ .map(|context| context.storage_key().serialized_storage_key())+ .and_then(|key| moli_storage_key::deserialize_serialized_storage_key(&key))+ .map(|key| key.origin().to_owned())+ else {+ return true;+ };+ host.permission_state_for_origins(permission, &requesting_origin, &embedding_origin) == "denied"}-fn copy_clipboard_items<'s>(+fn reject_denied_clipboard_access<'s>(scope: &mut v8::PinScope<'s, '_>,clipboard: v8::Local<'s, v8::Object>,-) -> v8::Local<'s, v8::Array> {- let item = first_clipboard_item(scope, clipboard);- let result = v8::Array::new(scope, i32::from(item.is_some()));- if let Some(item) = item {- let _ = result.set_index(scope, 0, item.into());+ permission: &str,+ rv: &mut v8::ReturnValue<'_, v8::Value>,+) -> bool {+ if !clipboard_permission_denied(scope, clipboard, permission) {+ return false;}- result+ let reason = super::super::new_dom_exception_value(+ scope,+ "Clipboard permission denied.",+ "NotAllowedError",+ );+ set_rejected_promise(scope, rv, reason);+ true}-fn first_clipboard_item<'s>(+fn clipboard_browser_context<'s>(scope: &mut v8::PinScope<'s, '_>,clipboard: v8::Local<'s, v8::Object>,-) -> Option<v8::Local<'s, v8::Object>> {- get_private_value(scope, clipboard, CLIPBOARD_ITEMS_SLOT)- .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())- .and_then(|items| items.get_index(scope, 0))- .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+) -> Option<crate::runtime::RendererBrowserContextRuntime> {+ let context = clipboard.get_creation_context(scope)?;+ let host_ptr = context_host_ptr_from_context_slot(context)?;+ let scope = &mut v8::ContextScope::new(scope, context);+ let host = unsafe { &*host_ptr };+ // Blink's CreateForRead/Write entry points return an empty Promise for an+ // invalid ScriptState. Check the receiver realm after WebIDL conversion,+ // which can itself detach the document through author code.+ host.current_runtime_window_execution_context_identity(scope)?;+ Some(host.browser_context_runtime())+}++fn copy_clipboard_items<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ runtime: &crate::runtime::RendererBrowserContextRuntime,+) -> Option<v8::Local<'s, v8::Array>> {+ let data = runtime.clipboard_data();+ let result = v8::Array::new(scope, i32::from(!data.is_empty()));+ if !data.is_empty() {+ let mut entries = Vec::with_capacity(data.len());+ for (mime_type, bytes) in data {+ let blob = blob::build_blob_object(scope, bytes, mime_type.clone())?;+ let promise = resolved_promise(scope, blob.into())?;+ entries.push((mime_type, promise));+ }+ let item = build_clipboard_item(scope, entries)?;+ result.set_index(scope, 0, item.into())?;+ }+ Some(result)+}++fn clipboard_item_bytes<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ item: v8::Local<'s, v8::Object>,+) -> Option<Vec<(String, Vec<u8>)>> {+ let types = get_private_value(scope, item, CLIPBOARD_ITEM_TYPES_SLOT)+ .and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())?;+ let mut data = Vec::with_capacity(types.length() as usize);+ for index in 0..types.length() {+ let mime_type = types+ .get_index(scope, index)?+ .to_string(scope)?+ .to_rust_string_lossy(scope);+ let promise = clipboard_item_data_promise(scope, item, &mime_type)?;+ if promise.state() != v8::PromiseState::Fulfilled {+ return None;+ }+ let blob = v8::Local::<v8::Object>::try_from(promise.result(scope)).ok()?;+ data.push((mime_type, blob::blob_bytes_from_object(scope, blob)?));+ }+ Some(data)}fn clipboard_item_data_promise<'s>(diff --git a/moli-renderer-v8/src/runtime/browser_context_runtime.rs b/moli-renderer-v8/src/runtime/browser_context_runtime.rsindex 448a50366..4f475ab63 100644--- a/moli-renderer-v8/src/runtime/browser_context_runtime.rs+++ b/moli-renderer-v8/src/runtime/browser_context_runtime.rs@@ -171,6 +171,9 @@ pub(crate) struct RendererStoragePartitionIdentity {#[derive(Debug)]struct RendererBrowserContextRuntimeInner {id: super::RendererBrowserContextRuntimeId,+ // Keep clipboard representations independent of any page's V8 objects so+ // other pages and replacement documents can read them in their own realm.+ clipboard_data: Mutex<Vec<(String, Vec<u8>)>>,message_port_registry: crate::message_port_runtime::SharedMessagePortRegistry,broadcast_channel_registry: crate::broadcast_channel_runtime::SharedBroadcastChannelRegistry,browser_resource_runtime: crate::network::BrowserResourceRuntimeBinding,@@ -340,6 +343,23 @@ impl Default for RendererBrowserContextRuntimeOwner {}impl RendererBrowserContextRuntime {+ pub(crate) fn clipboard_data(&self) -> Vec<(String, Vec<u8>)> {+ self.inner.clipboard_data.lock().clone()+ }++ pub(crate) fn clipboard_data_for_type(&self, mime_type: &str) -> Option<Vec<u8>> {+ self.inner+ .clipboard_data+ .lock()+ .iter()+ .find(|(candidate, _)| candidate == mime_type)+ .map(|(_, bytes)| bytes.clone())+ }++ pub(crate) fn set_clipboard_data(&self, data: Vec<(String, Vec<u8>)>) {+ *self.inner.clipboard_data.lock() = data;+ }+// A browser-context runtime is only valid while its thread-affine owner is// retained, so construction returns that owner rather than a bare handle.#[allow(clippy::new_ret_no_self)]@@ -528,6 +548,7 @@ impl RendererBrowserContextRuntime {Self {inner: Arc::new(RendererBrowserContextRuntimeInner {id,+ clipboard_data: Mutex::new(Vec::new()),message_port_registry,broadcast_channel_registry,browser_resource_runtime: browser_resource_runtime.clone(),@@ -993,6 +1014,27 @@ mod tests {assert!(runtime.shares_state_with(&clone));}+ #[test]+ fn clipboard_data_for_type_returns_an_independent_copy_of_the_matching_bytes() {+ let runtime = RendererBrowserContextRuntime::new();+ runtime.set_clipboard_data(vec![+ ("image/png".to_owned(), vec![0; 1024]),+ ("text/plain".to_owned(), b"hello".to_vec()),+ ]);++ let mut text = runtime.clipboard_data_for_type("text/plain").unwrap();+ assert_eq!(text, b"hello");+ text[0] = b'j';+ assert_eq!(+ runtime.clipboard_data_for_type("text/plain").unwrap(),+ b"hello"+ );+ assert!(runtime.clipboard_data_for_type("text/html").is_none());++ runtime.set_clipboard_data(Vec::new());+ assert!(runtime.clipboard_data_for_type("text/plain").is_none());+ }+#[test]fn worker_services_stay_deferred_until_first_use() {let runtime = RendererBrowserContextRuntime::new();diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/clipboard_storage.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/clipboard_storage.rsnew file mode 100644index 000000000..31cd32774--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/clipboard_storage.rs@@ -0,0 +1,551 @@+use super::*;++const CLIPBOARD_SNAPSHOT_PROBE: &str = r#"+(async () => {+ const clipboard = navigator.clipboard;+ const source = new Blob(['hello 世界 🦊'], {type: 'text/plain'});+ const item = new ClipboardItem({'text/plain': source});+ await clipboard.write([item]);+ const first = (await clipboard.read())[0];+ const second = (await clipboard.read())[0];+ const blob = await first.getType('text/plain');+ if (first === item || first === second || blob === source) return 'reused author objects';+ if (!(first instanceof ClipboardItem) || !(blob instanceof Blob)) return 'wrong realm';+ if (first.types.join(',') !== 'text/plain' || await blob.text() !== 'hello 世界 🦊') return 'bytes changed';+ Object.defineProperty(item, 'getType', {get() {throw Error('author getType');}});+ Object.defineProperty(source, 'text', {get() {throw Error('author text');}});+ if (await clipboard.readText() !== 'hello 世界 🦊') return 'read author properties';+ await clipboard.writeText('replacement');+ const replacement = (await clipboard.read())[0];+ if (replacement === first || await (await replacement.getType('text/plain')).text() !== 'replacement') {+ return 'replacement failed';+ }+ return 'ok';+})()+"#;++fn assert_clipboard_probe(vm: &mut ScriptVm, script: &str) {+ vm.eval(&format!(+ "globalThis.__clipboardStorageResult = 'pending'; ({script}).then(\+ result => globalThis.__clipboardStorageResult = result, \+ error => globalThis.__clipboardStorageResult = String(error));"+ ))+ .expect("clipboard probe should evaluate");+ vm.eval("0").expect("clipboard promises should drain");+ assert_eq!(+ vm.eval("globalThis.__clipboardStorageResult")+ .expect("clipboard result should evaluate"),+ "ok"+ );+}++#[test]+fn clipboard_storage_reads_new_items_and_blobs_from_byte_snapshots() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(&mut vm, CLIPBOARD_SNAPSHOT_PROBE);+}++#[test]+fn clipboard_storage_detached_handles_cannot_access_shared_data() {+ let mut vm = new_parsed_test_vm(+ "https://clipboard-storage.test/",+ "<!doctype html><body></body>",+ );+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const frame = document.createElement('iframe');+ document.body.append(frame);+ const stale = frame.contentWindow.navigator.clipboard;+ const item = new frame.contentWindow.ClipboardItem({'text/plain': 'stale item'});+ await navigator.clipboard.writeText('good');+ frame.remove();+ const operations = {+ read: () => stale.read(),+ readText: () => stale.readText(),+ write: () => stale.write([item]),+ writeText: () => stale.writeText('stale text')+ };+ for (const [name, operation] of Object.entries(operations)) {+ if (operation() !== undefined) return name + ' returned a Promise for a detached realm';+ }+ if (await navigator.clipboard.readText() !== 'good') return 'detached handle changed shared data';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_detached_pending_writes_do_not_commit_or_settle() {+ let mut vm = new_parsed_test_vm(+ "https://clipboard-storage.test/",+ "<!doctype html><body></body>",+ );+ vm.eval(+ r#"+ navigator.clipboard.writeText('good');+ globalThis.clipboardWriteOutcomes = [];+ for (const reject of [false, true]) {+ const frame = document.createElement('iframe');+ document.body.append(frame);+ let settle;+ const data = new Promise((resolve, fail) => settle = reject ? fail : resolve);+ const item = new frame.contentWindow.ClipboardItem({'text/plain': data});+ const index = clipboardWriteOutcomes.push('pending') - 1;+ frame.contentWindow.navigator.clipboard.write([item]).then(+ () => clipboardWriteOutcomes[index] = 'resolved',+ error => clipboardWriteOutcomes[index] = error.name+ );+ frame.remove();+ settle(reject ? Error('retired representation') : 'stale text');+ }+ "#,+ )+ .expect("detached writes should not throw synchronously");+ // eval drains microtasks, including representation validation and commit.+ assert_eq!(+ vm.eval("clipboardWriteOutcomes.join(',')")+ .expect("detached write outcomes"),+ "pending,pending"+ );+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => (await navigator.clipboard.readText()) === 'good' ? 'ok' : 'detached write committed')()+"#,+ );+}++#[test]+fn clipboard_storage_rechecks_realm_after_argument_conversion() {+ let mut vm = new_parsed_test_vm(+ "https://clipboard-storage.test/",+ "<!doctype html><body></body>",+ );+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ await navigator.clipboard.writeText('good');+ for (const method of ['writeText', 'write', 'read']) {+ const frame = document.createElement('iframe');+ document.body.append(frame);+ const clipboard = frame.contentWindow.navigator.clipboard;+ const item = new frame.contentWindow.ClipboardItem({'text/plain': 'stale item'});+ const argumentsByMethod = {+ writeText: {toString() {frame.remove(); return 'stale text';}},+ write: {[Symbol.iterator]: function* () {yield item; frame.remove();}},+ read: {get unsanitized() {frame.remove(); return ['invalid-format'];}}+ };+ if (clipboard[method](argumentsByMethod[method]) !== undefined) return method + ' used a retired realm';+ }+ if (await navigator.clipboard.readText() !== 'good') return 'argument conversion allowed a stale commit';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_read_text_selects_plain_text_representation() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const clipboard = navigator.clipboard;+ await clipboard.write([new ClipboardItem({'text/html': '<b>text</b>', 'text/plain': 'text'})]);+ if (await clipboard.readText() !== 'text') return 'wrong representation';+ await clipboard.write([new ClipboardItem({'text/html': '<b>html only</b>'})]);+ if (await clipboard.readText() !== '') return 'missing plain text was not empty';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_waits_for_all_representations_and_preserves_data_after_rejection() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const clipboard = navigator.clipboard;+ await clipboard.writeText('before');+ let resolve;+ const pending = new Promise(done => resolve = done);+ const write = clipboard.write([new ClipboardItem({+ 'text/plain': Promise.resolve('after'), 'text/html': pending+ })]);+ if (await clipboard.readText() !== 'before') return 'partially committed write';+ resolve(new Blob(['<b>after</b>'], {type: 'text/html'}));+ await write;+ const item = (await clipboard.read())[0];+ if (item.types.join(',') !== 'text/plain,text/html') return 'representation order';+ if (await clipboard.readText() !== 'after' ||+ await (await item.getType('text/html')).text() !== '<b>after</b>') return 'representation bytes';+ try {+ await clipboard.write([new ClipboardItem({+ 'text/plain': 'bad replacement',+ 'text/html': new Blob(['wrong type'], {type: 'text/plain'})+ })]);+ return 'accepted mismatched representation';+ } catch (error) {+ if (error.name !== 'NotAllowedError') return 'wrong rejection';+ }+ if (await clipboard.readText() !== 'after') return 'failed write replaced clipboard';+ const sentinel = Error('rejected representation');+ let reject;+ const rejection = new Promise((_, fail) => reject = fail);+ const failedWrite = clipboard.write([new ClipboardItem({'text/plain': rejection})]);+ reject(sentinel);+ try {await failedWrite; return 'accepted rejected representation';}+ catch (error) {if (error !== sentinel) return 'replaced rejection reason';}+ if (await clipboard.readText() !== 'after') return 'rejection cleared clipboard';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_overlapping_writes_commit_independently() {+ // Mirror Chromium's independent ClipboardPromise commits, including older+ // calls that finish last.+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const clipboard = navigator.clipboard;+ for (const method of ['writeText', 'write']) {+ let resolve;+ let result = 'pending';+ const older = clipboard.write([new ClipboardItem({+ 'text/plain': new Promise(done => resolve = done)+ })]).then(() => result = 'resolved', error => result = error.name);+ if (method === 'writeText') await clipboard.writeText('newer');+ else await clipboard.write([new ClipboardItem({'text/plain': 'newer'})]);+ if (result !== 'pending') return method + ' settled an independent write';+ if (await clipboard.readText() !== 'newer') return method + ' did not commit';++ resolve('older');+ await older;+ if (result !== 'resolved') return 'older write rejected after ' + method;+ if (await clipboard.readText() !== 'older') return 'last completed write did not commit';+ }+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_failed_newer_write_does_not_cancel_pending_write() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const clipboard = navigator.clipboard;+ await clipboard.writeText('initial');+ let resolve;+ let result = 'pending';+ const older = clipboard.write([new ClipboardItem({+ 'text/plain': new Promise(done => resolve = done)+ })]).then(() => result = 'resolved', error => result = error.name);+ const sentinel = Error('newer representation rejected');+ try {+ await clipboard.write([new ClipboardItem({'text/plain': Promise.reject(sentinel)})]);+ return 'accepted rejected representation';+ } catch (error) {+ if (error !== sentinel) return 'replaced rejection reason';+ }+ if (result !== 'pending') return 'failed newer write settled an independent write';+ if (await clipboard.readText() !== 'initial') return 'failed write changed clipboard';++ resolve('older');+ await older;+ if (result !== 'resolved') return 'older write rejected after failed newer write';+ if (await clipboard.readText() !== 'older') return 'older write did not commit';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_overlapping_child_realm_writes_commit_independently() {+ let mut vm = new_parsed_test_vm(+ "https://clipboard-storage.test/",+ "<!doctype html><body></body>",+ );+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const frame = document.createElement('iframe');+ document.body.append(frame);+ const child = frame.contentWindow;++ for (const [olderRealm, newerRealm] of [[window, child], [child, window]]) {+ let resolve;+ let result = 'pending';+ const older = olderRealm.navigator.clipboard.write([new olderRealm.ClipboardItem({+ 'text/plain': new olderRealm.Promise(done => resolve = done)+ })]).then(() => result = 'resolved', error => result = error.name);+ await newerRealm.navigator.clipboard.writeText('newer realm');+ if (result !== 'pending') return 'cross-realm write settled an independent write';+ if (await olderRealm.navigator.clipboard.readText() !== 'newer realm') return 'newer realm did not commit';++ resolve('older realm');+ await older;+ if (result !== 'resolved') return 'older realm write rejected';+ if (await newerRealm.navigator.clipboard.readText() !== 'older realm') return 'older realm did not commit';+ }+ return 'ok';+})()+"#,+ );+}++const CLIPBOARD_FRAME_PROBE: &str = r#"+(async () => {+ const frame = document.createElement('iframe');+ const loaded = new Promise(resolve => frame.onload = resolve);+ document.body.append(frame);+ await loaded;+ const child = frame.contentWindow;+ frame.focus();+ await navigator.clipboard.writeText('parent → child');+ if (await child.navigator.clipboard.readText() !== 'parent → child') return 'parent write invisible';+ const childItem = (await child.navigator.clipboard.read())[0];+ const childBlob = await childItem.getType('text/plain');+ if (!(childItem instanceof child.ClipboardItem) || !(childBlob instanceof child.Blob)) return 'child realm';+ await child.navigator.clipboard.write([new child.ClipboardItem({+ 'text/plain': new child.Blob(['child → parent'], {type: 'text/plain'})+ })]);+ if (await navigator.clipboard.readText() !== 'child → parent') return 'child write invisible';+ const parentItem = (await navigator.clipboard.read())[0];+ if (!(parentItem instanceof ClipboardItem) || !((await parentItem.getType('text/plain')) instanceof Blob)) {+ return 'parent realm';+ }+ document.body.tabIndex = 0;+ document.body.focus();+ frame.remove();+ if (await navigator.clipboard.readText() !== 'child → parent') return 'frame removal cleared clipboard';+ return 'ok';+})()+"#;++#[test]+fn clipboard_storage_is_shared_with_child_realms() {+ let mut vm = new_parsed_test_vm(+ "https://clipboard-storage.test/",+ "<!doctype html><body></body>",+ );+ // The synchronous VM fixture does not run the frame's later load task.+ let script = CLIPBOARD_FRAME_PROBE.replace(" await loaded;", " void loaded;");+ assert_clipboard_probe(&mut vm, &script);+}++fn clipboard_permission(+ name: &str,+ setting: &str,+) -> crate::protocol_types::PermissionOverrideRegistration {+ crate::protocol_types::PermissionOverrideRegistration {+ permission: serde_json::json!({"name": name}),+ setting: setting.to_owned(),+ origin: Some("https://clipboard-storage.test".to_owned()),+ embedded_origin: None,+ }+}++#[test]+fn clipboard_storage_respects_independent_read_and_write_permission_denials() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ vm.set_permission_overrides(&[clipboard_permission("clipboard-read", "denied")]);+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ await navigator.clipboard.writeText('write still allowed');+ for (const operation of ['read', 'readText']) {+ try {await navigator.clipboard[operation](); return 'allowed denied ' + operation;}+ catch (error) {if (error.name !== 'NotAllowedError') return 'read error';}+ }+ return 'ok';+})()+"#,+ );+ vm.set_permission_overrides(&[clipboard_permission("clipboard-write", "denied")]);+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => {+ const writes = [+ () => navigator.clipboard.writeText('denied replacement'),+ () => navigator.clipboard.write([new ClipboardItem({'text/plain': 'denied replacement'})])+ ];+ for (const write of writes) {+ try {await write(); return 'allowed denied write';}+ catch (error) {if (error.name !== 'NotAllowedError') return 'write error';}+ }+ if (await navigator.clipboard.readText() !== 'write still allowed') return 'denied write changed data';+ const item = (await navigator.clipboard.read())[0];+ if (await (await item.getType('text/plain')).text() !== 'write still allowed') return 'read denied by write permission';+ return 'ok';+})()+"#,+ );+}++#[test]+fn clipboard_storage_rechecks_write_permission_after_pending_data_settles() {+ let mut vm = new_storage_test_vm("https://clipboard-storage.test/");+ vm.eval(+ r#"+ navigator.clipboard.writeText('before revocation');+ const pending = new Promise(resolve => globalThis.__clipboardResolve = resolve);+ navigator.clipboard.write([new ClipboardItem({'text/plain': pending})]).then(+ () => globalThis.__clipboardWriteResult = 'accepted',+ error => globalThis.__clipboardWriteResult = error.name+ );+ "#,+ )+ .expect("pending clipboard write should start");+ vm.set_permission_overrides(&[clipboard_permission("clipboard-write", "denied")]);+ vm.eval("__clipboardResolve('after revocation')")+ .expect("clipboard data should settle");+ assert_eq!(+ vm.eval("__clipboardWriteResult").expect("write result"),+ "NotAllowedError"+ );+ assert_clipboard_probe(+ &mut vm,+ r#"+(async () => (await navigator.clipboard.readText()) === 'before revocation' ? 'ok' : 'revoked write committed')()+"#,+ );+}++#[tokio::test(flavor = "current_thread")]+async fn clipboard_storage_overlapping_page_writes_commit_independently() {+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())+ .expect("clipboard test loader");+ let owner = crate::runtime::RendererBrowserContextRuntime::new();+ let new_page = || {+ crate::runtime::PageVmTaskExecutorTestHarness::new_with_browser_context_runtime(+ url::Url::parse("https://clipboard-storage.test/").expect("clipboard URL"),+ &loader,+ owner.handle(),+ )+ };+ let mut older_page = new_page();+ older_page+ .eval(+ r#"+ navigator.clipboard.writeText('initial');+ const pending = new Promise(resolve => globalThis.__clipboardResolve = resolve);+ globalThis.__clipboardWriteResult = 'pending';+ navigator.clipboard.write([new ClipboardItem({'text/plain': pending})]).then(+ () => globalThis.__clipboardWriteResult = 'resolved',+ error => globalThis.__clipboardWriteResult = error.name+ );+ "#,+ )+ .expect("older page clipboard write should start");++ let mut newer_page = new_page();+ assert_clipboard_probe(+ &mut newer_page,+ r#"+(async () => {+ await navigator.clipboard.writeText('newer page');+ if (await navigator.clipboard.readText() !== 'newer page') return 'newer page did not commit';+ return 'ok';+})()+"#,+ );++ assert_eq!(+ older_page+ .eval("globalThis.__clipboardWriteResult")+ .expect("older write should remain pending"),+ "pending"+ );+ older_page+ .eval("__clipboardResolve('older page')")+ .expect("older page clipboard data should settle");+ assert_eq!(+ older_page+ .eval("globalThis.__clipboardWriteResult")+ .expect("older write result"),+ "resolved"+ );+ assert_clipboard_probe(+ &mut newer_page,+ r#"+(async () => (await navigator.clipboard.readText()) === 'older page' ? 'ok' : 'older page did not commit')()+"#,+ );+}++#[tokio::test(flavor = "current_thread")]+async fn clipboard_storage_survives_page_teardown_and_keeps_browser_contexts_separate() {+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default())+ .expect("clipboard test loader");+ let owner = crate::runtime::RendererBrowserContextRuntime::new();+ let new_page = || {+ crate::runtime::PageVmTaskExecutorTestHarness::new_with_browser_context_runtime(+ url::Url::parse("https://clipboard-storage.test/").expect("clipboard URL"),+ &loader,+ owner.handle(),+ )+ };+ {+ let mut page = new_page();+ assert_clipboard_probe(+ &mut page,+ r#"+(async () => {+ await navigator.clipboard.write([new ClipboardItem({+ 'text/plain': new Blob(['survives teardown'], {type: 'text/plain'}),+ 'image/png': new Blob([Uint8Array.from(atob('iVBORw0KGgoAAAANSUhEUgAAABkAAAAZCAIAAABLixI0AAAAJklEQVR4nGJg+M9ANTRq1qhZo2aNmjVq1qhZo2ZhIAAAAAD//wMA1XBuro0zsokAAAAASUVORK5CYII='), ch => ch.charCodeAt(0))], {type: 'image/png'})+ })]);+ return 'ok';+})()+"#,+ );+ }+ let mut replacement = new_page();+ assert_clipboard_probe(+ &mut replacement,+ r#"+(async () => {+ if (await navigator.clipboard.readText() !== 'survives teardown') return 'lost page data';+ const item = (await navigator.clipboard.read())[0];+ const blob = await item.getType('image/png');+ if (!(item instanceof ClipboardItem) || !(blob instanceof Blob)) return 'retired realm';+ const expected = Uint8Array.from(atob('iVBORw0KGgoAAAANSUhEUgAAABkAAAAZCAIAAABLixI0AAAAJklEQVR4nGJg+M9ANTRq1qhZo2aNmjVq1qhZo2ZhIAAAAAD//wMA1XBuro0zsokAAAAASUVORK5CYII='), ch => ch.charCodeAt(0));+ if (Array.from(new Uint8Array(await blob.arrayBuffer())).join(',') !== expected.join(',')) return 'binary data';+ return 'ok';+})()+"#,+ );+ let mut separate = new_storage_test_vm("https://clipboard-storage.test/");+ assert_clipboard_probe(+ &mut separate,+ r#"+(async () => {+ if (await navigator.clipboard.readText() !== '' || (await navigator.clipboard.read()).length !== 0) {+ return 'another browser context clipboard';+ }+ return 'ok';+})()+"#,+ );+}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rsindex de8e9068b..963963b24 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs@@ -8703,7 +8703,7 @@ fn async_clipboard_interfaces_are_branded_and_round_trip_text_data() {assert_eq!(vm.eval("JSON.stringify(globalThis.__asyncClipboardProbe)").expect("Async Clipboard promise result should evaluate"),- r#"{"state":"done","initialBlob":[true,"text/plain","hello"],"writtenText":"hello","read":[1,true,"opaque",false],"textWrite":[1,true,"text/plain","next"],"rejections":["TypeError","TypeError","TypeError","NotAllowedError","NotAllowedError","TypeError","NotFoundError","TypeError","NotAllowedError","NotAllowedError","TypeError"]}"#+ r#"{"state":"done","initialBlob":[true,"text/plain","hello"],"writtenText":"hello","read":[1,false,"opaque",false],"textWrite":[1,true,"text/plain","next"],"rejections":["TypeError","TypeError","TypeError","NotAllowedError","NotAllowedError","TypeError","NotFoundError","TypeError","NotAllowedError","NotAllowedError","TypeError"]}"#);}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.rsindex 7df1f0fa2..ae3505c82 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@@ -2,6 +2,7 @@ use super::*;mod broadcast_channel;mod chrome;+mod clipboard_storage;mod console;mod crypto_misc;mod crypto_subtle_aes;