feat(canvas): support native ImageBitmap cloning and transfer

This commit is contained in:
ldm0
2026-11-21 20:03:33 +08:00
parent d4c8e2ff4a
commit a38bdaa6e3
11 changed files with 655 additions and 22 deletions
+5 -4
View File
@@ -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;
@@ -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};
@@ -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,
@@ -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<Self> {
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<ImageBitmapClonePayload> {
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<v8::Local<'s, v8::Object>> {
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,
},
)
}
@@ -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(
@@ -417,6 +417,24 @@ fn parse_transfer_values<'s>(
}
if let Ok(object) = v8::Local::<v8::Object>::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(
@@ -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;
}
@@ -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::<v8::Object>::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&&copy 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='<iframe id=child></iframe>'")
.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(),
"[]"
);
}
@@ -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;
+97 -15
View File
@@ -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<ClonedBlob>,
file_system_handles: Vec<ClonedFileSystemHandle>,
rtc_certificates: Vec<ClonedCertificate>,
image_bitmaps: Vec<ImageBitmapClonePayload>,
pub(crate) metadata: StructuredCloneMetadata,
}
@@ -464,6 +469,7 @@ struct WireSerializer {
allowed_readable_streams: Vec<v8::Global<v8::Object>>,
allowed_writable_streams: Vec<v8::Global<v8::Object>>,
allowed_transform_streams: Vec<v8::Global<v8::Object>>,
transferred_image_bitmaps: Vec<v8::Global<v8::Object>>,
policy: StructuredClonePolicy,
wasm_modules: Rc<RefCell<ClonedWasmModuleStore>>,
blobs: Rc<RefCell<ClonedBlobStore>>,
@@ -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<HashMap<u32, v8::Global<v8::Object>>>,
file_system_handles: HashMap<u32, FileSystemHandleClonePayload>,
rtc_certificates: HashMap<u32, crate::context_bootstrap::rtc_certificate::CertificatePayload>,
image_bitmaps: Vec<ImageBitmapClonePayload>,
}
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<bool> {
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<v8::Local<'s, v8::Object>> {
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,
);
@@ -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();