Implement DOM to texture

components/canvas/webgl_mode/inprocess.rs

@@ -6,9 +6,12 @@ use ::gl_context::GLContextFactory;
 use ::webgl_thread::{WebGLExternalImageApi, WebGLExternalImageHandler, WebGLThreadObserver, WebGLThread};
 use canvas_traits::webgl::{WebGLChan, WebGLContextId, WebGLMsg, WebGLPipeline, WebGLReceiver};
 use canvas_traits::webgl::{WebGLSender, WebVRCommand, WebVRRenderHandler};
+use canvas_traits::webgl::DOMToTextureCommand;
 use canvas_traits::webgl::webgl_channel;
 use euclid::Size2D;
+use fnv::FnvHashMap;
 use gleam::gl;
+use servo_config::prefs::PREFS;
 use std::marker::PhantomData;
 use std::rc::Rc;
 use webrender;
@@ -23,14 +26,19 @@ impl WebGLThreads {
                webrender_gl: Rc<gl::Gl>,
                webrender_api_sender: webrender_api::RenderApiSender,
                webvr_compositor: Option<Box<WebVRRenderHandler>>)
-               -> (WebGLThreads, Box<webrender::ExternalImageHandler>) {
+               -> (WebGLThreads, Box<webrender::ExternalImageHandler>, Option<Box<webrender::OutputImageHandler>>) {
         // This implementation creates a single `WebGLThread` for all the pipelines.
         let channel = WebGLThread::start(gl_factory,
                                          webrender_api_sender,
                                          webvr_compositor.map(|c| WebVRRenderWrapper(c)),
                                          PhantomData);
+        let output_handler = if PREFS.is_dom_to_texture_enabled() {
+            Some(Box::new(OutputHandler::new(webrender_gl.clone(), channel.clone())))
+        } else {
+            None
+        };
         let external = WebGLExternalImageHandler::new(WebGLExternalImages::new(webrender_gl, channel.clone()));
-        (WebGLThreads(channel), Box::new(external))
+        (WebGLThreads(channel), Box::new(external), output_handler.map(|b| b as Box<_>))
     }
 
     /// Gets the WebGLThread handle for each script pipeline.
@@ -105,3 +113,47 @@ impl WebVRRenderHandler for WebVRRenderWrapper {
         self.0.handle(command, texture);
     }
 }
+
+/// struct used to implement DOMToTexture feature and webrender::OutputImageHandler trait.
+type OutputHandlerData = Option<(u32, Size2D<i32>)>;
+struct OutputHandler {
+    webrender_gl: Rc<gl::Gl>,
+    webgl_channel: WebGLSender<WebGLMsg>,
+    // Used to avoid creating a new channel on each received WebRender request.
+    lock_channel: (WebGLSender<OutputHandlerData>, WebGLReceiver<OutputHandlerData>),
+    sync_objects: FnvHashMap<webrender_api::PipelineId, gl::GLsync>,
+}
+
+impl OutputHandler {
+    fn new(webrender_gl: Rc<gl::Gl>, channel: WebGLSender<WebGLMsg>) -> Self {
+        Self {
+            webrender_gl,
+            webgl_channel: channel,
+            lock_channel: webgl_channel().unwrap(),
+            sync_objects: Default::default(),
+        }
+    }
+}
+
+/// Bridge between the WR frame outputs and WebGL to implement DOMToTexture synchronization.
+impl webrender::OutputImageHandler for OutputHandler {
+    fn lock(&mut self, id: webrender_api::PipelineId) -> Option<(u32, webrender_api::DeviceIntSize)> {
+        // Insert a fence in the WR command queue
+        let gl_sync = self.webrender_gl.fence_sync(gl::SYNC_GPU_COMMANDS_COMPLETE, 0);
+        // The lock command adds a WaitSync call on the WebGL command flow.
+        let command = DOMToTextureCommand::Lock(id, gl_sync as usize, self.lock_channel.0.clone());
+        self.webgl_channel.send(WebGLMsg::DOMToTextureCommand(command)).unwrap();
+        self.lock_channel.1.recv().unwrap().map(|(tex_id, size)| {
+            (tex_id, webrender_api::DeviceIntSize::new(size.width, size.height))
+        })
+    }
+
+    fn unlock(&mut self, id: webrender_api::PipelineId) {
+        if let Some(gl_sync) = self.sync_objects.remove(&id) {
+            // Flush the Sync object into the GPU's command queue to guarantee that it it's signaled.
+            self.webrender_gl.flush();
+            // Mark the sync object for deletion.
+            self.webrender_gl.delete_sync(gl_sync);
+        }
+    }
+}