Auto merge of #24524 - bblanke:consolidate-size-helpers, r=jdm

Make offscreen canvas rendering context use offscreen canvas' size; Consolidate size helpers

<!-- Please describe your changes on the following line: -->

Addresses issues raised in the review of PR #24518 and includes changes to 17 tests' metadata for those that now PASS.

Contains fixes in PR #24518:

Updated the offscreen canvas rendering context to use the offscreen canvas' size. This involved upgrading several methods to accept u64 sizes.

Additionally, the code in OffscreenCanvas::SetWidth() and OffscreenCanvas::SetHeight() was updated to send CanvasMsg::Recreate to the canvas paint thread.

---
<!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `___` with appropriate data: -->
- [X] `./mach build -d` does not report any errors
- [X] `./mach test-tidy` does not report any errors
- [X] These changes fix #24465 and fix #24536

<!-- Either: -->
- [X] There are tests for these changes – 17 were updated to PASS

7 files changed, 92 insertions, 39 deletions

diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs
index 9f6403bec5c..371b31bbdb0 100644
--- a/components/script/dom/canvasrenderingcontext2d.rs
+++ b/components/script/dom/canvasrenderingcontext2d.rs
@@ -22,9 +22,10 @@ use crate::dom::globalscope::GlobalScope;
 use crate::dom::htmlcanvaselement::HTMLCanvasElement;
 use crate::dom::imagedata::ImageData;
 use crate::dom::textmetrics::TextMetrics;
+use crate::euclidext::Size2DExt;
 use canvas_traits::canvas::{Canvas2dMsg, CanvasId, CanvasMsg};
 use dom_struct::dom_struct;
-use euclid::default::{Rect, Size2D};
+use euclid::default::{Point2D, Rect, Size2D};
 use ipc_channel::ipc::IpcSender;
 use servo_url::ServoUrl;
 use std::mem;
@@ -75,12 +76,13 @@ impl CanvasRenderingContext2D {
             .borrow()
             .get_ipc_renderer()
             .send(CanvasMsg::Recreate(
-                size,
+                size.to_u64(),
                 self.canvas_state.borrow().get_canvas_id(),
             ))
             .unwrap();
     }
 
