Use backend trait with associated types for 2d canvas backends abstraction (#36783)

Current abstraction was leaky and very hard to understand/impl because
it was so intervened with actual implementation.

Now we generalize both `CanvasState` and `CanvasData` over `B: Beckend`,
meaning that every type/method must be part of trait interface (that
lives in `beckend.rs`). Using associated trait types instead of `Box<dyn
>` allows us too remove the need for wrapper types (and `to_raquote()`
methods) as we can implement helper traits on (foreign) raquote types.
The only time we actually do dispatch (by enum) is at `Canvas` methods.

Implementation now only need to implement all backend traits and
helpers. I tried to restrain myself from actually cleaning abstraction
(where possible), to keep this change as much mechanical as possible,
but we should absolutely do that as a follow up.

Testing: Rust as we only do refactor, but there are also WPT tests

try run: https://github.com/sagudev/servo/actions/runs/14760658522

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

components/canvas/canvas_paint_thread.rs

@@ -11,18 +11,21 @@ use canvas_traits::ConstellationCanvasMsg;
 use canvas_traits::canvas::*;
 use compositing_traits::CrossProcessCompositorApi;
 use crossbeam_channel::{Sender, select, unbounded};
-use euclid::default::Size2D;
+use euclid::default::{Point2D, Rect, Size2D, Transform2D};
 use fonts::{FontContext, SystemFontServiceProxy};
 use ipc_channel::ipc::{self, IpcSender};
 use ipc_channel::router::ROUTER;
 use log::warn;
 use net_traits::ResourceThreads;
+use style::color::AbsoluteColor;
+use style::properties::style_structs::Font as FontStyleStruct;
 use webrender_api::ImageKey;
 
 use crate::canvas_data::*;
+use crate::raqote_backend::RaqoteBackend;
 
 pub struct CanvasPaintThread<'a> {
-    canvases: HashMap<CanvasId, CanvasData<'a>>,
+    canvases: HashMap<CanvasId, Canvas<'a>>,
     next_canvas_id: CanvasId,
     compositor_api: CrossProcessCompositorApi,
     font_context: Arc<FontContext>,
@@ -113,10 +116,14 @@ impl<'a> CanvasPaintThread<'a> {
         let canvas_id = self.next_canvas_id;
         self.next_canvas_id.0 += 1;
 
-        let canvas_data =
-            CanvasData::new(size, self.compositor_api.clone(), self.font_context.clone());
+        let canvas_data = CanvasData::new(
+            size,
+            self.compositor_api.clone(),
+            self.font_context.clone(),
+            RaqoteBackend,
+        );
         let image_key = canvas_data.image_key();
-        self.canvases.insert(canvas_id, canvas_data);
+        self.canvases.insert(canvas_id, Canvas::Raqote(canvas_data));
 
         (canvas_id, image_key)
     }
@@ -276,7 +283,347 @@ impl<'a> CanvasPaintThread<'a> {
         }
     }
 
-    fn canvas(&mut self, canvas_id: CanvasId) -> &mut CanvasData<'a> {
+    fn canvas(&mut self, canvas_id: CanvasId) -> &mut Canvas<'a> {
         self.canvases.get_mut(&canvas_id).expect("Bogus canvas id")
     }
 }
