From 88d6d203c19b274b275d48b321b28fec4d454b49 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Tue, 13 Oct 2026 02:55:28 +0800 Subject: [PATCH] fix(canvas): preserve pixel rectangles and native receivers --- .../src/context_bootstrap/canvas.rs | 16 +- .../src/context_bootstrap/canvas/context2d.rs | 215 +-------------- .../canvas/context2d/pixel_manipulation.rs | 247 ++++++++++++++++++ .../context_bootstrap/media_file_template.rs | 35 +-- .../script_vm/tests/canvas_pixel_geometry.js | 140 ++++++++++ .../script_vm/tests/canvas_pixel_geometry.rs | 78 ++++++ moli-renderer-v8/src/script_vm/tests/mod.rs | 1 + moli-webapi/src/image_data.rs | 9 + .../wpt/ported/idl/canvas2d-idlharness.html | 1 + 9 files changed, 497 insertions(+), 245 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/canvas/context2d/pixel_manipulation.rs create mode 100644 moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.js create mode 100644 moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.rs diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs index 351df20b11c..7e992c833f2 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs @@ -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::{ diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs index 17b303dda9f..67a4e58accd 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs @@ -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::::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::(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::(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::(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::(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 { - 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 { - 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; diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/context2d/pixel_manipulation.rs b/moli-renderer-v8/src/context_bootstrap/canvas/context2d/pixel_manipulation.rs new file mode 100644 index 00000000000..22de229683c --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/canvas/context2d/pixel_manipulation.rs @@ -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 { + 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::(scope, &args) else { + return; + }; + (parsed.width.unsigned_abs(), parsed.height.unsigned_abs()) + } else { + let Some(parsed) = webidl::parse_args::(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::(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::(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::(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, + ); + }); +} diff --git a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs index 682e1d3a7dd..e38328294c1 100644 --- a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs +++ b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs @@ -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); diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.js b/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.js new file mode 100644 index 00000000000..a6901d6f5c8 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.js @@ -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=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; +} diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.rs b/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.rs new file mode 100644 index 00000000000..f556edd0ae0 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/tests/canvas_pixel_geometry.rs @@ -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=''") + .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::::try_from(global.get(scope, key.into()).unwrap()).unwrap(); + let mut proxies = Vec::new(); + for index in 0..objects.length() { + let target = + v8::Local::::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"); +} diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index 762be5e2006..2a74066cc79 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -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; diff --git a/moli-webapi/src/image_data.rs b/moli-webapi/src/image_data.rs index 3cc76701351..c3ba6a04e06 100644 --- a/moli-webapi/src/image_data.rs +++ b/moli-webapi/src/image_data.rs @@ -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 { + let view = get_private_value(scope, object, IMAGE_DATA_DATA_SLOT) + .and_then(|value| v8::Local::::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>, diff --git a/moli-wpt-compat/fixtures/wpt/ported/idl/canvas2d-idlharness.html b/moli-wpt-compat/fixtures/wpt/ported/idl/canvas2d-idlharness.html index 8cdfca9e779..4d92aaf9c97 100644 --- a/moli-wpt-compat/fixtures/wpt/ported/idl/canvas2d-idlharness.html +++ b/moli-wpt-compat/fixtures/wpt/ported/idl/canvas2d-idlharness.html @@ -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 = {});