fix(canvas): preserve pixel rectangles and native receivers

This commit is contained in:
ldm0
2026-11-22 02:02:01 +08:00
parent 9430aa450b
commit 88d6d203c1
9 changed files with 497 additions and 245 deletions
@@ -119,12 +119,11 @@ pub(crate) use constructors::{
pub(crate) use context2d::{
canvas_context_arc_callback, canvas_context_arc_to_callback,
canvas_context_begin_path_callback, canvas_context_bezier_curve_to_callback,
canvas_context_close_path_callback, canvas_context_create_image_data_callback,
canvas_context_create_linear_gradient_callback, canvas_context_ellipse_callback,
canvas_context_fill_callback, canvas_context_fill_style_getter_callback,
canvas_context_fill_style_setter_callback, canvas_context_fill_text_callback,
canvas_context_font_getter_callback, canvas_context_font_setter_callback,
canvas_context_get_image_data_callback, canvas_context_get_line_dash_callback,
canvas_context_close_path_callback, canvas_context_create_linear_gradient_callback,
canvas_context_ellipse_callback, canvas_context_fill_callback,
canvas_context_fill_style_getter_callback, canvas_context_fill_style_setter_callback,
canvas_context_fill_text_callback, canvas_context_font_getter_callback,
canvas_context_font_setter_callback, canvas_context_get_line_dash_callback,
canvas_context_global_alpha_getter_callback, canvas_context_global_alpha_setter_callback,
canvas_context_global_composite_operation_getter_callback,
canvas_context_global_composite_operation_setter_callback,
@@ -139,7 +138,7 @@ pub(crate) use context2d::{
canvas_context_line_width_getter_callback, canvas_context_line_width_setter_callback,
canvas_context_measure_text_callback, canvas_context_miter_limit_getter_callback,
canvas_context_miter_limit_setter_callback, canvas_context_move_to_callback,
canvas_context_noop_callback, canvas_context_put_image_data_callback,
canvas_context_noop_callback,
canvas_context_quadratic_curve_to_callback, canvas_context_rect_callback,
canvas_context_reset_transform_callback, canvas_context_rotate_callback,
canvas_context_scale_callback, canvas_context_set_line_dash_callback,
@@ -147,7 +146,8 @@ pub(crate) use context2d::{
canvas_context_stroke_rect_callback, canvas_context_stroke_style_getter_callback,
canvas_context_stroke_style_setter_callback, canvas_context_stroke_text_callback,
canvas_context_transform_callback, canvas_context_translate_callback,
install_canvas_draw_image_bindings, install_canvas_rect_bindings, is_canvas_context_receiver,
install_canvas_draw_image_bindings, install_canvas_pixel_bindings,
install_canvas_rect_bindings, is_canvas_context_receiver,
};
pub(crate) use drawing_state::install_canvas_drawing_state_bindings;
pub(crate) use image_bitmap::{
@@ -1,22 +1,16 @@
use moli_webapi::canvas_context_values::ImageSmoothingQuality;
use super::backing_store::{
canvas_like_pixels_copy, canvas_owner_from_context, with_canvas_like_pixels_mut,
};
use super::backing_store::{canvas_owner_from_context, with_canvas_like_pixels_mut};
use super::helpers::{canonical_canvas_fill_style, canvas_unrestricted_double_arg};
use super::state::canvas_path_state;
use super::*;
use crate::context_bootstrap::image_data::{
build_image_data_object, build_image_data_object_with_bytes, image_data_bytes_from_object,
image_data_dimensions_from_object,
};
use crate::util::{get_private_value, set_private_value};
use crate::web_api_interfaces;
use crate::webidl;
use crate::webidl::dom_string_property_value as canvas_context_dom_string_value;
use moli_canvas::{
DEFAULT_FILL_STYLE, DEFAULT_FONT, blit_image_data, byte_len, draw_text, extract_image_data,
fill_style_rgba, measure_text_width, normalize_rect as canvas_normalize_rect, paint_rect,
DEFAULT_FILL_STYLE, DEFAULT_FONT, draw_text, fill_style_rgba, measure_text_width,
normalize_rect as canvas_normalize_rect, paint_rect,
};
use moli_layout::{
PaintBrush, PaintColor, PaintFragment, PaintLineCap, PaintLineJoin, PaintShape, PaintSnapshot,
@@ -106,57 +100,6 @@ struct CanvasContextMeasureTextArgs {
text: String,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.createImageData")]
struct CanvasContextCreateImageDataSizeArgs {
#[webidl(required, converter = "enforce_range_long")]
sw: i32,
#[webidl(required, converter = "enforce_range_long")]
sh: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.getImageData")]
struct CanvasContextGetImageDataArgs {
#[webidl(required, converter = "enforce_range_long")]
sx: i32,
#[webidl(required, converter = "enforce_range_long")]
sy: i32,
#[webidl(required, converter = "enforce_range_long")]
sw: i32,
#[webidl(required, converter = "enforce_range_long")]
sh: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.putImageData")]
struct CanvasContextPutImageDataArgs<'s> {
#[webidl(required)]
image_data: v8::Local<'s, v8::Object>,
#[webidl(required, converter = "enforce_range_long")]
dx: i32,
#[webidl(required, converter = "enforce_range_long")]
dy: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.putImageData")]
struct CanvasContextPutImageDataDirtyArgs<'s> {
#[webidl(required)]
image_data: v8::Local<'s, v8::Object>,
#[webidl(required, converter = "enforce_range_long")]
dx: i32,
#[webidl(required, converter = "enforce_range_long")]
dy: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyX")]
dirty_x: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyY")]
dirty_y: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyWidth")]
dirty_width: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyHeight")]
dirty_height: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.moveTo")]
@@ -1819,154 +1762,8 @@ fn canvas_context_relevant_context<'s>(
})
}
pub(crate) fn canvas_context_create_image_data_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let dimensions = if let Ok(object) = v8::Local::<v8::Object>::try_from(args.get(0)) {
image_data_dimensions_from_object(scope, object)
.or_else(|| image_data_width_height_from_webidl_args(scope, &args))
} else {
image_data_width_height_from_webidl_args(scope, &args)
};
let Some((width, height)) = dimensions else {
rv.set(v8::undefined(scope).into());
return;
};
let relevant_context = canvas_context_relevant_context(scope, args.this())
.unwrap_or_else(|| scope.get_current_context());
let target_scope = &mut v8::ContextScope::new(scope, relevant_context);
if let Some(image_data) = build_image_data_object(target_scope, width, height) {
rv.set(image_data.into());
} else {
rv.set(v8::undefined(target_scope).into());
}
}
pub(crate) fn canvas_context_put_image_data_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(canvas) = canvas_owner_from_context(scope, args.this()) else {
return;
};
let (image_data, dx, dy, dirty_rect) = if args.length() >= 7 {
let Some(parsed) = webidl::parse_args::<CanvasContextPutImageDataDirtyArgs>(scope, &args)
else {
return;
};
let dirty_rect = moli_canvas::ImageDataRect::new(
parsed.dirty_x,
parsed.dirty_y,
parsed.dirty_width,
parsed.dirty_height,
);
(parsed.image_data, parsed.dx, parsed.dy, Some(dirty_rect))
} else {
let Some(parsed) = webidl::parse_args::<CanvasContextPutImageDataArgs>(scope, &args) else {
return;
};
(parsed.image_data, parsed.dx, parsed.dy, None)
};
let Some((source_width, source_height)) = image_data_dimensions_from_object(scope, image_data)
else {
throw_type_error(
scope,
"CanvasRenderingContext2D.putImageData: argument 1 is not an ImageData object.",
);
return;
};
let Some(bytes) = image_data_bytes_from_object(scope, image_data) else {
return;
};
let dirty_rect = dirty_rect.unwrap_or_else(|| {
moli_canvas::ImageDataRect::new(0, 0, source_width as i32, source_height as i32)
});
let _ = with_canvas_like_pixels_mut(scope, canvas, |pixels, width, height| {
blit_image_data(
pixels,
width,
height,
&bytes,
source_width,
source_height,
dx,
dy,
dirty_rect,
);
});
}
pub(crate) fn canvas_context_get_image_data_callback<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let Some(parsed) = webidl::parse_args::<CanvasContextGetImageDataArgs>(scope, &args) else {
rv.set(v8::undefined(scope).into());
return;
};
let rect = moli_canvas::ImageDataRect::new(parsed.sx, parsed.sy, parsed.sw, parsed.sh);
let (width, height) = (rect.width(), rect.height());
if width == 0 || height == 0 {
webidl::throw_index_size_error(scope);
return;
}
if byte_len(width, height).is_none() {
webidl::throw_index_size_error(scope);
rv.set(v8::undefined(scope).into());
return;
}
let bytes = if let Some(canvas) = canvas_owner_from_context(scope, args.this()) {
canvas_like_pixels_copy(scope, canvas)
.map(|(pixels, canvas_width, canvas_height)| {
extract_image_data(&pixels, canvas_width, canvas_height, rect)
})
.unwrap_or_else(|| blank_image_data(width, height))
} else {
blank_image_data(width, height)
};
let relevant_context = canvas_context_relevant_context(scope, args.this())
.unwrap_or_else(|| scope.get_current_context());
let target_scope = &mut v8::ContextScope::new(scope, relevant_context);
let image_data = build_image_data_object_with_bytes(target_scope, width, height, bytes)
.or_else(|| build_image_data_object(target_scope, width, height));
let Some(image_data) = image_data else {
rv.set(v8::undefined(target_scope).into());
return;
};
rv.set(image_data.into());
}
fn image_data_width_height_from_webidl_args<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
) -> Option<(u32, u32)> {
let parsed = webidl::parse_args::<CanvasContextCreateImageDataSizeArgs>(scope, args)?;
let width = image_data_dimension_from_long(scope, parsed.sw)?;
let height = image_data_dimension_from_long(scope, parsed.sh)?;
if byte_len(width, height).is_none() {
webidl::throw_index_size_error(scope);
return None;
}
Some((width, height))
}
fn image_data_dimension_from_long(scope: &mut v8::PinScope<'_, '_>, value: i32) -> Option<u32> {
if value == 0 || value == i32::MIN {
webidl::throw_index_size_error(scope);
return None;
}
Some(value.unsigned_abs())
}
fn blank_image_data(width: u32, height: u32) -> Vec<u8> {
vec![0; byte_len(width, height).unwrap_or(0)]
}
mod draw_image;
pub(crate) use draw_image::install_canvas_draw_image_bindings;
mod pixel_manipulation;
pub(crate) use pixel_manipulation::install_canvas_pixel_bindings;
@@ -0,0 +1,247 @@
//! Canvas pixel operations: native receivers, overloads and signed rectangles.
use super::canvas_context_relevant_context;
use crate::context_bootstrap::{
canvas::backing_store::{
canvas_like_pixels_copy, canvas_owner_from_context, with_canvas_like_pixels_mut,
},
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,
},
throw_dom_exception_value,
};
use crate::{util::throw_type_error, web_api_interfaces, webidl};
use moli_canvas::{ImageDataRect, blit_image_data, byte_len, extract_image_data};
use moli_webapi_declare::{WebApiFunctionTemplate, web_api_object_target};
macro_rules! pixel_declaration {
($name:ident, $interface:path) => {
#[derive(WebApiFunctionTemplate)]
#[webapi(interface = $interface, enumerable)]
struct $name {
#[webapi(method = "createImageData", length = 1, callback = create_image_data)]
create: (),
#[webapi(method = "getImageData", length = 4, callback = get_image_data)]
get: (),
#[webapi(method = "putImageData", length = 3, callback = put_image_data)]
put: (),
}
};
}
pixel_declaration!(CanvasPixels, web_api_interfaces::CanvasRenderingContext2D);
pixel_declaration!(
OffscreenPixels,
web_api_interfaces::OffscreenCanvasRenderingContext2D
);
pub(crate) fn install_canvas_pixel_bindings<'s>(
scope: &mut v8::PinScope<'s, '_, ()>,
prototype: v8::Local<'s, v8::ObjectTemplate>,
interface: &str,
) {
match interface {
"CanvasRenderingContext2D" => CanvasPixels::initialize_prototype_template(scope, prototype),
"OffscreenCanvasRenderingContext2D" => {
OffscreenPixels::initialize_prototype_template(scope, prototype)
}
_ => unreachable!("only 2D contexts have pixel manipulation methods"),
}
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.createImageData")]
struct CreateSizeArgs {
#[webidl(required, converter = "enforce_range_long")]
width: i32,
#[webidl(required, converter = "enforce_range_long")]
height: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.createImageData")]
struct CreateSourceArgs<'s> {
#[webidl(required, interface = web_api_interfaces::ImageData)]
source: v8::Local<'s, v8::Object>,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.getImageData")]
struct GetArgs {
#[webidl(required, converter = "enforce_range_long")]
x: i32,
#[webidl(required, converter = "enforce_range_long")]
y: i32,
#[webidl(required, converter = "enforce_range_long")]
width: i32,
#[webidl(required, converter = "enforce_range_long")]
height: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.putImageData")]
struct PutArgs<'s> {
#[webidl(required, interface = web_api_interfaces::ImageData)]
source: v8::Local<'s, v8::Object>,
#[webidl(required, converter = "enforce_range_long")]
x: i32,
#[webidl(required, converter = "enforce_range_long")]
y: i32,
}
#[derive(webidl::WebIdlArgs)]
#[webidl(prefix = "CanvasRenderingContext2D.putImageData")]
struct PutDirtyArgs<'s> {
#[webidl(required, interface = web_api_interfaces::ImageData)]
source: v8::Local<'s, v8::Object>,
#[webidl(required, converter = "enforce_range_long")]
x: i32,
#[webidl(required, converter = "enforce_range_long")]
y: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyX")]
dirty_x: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyY")]
dirty_y: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyWidth")]
dirty_width: i32,
#[webidl(required, converter = "enforce_range_long", name = "dirtyHeight")]
dirty_height: i32,
}
fn validate_dimensions(scope: &mut v8::PinScope<'_, '_>, width: u32, height: u32) -> Option<usize> {
if width == 0 || height == 0 {
webidl::throw_index_size_error(scope);
return None;
}
byte_len(width, height).or_else(|| {
webidl::throw_index_size_error(scope);
None
})
}
fn create_image_data<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let context = web_api_object_target(scope, args.this()).expect("validated Canvas receiver");
// Overload selection uses argument count before any source inspection or conversion.
let (width, height) = if args.length() >= 2 {
let Some(parsed) = webidl::parse_args::<CreateSizeArgs>(scope, &args) else {
return;
};
(parsed.width.unsigned_abs(), parsed.height.unsigned_abs())
} else {
let Some(parsed) = webidl::parse_args::<CreateSourceArgs>(scope, &args) else {
return;
};
let source = web_api_object_target(scope, parsed.source).expect("validated ImageData");
let Some(dimensions) = image_data_dimensions_from_object(scope, source) else {
return;
};
dimensions
};
if validate_dimensions(scope, width, height).is_none() {
return;
}
let relevant = canvas_context_relevant_context(scope, context)
.unwrap_or_else(|| scope.get_current_context());
let scope = &mut v8::ContextScope::new(scope, relevant);
if let Some(image_data) = build_image_data_object(scope, width, height) {
rv.set(image_data.into());
}
}
fn get_image_data<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
mut rv: v8::ReturnValue<'_, v8::Value>,
) {
let context = web_api_object_target(scope, args.this()).expect("validated Canvas receiver");
let Some(parsed) = webidl::parse_args::<GetArgs>(scope, &args) else {
return;
};
let rect = ImageDataRect::new(parsed.x, parsed.y, parsed.width, parsed.height);
let (width, height) = (rect.width(), rect.height());
let Some(length) = validate_dimensions(scope, width, height) else {
return;
};
let bytes = canvas_owner_from_context(scope, context)
.and_then(|canvas| canvas_like_pixels_copy(scope, canvas))
.map(|(pixels, canvas_width, canvas_height)| {
extract_image_data(&pixels, canvas_width, canvas_height, rect)
})
.unwrap_or_else(|| vec![0; length]);
let relevant = canvas_context_relevant_context(scope, context)
.unwrap_or_else(|| scope.get_current_context());
let scope = &mut v8::ContextScope::new(scope, relevant);
if let Some(image_data) = build_image_data_object_with_bytes(scope, width, height, bytes) {
rv.set(image_data.into());
}
}
fn put_image_data<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: v8::FunctionCallbackArguments<'s>,
_rv: v8::ReturnValue<'_, v8::Value>,
) {
let context = web_api_object_target(scope, args.this()).expect("validated Canvas receiver");
let (source, x, y, dirty) = if args.length() >= 7 {
let Some(p) = webidl::parse_args::<PutDirtyArgs>(scope, &args) else {
return;
};
(
p.source,
p.x,
p.y,
Some(ImageDataRect::new(
p.dirty_x,
p.dirty_y,
p.dirty_width,
p.dirty_height,
)),
)
} else if args.length() == 3 {
let Some(p) = webidl::parse_args::<PutArgs>(scope, &args) else {
return;
};
(p.source, p.x, p.y, None)
} else {
throw_type_error(scope, "No matching putImageData overload.");
return;
};
let source = web_api_object_target(scope, source).expect("validated ImageData");
// Numeric conversion may detach the data. This check precedes even an empty dirty rectangle.
if image_data_buffer_is_detached(scope, source).unwrap_or(false) {
throw_dom_exception_value(
scope,
"The ImageData buffer is detached.",
"InvalidStateError",
);
return;
}
let Some((width, height)) = image_data_dimensions_from_object(scope, source) else {
return;
};
let Some(bytes) = image_data_bytes_from_object(scope, source) else {
return;
};
let dirty = dirty.unwrap_or_else(|| ImageDataRect::new(0, 0, width as i32, height as i32));
let Some(canvas) = canvas_owner_from_context(scope, context) else {
return;
};
let _ = with_canvas_like_pixels_mut(scope, canvas, |pixels, canvas_width, canvas_height| {
blit_image_data(
pixels,
canvas_width,
canvas_height,
&bytes,
width,
height,
x,
y,
dirty,
);
});
}
@@ -1,9 +1,8 @@
use super::canvas::{
canvas_context_begin_path_callback, canvas_context_create_image_data_callback,
canvas_context_create_linear_gradient_callback, canvas_context_fill_style_getter_callback,
canvas_context_fill_style_setter_callback, canvas_context_fill_text_callback,
canvas_context_font_getter_callback, canvas_context_font_setter_callback,
canvas_context_get_image_data_callback, canvas_context_get_line_dash_callback,
canvas_context_begin_path_callback, canvas_context_create_linear_gradient_callback,
canvas_context_fill_style_getter_callback, canvas_context_fill_style_setter_callback,
canvas_context_fill_text_callback, canvas_context_font_getter_callback,
canvas_context_font_setter_callback, canvas_context_get_line_dash_callback,
canvas_context_global_alpha_getter_callback, canvas_context_global_alpha_setter_callback,
canvas_context_global_composite_operation_getter_callback,
canvas_context_global_composite_operation_setter_callback,
@@ -17,14 +16,14 @@ use super::canvas::{
canvas_context_line_join_setter_callback, canvas_context_line_width_getter_callback,
canvas_context_line_width_setter_callback, canvas_context_measure_text_callback,
canvas_context_miter_limit_getter_callback, canvas_context_miter_limit_setter_callback,
canvas_context_noop_callback, canvas_context_put_image_data_callback,
canvas_context_noop_callback,
canvas_context_reset_transform_callback, canvas_context_rotate_callback,
canvas_context_scale_callback, canvas_context_set_line_dash_callback,
canvas_context_set_transform_callback,
canvas_context_stroke_rect_callback, canvas_context_stroke_style_getter_callback,
canvas_context_stroke_style_setter_callback, canvas_context_stroke_text_callback,
canvas_context_transform_callback, canvas_context_translate_callback,
install_canvas_draw_image_bindings, install_canvas_drawing_state_bindings, install_canvas_path_bindings, install_canvas_rect_bindings, install_canvas_style_state_bindings, install_canvas_template_bindings,
install_canvas_draw_image_bindings, install_canvas_pixel_bindings, install_canvas_drawing_state_bindings, install_canvas_path_bindings, install_canvas_rect_bindings, install_canvas_style_state_bindings, install_canvas_template_bindings,
install_canvas_transform_bindings, offscreen_canvas_convert_to_blob_callback,
offscreen_canvas_get_context_callback,
};
@@ -258,27 +257,6 @@ struct CanvasRenderingContext2dTemplateDeclaration {
callback = canvas_context_create_linear_gradient_callback
)]
create_linear_gradient: (),
#[webapi(
method = "createImageData",
length = 2,
callback = canvas_context_create_image_data_callback
)]
create_image_data: (),
#[webapi(
method = "putImageData",
length = 3,
callback = canvas_context_put_image_data_callback
)]
put_image_data: (),
#[webapi(
method = "getImageData",
length = 4,
callback = canvas_context_get_image_data_callback
)]
get_image_data: (),
}
pub(super) fn install_media_file_template_bindings<'s>(
@@ -305,6 +283,7 @@ pub(super) fn install_media_file_template_bindings<'s>(
install_canvas_transform_bindings(scope, proto, spec_name);
install_canvas_drawing_state_bindings(scope, proto, spec_name);
install_canvas_style_state_bindings(scope, proto, spec_name);
install_canvas_pixel_bindings(scope, proto, spec_name);
install_canvas_rect_bindings(scope, proto, spec_name);
install_canvas_path_bindings(scope, proto, spec_name);
install_canvas_draw_image_bindings(scope, proto, spec_name);
@@ -0,0 +1,140 @@
(owner, callee, kind, label) => {
const checks = [];
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 canvas = kind === 'element' ? owner.document.createElement('canvas') : new owner.OffscreenCanvas(6, 5);
canvas.width = 6; canvas.height = 5;
const context = canvas.getContext('2d');
const proto = callee[kind === 'element' ? 'CanvasRenderingContext2D' : 'OffscreenCanvasRenderingContext2D'].prototype;
const get = (...args) => Reflect.apply(proto.getImageData, context, args);
const put = (...args) => Reflect.apply(proto.putImageData, context, args);
const source = new owner.ImageData(4, 3);
for (let i = 0; i < 12; i++) source.data.set([(i*17+1)%256, (i*31+9)%256, (i*53+23)%256, 255], i*4);
const same = (actual, expected) => actual.length === expected.length && actual.every((v, i) => v === expected[i]);
let seed = 719;
const next = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed; };
const dirtyCases = [];
for (const destination of [-3, 0, 2]) for (const start of [-2, 0, 1, 4]) for (const span of [-5, -2, 0, 1, 3, 5]) {
dirtyCases.push([destination, 0, start, 0, span, 3]);
dirtyCases.push([0, destination, 0, start, 4, span]);
}
for (let i = 0; i < 160; i++) dirtyCases.push(Array.from({length: 6}, () => next()%13 - 6));
for (const bound of [-2147483648, 2147483647]) {
dirtyCases.push([0, 0, bound, 0, bound, 3], [0, 0, 1, 0, bound, 3],
[0, 0, 0, bound, 4, bound], [bound, 0, 0, 0, 4, 3],
[0, bound, 0, 0, 4, 3], [0, 0, bound, bound, 2, 2]);
}
dirtyCases.forEach(([dx, dy, x, y, w, h], index) => check('dirty rectangle ' + index, () => {
canvas.width = 6;
put(source, dx, dy, x, y, w, h);
const expected = [];
// Independent per-destination-pixel oracle: do not duplicate clipping/copy code.
for (let py = 0; py < 5; py++) for (let px = 0; px < 6; px++) {
const sx = px-dx, sy = py-dy;
const selected = sx >= 0 && sx < 4 && sy >= 0 && sy < 3 &&
sx >= Math.min(x,x+w) && sx < Math.max(x,x+w) &&
sy >= Math.min(y,y+h) && sy < Math.max(y,y+h);
expected.push(...(selected ? Array.from(source.data.slice((sy*4+sx)*4,(sy*4+sx+1)*4)) : [0,0,0,0]));
}
return same(Array.from(get(0,0,6,5).data), expected);
}));
const readCases=[];
for(const x of [-2,0,2,5]) for(const y of [-2,0,2,4])
for(const [w,h] of [[3,2],[-3,2],[3,-2],[-3,-2]]) readCases.push([x,y,w,h]);
for(const bound of [-2147483648,2147483647])
readCases.push([bound,0,-2,2],[0,bound,2,-2],[bound,bound,-2,-2]);
readCases.forEach(([x,y,w,h],index)=>check('read rectangle '+index,()=>{
canvas.width=6;put(source,1,1);
const data=get(x,y,w,h), expected=[];
for(let py=0;py<Math.abs(h);py++) for(let px=0;px<Math.abs(w);px++) {
const sx=Math.min(x,x+w)+px-1,sy=Math.min(y,y+h)+py-1;
expected.push(...(sx>=0&&sx<4&&sy>=0&&sy<3 ? Array.from(source.data.slice((sy*4+sx)*4,(sy*4+sx+1)*4)) : [0,0,0,0]));
}
return data.width===Math.abs(w)&&data.height===Math.abs(h)&&same(Array.from(data.data),expected);
}));
check('dirty write ignores drawing state',()=>{
canvas.width=6;
context.translate(100,100);context.globalAlpha=0;context.globalCompositeOperation='destination-out';
context.beginPath();context.rect(0,0,0,0);context.clip();
put(source,0,0,1,1,2,1);
return same(Array.from(get(1,1,2,1).data),Array.from(source.data.slice(20,28)));
});
check('numeric conversion can resize canvas',()=>{
canvas.width=6;
put(source,{valueOf(){canvas.width=7;return 1;}},0,1,0,1,1);
return same(Array.from(get(2,0,1,1).data),Array.from(source.data.slice(4,8)));
});
for(const name of ['getImageData','putImageData']) {
const revoked=owner.Proxy.revocable(context,{});revoked.revoke();
let hooks=0;
const author=new owner.Proxy(context,{get(){hooks++;throw Error('trap');},getPrototypeOf(){hooks++;throw Error('trap');}});
const receivers=[null,undefined,{},Object.create(proto),Object.create(context),author,revoked.proxy];
if(owner.document) receivers.push(kind==='element'?new owner.OffscreenCanvas(1,1).getContext('2d'):owner.document.createElement('canvas').getContext('2d'));
receivers.forEach((receiver,index)=>check(name+' receiver '+index,()=>{
const arg={valueOf(){hooks++;return 1;}};
try { Reflect.apply(proto[name],receiver,name==='getImageData'?[arg,0,1,1]:[source,arg,0]); }
catch(error) { return error instanceof callee.TypeError&&hooks===0; }
return false;
}));
}
for(let count=0;count<7;count++) if(count!==3) check('put arity '+count,()=>{
let conversions=0;
const args=[source,...Array.from({length:6},()=>({valueOf(){conversions++;return 0;}}))].slice(0,count);
try{put(...args);}catch(error){return error instanceof callee.TypeError&&conversions===0;}
return false;
});
const invalidSources=[{},Object.create(owner.ImageData.prototype),Object.create(source),new owner.Proxy(source,{})];
const revokedSource=owner.Proxy.revocable(source,{});revokedSource.revoke();invalidSources.push(revokedSource.proxy);
invalidSources.forEach((image,index)=>check('source brand '+index,()=>{
let conversions=0;
try{put(image,{valueOf(){conversions++;return 0;}},0);}catch(error){return error instanceof callee.TypeError&&conversions===0;}
return false;
}));
for(const dirty of [false,true]) check('detached buffer '+dirty,()=>{
const image=new owner.ImageData(1,1);owner.structuredClone(image.data.buffer,{transfer:[image.data.buffer]});
try{put(image,0,0,...(dirty?[0,0,0,0]:[]));}
catch(error){return error.name==='InvalidStateError'&&error instanceof callee.DOMException;}
return false;
});
check('conversion detaches source before dirty clipping',()=>{
const image=new owner.ImageData(1,1);
try{put(image,{valueOf(){owner.structuredClone(image.data.buffer,{transfer:[image.data.buffer]});return 0;}},0,2147483647,0,-2147483648,0);}
catch(error){return error.name==='InvalidStateError'&&error instanceof callee.DOMException;}
return false;
});
const create = (...args) => Reflect.apply(proto.createImageData, context, args);
check('create length is shortest overload',()=>proto.createImageData.length===1);
check('create negative dimensions allocate blank data',()=>{
const data=create(-2,-3);return data.width===2&&data.height===3&&Array.from(data.data).every(v=>v===0);
});
check('create single source clones dimensions without pixels',()=>{
const data=create(source);return data.width===4&&data.height===3&&Array.from(data.data).every(v=>v===0)&&data.data!==source.data;
});
check('create overload selected before source inspection',()=>{
const image=new owner.ImageData(4,3);let conversions=0;
image.valueOf=()=>{conversions++;return -2;};
const data=create(image,3);return conversions===1&&data.width===2&&data.height===3;
});
check('create does not convert non-interface single argument',()=>{
let conversions=0;
try{create({valueOf(){conversions++;return 2;}});}
catch(error){return error instanceof callee.TypeError&&conversions===0;}
return false;
});
check('create source dimensions survive detached pixels',()=>{
const image=new owner.ImageData(2,1);owner.structuredClone(image.data.buffer,{transfer:[image.data.buffer]});
const data=create(image);return data.width===2&&data.height===1&&data.data.length===8;
});
const revokedContext=owner.Proxy.revocable(context,{});revokedContext.revoke();
const createReceivers=[null,undefined,{},Object.create(proto),Object.create(context),new owner.Proxy(context,{}),revokedContext.proxy];
if(owner.document)createReceivers.push(kind==='element'?new owner.OffscreenCanvas(1,1).getContext('2d'):owner.document.createElement('canvas').getContext('2d'));
createReceivers.forEach((receiver,index)=>check('create receiver '+index,()=>{
let conversions=0;
try{Reflect.apply(proto.createImageData,receiver,[{valueOf(){conversions++;return 1;}},1]);}
catch(error){return error instanceof callee.TypeError&&conversions===0;}
return false;
}));
return checks;
}
@@ -0,0 +1,78 @@
use super::*;
#[test]
fn canvas_pixel_methods_preserve_rectangles_and_webidl_across_realms() {
let mut vm = new_storage_page_task_executor_test_vm("https://canvas-pixel-geometry.test/");
vm.eval("document.body.innerHTML='<iframe id=child></iframe>'")
.unwrap();
let script = format!(
r#"(() => {{
const probe = {};
const realms = [globalThis, document.getElementById('child').contentWindow];
const checks = [];
for(let owner=0;owner<2;owner++) for(let callee=0;callee<2;callee++)
for(const kind of ['element','offscreen'])
checks.push(...probe(realms[owner],realms[callee],kind,owner+'-'+callee+'-'+kind));
globalThis.__pixelGeometryChecks=checks;
return checks.length;
}})()"#,
include_str!("canvas_pixel_geometry.js")
);
assert_eq!(vm.eval(&script).unwrap(), "3456");
assert_eq!(
vm.eval("JSON.stringify(__pixelGeometryChecks.filter(row=>!row.passed))")
.unwrap(),
"[]"
);
}
#[test]
fn canvas_pixel_methods_share_registered_native_proxy_identity() {
let mut vm = new_storage_page_task_executor_test_vm("https://canvas-pixel-proxy.test/");
vm.eval(r#"
globalThis.pixelContexts=[document.createElement('canvas').getContext('2d'),new OffscreenCanvas(4,4).getContext('2d')];
globalThis.pixelSource=new ImageData(new Uint8ClampedArray([255,0,0,255,0,255,0,255]),2,1);
globalThis.pixelObjects=[...pixelContexts,pixelSource];
"#).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, "pixelObjects");
let objects =
v8::Local::<v8::Array>::try_from(global.get(scope, key.into()).unwrap()).unwrap();
let mut proxies = Vec::new();
for index in 0..objects.length() {
let target =
v8::Local::<v8::Object>::try_from(objects.get_index(scope, index).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).unwrap();
proxies.push(proxy.into());
}
let proxies = v8::Array::new_with_elements(scope, &proxies);
let key = crate::util::v8str(scope, "pixelProxies");
assert_eq!(
global.create_data_property(scope, key.into(), proxies.into()),
Some(true)
);
Ok(())
})
.unwrap();
assert_eq!(vm.eval(r#"(() => {
for(let index=0;index<2;index++) {
const proto=(index===0?CanvasRenderingContext2D:OffscreenCanvasRenderingContext2D).prototype;
const context=pixelProxies[index], source=pixelProxies[2];
proto.putImageData.call(context,source,0,0,1,0,1,1);
const actual=Array.from(proto.getImageData.call(context,2,1,-2,-1).data).join(',');
if(actual!=='0,0,0,0,0,255,0,255')throw Error('shared native rectangle '+actual);
const blank=proto.createImageData.call(context,source);
if(blank.width!==2||blank.height!==1||blank.data.some(value=>value!==0))throw Error('native source dimensions');
let calls=0,rejected=false;
try{proto.putImageData.call(context,new Proxy(source,{}),{valueOf(){calls++;return 0;}},0);}
catch(error){rejected=error instanceof TypeError;}
if(!rejected||calls!==0)throw Error('author source proxy');
}
return true;
})()"#).unwrap(), "true");
}
@@ -2311,6 +2311,7 @@ mod canvas_fill_rect;
mod canvas_image_proxies;
mod canvas_paths;
mod canvas_transfer_to_image_bitmap;
mod canvas_pixel_geometry;
mod canvas_style_state;
mod canvas_transform_snapshots;
+9
View File
@@ -388,6 +388,15 @@ fn image_data_string_from_object_slot<'s>(
.map(|value| value.to_rust_string_lossy(scope))
}
pub 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())
}
pub fn image_data_bytes_from_object<'s>(
scope: &mut v8::PinScope<'s, '_>,
object: v8::Local<'s, v8::Object>,
@@ -25,6 +25,7 @@ interface CanvasRenderingContext2D {
undefined strokeText(DOMString text, unrestricted double x, unrestricted double y, optional unrestricted double maxWidth);
object measureText(DOMString text);
ImageData createImageData([EnforceRange] long sw, [EnforceRange] long sh, optional ImageDataSettings settings = {});
ImageData createImageData(ImageData imagedata);
undefined putImageData(ImageData imagedata, [EnforceRange] long dx, [EnforceRange] long dy);
undefined putImageData(ImageData imagedata, [EnforceRange] long dx, [EnforceRange] long dy, [EnforceRange] long dirtyX, [EnforceRange] long dirtyY, [EnforceRange] long dirtyWidth, [EnforceRange] long dirtyHeight);
ImageData getImageData([EnforceRange] long sx, [EnforceRange] long sy, [EnforceRange] long sw, [EnforceRange] long sh, optional ImageDataSettings settings = {});