+
+enum Canvas<'a> {
+    Raqote(CanvasData<'a, RaqoteBackend>),
+}
+
+impl Canvas<'_> {
+    fn set_fill_style(&mut self, style: FillOrStrokeStyle) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_fill_style(style),
+        }
+    }
+
+    fn fill(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.fill(),
+        }
+    }
+
+    fn fill_text(&mut self, text: String, x: f64, y: f64, max_width: Option<f64>, is_rtl: bool) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.fill_text(text, x, y, max_width, is_rtl),
+        }
+    }
+
+    fn fill_rect(&mut self, rect: &Rect<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.fill_rect(rect),
+        }
+    }
+
+    fn set_stroke_style(&mut self, style: FillOrStrokeStyle) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_stroke_style(style),
+        }
+    }
+
+    fn stroke_rect(&mut self, rect: &Rect<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.stroke_rect(rect),
+        }
+    }
+
+    fn begin_path(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.begin_path(),
+        }
+    }
+
+    fn close_path(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.close_path(),
+        }
+    }
+
+    fn fill_path(&mut self, path: &[PathSegment]) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.fill_path(path),
+        }
+    }
+
+    fn stroke(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.stroke(),
+        }
+    }
+
+    fn stroke_path(&mut self, path: &[PathSegment]) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.stroke_path(path),
+        }
+    }
+
+    fn clip(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.clip(),
+        }
+    }
+
+    fn is_point_in_path(&mut self, x: f64, y: f64, fill_rule: FillRule, chan: IpcSender<bool>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.is_point_in_path(x, y, fill_rule, chan),
+        }
+    }
+
+    fn is_point_in_path_(
+        &mut self,
+        path: &[PathSegment],
+        x: f64,
+        y: f64,
+        fill_rule: FillRule,
+        chan: IpcSender<bool>,
+    ) {
+        match self {
+            Canvas::Raqote(canvas_data) => {
+                canvas_data.is_point_in_path_(path, x, y, fill_rule, chan)
+            },
+        }
+    }
+
+    fn clear_rect(&mut self, rect: &Rect<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.clear_rect(rect),
+        }
+    }
+
+    fn draw_image(
+        &mut self,
+        data: &[u8],
+        size: Size2D<u64>,
+        dest_rect: Rect<f64>,
+        source_rect: Rect<f64>,
+        smoothing_enabled: bool,
+        is_premultiplied: bool,
+    ) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.draw_image(
+                data,
+                size,
+                dest_rect,
+                source_rect,
+                smoothing_enabled,
+                is_premultiplied,
+            ),
+        }
+    }
+
+    fn read_pixels(
+        &mut self,
+        read_rect: Option<Rect<u64>>,
+        canvas_size: Option<Size2D<u64>>,
+    ) -> snapshot::Snapshot {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.read_pixels(read_rect, canvas_size),
+        }
+    }
+
+    fn move_to(&mut self, point: &Point2D<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.move_to(point),
+        }
+    }
+
+    fn line_to(&mut self, point: &Point2D<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.line_to(point),
+        }
+    }
+
+    fn rect(&mut self, rect: &Rect<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.rect(rect),
+        }
+    }
+
+    fn quadratic_curve_to(&mut self, cp: &Point2D<f32>, pt: &Point2D<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.quadratic_curve_to(cp, pt),
+        }
+    }
+
+    fn bezier_curve_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, pt: &Point2D<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.bezier_curve_to(cp1, cp2, pt),
+        }
+    }
+
+    fn arc(&mut self, center: &Point2D<f32>, radius: f32, start: f32, end: f32, ccw: bool) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.arc(center, radius, start, end, ccw),
+        }
+    }
+
+    fn arc_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, radius: f32) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.arc_to(cp1, cp2, radius),
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn ellipse(
+        &mut self,
+        center: &Point2D<f32>,
+        radius_x: f32,
+        radius_y: f32,
+        rotation: f32,
+        start: f32,
+        end: f32,
+        ccw: bool,
+    ) {
+        match self {
+            Canvas::Raqote(canvas_data) => {
+                canvas_data.ellipse(center, radius_x, radius_y, rotation, start, end, ccw)
+            },
+        }
+    }
+
+    fn restore_context_state(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.restore_context_state(),
+        }
+    }
+
+    fn save_context_state(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.save_context_state(),
+        }
+    }
+
+    fn set_line_width(&mut self, width: f32) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_line_width(width),
+        }
+    }
+
+    fn set_line_cap(&mut self, cap: LineCapStyle) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_line_cap(cap),
+        }
+    }
+
+    fn set_line_join(&mut self, join: LineJoinStyle) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_line_join(join),
+        }
+    }
+
+    fn set_miter_limit(&mut self, limit: f32) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_miter_limit(limit),
+        }
+    }
+
+    fn set_line_dash(&mut self, items: Vec<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_line_dash(items),
+        }
+    }
+
+    fn set_line_dash_offset(&mut self, offset: f32) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_line_dash_offset(offset),
+        }
+    }
+
+    fn set_transform(&mut self, matrix: &Transform2D<f32>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_transform(matrix),
+        }
+    }
+
+    fn set_global_alpha(&mut self, alpha: f32) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_global_alpha(alpha),
+        }
+    }
+
+    fn set_global_composition(&mut self, op: CompositionOrBlending) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_global_composition(op),
+        }
+    }
+
+    fn set_shadow_offset_x(&mut self, value: f64) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_shadow_offset_x(value),
+        }
+    }
+
+    fn set_shadow_offset_y(&mut self, value: f64) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_shadow_offset_y(value),
+        }
+    }
+
+    fn set_shadow_blur(&mut self, value: f64) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_shadow_blur(value),
+        }
+    }
+
+    fn set_shadow_color(&mut self, color: AbsoluteColor) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_shadow_color(color),
+        }
+    }
+
+    fn set_font(&mut self, font_style: FontStyleStruct) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_font(font_style),
+        }
+    }
+
+    fn set_text_align(&mut self, text_align: TextAlign) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_text_align(text_align),
+        }
+    }
+
+    fn set_text_baseline(&mut self, text_baseline: TextBaseline) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.set_text_baseline(text_baseline),
+        }
+    }
+
+    fn measure_text(&mut self, text: String) -> TextMetrics {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.measure_text(text),
+        }
+    }
+
+    fn clip_path(&mut self, path: &[PathSegment]) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.clip_path(path),
+        }
+    }
+
+    fn get_transform(&self) -> Transform2D<f32> {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.get_transform(),
+        }
+    }
+
+    fn put_image_data(&mut self, unwrap: Vec<u8>, rect: Rect<u64>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.put_image_data(unwrap, rect),
+        }
+    }
+
+    fn update_image_rendering(&mut self) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.update_image_rendering(),
+        }
+    }
+
+    fn recreate(&mut self, size: Option<Size2D<u64>>) {
+        match self {
+            Canvas::Raqote(canvas_data) => canvas_data.recreate(size),
+        }
+    }
+}