diff --git a/moli-renderer-v8/src/blob.rs b/moli-renderer-v8/src/blob.rs index 8b8945a1970..c29eb6d69ca 100644 --- a/moli-renderer-v8/src/blob.rs +++ b/moli-renderer-v8/src/blob.rs @@ -1,8 +1,8 @@ use crate::native_bridge; use moli_file_api::{BlobData, BlobId, BlobStore}; pub(super) use moli_v8_util::buffer_source_bytes_from_value; -pub(crate) use moli_webapi::blob::world_wrapper; -use moli_webapi::blob::{BlobReadMode, BlobRuntime, blob_id_from_object}; +pub(crate) use moli_webapi::blob::{blob_id_from_object, world_wrapper}; +use moli_webapi::blob::{BlobReadMode, BlobRuntime}; pub(super) use moli_webapi::blob::{ blob_constructor_callback, blob_data_from_object, blob_mime_type_from_object, blob_size_from_object, build_blob_object, build_blob_object_from_data, diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs index d04833ffc4f..e7f60a97bab 100644 --- a/moli-renderer-v8/src/context_bootstrap.rs +++ b/moli-renderer-v8/src/context_bootstrap.rs @@ -285,12 +285,11 @@ use self::assets::{ pub(crate) use self::broadcast_channel::{ dispatch_authorized_page_broadcast_channel_event, dispatch_broadcast_channel_events_for_channel, }; -#[cfg(test)] -pub(crate) use self::canvas::try_append_canvas_path_rect_for_test; pub(crate) use self::canvas::{ - CanvasContextKind, attach_canvas_like_context_object, build_canvas_rendering_context_2d_object, - build_offscreen_canvas_object, build_webgl_context_object, build_webgl2_context_object, - canvas_like_to_data_url, reset_html_canvas_backing_store_for_dimension_assignment, + BitmapRejection, BitmapTaskResult, CanvasContextKind, attach_canvas_like_context_object, + build_canvas_rendering_context_2d_object, build_offscreen_canvas_object, + build_webgl_context_object, build_webgl2_context_object, canvas_like_to_data_url, + reset_html_canvas_backing_store_for_dimension_assignment, settle_bitmap_task_result, }; use self::constructors::illegal_constructor_callback; pub(crate) use self::constructors::{ diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs index 9ecb3a4bd48..15daa2a57dd 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs @@ -91,8 +91,6 @@ mod objects; mod offscreen; mod path; mod path2d; -#[cfg(test)] -pub(crate) use self::state::try_append_canvas_path_rect_for_test; mod state; mod transform; use moli_webapi::webgl; @@ -139,7 +137,10 @@ pub(crate) use context2d::{ canvas_path_move_to_callback, canvas_path_quadratic_curve_to_callback, canvas_path_rect_callback, install_canvas_rect_bindings, is_canvas_context_receiver, }; -pub(crate) use image_bitmap::window_create_image_bitmap_callback; +pub(crate) use image_bitmap::{ + BitmapRejection, BitmapTaskResult, settle_bitmap_task_result, + window_create_image_bitmap_callback, +}; pub(crate) use objects::{build_canvas_rendering_context_2d_object, build_offscreen_canvas_object}; pub(crate) use offscreen::{ offscreen_canvas_convert_to_blob_callback, offscreen_canvas_get_context_callback, diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs b/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs index 3904acc5ecf..4109f351b56 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/backing_store.rs @@ -47,14 +47,6 @@ pub(crate) fn attach_canvas_like_context_object<'s>( let _ = ensure_canvas_like_backing_store(scope, canvas); } -pub(super) fn canvas_like_has_context<'s>( - scope: &mut v8::PinScope<'s, '_>, - canvas: v8::Local<'s, v8::Object>, -) -> bool { - get_private_value(scope, canvas, CANVAS_HAS_CONTEXT_SLOT) - .is_some_and(|value| value.boolean_value(scope)) -} - pub(crate) fn reset_canvas_like_backing_store<'s>( scope: &mut v8::PinScope<'s, '_>, canvas: v8::Local<'s, v8::Object>, @@ -225,6 +217,13 @@ pub(super) fn canvas_like_dimensions<'s>( scope: &mut v8::PinScope<'s, '_>, canvas: v8::Local<'s, v8::Object>, ) -> Option<(u32, u32)> { + if html_canvas_identity(scope, canvas).is_some() { + let width = + crate::native_bridge::element::canvas_dimension_value(scope, canvas, "width", 300); + let height = + crate::native_bridge::element::canvas_dimension_value(scope, canvas, "height", 150); + return Some((width, height)); + } let width = canvas_like_dimension(scope, canvas, OFFSCREEN_CANVAS_WIDTH_SLOT, "width")?; let height = canvas_like_dimension(scope, canvas, OFFSCREEN_CANVAS_HEIGHT_SLOT, "height")?; Some((width, height)) diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs index 47705927f57..5f816e15d87 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs @@ -692,9 +692,9 @@ fn canvas_context_global_composite_operation_assign<'s>( value: v8::Local<'s, v8::Value>, ) { // Per HTML spec: setting an unrecognised value for globalCompositeOperation - // (legacy aliases like `darker`/`clear`/`highlight`, capitalised variants, + // (legacy aliases like `darker`/`highlight`, capitalised variants, // unknown strings) must leave the property unchanged. Only the canonical - // lowercase tokens listed in VALID_GLOBAL_COMPOSITE_OPERATIONS are accepted. + // lowercase tokens in the shared native compositor are accepted. let Some(string) = canvas_context_dom_string_value( scope, value, @@ -1746,8 +1746,22 @@ pub(crate) fn canvas_context_draw_image_callback<'s>( let Ok(source) = v8::Local::::try_from(args.get(0)) else { return; }; - let Some((source_pixels, source_width, source_height)) = - html_image_pixels_copy(scope, source).or_else(|| canvas_like_pixels_copy(scope, source)) + let bitmap_pixels = if super::image_bitmap::image_bitmap_receiver_branded(scope, source) { + let Some(pixels) = super::image_bitmap::image_bitmap_pixels_copy(scope, source) else { + crate::context_bootstrap::throw_dom_exception_value( + scope, + "The ImageBitmap is detached.", + "InvalidStateError", + ); + return; + }; + Some(pixels) + } else { + None + }; + let Some((source_pixels, source_width, source_height)) = bitmap_pixels + .or_else(|| html_image_pixels_copy(scope, source)) + .or_else(|| canvas_like_pixels_copy(scope, source)) else { return; }; diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs index 079479b4afe..ff24ade177c 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap.rs @@ -1,10 +1,35 @@ -use super::backing_store::{canvas_like_has_context, canvas_like_pixels_copy}; -use crate::{ - context_bootstrap::new_dom_exception_value, util::throw_type_error, web_api_interfaces, +use super::backing_store::canvas_like_pixels_copy; +use super::offscreen::offscreen_canvas_receiver_branded; +use super::*; +use crate::context_bootstrap::new_dom_exception_value; +use crate::util::{ + context_host_ptr_from_global_bridge, + get_private_value, set_private_value, }; +use crate::web_api_interfaces; + +mod options; +use options::{BitmapOptions, BitmapParameters}; + +#[derive(Debug)] +pub(crate) struct BitmapTaskResult { + width: u32, + height: u32, + pixels: Vec, + premultiplied: bool, +} + +#[derive(Clone, Copy, Debug)] +pub(crate) enum BitmapRejection { + InvalidState, +} + pub(super) use moli_webapi::image_bitmap::{ - build_image_bitmap_object, install_image_bitmap_template_bindings, + IMAGE_BITMAP_WIDTH_SLOT, IMAGE_BITMAP_HEIGHT_SLOT, IMAGE_BITMAP_PIXELS_SLOT, + IMAGE_BITMAP_PREMULTIPLIED_SLOT, build_image_bitmap_object, + install_image_bitmap_template_bindings, }; + pub(crate) fn window_create_image_bitmap_callback<'s>( scope: &mut v8::PinScope<'s, '_>, args: v8::FunctionCallbackArguments<'s>, @@ -14,64 +39,283 @@ pub(crate) fn window_create_image_bitmap_callback<'s>( throw_type_error(scope, "createImageBitmap is not a constructor"); return; } - if args.length() == 0 { - throw_type_error( - scope, - "Failed to execute 'createImageBitmap' on 'Window': 1 argument required, but only 0 present.", - ); - return; - } - let Ok(source) = v8::Local::::try_from(args.get(0)) else { - throw_type_error( - scope, - "Failed to execute 'createImageBitmap' on 'Window': The provided value is not a valid image source.", - ); - return; - }; - if !web_api_interfaces::OffscreenCanvas::is_instance(scope, source) { - throw_type_error( - scope, - "Failed to execute 'createImageBitmap' on 'Window': The provided value is not a valid image source.", - ); - return; - } - let Some(resolver) = v8::PromiseResolver::new(scope) else { rv.set_undefined(); return; }; let promise = resolver.get_promise(scope); - if !canvas_like_has_context(scope, source) { - let error = new_dom_exception_value( - scope, - "Failed to execute 'createImageBitmap' on 'Window': The ImageBitmap could not be allocated.", - "InvalidStateError", - ); + rv.set(promise.into()); + + // Promise-returning Web IDL operations turn conversion failures (including + // arbitrary getter exceptions) into rejections of the returned Promise. + let parsed = { + let try_catch = std::pin::pin!(v8::TryCatch::new(scope)); + let mut conversion_scope = try_catch.init(); + match parse_bitmap_arguments(&mut conversion_scope, &args) { + Ok(parsed) => Ok(parsed), + Err(error) => { + webidl::throw_error(&mut conversion_scope, &error); + let exception = conversion_scope + .exception() + .unwrap_or_else(|| v8::undefined(&conversion_scope).into()); + conversion_scope.reset(); + Err(exception) + } + } + }; + let (source, parameters) = match parsed { + Ok(parsed) => parsed, + Err(exception) => { + let _ = resolver.reject(scope, exception); + return; + } + }; + if parameters + .crop + .is_some_and(|[_, _, width, height]| width == 0 || height == 0) + { + let message = crate::util::v8str(scope, "The crop rectangle has a zero dimension."); + let error = v8::Exception::range_error(scope, message); let _ = resolver.reject(scope, error); - rv.set(promise.into()); return; } - - let Some((_pixels, width, height)) = canvas_like_pixels_copy(scope, source) else { - let error = new_dom_exception_value( - scope, - "Failed to execute 'createImageBitmap' on 'Window': The ImageBitmap could not be allocated.", - "InvalidStateError", - ); - let _ = resolver.reject(scope, error); - rv.set(promise.into()); + if parameters.options.resize_width == Some(0) || parameters.options.resize_height == Some(0) { + reject_bitmap(scope, resolver); + return; + } + // Snapshot only after all observable conversions, which may mutate or + // detach the source. No V8 handles or live DOM state cross the task boundary. + let input = match source.snapshot(scope) { + Some(input) => input, + None => { + reject_bitmap(scope, resolver); + return; + } + }; + let producer = context_host_ptr_from_global_bridge(scope).and_then(|host_ptr| { + // SAFETY: the bridge points at this callback's live Window host. + unsafe { &mut *host_ptr }.register_pending_bitmap_task(scope, resolver) + }); + let Some(producer) = producer else { + reject_bitmap(scope, resolver); return; }; - let Some(bitmap) = build_image_bitmap_object(scope, width, height) else { - let error = new_dom_exception_value( + match input { + BitmapInput::Pixels(image) => { + let _ = producer.send(parameters.apply(image)); + } + BitmapInput::Blob(bytes) => { + let decode = move || { + let result = moli_image::decode_raster_image(&bytes) + .map_err(|_| BitmapRejection::InvalidState) + .and_then(|decoded| parameters.apply(decoded.image)); + let _ = producer.send(result); + }; + if let Ok(handle) = tokio::runtime::Handle::try_current() { + handle.spawn_blocking(decode); + } else { + std::thread::spawn(decode); + } + } + } +} + +#[derive(Clone, Copy)] +enum BitmapSourceKind { + Blob, + Canvas, + ImageData, + ImageBitmap, +} + +struct BitmapSource<'s> { + object: v8::Local<'s, v8::Object>, + kind: BitmapSourceKind, +} + +impl<'s> webidl::WebIdlConverter<'s> for BitmapSource<'s> { + type Options = (); + + fn convert( + scope: &mut v8::PinScope<'s, '_>, + value: v8::Local<'s, v8::Value>, + context: webidl::Context, + _options: &(), + ) -> Result { + let object = webidl::convert::>(scope, value, context)?; + let kind = if crate::blob::blob_id_from_object(scope, object).is_some() { + BitmapSourceKind::Blob + } else if offscreen_canvas_receiver_branded(scope, object) || is_html_canvas(scope, object) + { + BitmapSourceKind::Canvas + } else if crate::context_bootstrap::image_data::is_image_data_object(scope, object) { + BitmapSourceKind::ImageData + } else if image_bitmap_receiver_branded(scope, object) { + BitmapSourceKind::ImageBitmap + } else { + return Err(webidl::WebIdlError::custom_message( + "The value is not a supported ImageBitmapSource.", + )); + }; + Ok(Self { object, kind }) + } +} + +fn is_html_canvas<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) -> bool { + crate::native_bridge::node_runtime_and_handle_from_object_or_detached(scope, object) + .ok() + .is_some_and(|(host, handle)| { + unsafe { &*host } + .dom_host() + .is_html_element_named(handle, "canvas") + }) +} + +enum BitmapInput { + Blob(Vec), + Pixels(moli_image::RgbaImage), +} + +impl<'s> BitmapSource<'s> { + fn snapshot(self, scope: &mut v8::PinScope<'s, '_>) -> Option { + let (pixels, width, height) = match self.kind { + BitmapSourceKind::Blob => { + return crate::blob::blob_bytes_from_object(scope, self.object) + .map(BitmapInput::Blob); + } + BitmapSourceKind::Canvas => canvas_like_pixels_copy(scope, self.object)?, + BitmapSourceKind::ImageData => { + let data = + crate::context_bootstrap::image_data::image_data_clone_payload_from_object( + scope, + self.object, + )?; + (data.bytes, data.width, data.height) + } + BitmapSourceKind::ImageBitmap => image_bitmap_pixels_copy(scope, self.object)?, + }; + if width == 0 || height == 0 { + return None; + } + moli_image::RgbaImage::try_new(width, height, pixels) + .ok() + .map(BitmapInput::Pixels) + } +} + +fn parse_bitmap_arguments<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: &v8::FunctionCallbackArguments<'s>, +) -> Result<(BitmapSource<'s>, BitmapParameters), webidl::WebIdlError> { + let context = |index| webidl::Context::argument("createImageBitmap", index); + if args.length() == 0 { + return Err(webidl::WebIdlError::missing_required(context(1))); + } + if matches!(args.length(), 3 | 4) { + return Err(webidl::WebIdlError::custom_message( + "The crop overload requires five arguments.", + )); + } + let source = webidl::argument::(scope, args, 0, context(1))?; + let crop = if args.length() >= 5 { + let mut crop = [0; 4]; + for (index, coordinate) in crop.iter_mut().enumerate() { + *coordinate = webidl::argument::( + scope, + args, + index as i32 + 1, + context(index + 2), + )? + .0; + } + Some(crop) + } else { + None + }; + let options_index = if crop.is_some() { 5 } else { 1 }; + let options = webidl::parse_dictionary::( + scope, + args.get(options_index), + context(options_index as usize + 1), + )? + .unwrap_or_default(); + Ok((source, BitmapParameters { crop, options })) +} + +pub(crate) fn settle_bitmap_task_result<'s>( + scope: &mut v8::PinScope<'s, '_>, + resolver: v8::Local<'s, v8::PromiseResolver>, + result: Result, +) { + let bitmap = result.ok().and_then(|result| { + let bitmap = build_image_bitmap_object(scope, result.width, result.height)?; + let pixels = + super::super::image_data::new_uint8_clamped_array_from_bytes(scope, result.pixels)?; + set_private_value(scope, bitmap, IMAGE_BITMAP_PIXELS_SLOT, pixels.into()); + set_private_value( scope, - "Failed to execute 'createImageBitmap' on 'Window': The ImageBitmap could not be allocated.", - "InvalidStateError", + bitmap, + IMAGE_BITMAP_PREMULTIPLIED_SLOT, + v8::Boolean::new(scope, result.premultiplied).into(), ); - let _ = resolver.reject(scope, error); - rv.set(promise.into()); - return; - }; - let _ = resolver.resolve(scope, bitmap.into()); - rv.set(promise.into()); + Some(bitmap) + }); + match bitmap { + Some(bitmap) => { + let _ = resolver.resolve(scope, bitmap.into()); + } + None => reject_bitmap(scope, resolver), + } +} + +fn reject_bitmap<'s>( + scope: &mut v8::PinScope<'s, '_>, + resolver: v8::Local<'s, v8::PromiseResolver>, +) { + let error = new_dom_exception_value( + scope, + "The image source could not be decoded or allocated.", + "InvalidStateError", + ); + let _ = resolver.reject(scope, error); +} + +pub(super) fn image_bitmap_pixels_copy<'s>( + scope: &mut v8::PinScope<'s, '_>, + bitmap: v8::Local<'s, v8::Object>, +) -> Option<(Vec, u32, u32)> { + if !image_bitmap_receiver_branded(scope, bitmap) { + return None; + } + let width = get_private_value(scope, bitmap, IMAGE_BITMAP_WIDTH_SLOT)?.uint32_value(scope)?; + let height = get_private_value(scope, bitmap, IMAGE_BITMAP_HEIGHT_SLOT)?.uint32_value(scope)?; + let view = v8::Local::::try_from(get_private_value( + scope, + bitmap, + IMAGE_BITMAP_PIXELS_SLOT, + )?) + .ok()?; + let mut pixels = vec![0; view.byte_length()]; + view.copy_contents(&mut pixels); + if get_private_value(scope, bitmap, IMAGE_BITMAP_PREMULTIPLIED_SLOT) + .is_some_and(|value| value.boolean_value(scope)) + { + for pixel in pixels.chunks_exact_mut(4) { + let alpha = u32::from(pixel[3]); + for channel in &mut pixel[..3] { + *channel = (u32::from(*channel) * 255 + alpha / 2) + .checked_div(alpha) + .unwrap_or(0) + .min(255) as u8; + } + } + } + Some((pixels, width, height)) +} + +pub(super) fn image_bitmap_receiver_branded<'s>( + scope: &mut v8::PinScope<'s, '_>, + receiver: v8::Local<'s, v8::Object>, +) -> bool { + web_api_interfaces::ImageBitmap::is_instance(scope, receiver) } diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs new file mode 100644 index 00000000000..e6bd222f9fa --- /dev/null +++ b/moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs @@ -0,0 +1,191 @@ +use super::{BitmapRejection, BitmapTaskResult}; +use crate::webidl; +use moli_canvas::{DrawImageBlit, ScaleFilter, blit_draw_image_filtered, byte_len}; +use moli_image::RgbaImage; +use std::str::FromStr; + +#[derive(Clone, Copy, Default, strum::EnumString, webidl::WebIdlEnum)] +#[webidl(name = "ImageOrientation", parse_with = Self::parse)] +enum ImageOrientation { + #[default] + #[strum(serialize = "from-image")] + FromImage, + #[strum(serialize = "flipY")] + FlipY, +} + +impl ImageOrientation { + fn parse(value: &str) -> Option { + Self::from_str(value).ok() + } +} + +#[derive(Clone, Copy, Default, strum::EnumString, webidl::WebIdlEnum)] +#[webidl(name = "PremultiplyAlpha", parse_with = Self::parse)] +#[strum(serialize_all = "lowercase")] +enum PremultiplyAlpha { + None, + Premultiply, + #[default] + Default, +} + +impl PremultiplyAlpha { + fn parse(value: &str) -> Option { + Self::from_str(value).ok() + } +} + +#[derive(Clone, Copy, Default, strum::EnumString, webidl::WebIdlEnum)] +#[webidl(name = "ColorSpaceConversion", parse_with = Self::parse)] +#[strum(serialize_all = "lowercase")] +enum ColorSpaceConversion { + None, + #[default] + Default, +} + +impl ColorSpaceConversion { + fn parse(value: &str) -> Option { + Self::from_str(value).ok() + } +} + +#[derive(Clone, Copy, Default, strum::EnumString, webidl::WebIdlEnum)] +#[webidl(name = "ResizeQuality", parse_with = Self::parse)] +#[strum(serialize_all = "lowercase")] +enum ResizeQuality { + Pixelated, + #[default] + Low, + Medium, + High, +} + +impl ResizeQuality { + fn parse(value: &str) -> Option { + Self::from_str(value).ok() + } +} + +#[derive(Default, webidl::WebIdlDictionary)] +#[webidl(prefix = "ImageBitmapOptions")] +pub(super) struct BitmapOptions { + // The raster backend leaves color profiles unconverted in both modes. + // Members are declared in Web IDL's observable lexicographic read order. + #[webidl(name = "colorSpaceConversion", converter = "enum", default = ColorSpaceConversion::Default)] + _color_space_conversion: ColorSpaceConversion, + #[webidl(converter = "enum", default = ImageOrientation::FromImage)] + image_orientation: ImageOrientation, + #[webidl(converter = "enum", default = PremultiplyAlpha::Default)] + premultiply_alpha: PremultiplyAlpha, + #[webidl(converter = "enforce_range_unsigned_long")] + pub(super) resize_height: Option, + #[webidl(converter = "enum", default = ResizeQuality::Low)] + resize_quality: ResizeQuality, + #[webidl(converter = "enforce_range_unsigned_long")] + pub(super) resize_width: Option, +} + +pub(super) struct BitmapParameters { + pub(super) crop: Option<[i32; 4]>, + pub(super) options: BitmapOptions, +} + +impl BitmapParameters { + pub(super) fn apply(self, image: RgbaImage) -> Result { + if image.width == 0 || image.height == 0 { + return Err(BitmapRejection::InvalidState); + } + let [mut x, mut y, mut width, mut height] = self + .crop + .map(|crop| crop.map(f64::from)) + .unwrap_or([0.0, 0.0, f64::from(image.width), f64::from(image.height)]); + // Negative extents select the rectangle on the other side of the + // origin; they do not mirror its pixels. + if width < 0.0 { + x += width; + width = -width; + } + if height < 0.0 { + y += height; + height = -height; + } + let (output_width, output_height) = + match (self.options.resize_width, self.options.resize_height) { + (Some(w), Some(h)) => (w, h), + (Some(w), None) => (w, (height * f64::from(w) / width).ceil() as u32), + (None, Some(h)) => ((width * f64::from(h) / height).ceil() as u32, h), + (None, None) => (width as u32, height as u32), + }; + if output_width == 0 || output_height == 0 { + return Err(BitmapRejection::InvalidState); + } + let len = byte_len(output_width, output_height).ok_or(BitmapRejection::InvalidState)?; + let mut pixels = if x == 0.0 + && y == 0.0 + && width == f64::from(image.width) + && height == f64::from(image.height) + && output_width == image.width + && output_height == image.height + { + image.rgba + } else { + let mut pixels = vec![0; len]; + let blit = DrawImageBlit::new( + x, + y, + width, + height, + 0.0, + 0.0, + f64::from(output_width), + f64::from(output_height), + ) + .ok_or(BitmapRejection::InvalidState)?; + let filter = if matches!(self.options.resize_quality, ResizeQuality::Pixelated) { + ScaleFilter::Nearest + } else { + ScaleFilter::Bilinear + }; + blit_draw_image_filtered( + &mut pixels, + output_width, + output_height, + &image.rgba, + image.width, + image.height, + blit, + filter, + ); + pixels + }; + if matches!(self.options.image_orientation, ImageOrientation::FlipY) { + let row_len = output_width as usize * 4; + for y in 0..output_height as usize / 2 { + let bottom = (output_height as usize - y - 1) * row_len; + let (top_rows, bottom_rows) = pixels.split_at_mut(bottom); + top_rows[y * row_len..(y + 1) * row_len] + .swap_with_slice(&mut bottom_rows[..row_len]); + } + } + let premultiplied = matches!( + self.options.premultiply_alpha, + PremultiplyAlpha::Premultiply + ); + if premultiplied { + for pixel in pixels.chunks_exact_mut(4) { + let alpha = u32::from(pixel[3]); + for channel in &mut pixel[..3] { + *channel = ((u32::from(*channel) * alpha + 127) / 255) as u8; + } + } + } + Ok(BitmapTaskResult { + width: output_width, + height: output_height, + pixels, + premultiplied, + }) + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/state.rs b/moli-renderer-v8/src/context_bootstrap/canvas/state.rs index 2280504fea9..af72b743531 100644 --- a/moli-renderer-v8/src/context_bootstrap/canvas/state.rs +++ b/moli-renderer-v8/src/context_bootstrap/canvas/state.rs @@ -130,20 +130,6 @@ pub(super) fn reset_canvas_state<'s>( } } -#[cfg(test)] -pub(crate) fn try_append_canvas_path_rect_for_test<'s>( - scope: &mut v8::PinScope<'s, '_>, - object: v8::Local<'s, v8::Object>, - [x, y, width, height]: [f64; 4], -) -> bool { - let path = canvas_path_state(scope, object); - let Ok(mut path) = path.try_borrow_mut() else { - return false; - }; - path.rect(x, y, width, height); - true -} - #[cfg(test)] mod tests { use super::*; diff --git a/moli-renderer-v8/src/native_bridge/context_host/bitmap_tasks.rs b/moli-renderer-v8/src/native_bridge/context_host/bitmap_tasks.rs new file mode 100644 index 00000000000..d165bf2a175 --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/bitmap_tasks.rs @@ -0,0 +1,110 @@ +use super::*; + +pub(crate) struct PendingBitmapTask { + pub(crate) execution_context: super::WindowExecutionContextIdentity, + pub(crate) relevant_context: super::WindowExecutionContextBinding, + pub(crate) resolver: v8::Global, +} + +impl PageScriptHost { + pub(crate) fn register_pending_bitmap_task( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + resolver: v8::Local<'_, v8::PromiseResolver>, + ) -> Option { + let task_id = self.next_bitmap_task_id; + self.next_bitmap_task_id = self + .next_bitmap_task_id + .checked_next() + .expect("Page Bitmap task id overflow"); + let execution_context = self.current_runtime_window_execution_context_identity(scope)?; + let relevant_context = super::WindowExecutionContextBinding::new( + execution_context.owner(), + execution_context.dispatch_scope(), + execution_context.realm_token(), + v8::Global::new(scope, scope.get_current_context()), + ); + let producer = self + .page_bitmap_task_sender() + .bind_task(execution_context, task_id); + let replaced = self.pending_bitmap_tasks.insert( + task_id, + PendingBitmapTask { + execution_context, + relevant_context, + resolver: v8::Global::new(scope, resolver), + }, + ); + assert!( + replaced.is_none(), + "Page Bitmap task ids must never be reused" + ); + tracing::debug!( + task_id = task_id.task_id(), + ?execution_context, + "registered Bitmap task with Window execution context" + ); + Some(producer) + } + + pub(crate) fn current_pending_bitmap_task_execution_context( + &self, + task: crate::page_task_queue::RendererPageBitmapTaskId, + ) -> Option { + let pending = self.pending_bitmap_tasks.get(&task)?; + if !self.window_execution_context_identity_is_current(pending.execution_context) { + return None; + } + Some(pending.execution_context) + } + + pub(crate) fn take_pending_bitmap_task_for_exact_owner( + &mut self, + execution_context: super::WindowExecutionContextIdentity, + task: crate::page_task_queue::RendererPageBitmapTaskId, + ) -> Option { + let pending = self.pending_bitmap_tasks.get(&task)?; + if pending.execution_context != execution_context { + return None; + } + self.pending_bitmap_tasks.remove(&task) + } + + pub(crate) fn retire_bitmap_execution_context_owner( + &mut self, + retired_owner: super::WindowExecutionContextOwner, + ) -> usize { + let count_before = self.pending_bitmap_tasks.len(); + self.pending_bitmap_tasks + .retain(|_, pending| pending.relevant_context.owner() != retired_owner); + let retired_count = count_before - self.pending_bitmap_tasks.len(); + tracing::debug!( + ?retired_owner, + retired_count, + "retired Bitmap tasks with Window execution context" + ); + retired_count + } + + pub(crate) fn retire_bitmap_context_token( + &mut self, + context_token: super::RuntimeObservableContextToken, + ) -> usize { + let count_before = self.pending_bitmap_tasks.len(); + self.pending_bitmap_tasks + .retain(|_, pending| pending.relevant_context.realm_token() != context_token); + let retired_count = count_before - self.pending_bitmap_tasks.len(); + if retired_count > 0 { + tracing::debug!( + ?context_token, + retired_count, + "retired Bitmap tasks with destroyed V8 context" + ); + } + retired_count + } + + pub(crate) fn has_pending_bitmap_tasks(&self) -> bool { + !self.pending_bitmap_tasks.is_empty() + } +} diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs index 8a86eafc43a..32dbf19114b 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -513,7 +513,9 @@ impl PageScriptHost { pending_image_decode_requests: HashMap::new(), resource_timing_buffers: SharedResourceTimingBufferRegistry::new(), pending_font_face_loads: HashMap::new(), + next_bitmap_task_id: crate::page_task_queue::RendererPageBitmapTaskId::first(), next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId::first(), + pending_bitmap_tasks: HashMap::new(), pending_webcrypto_tasks: HashMap::new(), opfs_owner_state: None, history_queue: HistoryQueueState::default(), @@ -1148,6 +1150,16 @@ impl PageScriptHost { .worker_host_bridge() } + pub(crate) fn page_bitmap_task_sender( + &self, + ) -> &crate::page_task_queue::RendererPageBitmapTaskSender { + self.page_task_capabilities + .get() + .expect( + "a live Page Window must install its complete Page task capabilities before Bitmap registration", + ) + .bitmap_task() + } pub(crate) fn page_webcrypto_task_sender( &self, ) -> &crate::page_task_queue::RendererPageWebCryptoTaskSender { diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs index 197d0d5d6d7..137c7363fb6 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -156,6 +156,7 @@ mod security_policy; mod selection_records; mod service_workers; pub(crate) use service_workers::ServiceWorkerWindowOwner; +mod bitmap_tasks; mod document_execution_context; mod font_face_loads; mod shared_workers; @@ -1007,7 +1008,10 @@ pub(crate) struct PageScriptHost { pending_image_decode_requests: HashMap, resource_timing_buffers: SharedResourceTimingBufferRegistry, pending_font_face_loads: HashMap, + next_bitmap_task_id: crate::page_task_queue::RendererPageBitmapTaskId, next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId, + pending_bitmap_tasks: + HashMap, pending_webcrypto_tasks: HashMap< crate::page_task_queue::RendererPageWebCryptoTaskId, webcrypto_tasks::PendingWebCryptoTask, diff --git a/moli-renderer-v8/src/native_bridge/context_host/popups.rs b/moli-renderer-v8/src/native_bridge/context_host/popups.rs index 3c71987d47a..582e72efd7e 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/popups.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/popups.rs @@ -2256,6 +2256,8 @@ impl PageScriptHost { .retire_owner(execution_context_owner); let retired_timer_count = unsafe { &mut *self.document_runtime } .cancel_window_execution_context_timers(execution_context_owner); + let retired_bitmap_count = + self.retire_bitmap_execution_context_owner(execution_context_owner); let retired_webcrypto_count = self.retire_webcrypto_execution_context_owner(execution_context_owner); self.retire_opfs_execution_context_owner(execution_context_owner); @@ -2283,6 +2285,7 @@ impl PageScriptHost { tracing::debug!( ?execution_context_owner, retired_timer_count, + retired_bitmap_count, retired_webcrypto_count, retired_worker_count, retired_shared_worker_count, diff --git a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs index 7b52ceb3a3e..7d29dc0f5cf 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs @@ -111,6 +111,7 @@ impl PageScriptHost { let timers = self.cancel_timers_for_context_token(realm_token); let bindings = self.retire_runtime_binding_context_token(realm_token); let images = self.retire_image_decode_requests_for_context_token(realm_token); + let bitmaps = self.retire_bitmap_context_token(realm_token); let crypto = self.retire_webcrypto_context_token(realm_token); let fonts = self.retire_font_face_loads_for_context_token(realm_token); self.retire_opfs_context_token(realm_token); @@ -128,6 +129,7 @@ impl PageScriptHost { timers, bindings = bindings.retired_execution_context_count(), images, + bitmaps, crypto, fonts, workers, diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs index d9a540d448d..4037e42ccf6 100644 --- a/moli-renderer-v8/src/native_bridge/element.rs +++ b/moli-renderer-v8/src/native_bridge/element.rs @@ -256,7 +256,7 @@ pub(super) use attributes::{ node_toggle_attribute_callback, }; pub(crate) use canvas::{ - canvas_get_context_callback, canvas_to_data_url_callback, + canvas_dimension_value, canvas_get_context_callback, canvas_to_data_url_callback, canvas_transfer_control_to_offscreen_callback, }; pub(crate) use canvas::{ diff --git a/moli-renderer-v8/src/native_bridge/element/canvas.rs b/moli-renderer-v8/src/native_bridge/element/canvas.rs index 081d92cc2ee..46a0de883d1 100644 --- a/moli-renderer-v8/src/native_bridge/element/canvas.rs +++ b/moli-renderer-v8/src/native_bridge/element/canvas.rs @@ -123,7 +123,7 @@ fn set_canvas_dimension_attribute<'s>( true } -fn canvas_dimension_value<'s>( +pub(crate) fn canvas_dimension_value<'s>( scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>, name: &str, diff --git a/moli-renderer-v8/src/page_task_queue.rs b/moli-renderer-v8/src/page_task_queue.rs index bd40f9692b6..057d6ba3aee 100644 --- a/moli-renderer-v8/src/page_task_queue.rs +++ b/moli-renderer-v8/src/page_task_queue.rs @@ -1,3 +1,4 @@ +mod bitmap_task; mod broadcast_channel_delivery; mod child_frame_task; mod child_module_dependency_fetch_start; @@ -155,6 +156,11 @@ pub(crate) struct PageWindowDocumentTaskTurnAction { impl PageWindowDocumentTaskTurnAction {} +pub(crate) use self::bitmap_task::{ + PageBitmapTaskTargetEffect, PageBitmapTaskTurnAction, PageBitmapTaskTurnOutcome, + RendererPageBitmapTask, RendererPageBitmapTaskId, RendererPageBitmapTaskOwner, + RendererPageBitmapTaskProducer, RendererPageBitmapTaskSender, +}; pub(crate) use self::broadcast_channel_delivery::{ PageBroadcastChannelDeliveryDocumentEffect, PageBroadcastChannelDeliveryTurnAction, PageBroadcastChannelDeliveryTurnOutcome, RendererPageBroadcastChannelDeliveryOwner, diff --git a/moli-renderer-v8/src/page_task_queue/bitmap_task.rs b/moli-renderer-v8/src/page_task_queue/bitmap_task.rs new file mode 100644 index 00000000000..901374829c6 --- /dev/null +++ b/moli-renderer-v8/src/page_task_queue/bitmap_task.rs @@ -0,0 +1,257 @@ +use moli_owner_queue::{OwnerReadyTaskRoute, OwnerReadyTaskSource}; + +use crate::{ + context_bootstrap::{BitmapRejection, BitmapTaskResult}, + native_bridge::WindowExecutionContextIdentity, + resource_ready::{ReadyPageTask, RendererPageTaskReadyMetadata}, + runtime::{PageOwnerTurnOutcome, RendererDocumentToken}, +}; + +use super::{RendererOwnerWakeSender, RendererOwnerWakeSource, RendererPageTaskReadySignal}; + +/// PageVm-local identity of one pending Bitmap Promise. +/// +/// The id is never reused within a PageVm. The enclosing task owner carries +/// the root Page and Window-realm identities, so `document.open()` can preserve +/// Window-owned Bitmap work without projecting a Document identity into +/// the task identity. +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] +pub(crate) struct RendererPageBitmapTaskId(u64); + +impl RendererPageBitmapTaskId { + pub(crate) const fn first() -> Self { + Self(1) + } + + #[cfg(test)] + pub(crate) const fn new(task_id: u64) -> Self { + assert!(task_id != 0, "Bitmap task id must be non-zero"); + Self(task_id) + } + + pub(crate) const fn task_id(self) -> u64 { + self.0 + } + + pub(crate) const fn checked_next(self) -> Option { + match self.0.checked_add(1) { + Some(task_id) => Some(Self(task_id)), + None => None, + } + } +} + +/// Exact owner of one page-side Bitmap completion. +/// +/// The root token prevents PageVm-local ids from colliding across navigation. +/// The Window identity binds the Promise relevant realm. The task id then +/// identifies the pending resolver within that PageVm/realm. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct RendererPageBitmapTaskOwner { + root_document: RendererDocumentToken, + execution_context: WindowExecutionContextIdentity, + task: RendererPageBitmapTaskId, +} + +impl RendererPageBitmapTaskOwner { + pub(crate) const fn new( + root_document: RendererDocumentToken, + execution_context: WindowExecutionContextIdentity, + task: RendererPageBitmapTaskId, + ) -> Self { + Self { + root_document, + execution_context, + task, + } + } + + pub(crate) const fn root_document(self) -> RendererDocumentToken { + self.root_document + } + + pub(crate) const fn execution_context(self) -> WindowExecutionContextIdentity { + self.execution_context + } + + pub(crate) const fn task(self) -> RendererPageBitmapTaskId { + self.task + } +} + +#[derive(Debug)] +pub(crate) struct RendererPageBitmapTask { + owner: RendererPageBitmapTaskOwner, + result: Result, +} + +impl RendererPageBitmapTask { + fn new( + owner: RendererPageBitmapTaskOwner, + result: Result, + ) -> Self { + Self { owner, result } + } + + pub(crate) const fn owner(&self) -> RendererPageBitmapTaskOwner { + self.owner + } + + pub(crate) fn into_result(self) -> Result { + self.result + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct RendererPageBitmapTaskRouteClosed; + +#[derive(Clone, Debug)] +pub(crate) struct RendererPageBitmapTaskRoute { + task_route: + OwnerReadyTaskRoute, RendererPageTaskReadySignal>, +} + +impl RendererPageBitmapTaskRoute { + pub(crate) fn sender( + &self, + root_document: RendererDocumentToken, + ) -> RendererPageBitmapTaskSender { + RendererPageBitmapTaskSender { + task_route: self.task_route.clone(), + root_document, + } + } + + fn same_route_as(&self, source: &RendererPageBitmapTaskSource) -> bool { + self.task_route.same_source_as(&source.source) + } +} + +/// PageVm-stamped route used only while a Bitmap Promise is registered. +#[derive(Clone, Debug)] +pub(crate) struct RendererPageBitmapTaskSender { + task_route: + OwnerReadyTaskRoute, RendererPageTaskReadySignal>, + root_document: RendererDocumentToken, +} + +impl RendererPageBitmapTaskSender { + pub(crate) fn bind_task( + &self, + execution_context: WindowExecutionContextIdentity, + task: RendererPageBitmapTaskId, + ) -> RendererPageBitmapTaskProducer { + RendererPageBitmapTaskProducer { + task_route: self.task_route.clone(), + owner: RendererPageBitmapTaskOwner::new(self.root_document, execution_context, task), + } + } +} + +/// Single-use completion capability retained by one blocking bitmap job. +/// +/// Consuming `self` makes duplicate delivery impossible without cloning and +/// rebuilding the exact task at registration time. +#[derive(Debug)] +pub(crate) struct RendererPageBitmapTaskProducer { + task_route: + OwnerReadyTaskRoute, RendererPageTaskReadySignal>, + owner: RendererPageBitmapTaskOwner, +} + +impl RendererPageBitmapTaskProducer { + #[cfg(test)] + pub(crate) const fn owner(&self) -> RendererPageBitmapTaskOwner { + self.owner + } + + pub(crate) fn send( + self, + result: Result, + ) -> Result<(), RendererPageBitmapTaskRouteClosed> { + self.task_route + .send_and_signal_if_newly_ready(ReadyPageTask::new(RendererPageBitmapTask::new( + self.owner, result, + ))) + .map_err(|_| RendererPageBitmapTaskRouteClosed) + } +} + +/// Unique Page-lifetime consumer for completed Bitmap operations. +#[derive(Debug)] +pub(crate) struct RendererPageBitmapTaskSource { + source: + OwnerReadyTaskSource, RendererPageTaskReadySignal>, +} + +impl RendererPageBitmapTaskSource { + pub(crate) fn new(owner_wake: RendererOwnerWakeSender) -> Self { + Self { + source: OwnerReadyTaskSource::new(RendererPageTaskReadySignal::new( + owner_wake, + RendererOwnerWakeSource::BitmapTask, + )), + } + } + + pub(crate) fn route(&self) -> RendererPageBitmapTaskRoute { + RendererPageBitmapTaskRoute { + task_route: self.source.route(), + } + } + + pub(crate) fn next_ready_metadata(&mut self) -> Option { + self.source.front().map(ReadyPageTask::metadata) + } + + pub(crate) fn next_ready_owner(&mut self) -> Option { + self.source.front().map(|ready| ready.value().owner()) + } + + pub(crate) fn pop_front( + &mut self, + ) -> Option<(RendererPageTaskReadyMetadata, RendererPageBitmapTask)> { + self.source.pop_front().map(ReadyPageTask::into_parts) + } + + pub(crate) fn has_ready_task(&mut self) -> bool { + !self.source.is_empty() + } + + pub(crate) fn clear(&mut self) { + self.source.clear_local(); + } + + pub(crate) fn route_matches(&self, route: &RendererPageBitmapTaskRoute) -> bool { + route.same_route_as(self) + } +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum PageBitmapTaskTargetEffect { + SettledCurrentOwner, + IgnoredStaleOwner { + current_owner: Option, + }, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct PageBitmapTaskTurnAction { + pub(crate) owner: RendererPageBitmapTaskOwner, + pub(crate) target_effect: PageBitmapTaskTargetEffect, +} + +impl PageBitmapTaskTurnAction { + /// Whether the exact pending Promise was settled in its relevant realm. + /// + /// This reports the domain effect only. The selected-task dispatcher + /// decides which task-end checkpoint that effect requires. + pub(crate) const fn settled_current_owner(self) -> bool { + matches!( + self.target_effect, + PageBitmapTaskTargetEffect::SettledCurrentOwner + ) + } +} + +pub(crate) type PageBitmapTaskTurnOutcome = PageOwnerTurnOutcome; diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources.rs b/moli-renderer-v8/src/page_task_queue/owner_sources.rs index 9011293e9a9..5b3a82f8ec2 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources.rs @@ -17,6 +17,10 @@ use std::{cell::RefCell, rc::Rc}; use super::{ PageRuntimeWakeSignal, RendererOwnerWakeSender, RendererOwnerWakeSource, + bitmap_task::{ + RendererPageBitmapTask, RendererPageBitmapTaskOwner, RendererPageBitmapTaskRoute, + RendererPageBitmapTaskSender, RendererPageBitmapTaskSource, + }, child_frame_task::{ RendererPageChildFrameTask, RendererPageChildFrameTaskOwner, RendererPageChildFrameTaskRoute, RendererPageChildFrameTaskSender, @@ -177,6 +181,7 @@ pub(crate) struct RendererPageOwnedTaskSources { shared_worker_client_event: RendererPageSharedWorkerClientEventSource, service_worker_internal: RendererPageServiceWorkerInternalSource, service_worker_client_message: RendererPageServiceWorkerClientMessageSource, + bitmap_task: RendererPageBitmapTaskSource, webcrypto_task: RendererPageWebCryptoTaskSource, indexed_db_task: RendererPageIndexedDbTaskSource, opfs_task: RendererPageOpfsTaskSource, @@ -213,6 +218,7 @@ pub(crate) struct RendererPageTaskProducerRoutes { shared_worker_client_event: RendererPageSharedWorkerClientEventRoute, service_worker_internal: RendererPageServiceWorkerInternalRoute, service_worker_client_message: RendererPageServiceWorkerClientMessageRoute, + bitmap_task: RendererPageBitmapTaskRoute, webcrypto_task: RendererPageWebCryptoTaskRoute, indexed_db_task: RendererPageIndexedDbTaskRoute, opfs_task: RendererPageOpfsTaskRoute, @@ -292,6 +298,10 @@ pub(crate) enum RendererPageReadyDescriptor { ready: RendererPageTaskReadyMetadata, owner: RendererPageServiceWorkerClientMessageOwner, }, + BitmapTask { + ready: RendererPageTaskReadyMetadata, + owner: RendererPageBitmapTaskOwner, + }, WebCryptoTask { ready: RendererPageTaskReadyMetadata, owner: RendererPageWebCryptoTaskOwner, @@ -381,6 +391,7 @@ impl RendererPageReadyDescriptor { | Self::SharedWorkerClientEvent { ready, .. } | Self::ServiceWorkerInternal { ready, .. } | Self::ServiceWorkerClientMessage { ready, .. } + | Self::BitmapTask { ready, .. } | Self::WebCryptoTask { ready, .. } | Self::IndexedDbTask { ready, .. } | Self::OpfsTask { ready, .. } @@ -425,6 +436,7 @@ impl RendererPageReadyDescriptor { Self::ServiceWorkerClientMessage { .. } => { RendererPageTaskSourceKind::ServiceWorkerClientMessage } + Self::BitmapTask { .. } => RendererPageTaskSourceKind::BitmapTask, Self::WebCryptoTask { .. } => RendererPageTaskSourceKind::WebCryptoTask, Self::IndexedDbTask { .. } => RendererPageTaskSourceKind::IndexedDbTask, Self::OpfsTask { .. } => RendererPageTaskSourceKind::OpfsTask, @@ -470,6 +482,7 @@ impl RendererPageReadyDescriptor { | Self::SharedWorkerClientEvent { ready, .. } | Self::ServiceWorkerInternal { ready, .. } | Self::ServiceWorkerClientMessage { ready, .. } + | Self::BitmapTask { ready, .. } | Self::WebCryptoTask { ready, .. } | Self::IndexedDbTask { ready, .. } | Self::OpfsTask { ready, .. } @@ -516,6 +529,7 @@ pub(crate) enum RendererPageTaskSourceKind { SharedWorkerClientEvent, ServiceWorkerInternal, ServiceWorkerClientMessage, + BitmapTask, WebCryptoTask, IndexedDbTask, OpfsTask, @@ -535,7 +549,7 @@ pub(crate) enum RendererPageTaskSourceKind { } impl RendererPageTaskSourceKind { - pub(crate) const ALL: [Self; 29] = [ + pub(crate) const ALL: [Self; 30] = [ Self::ActionWindow, Self::Timer, Self::DomManipulation, @@ -549,6 +563,7 @@ impl RendererPageTaskSourceKind { Self::SharedWorkerClientEvent, Self::ServiceWorkerInternal, Self::ServiceWorkerClientMessage, + Self::BitmapTask, Self::WebCryptoTask, Self::IndexedDbTask, Self::OpfsTask, @@ -589,6 +604,7 @@ pub(crate) enum RendererPageSchedulerTask { SharedWorkerClientEvent(RendererPageSharedWorkerClientEventTask), ServiceWorkerInternal(RendererPageServiceWorkerInternalTask), ServiceWorkerClientMessage(RendererPageServiceWorkerClientMessageTask), + BitmapTask(RendererPageBitmapTask), WebCryptoTask(RendererPageWebCryptoTask), IndexedDbTask(RendererPageIndexedDbTask), OpfsTask(RendererPageOpfsTask), @@ -651,6 +667,7 @@ impl RendererPageOwnedTaskSources { RendererPageServiceWorkerInternalSource::new(owner_wake.clone()); let service_worker_client_message = RendererPageServiceWorkerClientMessageSource::new(owner_wake.clone()); + let bitmap_task = RendererPageBitmapTaskSource::new(owner_wake.clone()); let webcrypto_task = RendererPageWebCryptoTaskSource::new(owner_wake.clone()); let indexed_db_task = RendererPageIndexedDbTaskSource::new(owner_wake.clone()); let opfs_task = RendererPageOpfsTaskSource::new(owner_wake.clone()); @@ -685,6 +702,7 @@ impl RendererPageOwnedTaskSources { shared_worker_client_event: shared_worker_client_event.route(), service_worker_internal: service_worker_internal.route(), service_worker_client_message: service_worker_client_message.route(), + bitmap_task: bitmap_task.route(), webcrypto_task: webcrypto_task.route(), indexed_db_task: indexed_db_task.route(), opfs_task: opfs_task.route(), @@ -716,6 +734,7 @@ impl RendererPageOwnedTaskSources { shared_worker_client_event, service_worker_internal, service_worker_client_message, + bitmap_task, webcrypto_task, indexed_db_task, opfs_task, @@ -769,6 +788,7 @@ impl RendererPageOwnedTaskSources { && self .service_worker_client_message .route_matches(&routes.service_worker_client_message) + && self.bitmap_task.route_matches(&routes.bitmap_task) && self.webcrypto_task.route_matches(&routes.webcrypto_task) && self.indexed_db_task.route_matches(&routes.indexed_db_task) && self.opfs_task.route_matches(&routes.opfs_task) @@ -837,6 +857,7 @@ impl RendererPageOwnedTaskSources { shared_worker_client_event: self.shared_worker_client_event.route(), service_worker_internal: self.service_worker_internal.route(), service_worker_client_message: self.service_worker_client_message.route(), + bitmap_task: self.bitmap_task.route(), webcrypto_task: self.webcrypto_task.route(), indexed_db_task: self.indexed_db_task.route(), opfs_task: self.opfs_task.route(), @@ -947,6 +968,15 @@ impl RendererPageOwnedTaskSources { .expect("ready SharedWorker client event must retain its exact owner"), }, ); + let bitmap_task = self.bitmap_task.next_ready_metadata().map(|ready| { + RendererPageReadyDescriptor::BitmapTask { + ready, + owner: self + .bitmap_task + .next_ready_owner() + .expect("ready Bitmap task must retain its exact owner"), + } + }); let webcrypto_task = self.webcrypto_task.next_ready_metadata().map(|ready| { RendererPageReadyDescriptor::WebCryptoTask { ready, @@ -1150,6 +1180,7 @@ impl RendererPageOwnedTaskSources { shared_worker_client_event, service_worker_internal, service_worker_client_message, + bitmap_task, webcrypto_task, indexed_db_task, opfs_task, @@ -1303,6 +1334,14 @@ impl RendererPageOwnedTaskSources { ); RendererPageSchedulerTask::ServiceWorkerClientMessage(task) } + RendererPageReadyDescriptor::BitmapTask { ready, .. } => { + let (actual, task) = self + .bitmap_task + .pop_front() + .expect("selected Bitmap task must remain queued"); + assert_eq!(actual, ready, "selected Bitmap head changed before dequeue"); + RendererPageSchedulerTask::BitmapTask(task) + } RendererPageReadyDescriptor::WebCryptoTask { ready, .. } => { let (actual, task) = self .webcrypto_task @@ -1528,6 +1567,7 @@ impl RendererPageOwnedTaskSources { || self.shared_worker_client_event.has_ready_task() || self.service_worker_internal.has_ready_task() || self.service_worker_client_message.has_ready_task() + || self.bitmap_task.has_ready_task() || self.webcrypto_task.has_ready_task() || self.indexed_db_task.has_ready_task() || self.opfs_task.has_ready_task() @@ -1572,6 +1612,7 @@ impl RendererPageOwnedTaskSources { self.shared_worker_client_event.clear(); self.service_worker_internal.clear(); self.service_worker_client_message.clear(); + self.bitmap_task.clear(); self.webcrypto_task.clear(); self.indexed_db_task.clear(); self.opfs_task.clear(); @@ -1687,6 +1728,12 @@ impl RendererPageTaskProducerRoutes { RendererWorkerHostBridgeEventSender::new(self.networking.clone(), root_document) } + pub(crate) fn bitmap_task_sender( + &self, + root_document: RendererDocumentToken, + ) -> RendererPageBitmapTaskSender { + self.bitmap_task.sender(root_document) + } pub(crate) fn webcrypto_task_sender( &self, root_document: RendererDocumentToken, diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs index 16cd052d29e..f0655abbf47 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs @@ -9,7 +9,7 @@ use url::Url; use crate::{ PageId, - context_bootstrap::{IndexedDbTaskId, WebCryptoTaskResult}, + context_bootstrap::{BitmapRejection, IndexedDbTaskId, WebCryptoTaskResult}, document_runtime::DomHandle, frame_owner_model::{ ChildDocumentModuleFetchTarget, DocumentId, @@ -38,7 +38,8 @@ use crate::{ page_task_queue::{ MainDocumentMetaRefreshNavigationTask, PageOwnedInternalLoadingTask, RendererDedicatedWorkerClientEvent, RendererDedicatedWorkerMessageEvent, RendererOwnerWake, - RendererPageChildFrameTaskSender, RendererPageChildRealmMaterializationTarget, + RendererPageBitmapTaskId, RendererPageBitmapTaskSender, RendererPageChildFrameTaskSender, + RendererPageChildRealmMaterializationTarget, RendererPageDedicatedWorkerClientEventProducer, RendererPageHistoryTraversalSender, RendererPageHistoryTraversalTaskId, RendererPageHistoryTraversalTaskKind, RendererPageIndexedDbTaskKind, RendererPageIndexedDbTaskSender, @@ -65,7 +66,8 @@ use crate::{ use super::{ PageRuntimeWakeSignal, RendererOwnerWakeSender, RendererOwnerWakeSource, - RendererPageChildFrameTaskSource, RendererPageChildModuleDependencyFetchStartSender, + RendererPageBitmapTaskSource, RendererPageChildFrameTaskSource, + RendererPageChildModuleDependencyFetchStartSender, RendererPageChildModuleDependencyFetchStartSource, RendererPageChildModuleScriptTerminalSender, RendererPageChildModuleScriptTerminalSource, RendererPageChildModulepreloadEventActionSender, RendererPageChildModulepreloadEventActionSource, RendererPageDedicatedWorkerClientEventSource, @@ -261,6 +263,14 @@ struct SharedWorkerClientEventLane { wake_rx: tokio::sync::mpsc::UnboundedReceiver, } +struct BitmapTaskLane { + source: Option, + initial_sender: RendererPageBitmapTaskSender, + replacement_sender: RendererPageBitmapTaskSender, + execution_context: WindowExecutionContextIdentity, + wake_rx: tokio::sync::mpsc::UnboundedReceiver, +} + struct WebCryptoTaskLane { source: Option, initial_sender: RendererPageWebCryptoTaskSender, @@ -722,6 +732,58 @@ impl TypedPageSourceConformance for IndexedDbTaskLane { } } +impl BitmapTaskLane { + fn new() -> Self { + let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel(); + let source = RendererPageBitmapTaskSource::new(RendererOwnerWakeSender::new( + wake_tx, + RendererPageToken::new_for_testing(document_token(1).page_id), + )); + let route = source.route(); + let initial_sender = route.sender(document_token(1)); + let replacement_sender = route.sender(document_token(2)); + Self { + source: Some(source), + initial_sender, + replacement_sender, + execution_context: window_execution_context(76), + wake_rx, + } + } + + fn enqueue_with( + sender: &RendererPageBitmapTaskSender, + execution_context: WindowExecutionContextIdentity, + sequence: u64, + ) -> bool { + let producer = sender.bind_task(execution_context, RendererPageBitmapTaskId::new(sequence)); + assert_eq!(producer.owner().task().task_id(), sequence); + producer.send(Err(BitmapRejection::InvalidState)).is_ok() + } +} + +impl TypedPageSourceConformance for BitmapTaskLane { + fn enqueue_initial(&mut self, sequence: u64) -> bool { + Self::enqueue_with(&self.initial_sender, self.execution_context, sequence) + } + + fn enqueue_replacement(&mut self, sequence: u64) -> bool { + Self::enqueue_with(&self.replacement_sender, self.execution_context, sequence) + } + + fn pop_ready_metadata(&mut self) -> Option { + self.source.as_mut()?.pop_front().map(|(ready, _)| ready) + } + + fn take_wake(&mut self) -> Option { + self.wake_rx.try_recv().ok() + } + + fn retire_consumer(&mut self) { + drop(self.source.take()); + } +} + impl WebCryptoTaskLane { fn new() -> Self { let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel(); @@ -2195,6 +2257,11 @@ fn shared_worker_client_event_source_conforms_to_page_queue_contract() { assert_fifo_replacement_and_route_retirement(SharedWorkerClientEventLane::new()); } +#[test] +fn bitmap_task_source_conforms_to_page_queue_contract() { + assert_fifo_replacement_and_route_retirement(BitmapTaskLane::new()); +} + #[test] fn webcrypto_task_source_conforms_to_page_queue_contract() { assert_fifo_replacement_and_route_retirement(WebCryptoTaskLane::new()); @@ -2427,6 +2494,14 @@ fn unified_ready_descriptors_expose_one_fifo_head_per_typed_source() { .bind_client(allocated_shared_worker_client_id()) .send(SharedWorkerClientEvent::Closed) .expect("SharedWorker client event should enter the unified source set"); + routes + .bitmap_task_sender(document_token(1)) + .bind_task( + window_execution_context(88), + RendererPageBitmapTaskId::new(13), + ) + .send(Err(BitmapRejection::InvalidState)) + .expect("Bitmap task should enter the unified source set"); routes .webcrypto_task_sender(document_token(1)) .bind_task( @@ -2520,7 +2595,7 @@ fn unified_ready_descriptors_expose_one_fifo_head_per_typed_source() { .expect("dynamic-import action should enter the unified source set"); let descriptors = sources.ready_descriptors(); - assert_eq!(descriptors.len(), 18); + assert_eq!(descriptors.len(), 19); assert!(descriptors.iter().any(|descriptor| matches!( descriptor, RendererPageReadyDescriptor::DomManipulation { .. } @@ -2541,6 +2616,11 @@ fn unified_ready_descriptors_expose_one_fifo_head_per_typed_source() { descriptor, RendererPageReadyDescriptor::SharedWorkerClientEvent { .. } ))); + assert!( + descriptors + .iter() + .any(|descriptor| matches!(descriptor, RendererPageReadyDescriptor::BitmapTask { .. })) + ); assert!(descriptors.iter().any(|descriptor| matches!( descriptor, RendererPageReadyDescriptor::WebCryptoTask { .. } @@ -2610,7 +2690,7 @@ fn unified_ready_descriptors_expose_one_fifo_head_per_typed_source() { )); assert_eq!( sources.ready_descriptors().len(), - 17, + 18, "one Page turn must remove only the selected source head" ); } diff --git a/moli-renderer-v8/src/page_task_queue/resource_completions.rs b/moli-renderer-v8/src/page_task_queue/resource_completions.rs index ce41656824d..f824b6bc9a7 100644 --- a/moli-renderer-v8/src/page_task_queue/resource_completions.rs +++ b/moli-renderer-v8/src/page_task_queue/resource_completions.rs @@ -215,6 +215,7 @@ pub(crate) enum RendererOwnerWakeSource { ServiceWorkerClientMessage, /// A completed WebCrypto operation entered its exact Page/Window task /// source. The queued task, not this admission hint, owns identity. + BitmapTask, WebCryptoTask, /// A Page-side IndexedDB task entered its exact Window-realm source. IndexedDbTask, diff --git a/moli-renderer-v8/src/page_task_queue/senders.rs b/moli-renderer-v8/src/page_task_queue/senders.rs index fefe045acb7..2a20372dd53 100644 --- a/moli-renderer-v8/src/page_task_queue/senders.rs +++ b/moli-renderer-v8/src/page_task_queue/senders.rs @@ -17,6 +17,7 @@ use super::{ resource_completions::RendererOwnerWakeSender, }; use crate::page_resource_completion::RendererPageResourceCompletionSender; +use crate::page_task_queue::RendererPageBitmapTaskSender; use crate::page_task_queue::RendererPageChildFrameTaskSender; use crate::page_task_queue::RendererPageChildModuleDependencyFetchStartSender; use crate::page_task_queue::RendererPageChildModuleScriptTerminalSender; @@ -80,6 +81,7 @@ pub(crate) struct RendererPageJsContextTaskSenders { dedicated_worker_client_event: RendererPageDedicatedWorkerClientEventSender, shared_worker_client_event: RendererPageSharedWorkerClientEventSender, worker_host_bridge: RendererWorkerHostBridgeEventSender, + bitmap_task: RendererPageBitmapTaskSender, webcrypto_task: RendererPageWebCryptoTaskSender, indexed_db_task: RendererPageIndexedDbTaskSender, opfs_task: RendererPageOpfsTaskSender, @@ -173,6 +175,9 @@ impl RendererPageJsContextTaskSenders { &self.worker_host_bridge } + pub(crate) fn bitmap_task(&self) -> &RendererPageBitmapTaskSender { + &self.bitmap_task + } pub(crate) fn webcrypto_task(&self) -> &RendererPageWebCryptoTaskSender { &self.webcrypto_task } @@ -352,6 +357,7 @@ impl PageRuntimeTaskSource { .dedicated_worker_client_event_sender(root_document), shared_worker_client_event: routes.shared_worker_client_event_sender(root_document), worker_host_bridge: routes.worker_host_bridge_event_sender(root_document), + bitmap_task: routes.bitmap_task_sender(root_document), webcrypto_task: routes.webcrypto_task_sender(root_document), indexed_db_task: routes.indexed_db_task_sender(root_document), opfs_task: routes.opfs_task_sender(root_document), diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs index 15303935396..53481dee8b6 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -127,6 +127,7 @@ pub(crate) use self::page_turn_scheduler::{ PageOwnerBlockedReason, PageOwnerTurnOutcome, PageOwnerTurnReadiness, }; pub(crate) use self::page_vm::AuthorizedCurrentBroadcastChannelDelivery; +pub(crate) use self::page_vm::AuthorizedCurrentPageBitmapTask; pub(crate) use self::page_vm::AuthorizedCurrentPageChildClassicScriptSourceLoad; pub(crate) use self::page_vm::AuthorizedCurrentPageChildDocumentLifecycle; pub(crate) use self::page_vm::AuthorizedCurrentPageChildDocumentScriptReady; diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs index 8296b9a7e48..c3348b653b2 100644 --- a/moli-renderer-v8/src/runtime/owner.rs +++ b/moli-renderer-v8/src/runtime/owner.rs @@ -1120,6 +1120,7 @@ fn page_turn_trigger_log_label(trigger: PageTurnTrigger) -> &'static str { Some(RendererOwnerWakeSource::ServiceWorkerClientMessage) => { "service-worker-client-message-wake" } + Some(RendererOwnerWakeSource::BitmapTask) => "bitmap-task-wake", Some(RendererOwnerWakeSource::WebCryptoTask) => "webcrypto-task-wake", Some(RendererOwnerWakeSource::IndexedDbTask) => "indexed-db-task-wake", Some(RendererOwnerWakeSource::OpfsTask) => "opfs-task-wake", diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rs index 35227b948fe..6d868f0435e 100644 --- a/moli-renderer-v8/src/runtime/page_dom.rs +++ b/moli-renderer-v8/src/runtime/page_dom.rs @@ -657,6 +657,7 @@ impl PageVm { let pending_runtime_work = self .vm_mut() .has_post_domcontentloaded_runtime_work_for_wait() + || self.vm().has_pending_bitmap_tasks() || self.vm().has_pending_webcrypto_tasks() || self.vm().has_pending_opfs_tasks(); state.saw_post_domcontentloaded_runtime_work |= pending_runtime_work; diff --git a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs index c98ad9e0cac..ce6ca99d811 100644 --- a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs +++ b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs @@ -472,6 +472,7 @@ mod tests { }, page_resource_completion::RendererPageResourceCompletionOwner, page_task_queue::{ + RendererPageBitmapTaskId, RendererPageBitmapTaskOwner, RendererPageBroadcastChannelDeliveryOwner, RendererPageChildFrameTaskOwner, RendererPageChildFrameTaskTarget, RendererPageChildModuleDependencyFetchStartOwner, RendererPageChildModuleScriptTerminalOwner, @@ -750,6 +751,22 @@ mod tests { } } + fn bitmap_descriptor(ready_at: Instant, order: u64) -> RendererPageReadyDescriptor { + RendererPageReadyDescriptor::BitmapTask { + ready: ready_metadata(ready_at, order), + owner: RendererPageBitmapTaskOwner::new( + RendererDocumentToken::new_for_testing(crate::PageId::new_for_testing(1), 1), + WindowExecutionContextIdentity::new( + WindowExecutionContextOwner::Frame(LocalWindowId(7)), + OwnerDispatchScope::Top, + RuntimeObservableContextToken::from_raw(11), + WindowExecutionContextAccessPolicy::EnforceWebOrigin, + ), + RendererPageBitmapTaskId::new(order), + ), + } + } + fn webcrypto_descriptor(ready_at: Instant, order: u64) -> RendererPageReadyDescriptor { RendererPageReadyDescriptor::WebCryptoTask { ready: ready_metadata(ready_at, order), @@ -1033,6 +1050,7 @@ mod tests { RendererPageTaskSourceKind::ServiceWorkerClientMessage => { service_worker_client_message_descriptor(runnable_since, order) } + RendererPageTaskSourceKind::BitmapTask => bitmap_descriptor(runnable_since, order), RendererPageTaskSourceKind::WebCryptoTask => { webcrypto_descriptor(runnable_since, order) } diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs index 5c3805a4a7f..af0a29e2b41 100644 --- a/moli-renderer-v8/src/runtime/page_vm/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs @@ -187,6 +187,7 @@ pub(crate) use page_selected_task_test_harness::{ ClaimedPageSelectedTaskForTest, PageSelectedTaskTestSelector, }; pub(crate) use page_task_completion::{IntoPageTaskCompletion, PageTaskCompletion}; +mod page_bitmap_task; mod page_text_track_default_mode; mod page_text_track_default_mode_task_completion; mod page_text_track_load; @@ -212,6 +213,7 @@ mod parser_owned_module_completion; mod parser_task_completion; mod selected_page_task; +pub(crate) use page_bitmap_task::AuthorizedCurrentPageBitmapTask; pub(crate) use page_broadcast_channel_delivery::AuthorizedCurrentBroadcastChannelDelivery; pub(crate) use page_child_frame_task::{ AuthorizedCurrentPageChildClassicScriptSourceLoad, AuthorizedCurrentPageChildDocumentLifecycle, diff --git a/moli-renderer-v8/src/runtime/page_vm/page_bitmap_task.rs b/moli-renderer-v8/src/runtime/page_vm/page_bitmap_task.rs new file mode 100644 index 00000000000..551545b666b --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/page_bitmap_task.rs @@ -0,0 +1,68 @@ +use crate::page_task_queue::{ + PageBitmapTaskTargetEffect, PageBitmapTaskTurnAction, PageBitmapTaskTurnOutcome, + RendererPageBitmapTask, RendererPageBitmapTaskOwner, +}; + +use super::PageVm; + +/// Proof that the Page arbiter matched a selected completion against the exact +/// root PageVm, Window realm, and pending Promise entry. +pub(crate) struct AuthorizedCurrentPageBitmapTask(RendererPageBitmapTask); + +impl AuthorizedCurrentPageBitmapTask { + fn new(task: RendererPageBitmapTask) -> Self { + Self(task) + } + + pub(crate) fn into_task(self) -> RendererPageBitmapTask { + self.0 + } +} + +impl PageVm { + fn current_page_bitmap_task_owner( + &self, + expected: RendererPageBitmapTaskOwner, + ) -> Option { + let execution_context = self + .vm() + .current_pending_bitmap_task_execution_context(expected.task())?; + Some(RendererPageBitmapTaskOwner::new( + self.document_lifecycle.identity().document, + execution_context, + expected.task(), + )) + } + + pub(in crate::runtime) fn apply_selected_page_bitmap_task_turn( + &mut self, + task: RendererPageBitmapTask, + ) -> anyhow::Result { + let owner = task.owner(); + let current_owner = self.current_page_bitmap_task_owner(owner); + let target_effect = if current_owner == Some(owner) { + self.vm_mut() + .apply_current_bitmap_task_body(AuthorizedCurrentPageBitmapTask::new(task))?; + PageBitmapTaskTargetEffect::SettledCurrentOwner + } else { + // A root mismatch means `task_id` belongs to another PageVm + // namespace and must not be used to touch this PageVm's pending + // map. Within the same root, exact cleanup is safe and prevents a + // retired realm from retaining its resolver. + if owner.root_document() == self.document_lifecycle.identity().document { + self.vm_mut().discard_stale_bitmap_task(owner); + } + tracing::debug!( + ?owner, + ?current_owner, + "ignored stale exact-owner Bitmap task" + ); + PageBitmapTaskTargetEffect::IgnoredStaleOwner { current_owner } + }; + let action = PageBitmapTaskTurnAction { + owner, + target_effect, + }; + Ok(PageBitmapTaskTurnOutcome::new(action)) + } +} diff --git a/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs b/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs index 34988b1d3b4..bb77c451b9c 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs @@ -76,6 +76,7 @@ pub(crate) enum PageSelectedTaskTestSelector { StylesheetCompletion, TextTrackNetworking, UserInteraction, + BitmapTask, WebCryptoTask, WebSocket, WindowMessage, @@ -281,6 +282,9 @@ impl PageSelectedTaskTestSelector { RendererPageReadyDescriptor::MiscPlatformApi { .. } ) } + Self::BitmapTask => { + matches!(descriptor, RendererPageReadyDescriptor::BitmapTask { .. }) + } Self::WebCryptoTask => matches!( descriptor, RendererPageReadyDescriptor::WebCryptoTask { .. } @@ -406,6 +410,7 @@ impl PageSelectedTaskTestSelector { RendererPageSchedulerTask::SharedWorkerClientEvent(_), ) | (Self::UserInteraction, RendererPageSchedulerTask::UserInteraction(_)) + | (Self::BitmapTask, RendererPageSchedulerTask::BitmapTask(_)) | (Self::WebCryptoTask, RendererPageSchedulerTask::WebCryptoTask(_)) | (Self::WindowMessage, RendererPageSchedulerTask::WindowMessage(_)) => true, (Self::WebSocket, RendererPageSchedulerTask::WebSocket(_)) => true, diff --git a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs index f46e9efbf18..5be66a8b37d 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs @@ -88,6 +88,7 @@ impl PageVm { | RendererPageReadyDescriptor::SharedWorkerClientEvent { .. } | RendererPageReadyDescriptor::ServiceWorkerInternal { .. } | RendererPageReadyDescriptor::ServiceWorkerClientMessage { .. } + | RendererPageReadyDescriptor::BitmapTask { .. } | RendererPageReadyDescriptor::WebCryptoTask { .. } | RendererPageReadyDescriptor::IndexedDbTask { .. } | RendererPageReadyDescriptor::OpfsTask { .. } diff --git a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs index d33b9715bf5..d515012dce0 100644 --- a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs +++ b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs @@ -143,6 +143,13 @@ impl PageVm { .await?; Ok(()) } + RendererPageSchedulerTask::BitmapTask(task) => { + let outcome = self.apply_selected_page_bitmap_task_turn(task)?; + if outcome.action.settled_current_owner() { + self.finish_selected_page_task_checkpoint()?; + } + Ok(()) + } RendererPageSchedulerTask::WebCryptoTask(task) => { let outcome = self.apply_selected_page_webcrypto_task_turn(task)?; if outcome.action.settled_current_owner() { diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/bitmap.rs b/moli-renderer-v8/src/runtime/page_vm/tests/bitmap.rs new file mode 100644 index 00000000000..f4765c17c45 --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/tests/bitmap.rs @@ -0,0 +1,430 @@ +use super::*; + +#[tokio::test(flavor = "current_thread")] +async fn bitmap_argument_errors_reject_promises_without_queuing_decode_tasks() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + page_vm.vm_mut().eval(r#" + globalThis.outcomes = []; + globalThis.getters = []; + const source = new OffscreenCanvas(2, 3); + const marker = {}; + const probes = [ + () => createImageBitmap(), + () => createImageBitmap({width: 2, height: 3}), + () => createImageBitmap(source, 0, 0), + () => createImageBitmap(source, 0, 0, 0, 1), + () => createImageBitmap(source, {resizeWidth: 0}), + () => createImageBitmap(source, {resizeHeight: Infinity}), + () => createImageBitmap(source, {resizeWidth: -1}), + () => createImageBitmap(source, {imageOrientation: 'invalid'}), + () => createImageBitmap(new OffscreenCanvas(0, 3)), + () => createImageBitmap(source, { + get colorSpaceConversion() { getters.push('colorSpaceConversion'); }, + get imageOrientation() { getters.push('imageOrientation'); }, + get premultiplyAlpha() { getters.push('premultiplyAlpha'); throw marker; }, + get resizeHeight() { getters.push('unexpected'); } + }), + ]; + for (const probe of probes) { + const promise = probe(); + if (!(promise instanceof Promise)) throw new Error('missing Promise'); + promise.then(() => outcomes.push('unexpected success'), error => outcomes.push(error === marker ? 'marker' : error.name)); + } + 'scheduled' + "#)?; + assert!(!page_vm.vm().has_pending_bitmap_tasks()); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(outcomes)")?, r#"["TypeError","TypeError","TypeError","RangeError","InvalidStateError","TypeError","TypeError","TypeError","InvalidStateError","marker"]"#); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(getters)")?, r#"["colorSpaceConversion","imageOrientation","premultiplyAlpha"]"#); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap Web IDL rejections"); +} + +async fn run_ready_bitmap_task(page_vm: &mut PageVm) -> anyhow::Result<()> { + let loader = page_vm.request_client.clone(); + let deadline = Instant::now() + Duration::from_secs(5); + while !page_vm + .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::BitmapTask, &loader) + .await? + { + anyhow::ensure!( + Instant::now() < deadline, + "bitmap decode did not enqueue its result" + ); + tokio::time::sleep(Duration::from_millis(1)).await; + } + Ok(()) +} + +#[tokio::test(flavor = "current_thread")] +async fn bitmap_blob_decodes_bytes_and_settles_in_a_later_task_in_the_intrinsic_realm() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + let pixels = moli_image::RgbaImage::try_new(1, 2, vec![255, 0, 0, 255, 0, 255, 0, 255])?; + let encoded = moli_image::encode_png(&pixels)?.bytes; + page_vm.vm_mut().eval(&format!("globalThis.pngBytes = new Uint8Array({encoded:?}); 'ready'"))?; + page_vm.vm_mut().eval(r#" + globalThis.outcomes = []; + const prototype = ImageBitmap.prototype; + const valid = createImageBitmap(new Blob([pngBytes], {type: 'text/plain'}), {imageOrientation: 'flipY'}); + const invalid = createImageBitmap(new Blob(['not an image'], {type: 'image/png'})); + const empty = createImageBitmap(new Blob()); + globalThis.ImageBitmap = function ReplacedImageBitmap() {}; + pngBytes.fill(0); + valid.then(bitmap => { + const canvas = new OffscreenCanvas(1, 2); + const ctx = canvas.getContext('2d'); + ctx.drawImage(bitmap, 0, 0); + outcomes.push([Object.getPrototypeOf(bitmap) === prototype, bitmap.width, bitmap.height, Array.from(ctx.getImageData(0, 0, 1, 2).data)]); + }, error => outcomes.push(error.name)); + invalid.catch(error => outcomes.push('invalid:' + error.name)); + empty.catch(error => outcomes.push('empty:' + error.name)); + Promise.resolve().then(() => outcomes.push('microtask')); + 'scheduled' + "#)?; + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(outcomes)")?, r#"["microtask"]"#); + for _ in 0..3 { run_ready_bitmap_task(&mut page_vm).await?; } + assert!(!page_vm.vm().has_pending_bitmap_tasks()); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(outcomes.filter(Array.isArray))")?, "[[true,1,2,[0,255,0,255,255,0,0,255]]]"); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(outcomes.filter(value => typeof value === 'string').sort())")?, r#"["empty:InvalidStateError","invalid:InvalidStateError","microtask"]"#); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap Blob decode and Promise task timing"); +} + +#[tokio::test(flavor = "current_thread")] +async fn bitmap_snapshots_pixels_crops_resizes_and_rejects_closed_sources() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + page_vm.vm_mut().eval(r#" + globalThis.results = []; + const source = new OffscreenCanvas(2, 1); + const ctx = source.getContext('2d'); + ctx.fillStyle = 'red'; ctx.fillRect(0, 0, 2, 1); + const pending = createImageBitmap(source, 2, 0, -2, 1, {resizeWidth: 4, resizeQuality: 'pixelated'}); + ctx.fillStyle = 'blue'; ctx.fillRect(0, 0, 2, 1); + pending.then(async bitmap => { + const dest = new OffscreenCanvas(4, 2); + const destCtx = dest.getContext('2d'); + destCtx.drawImage(bitmap, 0, 0); + results.push([bitmap.width, bitmap.height, Array.from(destCtx.getImageData(0, 0, 1, 1).data)]); + const copyPromise = createImageBitmap(bitmap); + bitmap.close(); bitmap.close(); + try { destCtx.drawImage(bitmap, 0, 0); } catch(error) { results.push(error.name); } + await createImageBitmap(bitmap).catch(error => results.push(error.name)); + const copy = await copyPromise; + results.push([copy.width, copy.height]); + }); + const data = new ImageData(new Uint8ClampedArray([0, 255, 0, 255]), 1, 1); + createImageBitmap(data, -1, 0, 2, 1, {resizeQuality: 'pixelated'}).then(bitmap => { + const dest = new OffscreenCanvas(2, 1); + const ctx = dest.getContext('2d'); + ctx.drawImage(bitmap, 0, 0); + globalThis.cropPixels = Array.from(ctx.getImageData(0, 0, 2, 1).data); + }); + data.data.fill(0); + const htmlCanvas = document.createElement('canvas'); + htmlCanvas.width = 5; htmlCanvas.height = 3; + Object.defineProperty(htmlCanvas, 'width', {get() { throw new Error('observable width getter'); }}); + createImageBitmap(htmlCanvas).then(bitmap => globalThis.htmlDimensions = [bitmap.width, bitmap.height]); + 'scheduled' + "#)?; + for _ in 0..4 { run_ready_bitmap_task(&mut page_vm).await?; } + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(results)")?, r#"[[4,2,[255,0,0,255]],"InvalidStateError","InvalidStateError",[4,2]]"#); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(cropPixels)")?, "[0,0,0,0,0,255,0,255]"); + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(htmlDimensions)")?, "[5,3]"); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap snapshots and close"); +} + +#[tokio::test(flavor = "current_thread")] +async fn bitmap_task_survives_document_open_in_the_same_window() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + page_vm.vm_mut().eval(r#" + globalThis.outcome = 'pending'; + createImageBitmap(new OffscreenCanvas(3, 2)).then(bitmap => outcome = [bitmap.width, bitmap.height]); + document.open(); + 'replaced' + "#)?; + assert!(page_vm.vm().has_pending_bitmap_tasks()); + run_ready_bitmap_task(&mut page_vm).await?; + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(outcome)")?, "[3,2]"); + assert!(!page_vm.vm().has_pending_bitmap_tasks()); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap Window lifetime"); +} + +#[tokio::test(flavor = "current_thread")] +async fn bitmap_task_uses_child_intrinsics_and_retires_when_the_child_window_is_removed() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + let loader = page_vm.request_client.clone(); + page_vm.vm_mut().eval(r#" + const frame = document.createElement('iframe'); + globalThis.bitmapFrame = frame; + globalThis.bitmapChildOutcome = 'pending'; + (document.body || document.documentElement || document).appendChild(frame); + void frame.contentWindow.Function; + const script = frame.contentDocument.createElement('script'); + script.textContent = "createImageBitmap(new OffscreenCanvas(3, 4)).then(bitmap => { parent.bitmapChildOutcome = [bitmap.width, bitmap.height, Object.getPrototypeOf(bitmap) === ImageBitmap.prototype]; createImageBitmap(new OffscreenCanvas(1, 1)).then(() => parent.bitmapChildOutcome = 'stale'); });"; + frame.contentDocument.body.appendChild(script); + 'scheduled' + "#)?; + run_expected_child_realm_materialization_for_wait(&mut page_vm, "child bitmap realm").await; + assert!(page_vm.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::ChildDocumentScriptReady, &loader).await?); + run_ready_bitmap_task(&mut page_vm).await?; + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(bitmapChildOutcome)")?, "[3,4,true]"); + assert!(page_vm.vm().has_pending_bitmap_tasks()); + page_vm.vm_mut().eval("document.open(); 'retired'")?; + assert!(!page_vm.vm().has_pending_bitmap_tasks()); + run_ready_bitmap_task(&mut page_vm).await?; + assert_eq!(page_vm.vm_mut().eval("JSON.stringify(bitmapChildOutcome)")?, "[3,4,true]"); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap child realm settlement and retirement"); +} +use crate::context_bootstrap::BitmapRejection; +use crate::page_task_queue::{ + MainDocumentMetaRefreshNavigationTask, PageInternalLoadingTargetEffect, + PageOwnedInternalLoadingTask, +}; + +#[tokio::test(flavor = "current_thread")] +async fn create_image_bitmap_offscreen_canvas_and_close_contract() { + run_page_vm_async_test(async move { + let mut page_vm = test_page_vm(); + let loader = page_vm.request_client.clone(); + + page_vm.vm_mut().exec( + r#" + (() => { + const caughtName = callback => { + try { + callback(); + return "none"; + } catch (error) { + return error.name; + } + }; + const descriptor = Object.getOwnPropertyDescriptor(window, "createImageBitmap"); + const blank = new OffscreenCanvas(16, 9); + const drawn = new OffscreenCanvas(16, 9); + drawn.getContext("2d").fillRect(0, 0, 1, 1); + globalThis.__imageBitmapProbe = { + functionShape: [ + typeof createImageBitmap, + createImageBitmap.name, + createImageBitmap.length, + Object.prototype.hasOwnProperty.call(createImageBitmap, "prototype"), + descriptor.enumerable, + descriptor.configurable, + descriptor.writable, + caughtName(() => new createImageBitmap(drawn)), + caughtName(() => createImageBitmap().catch(() => {})), + ], + constructorShape: [ + typeof ImageBitmap, + ImageBitmap.name, + ImageBitmap.length, + Object.prototype.toString.call(ImageBitmap.prototype), + Object.getPrototypeOf(ImageBitmap.prototype) === Object.prototype, + caughtName(() => new ImageBitmap()), + ], + settled: false, + }; + Promise.all([ + createImageBitmap(blank).then( + () => "resolved", + error => `rejected:${error.name}`, + ), + createImageBitmap(drawn).then(bitmap => { + const before = [ + Object.prototype.toString.call(bitmap), + bitmap instanceof ImageBitmap, + Object.getPrototypeOf(bitmap) === ImageBitmap.prototype, + Object.getOwnPropertyNames(bitmap).length, + bitmap.width, + bitmap.height, + typeof bitmap.close, + ]; + const closeResult = bitmap.close(); + return [before, typeof closeResult, bitmap.width, bitmap.height]; + }), + ]).then(([blankOutcome, bitmapOutcome]) => { + __imageBitmapProbe.blankOutcome = blankOutcome; + __imageBitmapProbe.bitmapOutcome = bitmapOutcome; + __imageBitmapProbe.settled = true; + }); + })() + "#, + None, + ) + .expect("createImageBitmap probe should execute"); + + assert_eq!(page_vm.vm_mut().eval("String(__imageBitmapProbe.settled)")?, "false"); + for _ in 0..2 { + assert!(page_vm.run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::BitmapTask, &loader).await?); + } + let result = page_vm.vm_mut() + .eval("JSON.stringify(globalThis.__imageBitmapProbe)") + .expect("createImageBitmap probe should be readable"); + assert_eq!( + result, + r#"{"functionShape":["function","createImageBitmap",1,false,true,true,true,"TypeError","none"],"constructorShape":["function","ImageBitmap",0,"[object ImageBitmap]",true,"TypeError"],"settled":true,"blankOutcome":"resolved","bitmapOutcome":[["[object ImageBitmap]",true,true,0,16,9,"function"],"undefined",0,0]}"# + ); + Ok::<_, anyhow::Error>(()) + }).await.expect("bitmap task surface"); +} + +#[test] +fn bitmap_task_rejects_a_real_page_vm_replacement_identity_collision() { + run_page_vm_large_stack_async_test( + "bitmap-real-page-vm-replacement-collision", + || async move { + let (base_url, server) = spawn_path_response_http_server(vec![( + "/replacement.html", + "HTTP/1.1 200 OK", + "replacement".to_owned(), + Duration::ZERO, + )]) + .await; + let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()) + .expect("loader"); + let document_url = Url::parse(&format!("{base_url}/initial.html")).unwrap(); + let (page_vm, _resource_source, _owner_wake_rx) = + page_vm_with_bound_task_sources_and_owner_wake(&loader, document_url); + let local_executor = page_vm.local_executor.clone(); + + local_executor + .run(async move { + let mut page_vm = page_vm; + let retired_producer = page_vm + .vm_mut() + .register_pending_bitmap_task_producer_for_executor_test()?; + let retired_owner = retired_producer.owner(); + assert_eq!( + retired_owner.root_document(), + page_vm.document_lifecycle.identity().document + ); + retired_producer + .send(Err(BitmapRejection::InvalidState)) + .expect("retired Bitmap task should enter the stable Page source"); + + let replacement_url = format!("{base_url}/replacement.html"); + page_vm + .vm_mut() + .eval(&format!("location.href = {replacement_url:?}; 'queued'"))?; + let mut pending_document_lifecycle_turn = None; + let navigation = page_vm + .follow_pending_location_navigation_one_turn_async( + &mut pending_document_lifecycle_turn, + PageVmInitStage::Load, + ) + .await?; + assert!(matches!( + navigation, + crate::runtime::PageVmFollowNavigationTurnOutcome::Completed + | crate::runtime::PageVmFollowNavigationTurnOutcome::PostParseLifecycle { + .. + } + )); + + let current_producer = page_vm + .vm_mut() + .register_pending_bitmap_task_producer_for_executor_test()?; + let current_owner = current_producer.owner(); + assert_eq!( + retired_owner.task(), + current_owner.task(), + "fresh PageVm counters should naturally reuse the first Bitmap task id and transport generation" + ); + assert_eq!( + retired_owner.execution_context(), + current_owner.execution_context(), + "fresh PageVm counters should naturally reuse the top Window/realm identity" + ); + assert_ne!( + retired_owner.root_document(), + current_owner.root_document(), + "the stable Page queue must namespace identical local owners by root Document" + ); + assert_eq!( + current_owner.root_document(), + page_vm.document_lifecycle.identity().document + ); + current_producer + .send(Err(BitmapRejection::InvalidState)) + .expect("replacement Bitmap task should enter the same stable Page source"); + + let current_document_owner = page_vm + .vm() + .current_main_document_task_owner() + .expect("replacement main Document owner"); + page_vm + .vm() + .schedule_page_internal_loading_task( + PageOwnedInternalLoadingTask::MetaRefreshNavigation( + MainDocumentMetaRefreshNavigationTask::new( + current_document_owner, + 0, + ), + ), + Instant::now(), + ) + .expect("internal-loading task should enter the stable Page source"); + park_current_document_websocket_for_test( + &mut page_vm, + moli_websocket::Event::TextMessage { + socket_id: 41, + data: "blocked".to_owned(), + }, + ) + .await; + assert!( + page_vm + .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::BitmapTask, &loader) + .await?, + "retired Bitmap task should remain runnable beside independent internal-loading and backpressured WebSocket work" + ); + + assert_eq!( + page_vm + .vm() + .current_pending_bitmap_task_execution_context(current_owner.task()), + Some(current_owner.execution_context()), + "discarding the old completion must not remove the colliding replacement Promise" + ); + + assert!( + page_vm + .run_exact_selected_page_task_for_test(PageSelectedTaskTestSelector::BitmapTask, &loader) + .await?, + "replacement Bitmap task should consume the following turn" + ); + + assert_eq!( + page_vm + .vm() + .current_pending_bitmap_task_execution_context(current_owner.task()), + None, + "the current completion must settle exactly the replacement Promise" + ); + let internal_loading = page_vm + .run_internal_loading_body_for_test() + .expect("the independent internal-loading task should remain queued"); + assert_eq!( + internal_loading.action.target_effect, + PageInternalLoadingTargetEffect::AppliedToCurrentOwner { + effect: crate::page_task_queue::PageOwnedInternalLoadingTaskEffect::MetaRefreshNavigationNotActivated, + }, + "the synthetic refresh must still enforce its own post-load prerequisite" + ); + Ok::<_, anyhow::Error>(()) + }) + .await + .expect("Bitmap replacement should run through the typed task executor"); + server + .await + .expect("Bitmap PageVm replacement server should finish"); + }, + ); +} diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs index 3c6569c4236..5d2491cf3c7 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/mod.rs @@ -1,3 +1,4 @@ +mod bitmap; use crate::types::SubresourceInterceptionClasses; use std::{ sync::Arc, diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs index 904a97aeb27..bf38280fc0f 100644 --- a/moli-renderer-v8/src/script_vm.rs +++ b/moli-renderer-v8/src/script_vm.rs @@ -750,6 +750,7 @@ mod subresource_fetch; #[cfg(any(test, feature = "devtools"))] pub(crate) use subresource_command_completion::AsyncSubresourceCommandExecution; pub(crate) use subresource_fetch::AsyncSubresourceFetchBodyActivity; +mod bitmap_tasks; mod page_resource_completion_task_completion; mod text_search; mod text_track_default_mode; diff --git a/moli-renderer-v8/src/script_vm/bitmap_tasks.rs b/moli-renderer-v8/src/script_vm/bitmap_tasks.rs new file mode 100644 index 00000000000..c38c9aca175 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/bitmap_tasks.rs @@ -0,0 +1,83 @@ +use anyhow::Result; + +use super::ScriptVm; +use crate::{ + context_bootstrap::settle_bitmap_task_result, page_task_queue::RendererPageBitmapTaskOwner, + runtime::AuthorizedCurrentPageBitmapTask, +}; + +impl ScriptVm { + #[cfg(test)] + pub(crate) fn register_pending_bitmap_task_producer_for_executor_test( + &mut self, + ) -> Result { + self.with_default_context_scope_and_checkpoint_for_test(|scope, host_ptr| { + let resolver = v8::PromiseResolver::new(scope) + .expect("Bitmap executor test resolver should exist"); + unsafe { &mut *host_ptr } + .register_pending_bitmap_task(scope, resolver) + .ok_or_else(|| { + anyhow::anyhow!("Bitmap executor test must capture the current Window realm") + }) + }) + } + + pub(crate) fn current_pending_bitmap_task_execution_context( + &self, + task: crate::page_task_queue::RendererPageBitmapTaskId, + ) -> Option { + self._context_host + .borrow() + .current_pending_bitmap_task_execution_context(task) + } + + /// Settle one page-side Bitmap Promise body only after the Page arbiter + /// has authorized its exact PageVm and Window realm. + /// + /// The selected Page-task dispatcher owns the enclosing task's microtask + /// checkpoint. This method deliberately leaves reactions queued after + /// resolving or rejecting the Promise. + pub(crate) fn apply_current_bitmap_task_body( + &mut self, + authorization: AuthorizedCurrentPageBitmapTask, + ) -> Result<()> { + let task = authorization.into_task(); + let owner = task.owner(); + let pending = self + ._context_host + .borrow_mut() + .take_pending_bitmap_task_for_exact_owner(owner.execution_context(), owner.task()) + .ok_or_else(|| { + anyhow::anyhow!("authorized Bitmap task lost its exact pending Promise") + })?; + + let (bound_owner, bound_dispatch_scope, _realm_token, context) = + pending.relevant_context.into_parts(); + debug_assert_eq!(bound_owner, owner.execution_context().owner()); + debug_assert_eq!( + bound_dispatch_scope, + owner.execution_context().dispatch_scope() + ); + let context_ptr: *const v8::Global = &context; + let resolver = pending.resolver; + self.with_context_scope_by_ptr(context_ptr, move |scope, _host_ptr| { + let previous_dispatch_scope = bound_dispatch_scope.enter(scope); + let resolver = v8::Local::new(scope, &resolver); + settle_bitmap_task_result(scope, resolver, task.into_result()); + bound_dispatch_scope.defer_restore(scope, previous_dispatch_scope); + tracing::debug!( + task_id = owner.task().task_id(), + execution_context = ?owner.execution_context(), + "settled Bitmap task body in relevant Window execution context" + ); + Ok(()) + }) + } + + pub(crate) fn discard_stale_bitmap_task(&mut self, owner: RendererPageBitmapTaskOwner) { + let _ = self + ._context_host + .borrow_mut() + .take_pending_bitmap_task_for_exact_owner(owner.execution_context(), owner.task()); + } +} diff --git a/moli-renderer-v8/src/script_vm/runtime_observability.rs b/moli-renderer-v8/src/script_vm/runtime_observability.rs index 59f3e28407a..ec25d4bff09 100644 --- a/moli-renderer-v8/src/script_vm/runtime_observability.rs +++ b/moli-renderer-v8/src/script_vm/runtime_observability.rs @@ -838,6 +838,9 @@ impl ScriptVm { .dedicated_worker_running_worker_isolate_count_for_diagnostics() } + pub(crate) fn has_pending_bitmap_tasks(&self) -> bool { + self._context_host.borrow().has_pending_bitmap_tasks() + } pub(crate) fn has_pending_webcrypto_tasks(&self) -> bool { self._context_host.borrow().has_pending_webcrypto_tasks() } diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_factory_realms.rs b/moli-renderer-v8/src/script_vm/tests/canvas_factory_realms.rs index fe84af83ba2..a6238dda787 100644 --- a/moli-renderer-v8/src/script_vm/tests/canvas_factory_realms.rs +++ b/moli-renderer-v8/src/script_vm/tests/canvas_factory_realms.rs @@ -30,7 +30,7 @@ fn canvas_factories_keep_the_canvas_realm_across_borrowed_calls_and_adoption() { } #[test] -fn canvas_2d_creation_samples_dimensions_only_for_its_backing_store() { +fn canvas_2d_creation_uses_native_dimensions_without_author_getters() { let mut vm = new_parsed_test_vm( "https://canvas-factory-realms.test/", "", @@ -39,15 +39,24 @@ fn canvas_2d_creation_samples_dimensions_only_for_its_backing_store() { vm.eval( r#"(() => { const canvas=document.createElement('canvas'); + canvas.setAttribute('width','4'); + canvas.setAttribute('height','3'); const reads=[]; - Object.defineProperty(canvas,'width',{get(){reads.push('width');return 2;}}); - Object.defineProperty(canvas,'height',{get(){reads.push('height');return 3;}}); + for(const name of ['width','height'])Object.defineProperty(canvas,name,{get(){ + reads.push(name); + throw Error('author '+name+' getter'); + }}); const context=canvas.getContext('2d'); if(!(context instanceof CanvasRenderingContext2D))throw Error('context'); + if(context.canvas!==canvas || canvas.getContext('2d')!==context)throw Error('context identity'); + context.fillStyle='red'; + context.fillRect(3,2,1,1); + if(String(context.getImageData(3,2,1,1).data)!=='255,0,0,255')throw Error('native bitmap dimensions'); + if(String(context.getImageData(4,3,1,1).data)!=='0,0,0,0')throw Error('outside native bitmap'); return JSON.stringify(reads); })()"# ) .unwrap(), - r#"["width","height"]"# + "[]" ); } diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs index c72046c1fca..7818a210ddb 100644 --- a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs +++ b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs @@ -412,68 +412,31 @@ fn canvas_path_rasterization_clips_to_the_bitmap_with_transformed_caps() { } #[test] -fn canvas_path_drawing_uses_a_snapshot_during_dimension_reads() { - fn append_rect<'s>( - scope: &mut v8::PinScope<'s, '_>, - args: v8::FunctionCallbackArguments<'s>, - mut result: v8::ReturnValue<'_, v8::Value>, - ) { - let updated = v8::Local::::try_from(args.get(0)).is_ok_and(|target| { - crate::context_bootstrap::try_append_canvas_path_rect_for_test( - scope, - target, - [24.0, 4.0, 8.0, 8.0], - ) - }); - result.set(v8::Boolean::new(scope, updated).into()); - } - +fn canvas_path_drawing_uses_native_bitmap_dimensions() { let mut vm = new_storage_test_vm("https://canvas-paths.test/"); - vm.with_default_context_scope(|scope, _| { - let append_rect = v8::Function::new(scope, append_rect).unwrap(); - let global = scope.get_current_context().global(scope); - let name = crate::util::v8str(scope, "tryAppendTestRect"); - assert_eq!( - global.set(scope, name.into(), append_rect.into()), - Some(true) - ); - Ok(()) - }) - .unwrap(); - - for (operation, y) in [("fill", 6), ("stroke", 4)] { - for (target, argument) in [("ctx", ""), ("new Path2D()", "target")] { - let result = vm - .eval(&format!( - r#"(() => {{ - const canvas = document.createElement('canvas'); - canvas.width = canvas.height = 40; - const ctx = canvas.getContext('2d'); - ctx.lineWidth = 2; - const target = {target}; - target.rect(4, 4, 8, 8); - const edits = []; - Object.defineProperty(canvas, 'width', {{ - configurable: true, - get() {{ - edits.push(tryAppendTestRect(target)); - return 40; - }} - }}); - ctx.{operation}({argument}); - delete canvas.width; - const alpha = x => ctx.getImageData(x, {y}, 1, 1).data[3]; - const painted = [alpha(8), alpha(28)]; - ctx.{operation}({argument}); - return JSON.stringify([ - edits.length > 0 && edits.every(Boolean), ...painted, alpha(28) - ]); - }})()"# - )) - .expect("canvas path draw should succeed"); - assert_eq!(result, "[true,255,0,255]", "{operation} on {target}"); - } - } + let actual = vm + .eval( + r#"(() => { + const canvas = document.createElement('canvas'); + canvas.width = canvas.height = 40; + const ctx = canvas.getContext('2d'); + const path = new Path2D(); + let reads = 0; + Object.defineProperty(canvas, 'width', { + get() { + reads++; + path.rect(24, 4, 8, 8); + return 40; + } + }); + path.rect(4, 4, 8, 8); + ctx.fill(path); + const alpha = x => ctx.getImageData(x, 6, 1, 1).data[3]; + return JSON.stringify([reads, alpha(8), alpha(28)]); + })()"#, + ) + .expect("drawing must use native HTMLCanvasElement dimensions"); + assert_eq!(actual, "[0,255,0]"); } #[test] diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs index 601a37e9e06..5bd461ee9fe 100644 --- a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs +++ b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs @@ -29,85 +29,6 @@ async fn run_one_canvas_image_load_event_task( ); } -#[test] -fn create_image_bitmap_matches_chromium_offscreen_canvas_and_close_contract() { - let mut vm = new_storage_test_vm("https://image-bitmap-surface.test/"); - - vm.exec( - r#" - (() => { - const caughtName = callback => { - try { - callback(); - return "none"; - } catch (error) { - return error.name; - } - }; - const descriptor = Object.getOwnPropertyDescriptor(window, "createImageBitmap"); - const blank = new OffscreenCanvas(16, 9); - const drawn = new OffscreenCanvas(16, 9); - drawn.getContext("2d").fillRect(0, 0, 1, 1); - globalThis.__imageBitmapProbe = { - functionShape: [ - typeof createImageBitmap, - createImageBitmap.name, - createImageBitmap.length, - Object.prototype.hasOwnProperty.call(createImageBitmap, "prototype"), - descriptor.enumerable, - descriptor.configurable, - descriptor.writable, - caughtName(() => new createImageBitmap(drawn)), - caughtName(() => createImageBitmap()), - ], - constructorShape: [ - typeof ImageBitmap, - ImageBitmap.name, - ImageBitmap.length, - Object.prototype.toString.call(ImageBitmap.prototype), - Object.getPrototypeOf(ImageBitmap.prototype) === Object.prototype, - caughtName(() => new ImageBitmap()), - ], - settled: false, - }; - Promise.all([ - createImageBitmap(blank).then( - () => "resolved", - error => `rejected:${error.name}`, - ), - createImageBitmap(drawn).then(bitmap => { - const before = [ - Object.prototype.toString.call(bitmap), - bitmap instanceof ImageBitmap, - Object.getPrototypeOf(bitmap) === ImageBitmap.prototype, - Object.getOwnPropertyNames(bitmap).length, - bitmap.width, - bitmap.height, - typeof bitmap.close, - ]; - const closeResult = bitmap.close(); - return [before, typeof closeResult, bitmap.width, bitmap.height]; - }), - ]).then(([blankOutcome, bitmapOutcome]) => { - __imageBitmapProbe.blankOutcome = blankOutcome; - __imageBitmapProbe.bitmapOutcome = bitmapOutcome; - __imageBitmapProbe.settled = true; - }); - })() - "#, - None, - ) - .expect("createImageBitmap probe should execute"); - - let result = vm - .eval("JSON.stringify(globalThis.__imageBitmapProbe)") - .expect("createImageBitmap probe should be readable"); - assert_eq!( - result, - r#"{"functionShape":["function","createImageBitmap",1,false,true,true,true,"TypeError","TypeError"],"constructorShape":["function","ImageBitmap",0,"[object ImageBitmap]",true,"TypeError"],"settled":true,"blankOutcome":"rejected:InvalidStateError","bitmapOutcome":[["[object ImageBitmap]",true,true,0,16,9,"function"],"undefined",0,0]}"# - ); -} - #[test] fn canvas_html_and_offscreen_draw_with_modern_fill_and_stroke_colors() { let mut vm = new_storage_test_vm("https://canvas-css-colors.test/"); @@ -123,6 +44,8 @@ fn canvas_html_and_offscreen_draw_with_modern_fill_and_stroke_colors() { for (const [color, expected] of [ ['oklch(0.5 0 0)', [99, 99, 99, 255]], ['hsl(120 100% 50%)', [0, 255, 0, 255]], + ['CanvasText', [0, 0, 0, 255]], + ['currentcolor', [0, 0, 0, 255]], ['color(srgb 1 0 0 / 0.5)', [255, 0, 0, 128]], ['color-mix(in srgb, red 50%, blue 50%)', [128, 0, 128, 255]], ]) { @@ -132,8 +55,8 @@ fn canvas_html_and_offscreen_draw_with_modern_fill_and_stroke_colors() { ctx.strokeStyle = color; const style = ctx.fillStyle; if (ctx.strokeStyle !== style) throw new Error('stroke color differs'); - for (const invalid of ['oklch(invalid)', 'CanvasText', 'light-dark(red, blue)', - 'currentcolor', 'rgb(1, 2, 3, 1, 0)', 'rgb(50%, 0, 0)']) { + for (const invalid of ['oklch(invalid)', 'light-dark(red, blue)', + 'rgb(1, 2, 3, 1, 0)', 'rgb(50%, 0, 0)']) { ctx.fillStyle = invalid; ctx.strokeStyle = invalid; if (ctx.fillStyle !== style || ctx.strokeStyle !== style) { diff --git a/moli-webapi/src/image_bitmap.rs b/moli-webapi/src/image_bitmap.rs index 99f9f050b28..9b8ec4b1cba 100644 --- a/moli-webapi/src/image_bitmap.rs +++ b/moli-webapi/src/image_bitmap.rs @@ -4,8 +4,10 @@ use moli_v8_util::{ set_private_value, }; use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject}; -const IMAGE_BITMAP_WIDTH_SLOT: &str = "__moliImageBitmapWidth"; -const IMAGE_BITMAP_HEIGHT_SLOT: &str = "__moliImageBitmapHeight"; +pub const IMAGE_BITMAP_WIDTH_SLOT: &str = "__moliImageBitmapWidth"; +pub const IMAGE_BITMAP_HEIGHT_SLOT: &str = "__moliImageBitmapHeight"; +pub const IMAGE_BITMAP_PIXELS_SLOT: &str = "__moliImageBitmapPixels"; +pub const IMAGE_BITMAP_PREMULTIPLIED_SLOT: &str = "__moliImageBitmapPremultiplied"; const IMAGE_BITMAP_DIMENSION_SLOTS: &[&str] = &[IMAGE_BITMAP_WIDTH_SLOT, IMAGE_BITMAP_HEIGHT_SLOT]; @@ -91,5 +93,11 @@ fn image_bitmap_close_callback<'s>( for slot in IMAGE_BITMAP_DIMENSION_SLOTS { set_private_value(scope, args.this(), slot, v8::Number::new(scope, 0.0).into()); } + set_private_value( + scope, + args.this(), + IMAGE_BITMAP_PIXELS_SLOT, + v8::undefined(scope).into(), + ); rv.set_undefined(); }