mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 16:02:34 +00:00
fix(canvas): preserve native ImageData construction and clone graphs
This commit is contained in:
+1
-1
@@ -26,7 +26,7 @@
|
||||
new ImageData(2147483648, 2147483648);
|
||||
body.setAttribute("data-too-large", "no-error");
|
||||
} catch (error) {
|
||||
body.setAttribute("data-too-large", String(error).includes("IndexSizeError"));
|
||||
body.setAttribute("data-too-large", error instanceof RangeError);
|
||||
}
|
||||
</script>
|
||||
</body>
|
||||
|
||||
@@ -420,7 +420,7 @@ pub(crate) use self::geometry_clone::{
|
||||
use self::geometry_runtime::{build_dom_point_object, optional_dom_point_init_arg};
|
||||
pub(crate) use self::image_data::{
|
||||
ImageDataClonePayload, build_image_data_object_from_clone_payload,
|
||||
image_data_clone_payload_from_object,
|
||||
build_image_data_object_from_legacy_bytes, image_data_clone_payload_from_object,
|
||||
};
|
||||
pub(crate) use self::indexed_db::{
|
||||
IndexedDbTaskId, discard_indexed_db_task_by_id, flush_indexed_db_task_by_id,
|
||||
|
||||
@@ -7,7 +7,7 @@ use crate::context_bootstrap::{
|
||||
},
|
||||
image_data::{
|
||||
build_image_data_object, build_image_data_object_with_bytes, image_data_buffer_is_detached,
|
||||
image_data_bytes_from_object, image_data_dimensions_from_object,
|
||||
image_data_dimensions_from_object, image_data_rgba8_bytes_from_object,
|
||||
},
|
||||
throw_dom_exception_value,
|
||||
};
|
||||
@@ -224,7 +224,7 @@ fn put_image_data<'s>(
|
||||
let Some((width, height)) = image_data_dimensions_from_object(scope, source) else {
|
||||
return;
|
||||
};
|
||||
let Some(bytes) = image_data_bytes_from_object(scope, source) else {
|
||||
let Some(bytes) = image_data_rgba8_bytes_from_object(scope, source) else {
|
||||
return;
|
||||
};
|
||||
let dirty = dirty.unwrap_or_else(|| ImageDataRect::new(0, 0, width as i32, height as i32));
|
||||
|
||||
@@ -269,7 +269,13 @@ fn snapshot_bitmap_source<'s>(
|
||||
let data = crate::context_bootstrap::image_data::image_data_clone_payload_from_object(
|
||||
scope, source,
|
||||
)?;
|
||||
(data.bytes, data.width, data.height)
|
||||
(
|
||||
crate::context_bootstrap::image_data::image_data_rgba8_bytes_from_object(
|
||||
scope, source,
|
||||
)?,
|
||||
data.width,
|
||||
data.height,
|
||||
)
|
||||
} else {
|
||||
image_source_pixels(scope, source)?
|
||||
};
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
use super::*;
|
||||
use crate::util::{callback_data_index_value, get_private_value};
|
||||
use crate::web_api_interfaces;
|
||||
use crate::webidl;
|
||||
use moli_canvas::byte_len as rgba8_byte_len;
|
||||
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
|
||||
use crate::{web_api_interfaces, webidl};
|
||||
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject, web_api_object_target};
|
||||
use std::str::FromStr;
|
||||
use webidl::{SnapshotPrototype, WebIdlDictionarySerialize};
|
||||
|
||||
mod pixels;
|
||||
use pixels::{ImageDataArray, ImageDataPixelFormat, new_pixel_array, rgba8_bytes};
|
||||
|
||||
const IMAGE_DATA_WIDTH_SLOT: &str = "__moliImageDataWidth";
|
||||
const IMAGE_DATA_HEIGHT_SLOT: &str = "__moliImageDataHeight";
|
||||
@@ -20,58 +20,37 @@ struct ImageDataObjectDeclaration<'s> {
|
||||
width: u32,
|
||||
#[webapi(slot = IMAGE_DATA_HEIGHT_SLOT)]
|
||||
height: u32,
|
||||
#[webapi(slot = IMAGE_DATA_COLOR_SPACE_SLOT)]
|
||||
color_space: String,
|
||||
#[webapi(slot = IMAGE_DATA_PIXEL_FORMAT_SLOT)]
|
||||
pixel_format: &'static str,
|
||||
#[webapi(slot = IMAGE_DATA_DATA_SLOT)]
|
||||
data: v8::Local<'s, v8::Uint8ClampedArray>,
|
||||
data: v8::Local<'s, v8::ArrayBufferView>,
|
||||
}
|
||||
|
||||
#[derive(WebApiFunctionTemplate)]
|
||||
#[webapi(interface = web_api_interfaces::ImageData, receiver)]
|
||||
#[webapi(interface = web_api_interfaces::ImageData, enumerable, receiver)]
|
||||
struct ImageDataPrototypeDeclaration {
|
||||
#[webapi(
|
||||
accessor_property,
|
||||
getter = image_data_getter_callback,
|
||||
data = callback_data_index_value(scope, 0),
|
||||
enumerable
|
||||
)]
|
||||
#[webapi(accessor_property, getter = image_data_getter_callback, data = callback_data_index_value(scope, 0))]
|
||||
width: (),
|
||||
#[webapi(
|
||||
accessor_property,
|
||||
getter = image_data_getter_callback,
|
||||
data = callback_data_index_value(scope, 1),
|
||||
enumerable
|
||||
)]
|
||||
#[webapi(accessor_property, getter = image_data_getter_callback, data = callback_data_index_value(scope, 1))]
|
||||
height: (),
|
||||
#[webapi(
|
||||
accessor_property,
|
||||
getter = image_data_getter_callback,
|
||||
data = callback_data_index_value(scope, 2),
|
||||
enumerable
|
||||
)]
|
||||
#[webapi(accessor_property, getter = image_data_getter_callback, data = callback_data_index_value(scope, 2))]
|
||||
data: (),
|
||||
#[webapi(
|
||||
accessor_property,
|
||||
getter = image_data_getter_callback,
|
||||
data = callback_data_index_value(scope, 3),
|
||||
enumerable
|
||||
)]
|
||||
#[webapi(accessor_property, getter = image_data_getter_callback, data = callback_data_index_value(scope, 3))]
|
||||
color_space: (),
|
||||
#[webapi(
|
||||
accessor_property,
|
||||
getter = image_data_getter_callback,
|
||||
data = callback_data_index_value(scope, 4),
|
||||
enumerable
|
||||
)]
|
||||
#[webapi(accessor_property, getter = image_data_getter_callback, data = callback_data_index_value(scope, 4))]
|
||||
pixel_format: (),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub(crate) struct ImageDataClonePayload {
|
||||
/// Retain the native view while V8 sub-serializes it in the enclosing object graph.
|
||||
/// Copying bytes here would lose view identity, offsets and shared buffer references.
|
||||
pub(crate) struct ImageDataClonePayload<'s> {
|
||||
pub(crate) width: u32,
|
||||
pub(crate) height: u32,
|
||||
pub(crate) color_space: String,
|
||||
pub(crate) bytes: Vec<u8>,
|
||||
pub(crate) pixel_format: ImageDataPixelFormat,
|
||||
pub(crate) data: v8::Local<'s, v8::ArrayBufferView>,
|
||||
}
|
||||
|
||||
#[derive(
|
||||
@@ -89,26 +68,42 @@ impl ImageDataColorSpace {
|
||||
fn parse(value: &str) -> Option<Self> {
|
||||
Self::from_str(value).ok()
|
||||
}
|
||||
|
||||
fn label(self) -> &'static str {
|
||||
self.into()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "ImageDataSettings", snapshot)]
|
||||
#[derive(Default, webidl::WebIdlDictionary)]
|
||||
#[webidl(prefix = "ImageDataSettings")]
|
||||
struct ImageDataSettingsMembers {
|
||||
#[webidl(converter = "enum", default = ImageDataColorSpace::Srgb)]
|
||||
#[webidl(snapshot_slot = IMAGE_DATA_COLOR_SPACE_SLOT, snapshot_with = color_space_snapshot)]
|
||||
color_space: ImageDataColorSpace,
|
||||
#[webidl(converter = "enum")]
|
||||
color_space: Option<ImageDataColorSpace>,
|
||||
#[webidl(converter = "enum", default = ImageDataPixelFormat::RgbaUnorm8)]
|
||||
pixel_format: ImageDataPixelFormat,
|
||||
}
|
||||
|
||||
fn color_space_snapshot<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: &ImageDataColorSpace,
|
||||
_: SnapshotPrototype,
|
||||
) -> Option<v8::Local<'s, v8::Value>> {
|
||||
v8_string(scope, value.label()).map(Into::into)
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "ImageData")]
|
||||
struct ImageDataSizeArgs {
|
||||
#[webidl(required, converter = "unsigned_long")]
|
||||
width: u32,
|
||||
#[webidl(required, converter = "unsigned_long")]
|
||||
height: u32,
|
||||
#[webidl(dictionary)]
|
||||
settings: ImageDataSettingsMembers,
|
||||
}
|
||||
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
#[webidl(prefix = "ImageData")]
|
||||
struct ImageDataSourceArgs<'s> {
|
||||
#[webidl(required, converter = "raw")]
|
||||
data: ImageDataArray<'s>,
|
||||
#[webidl(required, converter = "unsigned_long")]
|
||||
width: u32,
|
||||
#[webidl(converter = "unsigned_long")]
|
||||
height: Option<u32>,
|
||||
#[webidl(dictionary)]
|
||||
settings: ImageDataSettingsMembers,
|
||||
}
|
||||
|
||||
pub(super) fn image_data_constructor_callback<'s>(
|
||||
@@ -123,16 +118,10 @@ pub(super) fn image_data_constructor_callback<'s>(
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
let Some((data, width, height, color_space)) = image_data_constructor_parts(scope, &args)
|
||||
else {
|
||||
let Some(parts) = image_data_constructor_parts(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
|
||||
color_space
|
||||
.initialize_snapshot(scope, args.this())
|
||||
.expect("ImageData settings");
|
||||
ImageDataObjectDeclaration::new(width, height, "rgba-unorm8", data)
|
||||
declaration(parts)
|
||||
.initialize(scope, args.this())
|
||||
.expect("ImageData declaration should initialize object");
|
||||
rv.set(args.this().into());
|
||||
@@ -151,98 +140,111 @@ fn image_data_getter_callback<'s>(
|
||||
args: v8::FunctionCallbackArguments<'s>,
|
||||
mut rv: v8::ReturnValue<'_, v8::Value>,
|
||||
) {
|
||||
let receiver = web_api_object_target(scope, args.this()).expect("validated ImageData receiver");
|
||||
let Some(slot) = callback_data_item(
|
||||
scope,
|
||||
&args,
|
||||
IMAGE_DATA_ATTRIBUTE_SLOTS,
|
||||
"ImageData attribute slots",
|
||||
) else {
|
||||
rv.set_undefined();
|
||||
return;
|
||||
};
|
||||
let value =
|
||||
get_private_value(scope, args.this(), slot).unwrap_or_else(|| v8::undefined(scope).into());
|
||||
rv.set(value);
|
||||
if let Some(value) = get_private_value(scope, receiver, slot) {
|
||||
rv.set(value);
|
||||
}
|
||||
}
|
||||
|
||||
fn image_data_constructor_parts<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
args: &v8::FunctionCallbackArguments<'s>,
|
||||
) -> Option<(
|
||||
v8::Local<'s, v8::Uint8ClampedArray>,
|
||||
u32,
|
||||
u32,
|
||||
ImageDataSettingsMembers,
|
||||
)> {
|
||||
if let Ok(data) = v8::Local::<v8::Uint8ClampedArray>::try_from(args.get(0)) {
|
||||
let width = image_data_dimension_arg(scope, args.get(1))?;
|
||||
let height = if args.length() > 2 && !args.get(2).is_undefined() {
|
||||
image_data_dimension_arg(scope, args.get(2))?
|
||||
} else {
|
||||
let pixels = data.byte_length() / 4;
|
||||
if width == 0 || pixels % width as usize != 0 {
|
||||
throw_image_data_index_size_error(scope);
|
||||
) -> Option<ImageDataClonePayload<'s>> {
|
||||
// Four arguments leave only the data overload. With two or three, the
|
||||
// distinguishing argument selects the native typed-array union or unsigned long.
|
||||
let (width, height, settings, data) =
|
||||
if args.length() >= 4 || ImageDataArray::matches(args.get(0)) {
|
||||
let parsed = webidl::parse_args::<ImageDataSourceArgs>(scope, args)?;
|
||||
let bytes_per_pixel = parsed.settings.pixel_format.bytes_per_pixel();
|
||||
let length = parsed.data.view.byte_length();
|
||||
if length == 0 || !length.is_multiple_of(bytes_per_pixel) {
|
||||
throw_invalid_image_data(scope);
|
||||
return None;
|
||||
}
|
||||
(pixels / width as usize) as u32
|
||||
let pixels = length / bytes_per_pixel;
|
||||
if parsed.width == 0 || !pixels.is_multiple_of(parsed.width as usize) {
|
||||
webidl::throw_index_size_error(scope);
|
||||
return None;
|
||||
}
|
||||
let Ok(height) = u32::try_from(pixels / parsed.width as usize) else {
|
||||
webidl::throw_index_size_error(scope);
|
||||
return None;
|
||||
};
|
||||
if parsed.height.is_some_and(|given| given != height) {
|
||||
webidl::throw_index_size_error(scope);
|
||||
return None;
|
||||
}
|
||||
if parsed.data.format != parsed.settings.pixel_format {
|
||||
throw_invalid_image_data(scope);
|
||||
return None;
|
||||
}
|
||||
(parsed.width, height, parsed.settings, parsed.data.view)
|
||||
} else {
|
||||
let parsed = webidl::parse_args::<ImageDataSizeArgs>(scope, args)?;
|
||||
if parsed.width == 0 || parsed.height == 0 {
|
||||
webidl::throw_index_size_error(scope);
|
||||
return None;
|
||||
}
|
||||
let data = allocate_pixel_array(
|
||||
scope,
|
||||
parsed.width,
|
||||
parsed.height,
|
||||
parsed.settings.pixel_format,
|
||||
)?;
|
||||
(parsed.width, parsed.height, parsed.settings, data)
|
||||
};
|
||||
let expected_len = image_data_expected_len(scope, width, height)?;
|
||||
if data.byte_length() != expected_len {
|
||||
throw_image_data_index_size_error(scope);
|
||||
return None;
|
||||
}
|
||||
let color_space = image_data_color_space_arg(scope, args.get(3))?;
|
||||
return Some((data, width, height, color_space));
|
||||
}
|
||||
|
||||
let width = image_data_dimension_arg(scope, args.get(0))?;
|
||||
let height = image_data_dimension_arg(scope, args.get(1))?;
|
||||
let color_space = image_data_color_space_arg(scope, args.get(2))?;
|
||||
let len = image_data_expected_len(scope, width, height)?;
|
||||
let data = new_uint8_clamped_array_from_bytes(scope, vec![0; len])?;
|
||||
Some((data, width, height, color_space))
|
||||
Some(ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
data,
|
||||
color_space: settings
|
||||
.color_space
|
||||
.unwrap_or(ImageDataColorSpace::Srgb)
|
||||
.label()
|
||||
.to_owned(),
|
||||
pixel_format: settings.pixel_format,
|
||||
})
|
||||
}
|
||||
|
||||
fn image_data_dimension_arg(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
value: v8::Local<'_, v8::Value>,
|
||||
) -> Option<u32> {
|
||||
let number = value.number_value(scope)?;
|
||||
if !number.is_finite() || number <= 0.0 || number > i32::MAX as f64 {
|
||||
throw_image_data_index_size_error(scope);
|
||||
fn allocate_pixel_array<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
width: u32,
|
||||
height: u32,
|
||||
format: ImageDataPixelFormat,
|
||||
) -> Option<v8::Local<'s, v8::ArrayBufferView>> {
|
||||
let Some(length) = format.byte_len(width, height) else {
|
||||
throw_image_data_allocation_error(scope);
|
||||
return None;
|
||||
};
|
||||
let mut bytes = Vec::new();
|
||||
if bytes.try_reserve_exact(length).is_err() {
|
||||
throw_image_data_allocation_error(scope);
|
||||
return None;
|
||||
}
|
||||
Some(number as u32)
|
||||
bytes.resize(length, 0);
|
||||
new_pixel_array(scope, bytes, format)
|
||||
}
|
||||
|
||||
fn image_data_color_space_arg<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
) -> Option<ImageDataSettingsMembers> {
|
||||
if webidl::is_nullish(value) {
|
||||
return Some(ImageDataSettingsMembers {
|
||||
color_space: ImageDataColorSpace::Srgb,
|
||||
});
|
||||
}
|
||||
let object = match v8::Local::<v8::Object>::try_from(value) {
|
||||
Ok(object) => object,
|
||||
Err(_) => {
|
||||
throw_type_error(
|
||||
scope,
|
||||
"Failed to construct 'ImageData': settings must be an object",
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let color_space =
|
||||
match webidl::parse_dictionary_object::<ImageDataSettingsMembers>(scope, object) {
|
||||
Ok(value) => value,
|
||||
Err(error) => {
|
||||
throw_type_error(scope, &error.to_string());
|
||||
return None;
|
||||
}
|
||||
};
|
||||
Some(color_space)
|
||||
fn throw_image_data_allocation_error(scope: &mut v8::PinScope<'_, '_>) {
|
||||
let message = crate::util::v8str(scope, "ImageData pixel storage could not be allocated.");
|
||||
let error = v8::Exception::range_error(scope, message);
|
||||
scope.throw_exception(error);
|
||||
}
|
||||
|
||||
fn throw_invalid_image_data(scope: &mut v8::PinScope<'_, '_>) {
|
||||
throw_dom_exception_value(
|
||||
scope,
|
||||
"The pixel array does not match the ImageData format.",
|
||||
"InvalidStateError",
|
||||
);
|
||||
}
|
||||
|
||||
const IMAGE_DATA_ATTRIBUTE_SLOTS: &[&str] = &[
|
||||
@@ -253,17 +255,6 @@ const IMAGE_DATA_ATTRIBUTE_SLOTS: &[&str] = &[
|
||||
IMAGE_DATA_PIXEL_FORMAT_SLOT,
|
||||
];
|
||||
|
||||
fn image_data_expected_len(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
width: u32,
|
||||
height: u32,
|
||||
) -> Option<usize> {
|
||||
rgba8_byte_len(width, height).or_else(|| {
|
||||
throw_image_data_index_size_error(scope);
|
||||
None
|
||||
})
|
||||
}
|
||||
|
||||
pub(in crate::context_bootstrap) fn new_uint8_clamped_array_from_bytes<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
bytes: Vec<u8>,
|
||||
@@ -274,24 +265,33 @@ pub(in crate::context_bootstrap) fn new_uint8_clamped_array_from_bytes<'s>(
|
||||
v8::Uint8ClampedArray::new(scope, buffer, 0, len)
|
||||
}
|
||||
|
||||
fn declaration(parts: ImageDataClonePayload<'_>) -> ImageDataObjectDeclaration<'_> {
|
||||
ImageDataObjectDeclaration::new(
|
||||
parts.width,
|
||||
parts.height,
|
||||
parts.color_space,
|
||||
parts.pixel_format.label(),
|
||||
parts.data,
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn build_image_data_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
width: u32,
|
||||
height: u32,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let ctor = v8::Local::<v8::Function>::try_from(super::shared::global_constructor_object(
|
||||
let format = ImageDataPixelFormat::RgbaUnorm8;
|
||||
let data = allocate_pixel_array(scope, width, height, format)?;
|
||||
build_image_data_object_from_clone_payload(
|
||||
scope,
|
||||
"ImageData",
|
||||
)?)
|
||||
.ok()?;
|
||||
let object = ctor.new_instance(
|
||||
scope,
|
||||
&[
|
||||
v8::Integer::new(scope, width as i32).into(),
|
||||
v8::Integer::new(scope, height as i32).into(),
|
||||
],
|
||||
)?;
|
||||
Some(object)
|
||||
ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space: "srgb".to_owned(),
|
||||
pixel_format: format,
|
||||
data,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn build_image_data_object_with_bytes<'s>(
|
||||
@@ -301,63 +301,78 @@ pub(super) fn build_image_data_object_with_bytes<'s>(
|
||||
bytes: Vec<u8>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let data = new_uint8_clamped_array_from_bytes(scope, bytes)?;
|
||||
let ctor = v8::Local::<v8::Function>::try_from(super::shared::global_constructor_object(
|
||||
build_image_data_object_from_clone_payload(
|
||||
scope,
|
||||
"ImageData",
|
||||
)?)
|
||||
.ok()?;
|
||||
let object = ctor.new_instance(
|
||||
scope,
|
||||
&[
|
||||
data.into(),
|
||||
v8::Integer::new(scope, width as i32).into(),
|
||||
v8::Integer::new(scope, height as i32).into(),
|
||||
],
|
||||
)?;
|
||||
Some(object)
|
||||
ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space: "srgb".to_owned(),
|
||||
pixel_format: ImageDataPixelFormat::RgbaUnorm8,
|
||||
data: data.into(),
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn build_image_data_object_from_clone_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
payload: ImageDataClonePayload,
|
||||
payload: ImageDataClonePayload<'s>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let data = new_uint8_clamped_array_from_bytes(scope, payload.bytes)?;
|
||||
let settings = ImageDataSettingsMembers {
|
||||
color_space: ImageDataColorSpace::parse(&payload.color_space)?,
|
||||
if payload.width == 0
|
||||
|| payload.height == 0
|
||||
|| payload
|
||||
.pixel_format
|
||||
.byte_len(payload.width, payload.height)?
|
||||
!= payload.data.byte_length()
|
||||
|| ImageDataArray::format(payload.data.into())? != payload.pixel_format
|
||||
|| ImageDataColorSpace::parse(&payload.color_space).is_none()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
.to_js_snapshot(scope, SnapshotPrototype::Ordinary)?;
|
||||
let ctor = v8::Local::<v8::Function>::try_from(super::shared::global_constructor_object(
|
||||
declaration(payload).bind(scope).ok()
|
||||
}
|
||||
|
||||
pub(crate) fn build_image_data_object_from_legacy_bytes<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
width: u32,
|
||||
height: u32,
|
||||
color_space: String,
|
||||
bytes: Vec<u8>,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let data = new_uint8_clamped_array_from_bytes(scope, bytes)?;
|
||||
build_image_data_object_from_clone_payload(
|
||||
scope,
|
||||
"ImageData",
|
||||
)?)
|
||||
.ok()?;
|
||||
ctor.new_instance(
|
||||
scope,
|
||||
&[
|
||||
data.into(),
|
||||
v8::Integer::new(scope, payload.width as i32).into(),
|
||||
v8::Integer::new(scope, payload.height as i32).into(),
|
||||
settings.into(),
|
||||
],
|
||||
ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space,
|
||||
pixel_format: ImageDataPixelFormat::RgbaUnorm8,
|
||||
data: data.into(),
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn image_data_clone_payload_from_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<ImageDataClonePayload> {
|
||||
) -> Option<ImageDataClonePayload<'s>> {
|
||||
let object = web_api_object_target(scope, object)?;
|
||||
let (width, height) = image_data_dimensions_from_object(scope, object)?;
|
||||
let bytes = image_data_bytes_from_object(scope, object)?;
|
||||
if bytes.len() != rgba8_byte_len(width, height)? {
|
||||
let data = image_data_view(scope, object)?;
|
||||
if data.buffer(scope)?.was_detached() {
|
||||
return None;
|
||||
}
|
||||
let color_space =
|
||||
image_data_string_from_object_slot(scope, object, IMAGE_DATA_COLOR_SPACE_SLOT)?;
|
||||
let pixel_format =
|
||||
image_data_string_from_object_slot(scope, object, IMAGE_DATA_PIXEL_FORMAT_SLOT)?
|
||||
.parse()
|
||||
.ok()?;
|
||||
Some(ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space,
|
||||
bytes,
|
||||
pixel_format,
|
||||
data,
|
||||
})
|
||||
}
|
||||
|
||||
@@ -376,11 +391,7 @@ fn image_data_dimension_from_object_slot<'s>(
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
slot: &'static str,
|
||||
) -> Option<u32> {
|
||||
let value = get_private_value(scope, object, slot)?.number_value(scope)?;
|
||||
if !value.is_finite() || value <= 0.0 || value > u32::MAX as f64 {
|
||||
return None;
|
||||
}
|
||||
Some(value as u32)
|
||||
get_private_value(scope, object, slot)?.uint32_value(scope)
|
||||
}
|
||||
|
||||
fn image_data_string_from_object_slot<'s>(
|
||||
@@ -388,40 +399,40 @@ fn image_data_string_from_object_slot<'s>(
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
slot: &'static str,
|
||||
) -> Option<String> {
|
||||
get_private_value(scope, object, slot).and_then(|value| {
|
||||
value
|
||||
.to_string(scope)
|
||||
.map(|value| value.to_rust_string_lossy(scope))
|
||||
})
|
||||
get_private_value(scope, object, slot)?
|
||||
.to_string(scope)
|
||||
.map(|value| value.to_rust_string_lossy(scope))
|
||||
}
|
||||
|
||||
fn image_data_view<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<v8::Local<'s, v8::ArrayBufferView>> {
|
||||
v8::Local::try_from(get_private_value(scope, object, IMAGE_DATA_DATA_SLOT)?).ok()
|
||||
}
|
||||
|
||||
pub(super) fn image_data_buffer_is_detached<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<bool> {
|
||||
let view = get_private_value(scope, object, IMAGE_DATA_DATA_SLOT)
|
||||
.and_then(|value| v8::Local::<v8::Uint8ClampedArray>::try_from(value).ok())?;
|
||||
Some(view.buffer(scope)?.was_detached())
|
||||
Some(
|
||||
image_data_view(scope, object)?
|
||||
.buffer(scope)?
|
||||
.was_detached(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn image_data_bytes_from_object<'s>(
|
||||
/// Convert only at the boundary to the existing RGBA8 canvas/bitmap backend.
|
||||
/// Native ImageData storage and structured clone keep the original pixel format.
|
||||
pub(super) fn image_data_rgba8_bytes_from_object<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<Vec<u8>> {
|
||||
let view = get_private_value(scope, object, IMAGE_DATA_DATA_SLOT)
|
||||
.and_then(|value| v8::Local::<v8::Uint8ClampedArray>::try_from(value).ok())?;
|
||||
let mut bytes = vec![0; view.byte_length()];
|
||||
let written = view.copy_contents(&mut bytes);
|
||||
bytes.truncate(written);
|
||||
Some(bytes)
|
||||
}
|
||||
|
||||
fn throw_image_data_index_size_error(scope: &mut v8::PinScope<'_, '_>) {
|
||||
crate::context_bootstrap::throw_dom_exception_value(
|
||||
scope,
|
||||
"The source width is zero or not a finite integer.",
|
||||
"IndexSizeError",
|
||||
);
|
||||
let view = image_data_view(scope, object)?;
|
||||
if view.buffer(scope)?.was_detached() {
|
||||
return None;
|
||||
}
|
||||
rgba8_bytes(view)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -0,0 +1,170 @@
|
||||
use crate::webidl;
|
||||
use std::str::FromStr;
|
||||
|
||||
#[derive(
|
||||
Clone,
|
||||
Copy,
|
||||
Debug,
|
||||
Default,
|
||||
Eq,
|
||||
PartialEq,
|
||||
strum::EnumString,
|
||||
strum::IntoStaticStr,
|
||||
webidl::WebIdlEnum,
|
||||
)]
|
||||
#[webidl(name = "ImageDataPixelFormat", parse_with = Self::parse)]
|
||||
pub(crate) enum ImageDataPixelFormat {
|
||||
#[default]
|
||||
#[strum(serialize = "rgba-unorm8")]
|
||||
RgbaUnorm8,
|
||||
#[strum(serialize = "rgba-float16")]
|
||||
RgbaFloat16,
|
||||
}
|
||||
|
||||
impl ImageDataPixelFormat {
|
||||
fn parse(value: &str) -> Option<Self> {
|
||||
Self::from_str(value).ok()
|
||||
}
|
||||
|
||||
pub(crate) fn label(self) -> &'static str {
|
||||
self.into()
|
||||
}
|
||||
|
||||
pub(super) fn bytes_per_pixel(self) -> usize {
|
||||
match self {
|
||||
Self::RgbaUnorm8 => 4,
|
||||
Self::RgbaFloat16 => 8,
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn byte_len(self, width: u32, height: u32) -> Option<usize> {
|
||||
(width as usize)
|
||||
.checked_mul(height as usize)?
|
||||
.checked_mul(self.bytes_per_pixel())
|
||||
.filter(|length| *length <= moli_canvas::MAX_RGBA8_BYTE_LENGTH)
|
||||
}
|
||||
}
|
||||
|
||||
/// The ImageDataArray union retains the view through later argument conversion.
|
||||
pub(super) struct ImageDataArray<'s> {
|
||||
pub(super) view: v8::Local<'s, v8::ArrayBufferView>,
|
||||
pub(super) format: ImageDataPixelFormat,
|
||||
}
|
||||
|
||||
impl ImageDataArray<'_> {
|
||||
pub(super) fn matches(value: v8::Local<'_, v8::Value>) -> bool {
|
||||
Self::format(value).is_some()
|
||||
}
|
||||
|
||||
pub(super) fn format(value: v8::Local<'_, v8::Value>) -> Option<ImageDataPixelFormat> {
|
||||
if value.is_uint8_clamped_array() {
|
||||
Some(ImageDataPixelFormat::RgbaUnorm8)
|
||||
} else if value.is_float16_array() {
|
||||
Some(ImageDataPixelFormat::RgbaFloat16)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'s> webidl::WebIdlConverter<'s> for ImageDataArray<'s> {
|
||||
type Options = ();
|
||||
|
||||
fn convert(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
context: webidl::Context,
|
||||
_options: &(),
|
||||
) -> Result<Self, webidl::WebIdlError> {
|
||||
let invalid = || webidl::WebIdlError::cannot_convert(context, "ImageDataArray");
|
||||
let format = Self::format(value).ok_or_else(invalid)?;
|
||||
let view = v8::Local::<v8::ArrayBufferView>::try_from(value).map_err(|_| invalid())?;
|
||||
let buffer = view.buffer(scope).ok_or_else(invalid)?;
|
||||
// Use native buffer flags, which survive detachment. No author getters
|
||||
// or Proxy traps participate in typed-array union conversion.
|
||||
if buffer.is_shared_array_buffer() || buffer.is_resizable_by_user_javascript() {
|
||||
return Err(webidl::WebIdlError::cannot_convert(
|
||||
context,
|
||||
"non-shared, non-resizable ImageDataArray",
|
||||
));
|
||||
}
|
||||
Ok(Self { view, format })
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn new_pixel_array<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
bytes: Vec<u8>,
|
||||
format: ImageDataPixelFormat,
|
||||
) -> Option<v8::Local<'s, v8::ArrayBufferView>> {
|
||||
match format {
|
||||
ImageDataPixelFormat::RgbaUnorm8 => {
|
||||
super::new_uint8_clamped_array_from_bytes(scope, bytes).map(Into::into)
|
||||
}
|
||||
ImageDataPixelFormat::RgbaFloat16 => {
|
||||
let length = bytes.len() / 2;
|
||||
let backing = v8::ArrayBuffer::new_backing_store_from_vec(bytes).make_shared();
|
||||
let buffer = v8::ArrayBuffer::with_backing_store(scope, &backing);
|
||||
v8::Float16Array::new(scope, buffer, 0, length).map(|view| {
|
||||
// SAFETY: Float16Array inherits ArrayBufferView in V8. rusty_v8
|
||||
// exposes construction/downcasts but omits this mechanical upcast.
|
||||
unsafe { v8::Local::<v8::ArrayBufferView>::cast_unchecked(view) }
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn rgba8_bytes(view: v8::Local<'_, v8::ArrayBufferView>) -> Option<Vec<u8>> {
|
||||
let format = ImageDataArray::format(view.into())?;
|
||||
let mut bytes = vec![0; view.byte_length()];
|
||||
let written = view.copy_contents(&mut bytes);
|
||||
bytes.truncate(written);
|
||||
Some(match format {
|
||||
ImageDataPixelFormat::RgbaUnorm8 => bytes,
|
||||
ImageDataPixelFormat::RgbaFloat16 => bytes
|
||||
.chunks_exact(2)
|
||||
.map(|pair| half_to_unorm8(u16::from_ne_bytes([pair[0], pair[1]])))
|
||||
.collect(),
|
||||
})
|
||||
}
|
||||
|
||||
fn half_to_unorm8(bits: u16) -> u8 {
|
||||
let sign = u32::from(bits & 0x8000) << 16;
|
||||
let exponent = u32::from((bits >> 10) & 0x1f);
|
||||
let fraction = u32::from(bits & 0x3ff);
|
||||
let value = match exponent {
|
||||
0 => (fraction as f32 * 2.0_f32.powi(-24)).copysign(f32::from_bits(sign)),
|
||||
31 => f32::from_bits(sign | 0x7f80_0000 | (fraction << 13)),
|
||||
_ => f32::from_bits(sign | ((exponent + 112) << 23) | (fraction << 13)),
|
||||
};
|
||||
// Casting also maps NaN to zero. Half precision expands exactly to f32.
|
||||
(value * 255.0).round_ties_even().clamp(0.0, 255.0) as u8
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::half_to_unorm8;
|
||||
|
||||
#[test]
|
||||
fn half_pixels_quantize_only_at_the_rgba8_backend_boundary() {
|
||||
for (bits, expected) in [
|
||||
(0x0000, 0),
|
||||
(0x8000, 0),
|
||||
(0x0001, 0),
|
||||
(0x03ff, 0),
|
||||
(0xbc00, 0),
|
||||
(0x3400, 64),
|
||||
(0x3800, 128),
|
||||
(0x3a00, 191),
|
||||
(0x3c00, 255),
|
||||
(0x4000, 255),
|
||||
(0x7bff, 255),
|
||||
(0x7c00, 255),
|
||||
(0xfc00, 0),
|
||||
(0x7e00, 0),
|
||||
(0xfe00, 0),
|
||||
] {
|
||||
assert_eq!(half_to_unorm8(bits), expected, "half bits {bits:04x}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,8 +15,8 @@ use crate::{
|
||||
},
|
||||
structured_clone::{
|
||||
BlobClonePayload, HOST_OBJECT_TAG_BLOB, HOST_OBJECT_TAG_CRYPTO_KEY,
|
||||
HOST_OBJECT_TAG_FILE_LIST, HOST_OBJECT_TAG_FILE_SYSTEM_HANDLE, HOST_OBJECT_TAG_IMAGE_DATA,
|
||||
blob_clone_payload_from_object, read_crypto_key_payload, read_image_data_payload,
|
||||
HOST_OBJECT_TAG_FILE_LIST, HOST_OBJECT_TAG_FILE_SYSTEM_HANDLE, HOST_OBJECT_TAG_IMAGE_DATA, HOST_OBJECT_TAG_IMAGE_DATA_GRAPH,
|
||||
blob_clone_payload_from_object, read_crypto_key_payload, read_image_data_payload, read_image_data_graph_payload,
|
||||
write_crypto_key_payload, write_image_data_payload,
|
||||
},
|
||||
};
|
||||
@@ -199,8 +199,7 @@ impl v8::ValueSerializerImpl for IndexedDbStructuredCloneSerializer {
|
||||
}
|
||||
Some("ImageData") => {
|
||||
if let Some(payload) = image_data_clone_payload_from_object(scope, object) {
|
||||
write_image_data_payload(serializer, payload);
|
||||
return Some(true);
|
||||
return write_image_data_payload(scope, serializer, payload);
|
||||
}
|
||||
}
|
||||
Some("FileSystemFileHandle" | "FileSystemDirectoryHandle")
|
||||
@@ -435,6 +434,7 @@ impl v8::ValueDeserializerImpl for IndexedDbStructuredCloneDeserializer<'_> {
|
||||
build_web_transport_error_from_clone_payload(scope, &payload)
|
||||
}
|
||||
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_CRYPTO_KEY => {
|
||||
read_crypto_key_payload(scope, deserializer).or_else(|| {
|
||||
let exception = dom_exception_value(
|
||||
|
||||
@@ -1793,7 +1793,7 @@ fn html_canvas_image_data_methods_parse_webidl_enforce_range_long() {
|
||||
|
||||
assert_eq!(
|
||||
result,
|
||||
r#"{"created":"2:3","createZero":"IndexSizeError","createSymbol":"TypeError","getNegative":"2|2|255,0,0,255,255,0,0,255,255,0,0,255,255,0,0,255","getMissing":"TypeError","getNan":"TypeError","getZero":"IndexSizeError","constructorOversized":"IndexSizeError","getOversized":"IndexSizeError","putCoerced":"0,0,0,0,255,0,0,255,0,255,0,255","putSymbol":"TypeError","afterBadPut":true,"dirtyNegative":"255,0,0,255,0,0,0,0","putPlainObject":"TypeError"}"#
|
||||
r#"{"created":"2:3","createZero":"IndexSizeError","createSymbol":"TypeError","getNegative":"2|2|255,0,0,255,255,0,0,255,255,0,0,255,255,0,0,255","getMissing":"TypeError","getNan":"TypeError","getZero":"IndexSizeError","constructorOversized":"RangeError","getOversized":"IndexSizeError","putCoerced":"0,0,0,0,255,0,0,255,0,255,0,255","putSymbol":"TypeError","afterBadPut":true,"dirtyNegative":"255,0,0,255,0,0,0,0","putPlainObject":"TypeError"}"#
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,194 @@
|
||||
(sourceRealm, realm, label) => {
|
||||
const checks = [];
|
||||
const C = realm.ImageData;
|
||||
const check = (name, run) => {
|
||||
try { checks.push({name: label + ':' + name, passed: run() === true}); }
|
||||
catch (error) { checks.push({name: label + ':' + name, passed: false, error: String(error)}); }
|
||||
};
|
||||
const construct = (...args) => Reflect.construct(C, args);
|
||||
const throws = (kind, run) => {
|
||||
try { run(); } catch (error) {
|
||||
return kind === 'TypeError' || kind === 'RangeError'
|
||||
? error instanceof realm[kind]
|
||||
: error.name === kind && error instanceof realm.DOMException;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
const same = (a, b) => a.length === b.length && a.every((v, i) => Object.is(v, b[i]));
|
||||
check('constructor length', () => C.length === 2);
|
||||
check('constructor requires new', () => throws('TypeError', () => C(1, 1)));
|
||||
for (const args of [[], [1], [new sourceRealm.Uint8ClampedArray(4)]]) {
|
||||
check('required arity ' + args.length + '-' + typeof args[0], () => throws('TypeError', () => Reflect.construct(C, args)));
|
||||
}
|
||||
check('required arity precedes conversion', () => {
|
||||
let calls = 0;
|
||||
const rejected = throws('TypeError', () => construct({valueOf() { calls++; return 1; }}));
|
||||
return rejected && calls === 0;
|
||||
});
|
||||
for (const [width, height, expectedWidth, expectedHeight] of [
|
||||
[1, 2, 1, 2], [2.9, 3.9, 2, 3], [4294967298, 4294967299, 2, 3],
|
||||
[-4294967295, -4294967294, 1, 2], ['2', true, 2, 1]
|
||||
]) check('unsigned dimensions ' + String(width), () => {
|
||||
const image = construct(width, height);
|
||||
return image.width === expectedWidth && image.height === expectedHeight &&
|
||||
image.data instanceof realm.Uint8ClampedArray && image.data.length === expectedWidth * expectedHeight * 4 &&
|
||||
image.data.every(v => v === 0);
|
||||
});
|
||||
for (const [index, value] of [0, -0, 0.9, -0.9, NaN, Infinity, -Infinity, 4294967296, undefined, null, 'bad'].entries()) {
|
||||
check('zero converted width ' + index, () => throws('IndexSizeError', () => construct(value, 2)));
|
||||
check('zero converted height ' + index, () => throws('IndexSizeError', () => construct(2, value)));
|
||||
}
|
||||
for (const value of [Symbol('size'), 1n]) check('invalid numeric ' + typeof value, () => throws('TypeError', () => construct(1, value)));
|
||||
check('dimension and settings conversion order before size check', () => {
|
||||
const order = [];
|
||||
const rejected = throws('IndexSizeError', () => construct(
|
||||
{valueOf() { order.push('width'); return 0; }},
|
||||
{valueOf() { order.push('height'); return 1; }},
|
||||
{get colorSpace() { order.push('colorSpace'); return 'srgb'; }, get pixelFormat() { order.push('pixelFormat'); return 'rgba-unorm8'; }}));
|
||||
return rejected && order.join(',') === 'width,height,colorSpace,pixelFormat';
|
||||
});
|
||||
check('dictionary exception identity before size check', () => {
|
||||
const marker = {};
|
||||
try { construct(0, 0, {get colorSpace() { throw marker; }}); }
|
||||
catch (error) { return error === marker; }
|
||||
return false;
|
||||
});
|
||||
check('pixelFormat exception identity', () => {
|
||||
const marker = {};
|
||||
try { construct(1, 1, {get pixelFormat() { throw marker; }}); }
|
||||
catch (error) { return error === marker; }
|
||||
return false;
|
||||
});
|
||||
for (const settings of [null, undefined, {}]) check('default settings ' + String(settings), () => {
|
||||
const image = construct(1, 1, settings);
|
||||
return image.colorSpace === 'srgb' && image.pixelFormat === 'rgba-unorm8';
|
||||
});
|
||||
for (const field of ['colorSpace', 'pixelFormat']) {
|
||||
for (const value of ['invalid', null, Symbol(field)]) check('invalid ' + field + ' ' + String(value), () =>
|
||||
throws('TypeError', () => construct(1, 1, {[field]: value})));
|
||||
}
|
||||
check('four arguments select data overload before numeric conversion', () => {
|
||||
let calls = 0;
|
||||
const rejected = throws('TypeError', () => construct({valueOf() { calls++; return 1; }}, 1, {}, {}));
|
||||
return rejected && calls === 0;
|
||||
});
|
||||
for (const [type, format, bytesPerElement] of [
|
||||
['Uint8ClampedArray', 'rgba-unorm8', 1], ['Float16Array', 'rgba-float16', 2]
|
||||
]) {
|
||||
const settings = {colorSpace: 'display-p3', pixelFormat: format};
|
||||
check(type + ' allocated storage', () => {
|
||||
const image = construct(3, 2, settings);
|
||||
return image.pixelFormat === format && image.colorSpace === 'display-p3' && image.data instanceof realm[type] &&
|
||||
image.data.length === 24 && image.data.byteOffset === 0 && image.data.buffer.byteLength === 24 * bytesPerElement && image.data.every(v => v === 0);
|
||||
});
|
||||
for (const explicitHeight of [false, true]) check(type + ' native subview identity ' + explicitHeight, () => {
|
||||
const buffer = new sourceRealm.ArrayBuffer(40 * bytesPerElement);
|
||||
const data = new sourceRealm[type](buffer, 4 * bytesPerElement, 24);
|
||||
const image = construct(data, 3, explicitHeight ? 2 : undefined, settings);
|
||||
data[1] = type === 'Float16Array' ? -0.5 : 7;
|
||||
return image.width === 3 && image.height === 2 && image.data === data && image.data[1] === data[1] &&
|
||||
image.data.buffer === buffer && image.data.byteOffset === 4 * bytesPerElement && image.pixelFormat === format;
|
||||
});
|
||||
for (const length of [0, 1, 3, 5, 7]) check(type + ' invalid element count ' + length, () =>
|
||||
throws('InvalidStateError', () => construct(new sourceRealm[type](length), 0, undefined, settings)));
|
||||
for (const [width, height] of [[0, undefined], [3, undefined], [1, 0], [1, 1], [2, 2]]) {
|
||||
check(type + ' inconsistent dimensions ' + width + '-' + height, () =>
|
||||
throws('IndexSizeError', () => construct(new sourceRealm[type](8), width, height, settings)));
|
||||
}
|
||||
check(type + ' mismatched format', () => throws('InvalidStateError', () =>
|
||||
construct(new sourceRealm[type](8), 1, undefined, {pixelFormat: type === 'Float16Array' ? 'rgba-unorm8' : 'rgba-float16'})));
|
||||
check(type + ' settings precede invalid length', () => {
|
||||
let calls = 0;
|
||||
const rejected = throws('InvalidStateError', () => construct(new sourceRealm[type](0), 0, undefined,
|
||||
{get pixelFormat() { calls++; return format; }}));
|
||||
return rejected && calls === 1;
|
||||
});
|
||||
check(type + ' dimension conversion can detach data', () => {
|
||||
const data = new sourceRealm[type](4), order = [];
|
||||
const rejected = throws('InvalidStateError', () => construct(data, {valueOf() {
|
||||
order.push('width'); sourceRealm.structuredClone(data.buffer, {transfer: [data.buffer]}); return 1;
|
||||
}}, undefined, {get pixelFormat() { order.push('pixelFormat'); return format; }}));
|
||||
return rejected && order.join(',') === 'width,pixelFormat';
|
||||
});
|
||||
check(type + ' dictionary conversion can detach data', () => {
|
||||
const data = new sourceRealm[type](4);
|
||||
return throws('InvalidStateError', () => construct(data, 1, 1, {get pixelFormat() {
|
||||
sourceRealm.structuredClone(data.buffer, {transfer: [data.buffer]}); return format;
|
||||
}}));
|
||||
});
|
||||
for (const detach of [false, true]) check(type + ' rejects resizable buffer before conversion ' + detach, () => {
|
||||
const buffer = new sourceRealm.ArrayBuffer(8 * bytesPerElement, {maxByteLength: 16 * bytesPerElement});
|
||||
const data = new sourceRealm[type](buffer);
|
||||
if (detach) sourceRealm.structuredClone(buffer, {transfer: [buffer]});
|
||||
let calls = 0;
|
||||
const rejected = throws('TypeError', () => construct(data, {valueOf() { calls++; return 1; }}, undefined, settings));
|
||||
return rejected && calls === 0;
|
||||
});
|
||||
check(type + ' rejects shared buffer before conversion', () => {
|
||||
const buffer = new sourceRealm.WebAssembly.Memory({initial: 1, maximum: 1, shared: true}).buffer;
|
||||
const data = new sourceRealm[type](buffer, 0, 4);
|
||||
let calls = 0;
|
||||
const rejected = throws('TypeError', () => construct(data, {valueOf() { calls++; return 1; }}, undefined, settings));
|
||||
return rejected && calls === 0;
|
||||
});
|
||||
check(type + ' clone preserves format pixels and independence', () => {
|
||||
const data = new sourceRealm[type](type === 'Float16Array' ? [-1, 0.5, 1024, 1] : [1, 127, 255, 17]);
|
||||
const image = construct(data, 1, 1, settings);
|
||||
const copy = realm.structuredClone(image);
|
||||
return copy instanceof C && copy.width === 1 && copy.height === 1 && copy.colorSpace === 'display-p3' &&
|
||||
copy.pixelFormat === format && copy.data instanceof realm[type] && copy.data !== data && copy.data.buffer !== data.buffer &&
|
||||
same(Array.from(copy.data), Array.from(data));
|
||||
});
|
||||
for (const first of ['image', 'data']) check(type + ' clone graph identity ' + first, () => {
|
||||
const data = new sourceRealm[type](new sourceRealm.ArrayBuffer(12 * bytesPerElement), 4 * bytesPerElement, 4);
|
||||
const image = construct(data, 1, 1, settings);
|
||||
const object = first === 'image' ? {image, data, buffer: data.buffer} : {data, buffer: data.buffer, image};
|
||||
object.again = image;
|
||||
const copy = realm.structuredClone(object);
|
||||
return copy.image === copy.again && copy.image.data === copy.data && copy.data.buffer === copy.buffer &&
|
||||
copy.data.byteOffset === 4 * bytesPerElement && copy.buffer.byteLength === 12 * bytesPerElement;
|
||||
});
|
||||
check(type + ' clone transferred backing buffer graph', () => {
|
||||
const data = new sourceRealm[type]([1, 0, 1, 1]);
|
||||
const image = construct(data, 1, 1, settings);
|
||||
const copy = realm.structuredClone({image, data, buffer: data.buffer}, {transfer: [data.buffer]});
|
||||
return data.byteLength === 0 && image.width === 1 && copy.image.data === copy.data && copy.data.buffer === copy.buffer &&
|
||||
same(Array.from(copy.data), [1, 0, 1, 1]);
|
||||
});
|
||||
check(type + ' detached data cannot clone', () => {
|
||||
const data = new sourceRealm[type](4), image = construct(data, 1, 1, settings);
|
||||
sourceRealm.structuredClone(data.buffer, {transfer: [data.buffer]});
|
||||
return throws('DataCloneError', () => realm.structuredClone(image));
|
||||
});
|
||||
}
|
||||
const image = construct(1, 1);
|
||||
for (const attribute of ['width', 'height', 'data', 'colorSpace', 'pixelFormat']) {
|
||||
const getter = Object.getOwnPropertyDescriptor(C.prototype, attribute).get;
|
||||
const revoked = sourceRealm.Proxy.revocable(image, {}); revoked.revoke();
|
||||
for (const [index, receiver] of [null, undefined, {}, Object.create(C.prototype), Object.create(image), new sourceRealm.Proxy(image, {}), revoked.proxy].entries()) {
|
||||
check(attribute + ' rejects receiver ' + index, () => throws('TypeError', () => Reflect.apply(getter, receiver, [])));
|
||||
}
|
||||
}
|
||||
check('native dimensions ignore author properties', () => {
|
||||
const data = new sourceRealm.Uint8ClampedArray(8);
|
||||
for (const key of ['byteLength', 'length', 'buffer']) Object.defineProperty(data, key, {get() { throw Error('author ' + key); }});
|
||||
const result = construct(data, 2);
|
||||
return result.width === 2 && result.height === 1 && result.data === data;
|
||||
});
|
||||
check('subclass initializes native ImageData state', () => {
|
||||
class Child extends C {}
|
||||
const result = new Child(1, 2);
|
||||
return result instanceof Child && result instanceof C && result.width === 1 && result.height === 2;
|
||||
});
|
||||
check('clone ignores poisoned globals and instance accessors', () => {
|
||||
const image = construct(new sourceRealm.Uint8ClampedArray([1, 2, 3, 4]), 1, 1);
|
||||
for (const key of ['width', 'height', 'data', 'colorSpace', 'pixelFormat']) Object.defineProperty(image, key, {get() { throw Error('author ' + key); }});
|
||||
const original = realm.ImageData;
|
||||
try {
|
||||
realm.ImageData = function() { throw Error('author constructor'); };
|
||||
const copy = realm.structuredClone(image);
|
||||
return copy instanceof C && copy.width === 1 && same(Array.from(copy.data), [1, 2, 3, 4]);
|
||||
} finally { realm.ImageData = original; }
|
||||
});
|
||||
return checks;
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
use super::*;
|
||||
use v8::ValueSerializerHelper;
|
||||
|
||||
#[test]
|
||||
fn image_data_constructors_and_clone_graphs_preserve_native_state_across_realms() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://image-data-native.test/");
|
||||
vm.eval("document.body.innerHTML='<iframe id=child></iframe>'")
|
||||
.unwrap();
|
||||
vm.eval(&format!(
|
||||
"const imageDataProbe={};const imageDataRealms=[globalThis,document.getElementById('child').contentWindow];\
|
||||
globalThis.imageDataChecks=[];\
|
||||
for(let source=0;source<2;source++)for(let callee=0;callee<2;callee++)\
|
||||
imageDataChecks.push(...imageDataProbe(imageDataRealms[source],imageDataRealms[callee],source+'-'+callee));",
|
||||
include_str!("image_data_native.js"),
|
||||
)).unwrap();
|
||||
assert_eq!(vm.eval("imageDataChecks.length").unwrap(), "544");
|
||||
assert_eq!(
|
||||
vm.eval("JSON.stringify(imageDataChecks.filter(row=>!row.passed))")
|
||||
.unwrap(),
|
||||
"[]"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_data_accessors_accept_registered_native_proxy_identity() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://image-data-proxy.test/");
|
||||
vm.eval("globalThis.imageDataNative=new ImageData(new Float16Array([-1,0.5,2,1]),1,1,{colorSpace:'display-p3',pixelFormat:'rgba-float16'});").unwrap();
|
||||
let context_ptr = &vm.page_default_runtime.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, "imageDataNative");
|
||||
let target =
|
||||
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, target, handler).unwrap();
|
||||
moli_webapi_declare::register_web_api_proxy(scope, proxy)?;
|
||||
let key = crate::util::v8str(scope, "imageDataProxy");
|
||||
assert_eq!(
|
||||
global.create_data_property(scope, key.into(), proxy.into()),
|
||||
Some(true)
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(vm.eval(r#"(() => {
|
||||
for(const name of ['width','height','data','colorSpace','pixelFormat']) {
|
||||
const get=Object.getOwnPropertyDescriptor(ImageData.prototype,name).get;
|
||||
if(get.call(imageDataProxy)!==get.call(imageDataNative))throw Error(name+' native identity');
|
||||
let rejected=false;
|
||||
try{get.call(new Proxy(imageDataProxy,{}));}catch(error){rejected=error instanceof TypeError;}
|
||||
if(!rejected)throw Error(name+' author proxy');
|
||||
}
|
||||
const context=new OffscreenCanvas(1,1).getContext('2d');
|
||||
context.putImageData(imageDataProxy,0,0);
|
||||
return Array.from(context.getImageData(0,0,1,1).data).join();
|
||||
})()"#).unwrap(), "0,128,255,255");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_data_indexeddb_preserves_typed_arrays_and_shared_graph_references() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://image-data-storage.test/");
|
||||
vm.eval(r#"(() => {
|
||||
globalThis.imageDataStorage='pending';
|
||||
const rows=[];
|
||||
for(const [ArrayType,pixelFormat] of [[Uint8ClampedArray,'rgba-unorm8'],[Float16Array,'rgba-float16']]) {
|
||||
const buffer=new ArrayBuffer(ArrayType.BYTES_PER_ELEMENT*12);
|
||||
const data=new ArrayType(buffer,ArrayType.BYTES_PER_ELEMENT*4,4);
|
||||
data.set([1,0,1,1]);
|
||||
const image=new ImageData(data,1,1,{pixelFormat,colorSpace:'display-p3'});
|
||||
rows.push({image,again:image,data,buffer});
|
||||
}
|
||||
const request=indexedDB.open('image-data-graph-'+Math.random(),1);
|
||||
const fail=event=>{imageDataStorage='error:'+event.target.error?.name;};
|
||||
request.onerror=fail;
|
||||
request.onupgradeneeded=()=>request.result.createObjectStore('values');
|
||||
request.onsuccess=()=>{
|
||||
const db=request.result,write=db.transaction('values','readwrite');
|
||||
write.onerror=fail;write.objectStore('values').put(rows,'pixels');
|
||||
rows[0].data[0]=99;rows[1].data[0]=-99;
|
||||
write.oncomplete=()=>{
|
||||
const read=db.transaction('values').objectStore('values').get('pixels');read.onerror=fail;
|
||||
read.onsuccess=()=>{
|
||||
try {
|
||||
imageDataStorage=read.result.length===2&&read.result.every((row,index)=>
|
||||
row.image instanceof ImageData&&row.image===row.again&&row.image.data===row.data&&row.data.buffer===row.buffer&&
|
||||
row.data.byteOffset===4*(index?2:1)&&row.buffer.byteLength===12*(index?2:1)&&
|
||||
row.image.pixelFormat===(index?'rgba-float16':'rgba-unorm8')&&row.image.colorSpace==='display-p3'&&
|
||||
Array.from(row.data).join()==='1,0,1,1'&&row.data instanceof (index?Float16Array:Uint8ClampedArray));
|
||||
}finally{db.close();}
|
||||
};
|
||||
};
|
||||
};
|
||||
})()"#).unwrap();
|
||||
assert_eq!(
|
||||
vm.eval_after_selected_page_tasks("String(imageDataStorage)")
|
||||
.unwrap(),
|
||||
"true"
|
||||
);
|
||||
}
|
||||
|
||||
struct LegacyImageDataWriter;
|
||||
|
||||
impl v8::ValueSerializerImpl for LegacyImageDataWriter {
|
||||
fn throw_data_clone_error<'s>(
|
||||
&self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
message: v8::Local<'s, v8::String>,
|
||||
) {
|
||||
let error = v8::Exception::error(scope, message);
|
||||
scope.throw_exception(error);
|
||||
}
|
||||
|
||||
fn has_custom_host_object(&self, _isolate: &v8::Isolate) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
fn is_host_object<'s>(
|
||||
&self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
) -> Option<bool> {
|
||||
Some(crate::web_api_interfaces::ImageData::is_instance(
|
||||
scope, object,
|
||||
))
|
||||
}
|
||||
|
||||
fn write_host_object<'s>(
|
||||
&self,
|
||||
_scope: &mut v8::PinScope<'s, '_>,
|
||||
_object: v8::Local<'s, v8::Object>,
|
||||
serializer: &dyn v8::ValueSerializerHelper,
|
||||
) -> Option<bool> {
|
||||
// The pre-graph record consists of tag, dimensions, color-space bytes
|
||||
// and RGBA8 bytes. Keep this independent of the current writer.
|
||||
for value in [2, 1, 2, 10] {
|
||||
serializer.write_uint32(value);
|
||||
}
|
||||
serializer.write_raw_bytes(b"display-p3");
|
||||
serializer.write_uint32(8);
|
||||
serializer.write_raw_bytes(&[1, 2, 3, 4, 5, 6, 7, 8]);
|
||||
Some(true)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_data_legacy_serialized_records_remain_readable() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://image-data-legacy.test/");
|
||||
vm.eval("globalThis.legacyImageDataSource=new ImageData(1,2)")
|
||||
.unwrap();
|
||||
let context_ptr = &vm.page_default_runtime.context as *const _;
|
||||
vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
|
||||
let context = scope.get_current_context();
|
||||
let global = context.global(scope);
|
||||
let key = crate::util::v8str(scope, "legacyImageDataSource");
|
||||
let source = global.get(scope, key.into()).unwrap();
|
||||
let serializer = v8::ValueSerializer::new(scope, Box::new(LegacyImageDataWriter));
|
||||
serializer.write_header();
|
||||
assert_eq!(serializer.write_value(context, source), Some(true));
|
||||
let mut payload = crate::structured_clone::V8StructuredClonePayload::default();
|
||||
payload.base.wire_bytes = serializer.release();
|
||||
drop(serializer);
|
||||
let result = crate::structured_clone::deserialize_from_wire(scope, &payload).unwrap();
|
||||
let key = crate::util::v8str(scope, "legacyImageDataResult");
|
||||
assert_eq!(
|
||||
global.create_data_property(scope, key.into(), result),
|
||||
Some(true)
|
||||
);
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(vm.eval("[legacyImageDataResult instanceof ImageData,legacyImageDataResult.width,legacyImageDataResult.height,legacyImageDataResult.colorSpace,legacyImageDataResult.pixelFormat,Array.from(legacyImageDataResult.data)].join('|')").unwrap(), "true|1|2|display-p3|rgba-unorm8|1,2,3,4,5,6,7,8");
|
||||
}
|
||||
@@ -2305,6 +2305,7 @@ mod device_events;
|
||||
mod document_shadow_handler_receivers;
|
||||
mod document_svg_root;
|
||||
mod image_bitmap_tasks;
|
||||
mod image_data_native;
|
||||
mod payment_events;
|
||||
mod payment_request;
|
||||
mod reporting_observer;
|
||||
|
||||
@@ -19,7 +19,7 @@ use crate::{
|
||||
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, build_quota_exceeded_error_object,
|
||||
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,
|
||||
@@ -60,6 +60,7 @@ const HOST_OBJECT_TAG_VIDEO_FRAME: u32 = 15;
|
||||
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;
|
||||
const HOST_OBJECT_TAG_TRANSFERRED_MESSAGE_PORT: u32 = 22;
|
||||
const HOST_OBJECT_TAG_RTC_ENCODED_AUDIO_FRAME: u32 = 16;
|
||||
const HOST_OBJECT_TAG_RTC_ENCODED_VIDEO_FRAME: u32 = 17;
|
||||
@@ -582,8 +583,7 @@ impl v8::ValueSerializerImpl for WireSerializer {
|
||||
}
|
||||
Some("ImageData") => {
|
||||
if let Some(payload) = image_data_clone_payload_from_object(scope, object) {
|
||||
write_image_data_payload(serializer, payload);
|
||||
return Some(true);
|
||||
return write_image_data_payload(scope, serializer, payload);
|
||||
}
|
||||
}
|
||||
Some("VideoFrame") => {
|
||||
@@ -916,6 +916,7 @@ impl v8::ValueDeserializerImpl for WireDeserializer {
|
||||
ensure_message_port_wrapper_for_id(scope, port_id)
|
||||
}
|
||||
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_VIDEO_FRAME => {
|
||||
let info = read_raw_vec(deserializer)
|
||||
.and_then(|bytes| serde_json::from_slice(&bytes).ok());
|
||||
@@ -1216,17 +1217,42 @@ pub(crate) fn build_blob_object_from_clone_payload<'s>(
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn write_image_data_payload(
|
||||
pub(crate) fn write_image_data_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
serializer: &dyn v8::ValueSerializerHelper,
|
||||
payload: ImageDataClonePayload,
|
||||
) {
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_IMAGE_DATA);
|
||||
payload: ImageDataClonePayload<'s>,
|
||||
) -> Option<bool> {
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_IMAGE_DATA_GRAPH);
|
||||
serializer.write_uint32(payload.width);
|
||||
serializer.write_uint32(payload.height);
|
||||
write_raw_vec(serializer, payload.color_space.as_bytes());
|
||||
write_raw_vec(serializer, &payload.bytes);
|
||||
write_string(serializer, &payload.color_space);
|
||||
write_string(serializer, payload.pixel_format.label());
|
||||
serializer.write_value(scope.get_current_context(), payload.data.into())
|
||||
}
|
||||
|
||||
pub(crate) fn read_image_data_graph_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
deserializer: &dyn v8::ValueDeserializerHelper,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let width = read_u32(deserializer)?;
|
||||
let height = read_u32(deserializer)?;
|
||||
let color_space = read_string(deserializer)?;
|
||||
let pixel_format = read_string(deserializer)?.parse().ok()?;
|
||||
let data = deserializer.read_value(scope.get_current_context())?;
|
||||
let data = v8::Local::<v8::ArrayBufferView>::try_from(data).ok()?;
|
||||
build_image_data_object_from_clone_payload(
|
||||
scope,
|
||||
ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space,
|
||||
pixel_format,
|
||||
data,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// Keep the original byte-only record readable for existing IndexedDB/history data.
|
||||
pub(crate) fn read_image_data_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
deserializer: &dyn v8::ValueDeserializerHelper,
|
||||
@@ -1244,15 +1270,7 @@ pub(crate) fn read_image_data_payload<'s>(
|
||||
throw_data_clone_exception(scope, "Failed to deserialize ImageData pixel data.");
|
||||
return None;
|
||||
};
|
||||
build_image_data_object_from_clone_payload(
|
||||
scope,
|
||||
ImageDataClonePayload {
|
||||
width,
|
||||
height,
|
||||
color_space,
|
||||
bytes,
|
||||
},
|
||||
)
|
||||
build_image_data_object_from_legacy_bytes(scope, width, height, color_space, bytes)
|
||||
}
|
||||
|
||||
fn write_geometry_clone_payload(
|
||||
|
||||
Reference in New Issue
Block a user