Remove the DOMToTexture feature

This relies on WebRender's frame output API, `set_output_image_handler`,
which has been removed from the latest upstream [1]. It's sad to remove
this feature, which was probably a lot of work to implement, but it
seems difficult to patch WebRender to restore this functionality.

Fixes servo#29936.

1. https://hg.mozilla.org/mozilla-central/rev/361521e3c52324809553c555fb066d50f023d9bf

Author: mrobinson

Cargo.lock

@@ -7,12 +7,8 @@ use canvas_traits::webgl::webgl_channel;
 use canvas_traits::webgl::{WebGLContextId, WebGLMsg, WebGLThreads};
 use euclid::default::Size2D;
 use fnv::FnvHashMap;
-use gleam;
-use servo_config::pref;
-use sparkle::gl;
 use sparkle::gl::GlType;
 use std::default::Default;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use surfman::Device;
 use surfman::SurfaceInfo;
@@ -30,15 +26,13 @@ use webxr_api::LayerGrandManager as WebXRLayerGrandManager;
 pub struct WebGLComm {
     pub webgl_threads: WebGLThreads,
     pub image_handler: Box<dyn WebrenderExternalImageApi>,
-    pub output_handler: Option<Box<dyn webrender_api::OutputImageHandler>>,
     pub webxr_layer_grand_manager: WebXRLayerGrandManager<WebXRSurfman>,
 }
 
 impl WebGLComm {
     /// Creates a new `WebGLComm` object.
     pub fn new(
         surfman: WebrenderSurfman,
-        webrender_gl: Rc<dyn gleam::gl::Gl>,
         webrender_api_sender: webrender_api::RenderApiSender,
         webrender_doc: webrender_api::DocumentId,
         external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@@ -64,20 +58,13 @@ impl WebGLComm {
             webxr_init,
         };
 
-        let output_handler = if pref!(dom.webgl.dom_to_texture.enabled) {
-            Some(Box::new(OutputHandler::new(webrender_gl.clone())))
-        } else {
-            None
-        };
-
         let external = WebGLExternalImages::new(surfman, webrender_swap_chains);
 
         WebGLThread::run_on_own_thread(init);
 
         WebGLComm {
             webgl_threads: WebGLThreads(sender),
             image_handler: Box::new(external),
-            output_handler: output_handler.map(|b| b as Box<_>),
             webxr_layer_grand_manager: webxr_layer_grand_manager,
         }
     }
@@ -144,43 +131,3 @@ impl WebrenderExternalImageApi for WebGLExternalImages {
         self.unlock_swap_chain(id);
     }
 }
-
-/// struct used to implement DOMToTexture feature and webrender::OutputImageHandler trait.
-struct OutputHandler {
-    webrender_gl: Rc<dyn gleam::gl::Gl>,
-    sync_objects: FnvHashMap<webrender_api::PipelineId, gleam::gl::GLsync>,
-}
-
-impl OutputHandler {
-    fn new(webrender_gl: Rc<dyn gleam::gl::Gl>) -> Self {
-        OutputHandler {
-            webrender_gl,
-            sync_objects: Default::default(),
-        }
-    }
-}
-
-/// Bridge between the WR frame outputs and WebGL to implement DOMToTexture synchronization.
-impl webrender_api::OutputImageHandler for OutputHandler {
-    fn lock(
-        &mut self,
-        id: webrender_api::PipelineId,
-    ) -> Option<(u32, webrender_api::units::FramebufferIntSize)> {
-        // Insert a fence in the WR command queue
-        let gl_sync = self
-            .webrender_gl
-            .fence_sync(gl::SYNC_GPU_COMMANDS_COMPLETE, 0);
-        self.sync_objects.insert(id, gl_sync);
-        // https://github.com/servo/servo/issues/24615
-        None
-    }
-
-    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);
-        }
-    }
-}

components/canvas/webgl_mode/inprocess.rs

@@ -10,7 +10,6 @@ use canvas_traits::webgl::ActiveAttribInfo;
 use canvas_traits::webgl::ActiveUniformBlockInfo;
 use canvas_traits::webgl::ActiveUniformInfo;
 use canvas_traits::webgl::AlphaTreatment;
-use canvas_traits::webgl::DOMToTextureCommand;
 use canvas_traits::webgl::GLContextAttributes;
 use canvas_traits::webgl::GLLimits;
 use canvas_traits::webgl::GlType;
