diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index 64532533590..0dbb2500f73 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -339,10 +339,11 @@ pub(crate) use self::broadcast_channel::{ pub(crate) use self::canvas::{ BitmapRejection, BitmapTaskResult, Canvas2dSettings, CanvasBlobCompletion, CanvasBlobEncodeJob, CanvasBlobFile, CanvasBlobPromise, CanvasBlobTask, CanvasBlobTaskEffect, CanvasContextKind, - attach_canvas_like_context_object, build_bitmap_renderer_context, - build_canvas_rendering_context_2d_object, build_offscreen_canvas_object, - build_webgl_context_object, build_webgl2_context_object, canvas_like_to_data_url, - create_image_bitmap_callback, parse_canvas_2d_settings, + ImageBitmapClonePayload, attach_canvas_like_context_object, build_bitmap_renderer_context, + build_canvas_rendering_context_2d_object, build_image_bitmap_from_clone_payload, + build_offscreen_canvas_object, build_webgl_context_object, build_webgl2_context_object, + canvas_like_to_data_url, create_image_bitmap_callback, detach_image_bitmap, + image_bitmap_clone_payload_from_object, parse_canvas_2d_settings, reset_html_canvas_backing_store_for_dimension_assignment, settle_bitmap_task_result, }; use self::constructors::illegal_constructor_callback; diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs index 862ed2fd74c..85e87f43f64 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs @@ -118,7 +118,9 @@ pub(crate) use context2d::{ }; pub(crate) use drawing_state::install_canvas_drawing_state_bindings; pub(crate) use image_bitmap::{ - BitmapRejection, BitmapTaskResult, create_image_bitmap_callback, settle_bitmap_task_result, + BitmapRejection, BitmapTaskResult, ImageBitmapClonePayload, + build_image_bitmap_from_clone_payload, create_image_bitmap_callback, detach_image_bitmap, + image_bitmap_clone_payload_from_object, settle_bitmap_task_result, window_create_image_bitmap_callback, }; pub(crate) use objects::{build_canvas_rendering_context_2d_object, build_offscreen_canvas_object}; diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs index cefde5f60d2..b24fae9e649 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs @@ -10,6 +10,11 @@ use crate::web_api_interfaces; mod options; use options::{BitmapOptions, BitmapParameters}; +mod structured_clone; +pub(crate) use structured_clone::{ + ImageBitmapClonePayload, build_image_bitmap_from_clone_payload, + image_bitmap_clone_payload_from_object, +}; #[derive(Debug)] pub(crate) struct BitmapTaskResult { @@ -21,7 +26,7 @@ pub(crate) enum BitmapRejection { InvalidState, } -pub(super) use moli_webapi::image_bitmap::{ +pub(crate) use moli_webapi::image_bitmap::{ IMAGE_BITMAP_WIDTH_SLOT, IMAGE_BITMAP_HEIGHT_SLOT, IMAGE_BITMAP_PIXELS_SLOT, IMAGE_BITMAP_PREMULTIPLIED_SLOT, IMAGE_BITMAP_ORIGIN_CLEAN_SLOT, IMAGE_BITMAP_COLOR_SPACE_SLOT, IMAGE_BITMAP_PIXEL_FORMAT_SLOT, build_image_bitmap_object, detach_image_bitmap, install_image_bitmap_template_bindings, diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/structured_clone.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/structured_clone.rs new file mode 100644 index 00000000000..51cdfd69598 --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/structured_clone.rs @@ -0,0 +1,104 @@ +use super::{BitmapData, build_image_bitmap_from_data, image_bitmap_data, image_bitmap_snapshot}; +use crate::context_bootstrap::canvas::pixels::CanvasImage; +use crate::context_bootstrap::image_data::{ImageDataColorSpace, ImageDataPixelFormat}; +use moli_canvas::{AlphaMode, PixelBuffer, PixelFormat}; + +/// An owned bitmap snapshot; no V8 handles or sender realm survive serialization. +#[derive(Clone, Debug)] +pub(crate) struct ImageBitmapClonePayload(CanvasImage); + +impl ImageBitmapClonePayload { + pub(crate) fn write(&self, serializer: &dyn v8::ValueSerializerHelper) { + let image = &self.0; + serializer.write_uint32(image.pixels.width()); + serializer.write_uint32(image.pixels.height()); + serializer.write_uint32(match image.pixels.alpha_mode() { + AlphaMode::Straight => 0, + AlphaMode::Premultiplied => 1, + }); + serializer.write_uint32(match image.color_space { + ImageDataColorSpace::Srgb => 0, + ImageDataColorSpace::DisplayP3 => 1, + }); + serializer.write_uint32(match image.pixels.format() { + PixelFormat::Unorm8 => 0, + PixelFormat::Float16 => 1, + }); + let bytes = image.pixels.bytes(); + serializer.write_uint32(bytes.len() as u32); + serializer.write_raw_bytes(bytes); + } + + pub(crate) fn read(deserializer: &dyn v8::ValueDeserializerHelper) -> Option { + let read = || { + let mut value = 0; + deserializer.read_uint32(&mut value).then_some(value) + }; + let width = read()?; + let height = read()?; + if width == 0 || height == 0 { + return None; + } + let alpha_mode = match read()? { + 0 => AlphaMode::Straight, + 1 => AlphaMode::Premultiplied, + _ => return None, + }; + let color_space = match read()? { + 0 => ImageDataColorSpace::Srgb, + 1 => ImageDataColorSpace::DisplayP3, + _ => return None, + }; + let format = match read()? { + 0 => PixelFormat::Unorm8, + 1 => PixelFormat::Float16, + _ => return None, + }; + let length = read()? as usize; + if format.byte_len(width, height)? != length { + return None; + } + let bytes = deserializer.read_raw_bytes(length)?.to_vec(); + Some(Self(CanvasImage { + pixels: PixelBuffer::new_with_alpha_mode(width, height, format, alpha_mode, bytes)?, + color_space, + origin_clean: true, + })) + } +} + +pub(crate) fn image_bitmap_clone_payload_from_object<'s>( + scope: &mut v8::PinScope<'s, '_>, + bitmap: v8::Local<'s, v8::Object>, +) -> Option { + if !image_bitmap_data(scope, bitmap)?.origin_clean { + return None; + } + let image = image_bitmap_snapshot(scope, bitmap)?; + Some(ImageBitmapClonePayload(image)) +} + +pub(crate) fn build_image_bitmap_from_clone_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + payload: ImageBitmapClonePayload, +) -> Option> { + let image = payload.0; + let width = image.pixels.width(); + let height = image.pixels.height(); + let premultiplied = image.pixels.alpha_mode() == AlphaMode::Premultiplied; + let color_space = image.color_space; + let pixel_format = ImageDataPixelFormat::from_native(image.pixels.format()); + let pixels = image.into_view(scope)?; + build_image_bitmap_from_data( + scope, + BitmapData { + pixels, + width, + height, + premultiplied, + color_space, + pixel_format, + origin_clean: true, + }, + ) +} 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 19b6650eacf..156666c858a 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 @@ -30,7 +30,8 @@ use crate::{ build_web_transport_error_from_clone_payload, web_transport_error_clone_payload_from_object, }, structured_clone::{ - HOST_OBJECT_TAG_WEB_TRANSPORT_ERROR, read_web_transport_error_payload, + HOST_OBJECT_TAG_IMAGE_BITMAP, HOST_OBJECT_TAG_WEB_TRANSPORT_ERROR, + read_image_bitmap_payload, read_web_transport_error_payload, write_image_bitmap_payload, write_web_transport_error_payload, }, }; @@ -153,6 +154,7 @@ impl v8::ValueSerializerImpl for IndexedDbStructuredCloneSerializer { return Some(true); } } + Some("ImageBitmap") => return write_image_bitmap_payload(scope, serializer, object), Some("FileList") => { let Some(files) = file_list_files_from_object(scope, object) else { let exception = dom_exception_value( @@ -445,6 +447,7 @@ impl v8::ValueDeserializerImpl for IndexedDbStructuredCloneDeserializer<'_> { } HOST_OBJECT_TAG_IMAGE_DATA => read_image_data_payload(scope, deserializer), HOST_OBJECT_TAG_IMAGE_DATA_GRAPH => read_image_data_graph_payload(scope, deserializer), + HOST_OBJECT_TAG_IMAGE_BITMAP => read_image_bitmap_payload(scope, deserializer), HOST_OBJECT_TAG_CRYPTO_KEY => { read_crypto_key_payload(scope, deserializer).or_else(|| { let exception = dom_exception_value( diff --git a/moli-renderer-v8/src/context_bootstrap/shared/clone.rs b/moli-renderer-v8/src/context_bootstrap/shared/clone.rs index 08db647af57..90f9327a3cd 100644 --- a/moli-renderer-v8/src/context_bootstrap/shared/clone.rs +++ b/moli-renderer-v8/src/context_bootstrap/shared/clone.rs @@ -417,6 +417,24 @@ fn parse_transfer_values<'s>( } if let Ok(object) = v8::Local::::try_from(candidate) { match moli_webapi_declare::web_api_object_type(scope, object).map(|kind| kind.name()) { + Some("ImageBitmap") => { + let target = moli_webapi_declare::web_api_object_target(scope, object)?; + if seen + .iter() + .any(|existing| existing.strict_equals(target.into())) + { + operation.throw_data_clone_error( + scope, + "transfer list contains duplicate transferable entries.", + ); + return None; + } + // Closed and tainted bitmaps are checked by the transfer + // steps, after the message's observable getters have run. + seen.push(target.into()); + entries.push(WireTransfer::ImageBitmap(target)); + continue; + } Some("VideoFrame") => { if crate::context_bootstrap::video_frame::is_closed(scope, object) { operation.throw_data_clone_error( diff --git a/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.js b/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.js new file mode 100644 index 00000000000..9e98ff7b9a6 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.js @@ -0,0 +1,220 @@ +async (owner, callee, label) => { + const checks = []; + const check = async (name, run) => { + try { + await run(); + checks.push({name: label + ': ' + name, passed: true}); + } catch (error) { + checks.push({name: label + ': ' + name, passed: false, error: String(error)}); + } + }; + const assert = (value, message = 'assertion failed') => { + if (!value) throw new Error(message); + }; + const same = (actual, expected) => actual.length === expected.length && + actual.every((value, index) => Object.is(value, expected[index]) || value === expected[index]); + const throws = (run, expected = 'DataCloneError') => { + try { run(); } catch (error) { + assert(error instanceof callee.DOMException && error.name === expected, String(error)); + return; + } + throw new Error('expected ' + expected); + }; + const make = (colorSpace = 'srgb', colorType = 'unorm8') => { + const canvas = new owner.OffscreenCanvas(2, 1); + const context = canvas.getContext('2d', {colorSpace, colorType}); + const data = colorType === 'float16' + ? new owner.Float16Array([1.25, -0.25, 0.125, 0.5, 0.25, 0.5, 0.75, 1]) + : new owner.Uint8ClampedArray([17, 34, 51, 255, 255, 0, 128, 128]); + context.putImageData(new owner.ImageData(data, 2, 1, { + colorSpace, pixelFormat: colorType === 'float16' ? 'rgba-float16' : 'rgba-unorm8' + }), 0, 0); + return canvas.transferToImageBitmap(); + }; + const pixels = (bitmap, colorSpace = 'srgb', colorType = 'unorm8') => { + const context = new callee.OffscreenCanvas(2, 1).getContext('2d', {colorSpace, colorType}); + context.drawImage(bitmap, 0, 0); + return Array.from(context.getImageData(0, 0, 2, 1, { + colorSpace, pixelFormat: colorType === 'float16' ? 'rgba-float16' : 'rgba-unorm8' + }).data); + }; + for (const colorSpace of ['srgb', 'display-p3']) { + for (const colorType of ['unorm8', 'float16']) { + for (const transfer of [false, true]) { + await check(`${transfer ? 'transfer' : 'clone'} ${colorSpace} ${colorType}`, () => { + const bitmap = make(colorSpace, colorType); + const expected = pixels(bitmap, colorSpace, colorType); + const copy = callee.structuredClone(bitmap, {transfer: transfer ? [bitmap] : []}); + assert(Object.getPrototypeOf(copy) === callee.ImageBitmap.prototype, 'receiving realm'); + assert(copy.width === 2 && copy.height === 1); + assert(bitmap.width === (transfer ? 0 : 2) && bitmap.height === (transfer ? 0 : 1)); + bitmap.close(); + assert(same(pixels(copy, colorSpace, colorType), expected), 'exact pixels'); + if (colorType === 'float16') assert(expected[0] > 1 && expected[1] < 0, 'HDR gamut retained'); + copy.close(); + }); + } + } + } + await check('graph cycles and repeated identity', () => { + const bitmap = make(), graph = {first: bitmap, second: bitmap, map: new owner.Map([[bitmap, bitmap]])}; + graph.self = graph; + const copy = callee.structuredClone(graph); + assert(copy.self === copy && copy.first === copy.second && copy.map.get(copy.first) === copy.first); + assert(copy.first !== bitmap); + bitmap.close(); copy.first.close(); + }); + await check('transfer graph preserves repeated identity', () => { + const bitmap = make(), copy = callee.structuredClone([bitmap, bitmap], {transfer: [bitmap]}); + assert(copy[0] === copy[1] && copy[0].width === 2 && bitmap.width === 0); + copy[0].close(); + }); + await check('unreferenced transfers detach', () => { + const bitmap = make(); + assert(callee.structuredClone(3, {transfer: [bitmap]}) === 3 && bitmap.width === 0); + }); + await check('native slots ignore author geometry and prototype mutations', () => { + const bitmap = make(), expected = pixels(bitmap); + Object.defineProperties(bitmap, {width: {get() {throw new Error('author width');}}, height: {value: 999}}); + Object.setPrototypeOf(bitmap, null); + Object.freeze(bitmap); + const copy = callee.structuredClone(bitmap); + assert(copy.width === 2 && copy.height === 1 && same(pixels(copy), expected)); + owner.ImageBitmap.prototype.close.call(bitmap); copy.close(); + }); + await check('closed bitmap rejects ordinary cloning', () => { + const bitmap = make(); bitmap.close(); + throws(() => callee.structuredClone(bitmap)); + }); + await check('closed transfer is rejected after message serialization', () => { + const bitmap = make(); bitmap.close(); + const sentinel = new Error('getter wins'); + let caught; + try { callee.structuredClone({bitmap, get value() {throw sentinel;}}, {transfer: [bitmap]}); } + catch (error) { caught = error; } + assert(caught === sentinel); + throws(() => callee.structuredClone(bitmap, {transfer: [bitmap]})); + }); + await check('getter closes referenced transfer before transfer steps', () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4); + throws(() => callee.structuredClone({bitmap, get value() {bitmap.close(); return 1;}}, {transfer: [bitmap, buffer]})); + assert(buffer.byteLength === 4); + }); + await check('getter closes unreferenced transfer before transfer steps', () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4); + throws(() => callee.structuredClone({get value() {bitmap.close(); return 1;}}, {transfer: [bitmap, buffer]})); + assert(buffer.byteLength === 4); + }); + await check('serialization failure leaves all senders usable', () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4); + throws(() => callee.structuredClone({bitmap, bad() {}}, {transfer: [bitmap, buffer]})); + assert(bitmap.width === 2 && buffer.byteLength === 4); + bitmap.close(); + }); + await check('duplicate transfer rejects before message getters', () => { + const bitmap = make(); let reads = 0; + throws(() => callee.structuredClone({get value() {reads++;}}, {transfer: [bitmap, bitmap]})); + assert(reads === 0 && bitmap.width === 2); bitmap.close(); + }); + await check('author proxies and forged prototypes have no native brand', () => { + const bitmap = make(); let traps = 0; + const revoked = owner.Proxy.revocable(bitmap, {}); revoked.revoke(); + for (const value of [new owner.Proxy(bitmap, {get() {traps++;}}), revoked.proxy, + Object.create(bitmap), Object.create(owner.ImageBitmap.prototype)]) { + throws(() => callee.structuredClone(1, {transfer: [value]})); + } + throws(() => callee.structuredClone(new owner.Proxy(bitmap, {get() {traps++;}}))); + assert(traps === 0 && bitmap.width === 2); bitmap.close(); + }); + await check('ArrayBuffer bytes are captured after message getters', () => { + const bitmap = make(), bytes = new owner.Uint8Array([1, 2]); + const copy = callee.structuredClone({bitmap, bytes, get mutate() {bytes[0] = 42;}}, {transfer: [bitmap, bytes.buffer]}); + assert(copy.bytes[0] === 42 && copy.bitmap.width === 2 && bytes.byteLength === 0); + copy.bitmap.close(); + }); + await check('detached ArrayBuffer is checked after message getters', () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4), sentinel = new Error('getter wins'); + owner.structuredClone(buffer, {transfer: [buffer]}); + let caught; + try { callee.structuredClone({bitmap, get value() {throw sentinel;}}, {transfer: [buffer, bitmap]}); } + catch (error) { caught = error; } + assert(caught === sentinel && bitmap.width === 2); + bitmap.close(); + }); + await check('getter detaches ArrayBuffer before mixed transfer steps', () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4); + throws(() => callee.structuredClone({bitmap, get value() { + owner.structuredClone(buffer, {transfer: [buffer]}); return 1; + }}, {transfer: [buffer, bitmap]})); + assert(bitmap.width === 2); + bitmap.close(); + }); + for (const bufferFirst of [false, true]) { + await check('transfer failure respects list order: buffer first ' + bufferFirst, () => { + const bitmap = make(), buffer = new owner.ArrayBuffer(4); bitmap.close(); + throws(() => callee.structuredClone({bitmap}, {transfer: bufferFirst ? [buffer, bitmap] : [bitmap, buffer]})); + assert(buffer.byteLength === (bufferFirst ? 0 : 4)); + }); + } + await check('MessageChannel round trip clones and transfers', async () => { + const {port1, port2} = new owner.MessageChannel(); + try { + for (const transfer of [false, true]) { + const bitmap = make('display-p3', 'float16'), expected = pixels(bitmap, 'display-p3', 'float16'); + const received = new Promise(resolve => {port2.onmessage = event => resolve(event.data);}); + port1.postMessage([bitmap, bitmap], transfer ? [bitmap] : []); + const copy = await received; + assert(copy[0] === copy[1] && same(pixels(copy[0], 'display-p3', 'float16'), expected)); + assert(bitmap.width === (transfer ? 0 : 2)); + bitmap.close(); copy[0].close(); + } + } finally { port1.close(); port2.close(); } + }); + await check('IndexedDB stores independent bitmap snapshots', async () => { + const request = req => new Promise((resolve, reject) => { + req.onsuccess = () => resolve(req.result); + req.onerror = () => reject(req.error); + }); + const name = 'bitmap-clone-' + label; + const open = owner.indexedDB.open(name, 1); + open.onupgradeneeded = () => open.result.createObjectStore('bitmaps'); + const database = await request(open); + try { + const bitmap = make('display-p3', 'float16'), expected = pixels(bitmap, 'display-p3', 'float16'); + const transaction = database.transaction('bitmaps', 'readwrite'); + const complete = new Promise((resolve, reject) => { + transaction.oncomplete = resolve; + transaction.onabort = () => reject(transaction.error); + }); + transaction.objectStore('bitmaps').put([bitmap, bitmap], 'bitmap'); + bitmap.close(); + await complete; + const store = database.transaction('bitmaps').objectStore('bitmaps'); + const first = request(store.get('bitmap')), second = request(store.get('bitmap')); + const [a, b] = await Promise.all([first, second]); + assert(a[0] === a[1] && b[0] === b[1] && a[0] !== b[0]); + assert(Object.getPrototypeOf(a[0]) === owner.ImageBitmap.prototype); + a[0].close(); + assert(same(pixels(b[0], 'display-p3', 'float16'), expected)); + b[0].close(); + } finally { database.close(); await request(owner.indexedDB.deleteDatabase(name)); } + }); + if (typeof owner.document !== 'undefined') { + await check('structuredClone uses the receiving Window realm', () => { + const bitmap = make(); + const copy = callee.structuredClone.call(owner, bitmap); + assert(Object.getPrototypeOf(copy) === owner.ImageBitmap.prototype); + bitmap.close(); copy.close(); + }); + await check('history storage preserves bitmap data and graph identity', () => { + const bitmap = make('display-p3', 'float16'), expected = pixels(bitmap, 'display-p3', 'float16'); + owner.history.replaceState([bitmap, bitmap], ''); + bitmap.close(); + const copy = owner.history.state; + assert(copy[0] === copy[1] && Object.getPrototypeOf(copy[0]) === owner.ImageBitmap.prototype); + assert(same(pixels(copy[0], 'display-p3', 'float16'), expected)); + copy[0].close(); owner.history.replaceState(null, ''); + }); + } + return checks; +} diff --git a/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.rs b/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.rs new file mode 100644 index 00000000000..329f4ddc8ae --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/image_bitmap_clone.rs @@ -0,0 +1,143 @@ +use super::*; +use std::time::{Duration, Instant}; +use v8::{ValueDeserializerHelper, ValueSerializerHelper}; + +#[test] +fn image_bitmap_clone_rejects_malformed_pixel_records_before_allocation() { + struct Delegate; + impl v8::ValueSerializerImpl for Delegate { + fn throw_data_clone_error<'s>( + &self, + _scope: &mut v8::PinScope<'s, '_>, + _message: v8::Local<'s, v8::String>, + ) { + panic!("raw record setup must not throw"); + } + } + impl v8::ValueDeserializerImpl for Delegate {} + let mut vm = new_storage_page_task_executor_test_vm("https://bitmap-clone.test/"); + let context_ptr = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let context = scope.get_current_context(); + for header in [ + vec![], + vec![0, 1, 0, 0, 0, 0], + vec![1, 1, 2, 0, 0, 4], + vec![1, 1, 0, 2, 0, 4], + vec![1, 1, 0, 0, 2, 4], + vec![1, 1, 0, 0, 0, 3], + vec![1, 1, 0, 0, 1, 4], + vec![u32::MAX, u32::MAX, 0, 0, 1, 0], + vec![1, 1, 0, 0, 0, 4], + ] { + let serializer = v8::ValueSerializer::new(scope, Box::new(Delegate)); + serializer.write_header(); + for value in &header { + serializer.write_uint32(*value); + } + let bytes = serializer.release(); + let deserializer = v8::ValueDeserializer::new(scope, Box::new(Delegate), &bytes); + assert_eq!(deserializer.read_header(context), Some(true)); + assert!( + crate::context_bootstrap::ImageBitmapClonePayload::read(&deserializer).is_none(), + "{header:?}" + ); + } + Ok(()) + }) + .unwrap(); +} + +#[test] +fn image_bitmap_clone_payload_and_transfer_lists_use_native_identity_and_intrinsic_prototypes() { + let mut vm = new_storage_page_task_executor_test_vm("https://bitmap-clone.test/"); + vm.eval("const canvas=new OffscreenCanvas(2,1);canvas.getContext('2d');globalThis.bitmap=canvas.transferToImageBitmap()") + .unwrap(); + let context_ptr = &vm.current_main_world().unwrap().context as *const _; + vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| { + let global = scope.get_current_context().global(scope); + let key = crate::util::v8str(scope, "bitmap"); + let bitmap = + v8::Local::::try_from(global.get(scope, key.into()).unwrap()).unwrap(); + let handler = crate::util::new_null_prototype_object(scope); + let proxy = v8::Proxy::new(scope, bitmap, handler).unwrap(); + moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap(); + let payload = + crate::context_bootstrap::image_bitmap_clone_payload_from_object(scope, proxy.into()) + .unwrap(); + let copy = crate::context_bootstrap::build_image_bitmap_from_clone_payload(scope, payload) + .unwrap(); + let key = crate::util::v8str(scope, "nativeBitmapCopy"); + assert_eq!( + global.create_data_property(scope, key.into(), copy.into()), + Some(true) + ); + let key = crate::util::v8str(scope, "bitmapProxy"); + assert_eq!( + global.create_data_property(scope, key.into(), proxy.into()), + Some(true) + ); + Ok(()) + }) + .unwrap(); + assert_eq!(vm.eval(r#"(() => { + let reads=0,error; + try{structuredClone({get value(){reads++;}},{transfer:[bitmapProxy,bitmap]});} + catch(caught){error=caught;} + return error instanceof DOMException&&error.name==='DataCloneError'&&reads===0&&bitmap.width===2; + })()"#).unwrap(),"true"); + assert_eq!( + vm.eval( + r#"(() => { + const copy=structuredClone(bitmap); + return copy.width===2&&bitmapProxy.width===2&© instanceof ImageBitmap&&nativeBitmapCopy.width===2; + })()"# + ) + .unwrap(), + "true" + ); + assert_eq!(vm.eval(r#"(() => { + const prototype=ImageBitmap.prototype; + globalThis.ImageBitmap=function(){throw Error('author constructor');}; + const copy=structuredClone(bitmap,{transfer:[bitmapProxy]}); + return copy.width===2&&Object.getPrototypeOf(copy)===prototype&&bitmap.width===0&&bitmapProxy.width===0; + })()"#).unwrap(),"true"); +} + +#[tokio::test(flavor = "current_thread")] +async fn image_bitmap_clone_and_transfer_preserve_pixels_lifetime_and_receiving_realms() { + let mut vm = new_storage_page_task_executor_test_vm("https://bitmap-clone.test/"); + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + vm.eval("document.body.innerHTML=''") + .unwrap(); + vm.eval(&format!( + r#"(async () => {{ + const probe={}, realms=[globalThis,document.getElementById('child').contentWindow], checks=[]; + for(let owner=0;owner<2;owner++)for(let callee=0;callee<2;callee++) + checks.push(...await probe(realms[owner],realms[callee],owner+'-'+callee)); + globalThis.__bitmapClones=checks; + }})().catch(error=>globalThis.__bitmapClones=String(error));"#, + include_str!("image_bitmap_clone.js") + )) + .unwrap(); + let deadline = Instant::now() + Duration::from_secs(30); + while vm.eval("typeof __bitmapClones").unwrap() == "undefined" { + vm.run_one_oldest_ready_page_task_executor_turn(&loader) + .await + .unwrap(); + assert!(Instant::now() < deadline, "bitmap clone contract timed out"); + tokio::time::sleep(Duration::from_millis(1)).await; + } + assert_eq!( + vm.eval("Array.isArray(__bitmapClones)").unwrap(), + "true", + "{}", + vm.eval("JSON.stringify(__bitmapClones)").unwrap() + ); + assert_eq!(vm.eval("__bitmapClones.length").unwrap(), "112"); + assert_eq!( + vm.eval("JSON.stringify(__bitmapClones.filter(row=>!row.passed))") + .unwrap(), + "[]" + ); +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 1e42c660416..af97f7be36f 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -2344,6 +2344,7 @@ mod device_events; mod document_location_materialization; mod document_shadow_handler_receivers; mod document_svg_root; +mod image_bitmap_clone; mod image_bitmap_tasks; mod image_data_native; mod payment_events; diff --git a/moli-renderer-v8/src/structured_clone.rs b/moli-renderer-v8/src/structured_clone.rs index cc7e477f8fc..b77a1001bb5 100644 --- a/moli-renderer-v8/src/structured_clone.rs +++ b/moli-renderer-v8/src/structured_clone.rs @@ -14,27 +14,29 @@ use crate::{ context_bootstrap::{ CryptoKeyAlgorithmClonePayload, CryptoKeyClonePayload, EncodedVideoChunkClonePayload, EncodedVideoChunkType, FileSystemFileSnapshotClonePayload, FileSystemHandleClonePayload, - GeometryClonePayload, ImageDataClonePayload, ReadableStreamClonePayload, - TransferredMessagePort, TransformStreamClonePayload, WritableStreamClonePayload, - attach_file_system_file_snapshot_clone_payload, build_dom_exception_object, - build_encoded_video_chunk_from_clone_payload, build_file_list_object, - build_file_system_handle_from_clone_payload, build_geometry_object_from_clone_payload, - build_geometry_quad_from_cloned_points, build_image_data_object_from_clone_payload, + GeometryClonePayload, ImageBitmapClonePayload, ImageDataClonePayload, + ReadableStreamClonePayload, TransferredMessagePort, TransformStreamClonePayload, + WritableStreamClonePayload, attach_file_system_file_snapshot_clone_payload, + build_dom_exception_object, build_encoded_video_chunk_from_clone_payload, + build_file_list_object, build_file_system_handle_from_clone_payload, + build_geometry_object_from_clone_payload, build_geometry_quad_from_cloned_points, + build_image_bitmap_from_clone_payload, build_image_data_object_from_clone_payload, build_image_data_object_from_legacy_bytes, build_quota_exceeded_error_object, build_readable_stream_clone_shell, build_transform_stream_clone_shell, build_writable_stream_clone_shell, crypto_key_clone_payload_from_object, - crypto_key_object_from_clone_payload, detach_message_port_owner_for_transfer, - detach_transferred_message_port, discard_message_port_channel, dom_exception_clone_fields, + crypto_key_object_from_clone_payload, detach_image_bitmap, + detach_message_port_owner_for_transfer, detach_transferred_message_port, + discard_message_port_channel, dom_exception_clone_fields, encoded_video_chunk_clone_payload_from_object, ensure_message_port_wrapper_for_id, file_list_files_from_object, file_system_file_snapshot_clone_payload_from_object, file_system_handle_clone_payload_from_object, geometry_clone_payload_from_object, - geometry_quad_clone_points, image_data_clone_payload_from_object, - initialize_readable_stream_clone_shell, initialize_transform_stream_clone_shell, - initialize_writable_stream_clone_shell, message_port_transfer_from_object, - new_disconnected_message_port_object, new_dom_exception_value, - prepare_readable_stream_transfer, prepare_transform_stream_transfer, - prepare_writable_stream_transfer, quota_exceeded_error_clone_fields, - require_internal_stream_value, + geometry_quad_clone_points, image_bitmap_clone_payload_from_object, + image_data_clone_payload_from_object, initialize_readable_stream_clone_shell, + initialize_transform_stream_clone_shell, initialize_writable_stream_clone_shell, + message_port_transfer_from_object, new_disconnected_message_port_object, + new_dom_exception_value, prepare_readable_stream_transfer, + prepare_transform_stream_transfer, prepare_writable_stream_transfer, + quota_exceeded_error_clone_fields, require_internal_stream_value, }, types::MessagePortId, }; @@ -62,6 +64,8 @@ const HOST_OBJECT_TAG_RTC_ENCODED_AUDIO_FRAME: u32 = 16; const HOST_OBJECT_TAG_RTC_ENCODED_VIDEO_FRAME: u32 = 17; const HOST_OBJECT_TAG_RTC_CERTIFICATE: u32 = 18; pub(crate) const HOST_OBJECT_TAG_IMAGE_DATA_GRAPH: u32 = 19; +pub(crate) const HOST_OBJECT_TAG_IMAGE_BITMAP: u32 = 20; +const HOST_OBJECT_TAG_TRANSFERRED_IMAGE_BITMAP: u32 = 21; const HOST_OBJECT_TAG_TRANSFERRED_MESSAGE_PORT: u32 = 22; const GEOMETRY_KIND_DOM_POINT_READONLY: u32 = 0; @@ -84,6 +88,7 @@ pub(crate) struct V8StructuredClonePayload { blobs: Vec, file_system_handles: Vec, rtc_certificates: Vec, + image_bitmaps: Vec, pub(crate) metadata: StructuredCloneMetadata, } @@ -464,6 +469,7 @@ struct WireSerializer { allowed_readable_streams: Vec>, allowed_writable_streams: Vec>, allowed_transform_streams: Vec>, + transferred_image_bitmaps: Vec>, policy: StructuredClonePolicy, wasm_modules: Rc>, blobs: Rc>, @@ -586,6 +592,20 @@ impl v8::ValueSerializerImpl for WireSerializer { return write_image_data_payload(scope, serializer, payload); } } + Some("ImageBitmap") => { + let target = moli_webapi_declare::web_api_object_target(scope, object)?; + if let Some(index) = self + .transferred_image_bitmaps + .iter() + .position(|bitmap| v8::Local::new(scope, bitmap).strict_equals(target.into())) + { + // Transfer steps run after the entire message is serialized. + serializer.write_uint32(HOST_OBJECT_TAG_TRANSFERRED_IMAGE_BITMAP); + serializer.write_uint32(index as u32); + return Some(true); + } + return write_image_bitmap_payload(scope, serializer, target); + } Some("VideoFrame") => { if self.policy == StructuredClonePolicy::Storage { throw_data_clone_exception(scope, "VideoFrame cannot be stored."); @@ -848,6 +868,7 @@ struct WireDeserializer { blob_objects: RefCell>>, file_system_handles: HashMap, rtc_certificates: HashMap, + image_bitmaps: Vec, } impl WireDeserializer { @@ -920,6 +941,17 @@ impl v8::ValueDeserializerImpl for WireDeserializer { } HOST_OBJECT_TAG_IMAGE_DATA => read_image_data_payload(scope, deserializer), HOST_OBJECT_TAG_IMAGE_DATA_GRAPH => read_image_data_graph_payload(scope, deserializer), + HOST_OBJECT_TAG_IMAGE_BITMAP => read_image_bitmap_payload(scope, deserializer), + HOST_OBJECT_TAG_TRANSFERRED_IMAGE_BITMAP => { + let payload = read_u32(deserializer) + .and_then(|index| self.image_bitmaps.get(index as usize).cloned()); + payload + .and_then(|payload| build_image_bitmap_from_clone_payload(scope, payload)) + .or_else(|| { + throw_data_clone_exception(scope, "Failed to deserialize ImageBitmap."); + None + }) + } HOST_OBJECT_TAG_VIDEO_FRAME => { let info = read_raw_vec(deserializer) .and_then(|bytes| serde_json::from_slice(&bytes).ok()); @@ -1223,6 +1255,35 @@ pub(crate) fn build_blob_object_from_clone_payload<'s>( } } +pub(crate) fn write_image_bitmap_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + serializer: &dyn v8::ValueSerializerHelper, + bitmap: v8::Local<'s, v8::Object>, +) -> Option { + let Some(payload) = image_bitmap_clone_payload_from_object(scope, bitmap) else { + throw_data_clone_exception( + scope, + "A closed or non-origin-clean ImageBitmap cannot be cloned.", + ); + return None; + }; + serializer.write_uint32(HOST_OBJECT_TAG_IMAGE_BITMAP); + payload.write(serializer); + Some(true) +} + +pub(crate) fn read_image_bitmap_payload<'s>( + scope: &mut v8::PinScope<'s, '_>, + deserializer: &dyn v8::ValueDeserializerHelper, +) -> Option> { + ImageBitmapClonePayload::read(deserializer) + .and_then(|payload| build_image_bitmap_from_clone_payload(scope, payload)) + .or_else(|| { + throw_data_clone_exception(scope, "Failed to deserialize ImageBitmap."); + None + }) +} + pub(crate) fn write_image_data_payload<'s>( scope: &mut v8::PinScope<'s, '_>, serializer: &dyn v8::ValueSerializerHelper, @@ -1695,6 +1756,7 @@ pub(crate) enum WireTransfer<'s> { WritableStream(v8::Local<'s, v8::Object>), TransformStream(v8::Local<'s, v8::Object>), VideoFrame(v8::Local<'s, v8::Object>), + ImageBitmap(v8::Local<'s, v8::Object>), } #[derive(Default)] @@ -1781,6 +1843,18 @@ impl<'s> PreparedStructuredClone<'s> { WireTransfer::VideoFrame(frame) => { crate::context_bootstrap::video_frame::close_object(scope, frame); } + WireTransfer::ImageBitmap(bitmap) => { + let Some(payload) = image_bitmap_clone_payload_from_object(scope, bitmap) + else { + throw_data_clone_exception( + scope, + "A closed or non-origin-clean ImageBitmap cannot be transferred.", + ); + return None; + }; + self.payload.image_bitmaps.push(payload); + detach_image_bitmap(scope, bitmap); + } WireTransfer::MessagePort(_) => {} WireTransfer::ReadableStream(stream) => { let prepared = prepare_readable_stream_transfer(scope, stream)?; @@ -1888,6 +1962,7 @@ fn prepare_for_wire_with_policy<'s>( let mut writable_stream_transfers = Vec::new(); let mut transform_stream_transfers = Vec::new(); let mut video_frame_transfers = Vec::new(); + let mut image_bitmap_transfers = Vec::new(); for transfer in transfers.entries { match *transfer { WireTransfer::ArrayBuffer(buffer) => array_buffer_transfers.push(buffer), @@ -1896,6 +1971,7 @@ fn prepare_for_wire_with_policy<'s>( WireTransfer::WritableStream(stream) => writable_stream_transfers.push(stream), WireTransfer::TransformStream(stream) => transform_stream_transfers.push(stream), WireTransfer::VideoFrame(frame) => video_frame_transfers.push(frame), + WireTransfer::ImageBitmap(bitmap) => image_bitmap_transfers.push(bitmap), } } for frame in &video_frame_transfers { @@ -1928,6 +2004,10 @@ fn prepare_for_wire_with_policy<'s>( .iter() .map(|stream| v8::Global::new(scope, *stream)) .collect(), + transferred_image_bitmaps: image_bitmap_transfers + .iter() + .map(|bitmap| v8::Global::new(scope, *bitmap)) + .collect(), policy, wasm_modules: Rc::clone(&wasm_modules), blobs: Rc::clone(&blobs), @@ -1979,6 +2059,7 @@ fn prepare_for_wire_with_policy<'s>( blobs, file_system_handles, rtc_certificates, + image_bitmaps: Vec::with_capacity(image_bitmap_transfers.len()), metadata, }, message_ports: message_port_transfers, @@ -2120,6 +2201,7 @@ fn deserialize_from_wire_impl<'s>( blob_objects: RefCell::new(HashMap::new()), file_system_handles, rtc_certificates, + image_bitmaps: payload.image_bitmaps.clone(), }), &payload.base.wire_bytes, ); diff --git a/moli-renderer-v8/src/worker/thread/tests/image_bitmap.rs b/moli-renderer-v8/src/worker/thread/tests/image_bitmap.rs index 5b3f3547529..0cf13abc354 100644 --- a/moli-renderer-v8/src/worker/thread/tests/image_bitmap.rs +++ b/moli-renderer-v8/src/worker/thread/tests/image_bitmap.rs @@ -1,5 +1,59 @@ use super::*; +#[tokio::test] +async fn worker_image_bitmap_clone_and_transfer_preserve_native_data_across_global_kinds() { + ensure_v8(); + let manager = crate::new_indexed_db_manager(None).unwrap(); + let browser_context_runtime = + crate::runtime::RendererBrowserContextRuntime::new_with_registries_for_test( + crate::message_port_runtime::new_message_port_registry(), + crate::broadcast_channel_runtime::new_broadcast_channel_registry(), + ); + let storage_key = moli_storage_key::MoliStorageKey::new( + "https://bitmap-clone.test".to_owned(), + "https://bitmap-clone.test".to_owned(), + None, + moli_storage_key::StoragePartitionRelation::FirstParty, + ); + for kind in [ + super::super::WorkerGlobalKind::Dedicated { + name: String::new(), + }, + super::super::WorkerGlobalKind::Shared { + name: "bitmap-clone".to_owned(), + storage_key, + }, + super::super::WorkerGlobalKind::Service { + registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1), + version_id: ServiceWorkerVersionId::from_u64_for_test(1), + scope_url: url::Url::parse("https://bitmap-clone.test/").unwrap(), + }, + ] { + let source = format!( + "const probe={}; probe(globalThis,globalThis,'worker').then(checks=>console.log(JSON.stringify({{total:checks.length,failures:checks.filter(row=>!row.passed)}})));", + include_str!("../../../script_vm/tests/image_bitmap_clone.js") + ); + let mut handle = spawn_test_worker_with_options( + WorkerSpawnOptions::new(source, "https://bitmap-clone.test/worker.js".to_owned()) + .with_worker_context_runtime(browser_context_runtime.worker_context_runtime()) + .with_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager))) + .with_global_kind(kind), + ); + let message = timeout(Duration::from_secs(30), handle.recv()) + .await + .unwrap() + .unwrap(); + let WorkerToParentMessage::Console(console) = message else { + panic!("expected completed bitmap clone checks, got {message:?}"); + }; + let result: serde_json::Value = + serde_json::from_str(console.message.strip_prefix("log: ").unwrap()).unwrap(); + assert_eq!(result["total"], 26, "{result}"); + assert_eq!(result["failures"], serde_json::json!([]), "{result}"); + handle.terminate_and_join(); + } +} + #[tokio::test] async fn worker_canvas_hdr_pixels_preserve_precision_across_global_kinds() { ensure_v8();