From 7cdc4cbe53318e0fee9b39bdae1dfdcf7eff24f5 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Wed, 9 Sep 2026 22:53:38 +0800 Subject: [PATCH] fix(canvas): settle ImageBitmap promises through bitmap tasks Reject Web IDL conversion errors through the returned Promise and decode raster Blobs from their bytes on the blocking pool. Deliver results through a dedicated bitmap task source bound to the exact Page and Window realm. Retain canvas, ImageData and ImageBitmap pixel snapshots for crop, resize, flip and alpha processing. Clear pixels on close and reject closed sources in drawImage. Read HTML canvas dimensions from native attributes. Cover Promise timing, pixels, intrinsic prototypes, child realm retirement, document.open and real navigation identity collisions with Page task tests. --- moli-renderer-v8/src/blob.rs | 4 +- moli-renderer-v8/src/context_bootstrap.rs | 9 +- .../src/context_bootstrap/canvas.rs | 7 +- .../context_bootstrap/canvas/backing_store.rs | 15 +- .../src/context_bootstrap/canvas/context2d.rs | 22 +- .../context_bootstrap/canvas/image_bitmap.rs | 348 +++++++++++--- .../canvas/image_bitmap/options.rs | 191 ++++++++ .../src/context_bootstrap/canvas/state.rs | 14 - .../context_host/bitmap_tasks.rs | 110 +++++ .../src/native_bridge/context_host/core.rs | 12 + .../src/native_bridge/context_host/mod.rs | 4 + .../src/native_bridge/context_host/popups.rs | 3 + .../context_host/runtime_observable.rs | 2 + moli-renderer-v8/src/native_bridge/element.rs | 2 +- .../src/native_bridge/element/canvas.rs | 2 +- moli-renderer-v8/src/page_task_queue.rs | 6 + .../src/page_task_queue/bitmap_task.rs | 257 +++++++++++ .../src/page_task_queue/owner_sources.rs | 49 +- .../owner_sources/conformance_tests.rs | 90 +++- .../page_task_queue/resource_completions.rs | 1 + .../src/page_task_queue/senders.rs | 6 + moli-renderer-v8/src/runtime/mod.rs | 1 + moli-renderer-v8/src/runtime/owner.rs | 1 + moli-renderer-v8/src/runtime/page_dom.rs | 1 + .../src/runtime/page_turn_scheduler.rs | 18 + moli-renderer-v8/src/runtime/page_vm/mod.rs | 2 + .../src/runtime/page_vm/page_bitmap_task.rs | 68 +++ .../page_selected_task_test_harness.rs | 5 + .../page_vm/page_typed_immediate_source.rs | 1 + .../src/runtime/page_vm/selected_page_task.rs | 7 + .../src/runtime/page_vm/tests/bitmap.rs | 430 ++++++++++++++++++ .../src/runtime/page_vm/tests/mod.rs | 1 + moli-renderer-v8/src/script_vm.rs | 1 + .../src/script_vm/bitmap_tasks.rs | 83 ++++ .../src/script_vm/runtime_observability.rs | 3 + .../script_vm/tests/canvas_factory_realms.rs | 17 +- .../src/script_vm/tests/canvas_paths.rs | 85 +--- .../src/script_vm/tests/canvas_webgl.rs | 85 +--- moli-webapi/src/image_bitmap.rs | 12 +- 39 files changed, 1731 insertions(+), 244 deletions(-) create mode 100644 moli-renderer-v8/src/context_bootstrap/canvas/image_bitmap/options.rs create mode 100644 moli-renderer-v8/src/native_bridge/context_host/bitmap_tasks.rs create mode 100644 moli-renderer-v8/src/page_task_queue/bitmap_task.rs create mode 100644 moli-renderer-v8/src/runtime/page_vm/page_bitmap_task.rs create mode 100644 moli-renderer-v8/src/runtime/page_vm/tests/bitmap.rs create mode 100644 moli-renderer-v8/src/script_vm/bitmap_tasks.rs 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(); }