Introduce WebrenderExternalImageRegistry

components/canvas/webgl_mode/inprocess.rs

@@ -13,7 +13,8 @@ use fnv::FnvHashMap;
 use gleam::gl;
 use servo_config::pref;
 use std::rc::Rc;
-use webrender_traits::WebrenderExternalImageApi;
+use std::sync::{Arc, Mutex};
+use webrender_traits::{WebrenderExternalImageApi, WebrenderExternalImageRegistry};
 
 /// WebGL Threading API entry point that lives in the constellation.
 pub struct WebGLThreads(WebGLSender<WebGLMsg>);
@@ -25,6 +26,7 @@ impl WebGLThreads {
         webrender_gl: Rc<dyn gl::Gl>,
         webrender_api_sender: webrender_api::RenderApiSender,
         webvr_compositor: Option<Box<dyn WebVRRenderHandler>>,
+        external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
     ) -> (
         WebGLThreads,
         Box<dyn WebrenderExternalImageApi>,
@@ -35,6 +37,7 @@ impl WebGLThreads {
             gl_factory,
             webrender_api_sender,
             webvr_compositor.map(|c| WebVRRenderWrapper(c)),
+            external_images,
         );
         let output_handler = if pref!(dom.webgl.dom_to_texture.enabled) {
             Some(Box::new(OutputHandler::new(

components/canvas/webgl_thread.rs

@@ -12,7 +12,9 @@ use half::f16;
 use offscreen_gl_context::{DrawBuffer, GLContext, NativeGLContextMethods};
 use pixels::{self, PixelFormat};
 use std::borrow::Cow;
+use std::sync::{Arc, Mutex};
 use std::thread;
+use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
 
 /// WebGL Threading API entry point that lives in the constellation.
 /// It allows to get a WebGLThread handle for each script pipeline.
@@ -58,12 +60,13 @@ pub struct WebGLThread<VR: WebVRRenderHandler + 'static> {
     cached_context_info: FnvHashMap<WebGLContextId, WebGLContextInfo>,
     /// Current bound context.
     bound_context_id: Option<WebGLContextId>,
-    /// Id generator for new WebGLContexts.
-    next_webgl_id: usize,
     /// Handler user to send WebVR commands.
     webvr_compositor: Option<VR>,
     /// Texture ids and sizes used in DOM to texture outputs.
     dom_outputs: FnvHashMap<webrender_api::PipelineId, DOMToTextureData>,
+    /// List of registered webrender external images.
+    /// We use it to get an unique ID for new WebGLContexts.
+    external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
 }
 
 impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
@@ -71,6 +74,7 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
         gl_factory: GLContextFactory,
         webrender_api_sender: webrender_api::RenderApiSender,
         webvr_compositor: Option<VR>,
+        external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
     ) -> Self {
         WebGLThread {
             gl_factory,
@@ -78,9 +82,9 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
             contexts: Default::default(),
             cached_context_info: Default::default(),
             bound_context_id: None,
-            next_webgl_id: 0,
             webvr_compositor,
             dom_outputs: Default::default(),
+            external_images,
         }
     }
 
@@ -90,14 +94,19 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
         gl_factory: GLContextFactory,
         webrender_api_sender: webrender_api::RenderApiSender,
         webvr_compositor: Option<VR>,
+        external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
     ) -> WebGLSender<WebGLMsg> {
         let (sender, receiver) = webgl_channel::<WebGLMsg>().unwrap();
         let result = sender.clone();
         thread::Builder::new()
             .name("WebGLThread".to_owned())
             .spawn(move || {
-                let mut renderer =
-                    WebGLThread::new(gl_factory, webrender_api_sender, webvr_compositor);
+                let mut renderer = WebGLThread::new(
+                    gl_factory,
+                    webrender_api_sender,
+                    webvr_compositor,
+                    external_images,
+                );
                 let webgl_chan = WebGLChan(sender);
                 loop {
                     let msg = receiver.recv().unwrap();
@@ -287,9 +296,14 @@ impl<VR: WebVRRenderHandler + 'static> WebGLThread<VR> {
             })
             .map_err(|msg: &str| msg.to_owned())?;
 
-        let id = WebGLContextId(self.next_webgl_id);
+        let id = WebGLContextId(
+            self.external_images
+                .lock()
+                .unwrap()
+                .next_id(WebrenderImageHandlerType::WebGL)
+                .0 as usize,
+        );
         let (size, texture_id, limits) = ctx.get_info();
-        self.next_webgl_id += 1;
         self.contexts.insert(
             id,
             GLContextData {