mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
feat(canvas): support native ImageBitmap cloning and transfer
This commit is contained in:
@@ -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&© 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;
|
||||
|
||||
@@ -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();
|
||||
|
||||
Reference in New Issue
Block a user