mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
fix(canvas): preserve pixel rectangles and native receivers
This commit is contained in:
@@ -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;
|
||||
|
||||
|
||||
@@ -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 = {});
|
||||
|
||||
Reference in New Issue
Block a user