+    //  TODO: This duplicates functionality in canvas state
     // https://html.spec.whatwg.org/multipage/#reset-the-rendering-context-to-its-default-state
     fn reset_to_initial_state(&self) {
         self.canvas_state
@@ -90,6 +92,15 @@ impl CanvasRenderingContext2D {
             .clear();
         *self.canvas_state.borrow().get_state().borrow_mut() = CanvasContextState::new();
     }
+    /*
+        pub fn get_canvas_state(&self) -> Ref<CanvasState> {
+            self.canvas_state.borrow()
+        }
+    */
+
+    pub fn set_canvas_bitmap_dimensions(&self, size: Size2D<u64>) {
+        self.canvas_state.borrow().set_bitmap_dimensions(size);
+    }
 
     pub fn mark_as_dirty(&self) {
         self.canvas_state
@@ -116,6 +127,7 @@ impl CanvasRenderingContext2D {
         self.canvas_state.borrow().send_canvas_2d_msg(msg)
     }
 
+    // TODO: Remove this
     pub fn get_ipc_renderer(&self) -> IpcSender<CanvasMsg> {
         self.canvas_state.borrow().get_ipc_renderer().clone()
     }
@@ -125,10 +137,14 @@ impl CanvasRenderingContext2D {
     }
 
     pub fn get_rect(&self, rect: Rect<u32>) -> Vec<u8> {
+        let rect = Rect::new(
+            Point2D::new(rect.origin.x as u64, rect.origin.y as u64),
+            Size2D::new(rect.size.width as u64, rect.size.height as u64),
+        );
         self.canvas_state.borrow().get_rect(
             self.canvas
                 .as_ref()
-                .map_or(Size2D::zero(), |c| c.get_size()),
+                .map_or(Size2D::zero(), |c| c.get_size().to_u64()),
             rect,
         )
     }
@@ -469,7 +485,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         self.canvas_state.borrow().get_image_data(
             self.canvas
                 .as_ref()
-                .map_or(Size2D::zero(), |c| c.get_size()),
+                .map_or(Size2D::zero(), |c| c.get_size().to_u64()),
             &self.global(),
             sx,
             sy,
@@ -483,7 +499,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         self.canvas_state.borrow().put_image_data(
             self.canvas
                 .as_ref()
-                .map_or(Size2D::zero(), |c| c.get_size()),
+                .map_or(Size2D::zero(), |c| c.get_size().to_u64()),
             imagedata,
             dx,
             dy,
@@ -505,7 +521,7 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
         self.canvas_state.borrow().put_image_data_(
             self.canvas
                 .as_ref()
-                .map_or(Size2D::zero(), |c| c.get_size()),
+                .map_or(Size2D::zero(), |c| c.get_size().to_u64()),
             imagedata,
             dx,
             dy,
diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs
index 9e638539995..8924f8ddd1c 100644
--- a/components/script/dom/htmlcanvaselement.rs
+++ b/components/script/dom/htmlcanvaselement.rs
@@ -28,6 +28,7 @@ use crate::dom::webgl2renderingcontext::WebGL2RenderingContext;
 use crate::dom::webglrenderingcontext::{
     LayoutCanvasWebGLRenderingContextHelpers, WebGLRenderingContext,
 };
+use crate::euclidext::Size2DExt;
 use crate::script_runtime::JSContext;
 use base64;
 use canvas_traits::canvas::{CanvasId, CanvasMsg, FromScriptMsg};
@@ -94,7 +95,9 @@ impl HTMLCanvasElement {
         let size = self.get_size();
         if let Some(ref context) = *self.context.borrow() {
             match *context {
-                CanvasContext::Context2d(ref context) => context.set_bitmap_dimensions(size),
+                CanvasContext::Context2d(ref context) => {
+                    context.set_canvas_bitmap_dimensions(size.to_u64())
+                },
                 CanvasContext::WebGL(ref context) => context.recreate(size),
                 CanvasContext::WebGL2(ref context) => context.recreate(size),
             }
diff --git a/components/script/dom/imagedata.rs b/components/script/dom/imagedata.rs
index d89e5e36d1b..b09984e267f 100644
--- a/components/script/dom/imagedata.rs
+++ b/components/script/dom/imagedata.rs
@@ -169,8 +169,8 @@ impl ImageData {
     }
 
     #[allow(unsafe_code)]
-    pub unsafe fn get_rect(&self, rect: Rect<u32>) -> Cow<[u8]> {
-        pixels::rgba8_get_rect(self.as_slice(), self.get_size(), rect)
+    pub unsafe fn get_rect(&self, rect: Rect<u64>) -> Cow<[u8]> {
+        pixels::rgba8_get_rect(self.as_slice(), self.get_size().to_u64(), rect)
     }
 
     pub fn get_size(&self) -> Size2D<u32> {
@@ -194,3 +194,13 @@ impl ImageDataMethods for ImageData {
         NonNull::new(self.data.get()).expect("got a null pointer")
     }
 }
+
+pub trait Size2DExt {
+    fn to_u64(&self) -> Size2D<u64>;
+}
+
+impl Size2DExt for Size2D<u32> {
+    fn to_u64(&self) -> Size2D<u64> {
+        return Size2D::new(self.width as u64, self.height as u64);
+    }
+}
diff --git a/components/script/dom/offscreencanvas.rs b/components/script/dom/offscreencanvas.rs
index 142379519fb..69c1114768c 100644
--- a/components/script/dom/offscreencanvas.rs
+++ b/components/script/dom/offscreencanvas.rs
@@ -92,11 +92,9 @@ impl OffscreenCanvas {
                 OffscreenCanvasContext::OffscreenContext2d(ref ctx) => Some(DomRoot::from_ref(ctx)),
             };
         }
-        let size = self.get_size();
         let context = OffscreenCanvasRenderingContext2D::new(
             &self.global(),
             self,
-            size,
             self.placeholder.as_ref().map(|c| &**c),
         );
         *self.context.borrow_mut() = Some(OffscreenCanvasContext::OffscreenContext2d(
@@ -136,6 +134,14 @@ impl OffscreenCanvasMethods for OffscreenCanvas {
     // https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-width
     fn SetWidth(&self, value: u64) {
         self.width.set(value);
+
+        if let Some(canvas_context) = self.context() {
+            match &*canvas_context {
+                OffscreenCanvasContext::OffscreenContext2d(rendering_context) => {
+                    rendering_context.set_canvas_bitmap_dimensions(self.get_size());
+                },
+            }
+        }
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-height
@@ -146,5 +152,13 @@ impl OffscreenCanvasMethods for OffscreenCanvas {
     // https://html.spec.whatwg.org/multipage/#dom-offscreencanvas-height
     fn SetHeight(&self, value: u64) {
         self.height.set(value);
+
+        if let Some(canvas_context) = self.context() {
+            match &*canvas_context {
+                OffscreenCanvasContext::OffscreenContext2d(rendering_context) => {
+                    rendering_context.set_canvas_bitmap_dimensions(self.get_size());
+                },
+            }
+        }
     }
 }
diff --git a/components/script/dom/offscreencanvasrenderingcontext2d.rs b/components/script/dom/offscreencanvasrenderingcontext2d.rs
index 04e0a13032c..077752d9d6e 100644
--- a/components/script/dom/offscreencanvasrenderingcontext2d.rs
+++ b/components/script/dom/offscreencanvasrenderingcontext2d.rs
@@ -30,44 +30,32 @@ use euclid::default::Size2D;
 #[dom_struct]
 pub struct OffscreenCanvasRenderingContext2D {
     reflector_: Reflector,
-    canvas: Option<Dom<OffscreenCanvas>>,
+    canvas: Dom<OffscreenCanvas>,
     canvas_state: DomRefCell<CanvasState>,
     htmlcanvas: Option<Dom<HTMLCanvasElement>>,
-    width: u32,
-    height: u32,
 }
 
 impl OffscreenCanvasRenderingContext2D {
     fn new_inherited(
         global: &GlobalScope,
-        canvas: Option<&OffscreenCanvas>,
-        size: Size2D<u64>,
+        canvas: &OffscreenCanvas,
         htmlcanvas: Option<&HTMLCanvasElement>,
     ) -> OffscreenCanvasRenderingContext2D {
         OffscreenCanvasRenderingContext2D {
             reflector_: Reflector::new(),
-            canvas: canvas.map(Dom::from_ref),
+            canvas: Dom::from_ref(canvas),
             htmlcanvas: htmlcanvas.map(Dom::from_ref),
-            canvas_state: DomRefCell::new(CanvasState::new(
-                global,
-                Size2D::new(size.width as u64, size.height as u64),
-            )),
-            width: size.width as u32,
-            height: size.height as u32,
+            canvas_state: DomRefCell::new(CanvasState::new(global, canvas.get_size())),
         }
     }
 
     pub fn new(
         global: &GlobalScope,
         canvas: &OffscreenCanvas,
-        size: Size2D<u64>,
         htmlcanvas: Option<&HTMLCanvasElement>,
     ) -> DomRoot<OffscreenCanvasRenderingContext2D> {
         let boxed = Box::new(OffscreenCanvasRenderingContext2D::new_inherited(
-            global,
-            Some(canvas),
-            size,
-            htmlcanvas,
+            global, canvas, htmlcanvas,
         ));
         reflect_dom_object(
             boxed,
@@ -75,12 +63,21 @@ impl OffscreenCanvasRenderingContext2D {
             OffscreenCanvasRenderingContext2DBinding::Wrap,
         )
     }
+    /*
+    pub fn get_canvas_state(&self) -> Ref<CanvasState> {
+        self.canvas_state.borrow()
+    }
+    */
+
+    pub fn set_canvas_bitmap_dimensions(&self, size: Size2D<u64>) {
+        self.canvas_state.borrow().set_bitmap_dimensions(size);
+    }
 }
 
 impl OffscreenCanvasRenderingContext2DMethods for OffscreenCanvasRenderingContext2D {
     // https://html.spec.whatwg.org/multipage/offscreencontext2d-canvas
     fn Canvas(&self) -> DomRoot<OffscreenCanvas> {
-        DomRoot::from_ref(self.canvas.as_ref().expect("No canvas."))
+        DomRoot::from_ref(&self.canvas)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-fillrect
@@ -315,7 +312,7 @@ impl OffscreenCanvasRenderingContext2DMethods for OffscreenCanvasRenderingContex
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-getimagedata
     fn GetImageData(&self, sx: i32, sy: i32, sw: i32, sh: i32) -> Fallible<DomRoot<ImageData>> {
         self.canvas_state.borrow().get_image_data(
-            Size2D::new(self.width, self.height),
+            self.canvas.get_size(),
             &self.global(),
             sx,
             sy,
@@ -326,12 +323,9 @@ impl OffscreenCanvasRenderingContext2DMethods for OffscreenCanvasRenderingContex
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
     fn PutImageData(&self, imagedata: &ImageData, dx: i32, dy: i32) {
-        self.canvas_state.borrow().put_image_data(
-            Size2D::new(self.width, self.height),
-            imagedata,
-            dx,
-            dy,
-        )
+        self.canvas_state
+            .borrow()
+            .put_image_data(self.canvas.get_size(), imagedata, dx, dy)
     }
 
     // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata
@@ -347,7 +341,7 @@ impl OffscreenCanvasRenderingContext2DMethods for OffscreenCanvasRenderingContex
         dirty_height: i32,
     ) {
         self.canvas_state.borrow().put_image_data_(
-            Size2D::new(self.width, self.height),
+            self.canvas.get_size(),
             imagedata,
             dx,
             dy,
diff --git a/components/script/dom/paintrenderingcontext2d.rs b/components/script/dom/paintrenderingcontext2d.rs
index 1bbb52d05fe..e4b0a3cf71e 100644
--- a/components/script/dom/paintrenderingcontext2d.rs
+++ b/components/script/dom/paintrenderingcontext2d.rs
@@ -21,6 +21,7 @@ use crate::dom::canvasgradient::CanvasGradient;
 use crate::dom::canvaspattern::CanvasPattern;
 use crate::dom::canvasrenderingcontext2d::CanvasRenderingContext2D;
 use crate::dom::paintworkletglobalscope::PaintWorkletGlobalScope;
+use crate::euclidext::Size2DExt;
 use canvas_traits::canvas::CanvasImageData;
 use canvas_traits::canvas::CanvasMsg;
 use canvas_traits::canvas::FromLayoutMsg;
@@ -75,7 +76,7 @@ impl PaintRenderingContext2D {
         let size = size * device_pixel_ratio;
         self.device_pixel_ratio.set(device_pixel_ratio);
         self.context
-            .set_bitmap_dimensions(size.to_untyped().to_u32());
+            .set_canvas_bitmap_dimensions(size.to_untyped().to_u64());
         self.scale_by_device_pixel_ratio();
     }
 
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index 228ccd491b9..c843ab578d1 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -2963,11 +2963,16 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         let src_origin = Point2D::new(x, y);
         let src_size = Size2D::new(width as u32, height as u32);
         let fb_size = Size2D::new(fb_width as u32, fb_height as u32);
-        let src_rect = match pixels::clip(src_origin, src_size, fb_size) {
+        let src_rect = match pixels::clip(src_origin, src_size.to_u64(), fb_size.to_u64()) {
             Some(rect) => rect,
             None => return,
         };
 
+        // Note: we're casting a Rect<u64> back into a Rect<u32> here, but it's okay because
+        //  it used u32 data types to begin with. It just got converted to Rect<u64> in
+        //  pixels::clip
+        let src_rect = src_rect.to_u32();
+
         let mut dest_offset = 0;
         if x < 0 {
             dest_offset += -x * bytes_per_pixel;
@@ -4485,3 +4490,13 @@ impl WebGLMessageSender {
         self.wake_after_send(|| self.sender.send_dom_to_texture(command))
     }
 }
+
+pub trait Size2DExt {
+    fn to_u64(&self) -> Size2D<u64>;
+}
+
+impl Size2DExt for Size2D<u32> {
+    fn to_u64(&self) -> Size2D<u64> {
+        return Size2D::new(self.width as u64, self.height as u64);
+    }
+}