compositing: Use webrender_api::ExternalImageSource instead of WebRenderImageSource (#38703)

There is no reason to roll our own type.

Motivation: I need `ExternalImageSource::Invalid`.

Testing: Covered by existing WPT tests, but it's just refactor

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

components/media/lib.rs

@@ -10,8 +10,8 @@ mod media_thread;
 use std::sync::{Arc, Mutex};
 
 use compositing_traits::{
-    WebrenderExternalImageApi, WebrenderExternalImageHandlers, WebrenderExternalImageRegistry,
+    ExternalImageSource, WebrenderExternalImageApi, WebrenderExternalImageHandlers,
-    WebrenderImageHandlerType, WebrenderImageSource,
+    WebrenderExternalImageRegistry, WebrenderImageHandlerType,
 };
 use euclid::default::Size2D;
 use ipc_channel::ipc::{IpcReceiver, IpcSender, channel};
@@ -214,7 +214,7 @@ impl GLPlayerExternalImages {
 }
 
 impl WebrenderExternalImageApi for GLPlayerExternalImages {
-    fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
+    fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
         // The GLPlayerMsgForward::Lock message inserts a fence in the
         // GLPlayer command queue.
         self.glplayer_channel
@@ -228,7 +228,7 @@ impl WebrenderExternalImageApi for GLPlayerExternalImages {
         // internal OpenGL subsystem.
         //self.webrender_gl
         //    .wait_sync(gl_sync as gl::GLsync, 0, gl::TIMEOUT_IGNORED);
-        (WebrenderImageSource::TextureHandle(image_id), size)
+        (ExternalImageSource::NativeTexture(image_id), size)
     }
 
     fn unlock(&mut self, id: u64) {

components/shared/compositing/lib.rs

@@ -30,12 +30,13 @@ use euclid::default::Size2D as UntypedSize2D;
 use ipc_channel::ipc::{self, IpcSharedMemory};
 use profile_traits::mem::{OpaqueSender, ReportsChan};
 use serde::{Deserialize, Serialize};
+pub use webrender_api::ExternalImageSource;
 use webrender_api::units::{LayoutVector2D, TexelRect};
 use webrender_api::{
     BuiltDisplayList, BuiltDisplayListDescriptor, ExternalImage, ExternalImageData,
-    ExternalImageHandler, ExternalImageId, ExternalImageSource, ExternalScrollId,
+    ExternalImageHandler, ExternalImageId, ExternalScrollId, FontInstanceFlags, FontInstanceKey,
-    FontInstanceFlags, FontInstanceKey, FontKey, ImageData, ImageDescriptor, ImageKey,
+    FontKey, ImageData, ImageDescriptor, ImageKey, NativeFontHandle,
-    NativeFontHandle, PipelineId as WebRenderPipelineId,
+    PipelineId as WebRenderPipelineId,
 };
 
 use crate::viewport_description::ViewportDescription;
@@ -341,15 +342,10 @@ impl CrossProcessCompositorApi {
 /// This trait is used to notify lock/unlock messages and get the
 /// required info that WR needs.
 pub trait WebrenderExternalImageApi {
-    fn lock(&mut self, id: u64) -> (WebrenderImageSource, UntypedSize2D<i32>);
+    fn lock(&mut self, id: u64) -> (ExternalImageSource, UntypedSize2D<i32>);
     fn unlock(&mut self, id: u64);
 }
 
-pub enum WebrenderImageSource<'a> {
-    TextureHandle(u32),
-    Raw(&'a [u8]),
-}
-
 /// Type of Webrender External Image Handler.
 pub enum WebrenderImageHandlerType {
     WebGL,
@@ -438,7 +434,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
             WebrenderImageHandlerType::WebGL => {
                 let (source, size) = self.webgl_handler.as_mut().unwrap().lock(key.0);
                 let texture_id = match source {
-                    WebrenderImageSource::TextureHandle(b) => b,
+                    ExternalImageSource::NativeTexture(b) => b,
                     _ => panic!("Wrong type"),
                 };
                 ExternalImage {
@@ -449,7 +445,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
             WebrenderImageHandlerType::Media => {
                 let (source, size) = self.media_handler.as_mut().unwrap().lock(key.0);
                 let texture_id = match source {
-                    WebrenderImageSource::TextureHandle(b) => b,
+                    ExternalImageSource::NativeTexture(b) => b,
                     _ => panic!("Wrong type"),
                 };
                 ExternalImage {
@@ -460,7 +456,7 @@ impl ExternalImageHandler for WebrenderExternalImageHandlers {
             WebrenderImageHandlerType::WebGPU => {
                 let (source, size) = self.webgpu_handler.as_mut().unwrap().lock(key.0);
                 let buffer = match source {
-                    WebrenderImageSource::Raw(b) => b,
+                    ExternalImageSource::RawData(b) => b,
                     _ => panic!("Wrong type"),
                 };
                 ExternalImage {

components/webgl/webgl_mode/inprocess.rs

@@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
 use canvas_traits::webgl::{GlType, WebGLContextId, WebGLMsg, WebGLThreads, webgl_channel};
 use compositing_traits::rendering_context::RenderingContext;
 use compositing_traits::{
-    CrossProcessCompositorApi, WebrenderExternalImageApi, WebrenderExternalImageRegistry,
+    CrossProcessCompositorApi, ExternalImageSource, WebrenderExternalImageApi,
-    WebrenderImageSource,
+    WebrenderExternalImageRegistry,
 };
 use euclid::default::Size2D;
 use fnv::FnvHashMap;
@@ -134,10 +134,10 @@ impl WebGLExternalImages {
 }
 
 impl WebrenderExternalImageApi for WebGLExternalImages {
-    fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
+    fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
         let id = WebGLContextId(id);
         let (texture_id, size) = self.lock_swap_chain(id).unwrap_or_default();
-        (WebrenderImageSource::TextureHandle(texture_id), size)
+        (ExternalImageSource::NativeTexture(texture_id), size)
     }
 
     fn unlock(&mut self, id: u64) {

components/webgpu/swapchain.rs

@@ -9,8 +9,8 @@ use std::sync::{Arc, Mutex};
 
 use arrayvec::ArrayVec;
 use compositing_traits::{
-    CrossProcessCompositorApi, SerializableImageData, WebrenderExternalImageApi,
+    CrossProcessCompositorApi, ExternalImageSource, SerializableImageData,
-    WebrenderImageSource,
+    WebrenderExternalImageApi,
 };
 use euclid::default::Size2D;
 use ipc_channel::ipc::IpcSender;
@@ -83,7 +83,7 @@ pub struct WGPUExternalImages {
 }
 
 impl WebrenderExternalImageApi for WGPUExternalImages {
-    fn lock(&mut self, id: u64) -> (WebrenderImageSource, Size2D<i32>) {
+    fn lock(&mut self, id: u64) -> (ExternalImageSource, Size2D<i32>) {
         let id = WebGPUContextId(id);
         let webgpu_contexts = self.images.lock().unwrap();
         let context_data = webgpu_contexts.get(&id).unwrap();
@@ -99,7 +99,7 @@ impl WebrenderExternalImageApi for WGPUExternalImages {
         };
         self.locked_ids.insert(id, data);
         (
-            WebrenderImageSource::Raw(self.locked_ids.get(&id).unwrap().as_slice()),
+            ExternalImageSource::RawData(self.locked_ids.get(&id).unwrap().as_slice()),
             size,
         )
     }