@@ -239,8 +238,6 @@ pub(crate) struct WebGLThread {
     cached_context_info: FnvHashMap<WebGLContextId, WebGLContextInfo>,
     /// Current bound context.
     bound_context_id: Option<WebGLContextId>,
-    /// 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>>,
@@ -298,7 +295,6 @@ impl WebGLThread {
             contexts: Default::default(),
             cached_context_info: Default::default(),
             bound_context_id: None,
-            dom_outputs: Default::default(),
             external_images,
             sender,
             receiver: receiver.into_inner(),
@@ -410,9 +406,6 @@ impl WebGLThread {
             WebGLMsg::SwapBuffers(swap_ids, sender, sent_time) => {
                 self.handle_swap_buffers(swap_ids, sender, sent_time);
             },
-            WebGLMsg::DOMToTextureCommand(command) => {
-                self.handle_dom_to_texture(command);
-            },
             WebGLMsg::Exit => {
                 return true;
             },
@@ -890,88 +883,6 @@ impl WebGLThread {
         SurfaceAccess::GPUOnly
     }
 
-    fn handle_dom_to_texture(&mut self, command: DOMToTextureCommand) {
-        match command {
-            DOMToTextureCommand::Attach(context_id, texture_id, document_id, pipeline_id, size) => {
-                let data = Self::make_current_if_needed(
-                    &self.device,
-                    context_id,
-                    &self.contexts,
-                    &mut self.bound_context_id,
-                )
-                .expect("WebGLContext not found in a WebGL DOMToTextureCommand::Attach command");
-                // Initialize the texture that WR will use for frame outputs.
-                data.gl.tex_image_2d(
-                    gl::TEXTURE_2D,
-                    0,
-                    gl::RGBA as gl::GLint,
-                    size.width,
-                    size.height,
-                    0,
-                    gl::RGBA,
-                    gl::UNSIGNED_BYTE,
-                    gl::TexImageSource::Pixels(None),
-                );
-                self.dom_outputs.insert(
-                    pipeline_id,
-                    DOMToTextureData {
-                        context_id,
-                        texture_id,
-                        document_id,
-                        size,
-                    },
-                );
-                let mut txn = webrender_api::Transaction::new();
-                txn.enable_frame_output(pipeline_id, true);
-                self.webrender_api.send_transaction(document_id, txn);
-            },
-            DOMToTextureCommand::Lock(pipeline_id, gl_sync, sender) => {
-                let result = self.handle_dom_to_texture_lock(pipeline_id, gl_sync);
-                // Send the texture id and size to WR.
-                sender.send(result).unwrap();
-            },
-            DOMToTextureCommand::Detach(texture_id) => {
-                if let Some((pipeline_id, document_id)) = self
-                    .dom_outputs
-                    .iter()
-                    .find(|&(_, v)| v.texture_id == texture_id)
-                    .map(|(k, v)| (*k, v.document_id))
-                {
-                    let mut txn = webrender_api::Transaction::new();
-                    txn.enable_frame_output(pipeline_id, false);
-                    self.webrender_api.send_transaction(document_id, txn);
-                    self.dom_outputs.remove(&pipeline_id);
-                }
-            },
-        }
-    }
-
-    pub(crate) fn handle_dom_to_texture_lock(
-        &mut self,
-        pipeline_id: webrender_api::PipelineId,
-        gl_sync: usize,
-    ) -> Option<(u32, Size2D<i32>)> {
-        let device = &self.device;
-        let contexts = &self.contexts;
-        let bound_context_id = &mut self.bound_context_id;
-        self.dom_outputs.get(&pipeline_id).and_then(|dom_data| {
-            let data = Self::make_current_if_needed(
-                device,
-                dom_data.context_id,
-                contexts,
-                bound_context_id,
-            );
-            data.and_then(|data| {
-                // The next glWaitSync call is used to synchronize the two flows of
-                // OpenGL commands (WR and WebGL) in order to avoid using semi-ready WR textures.
-                // glWaitSync doesn't block WebGL CPU thread.
-                data.gl
-                    .wait_sync(gl_sync as gl::GLsync, 0, gl::TIMEOUT_IGNORED);
-                Some((dom_data.texture_id.get(), dom_data.size))
-            })
-        })
-    }
-
     /// Gets a reference to a Context for a given WebGLContextId and makes it current if required.
     fn make_current_if_needed<'a>(
         device: &Device,
@@ -1106,14 +1017,6 @@ fn current_wr_texture_target(device: &Device) -> webrender_api::TextureTarget {
     }
 }
 
-/// Data about the linked DOM<->WebGLTexture elements.
-struct DOMToTextureData {
-    context_id: WebGLContextId,
-    texture_id: WebGLTextureId,
-    document_id: webrender_api::DocumentId,
-    size: Size2D<i32>,
-}
-
 /// WebGL Commands Implementation
 pub struct WebGLImpl;