Use non-IPC webrender API over explicit IPC channels.

components/canvas/Cargo.toml

@@ -21,6 +21,7 @@ azure = {git = "https://github.com/servo/rust-azure", optional = true}
 bitflags = "1.0"
 byteorder = "1"
 canvas_traits = {path = "../canvas_traits"}
+crossbeam-channel = "0.3"
 cssparser = "0.27.1"
 embedder_traits = {path = "../embedder_traits"}
 euclid = "0.20"
@@ -35,7 +36,7 @@ pixels = {path = "../pixels"}
 servo_config = {path = "../config"}
 sparkle = "0.1.12"
 webrender = {git = "https://github.com/servo/webrender"}
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender"}
 webrender_traits = {path = "../webrender_traits"}
 webxr-api = {git = "https://github.com/servo/webxr", features = ["ipc"]}
 # NOTE: the sm-angle feature only enables angle on windows, not other platforms!

components/canvas/canvas_paint_thread.rs

@@ -3,9 +3,12 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 use crate::canvas_data::*;
+use crate::ConstellationCanvasMsg;
 use canvas_traits::canvas::*;
+use crossbeam_channel::{select, unbounded, Sender};
 use euclid::default::Size2D;
 use ipc_channel::ipc::{self, IpcSender};
+use ipc_channel::router::ROUTER;
 use std::borrow::ToOwned;
 use std::collections::HashMap;
 use std::thread;
@@ -30,53 +33,69 @@ impl<'a> CanvasPaintThread<'a> {
 
     /// Creates a new `CanvasPaintThread` and returns an `IpcSender` to
     /// communicate with it.
-    pub fn start() -> IpcSender<CanvasMsg> {
-        let (sender, receiver) = ipc::channel::<CanvasMsg>().unwrap();
+    pub fn start() -> (Sender<ConstellationCanvasMsg>, IpcSender<CanvasMsg>) {
+        let (ipc_sender, ipc_receiver) = ipc::channel::<CanvasMsg>().unwrap();
+        let msg_receiver = ROUTER.route_ipc_receiver_to_new_crossbeam_receiver(ipc_receiver);
+        let (create_sender, create_receiver) = unbounded();
         thread::Builder::new()
             .name("CanvasThread".to_owned())
             .spawn(move || {
                 let mut canvas_paint_thread = CanvasPaintThread::new();
                 loop {
-                    match receiver.recv() {
-                        Ok(msg) => match msg {
-                            CanvasMsg::Canvas2d(message, canvas_id) => {
-                                canvas_paint_thread.process_canvas_2d_message(message, canvas_id);
-                            },
-                            CanvasMsg::Close(canvas_id) => {
-                                canvas_paint_thread.canvases.remove(&canvas_id);
-                            },
-                            CanvasMsg::Create(creator, size, webrenderer_api_sender, antialias) => {
-                                let canvas_id = canvas_paint_thread.create_canvas(
+                    select! {
+                        recv(msg_receiver) -> msg => {
+                            match msg {
+                                Ok(CanvasMsg::Canvas2d(message, canvas_id)) => {
+                                    canvas_paint_thread.process_canvas_2d_message(message, canvas_id);
+                                },
+                                Ok(CanvasMsg::Close(canvas_id)) => {
+                                    canvas_paint_thread.canvases.remove(&canvas_id);
+                                },
+                                Ok(CanvasMsg::Recreate(size, canvas_id)) => {
+                                    canvas_paint_thread.canvas(canvas_id).recreate(size);
+                                },
+                                Ok(CanvasMsg::FromScript(message, canvas_id)) => match message {
+                                    FromScriptMsg::SendPixels(chan) => {
+                                        canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
+                                    },
+                                },
+                                Ok(CanvasMsg::FromLayout(message, canvas_id)) => match message {
+                                    FromLayoutMsg::SendData(chan) => {
+                                        canvas_paint_thread.canvas(canvas_id).send_data(chan);
+                                    },
+                                },
+                                Err(e) => {
+                                    warn!("Error on CanvasPaintThread receive ({})", e);
+                                },
+                            }
+                        }
+                        recv(create_receiver) -> msg => {
+                            match msg {
+                                Ok(ConstellationCanvasMsg::Create {
+                                    id_sender: creator,
                                     size,
-                                    webrenderer_api_sender,
-                                    antialias,
-                                );
-                                creator.send(canvas_id).unwrap();
-                            },
-                            CanvasMsg::Recreate(size, canvas_id) => {
-                                canvas_paint_thread.canvas(canvas_id).recreate(size);
-                            },
-                            CanvasMsg::FromScript(message, canvas_id) => match message {
-                                FromScriptMsg::SendPixels(chan) => {
-                                    canvas_paint_thread.canvas(canvas_id).send_pixels(chan);
+                                    webrender_sender: webrenderer_api_sender,
+                                    antialias
+                                }) => {
+                                    let canvas_id = canvas_paint_thread.create_canvas(
+                                        size,
+                                        webrenderer_api_sender,
+                                        antialias,
+                                    );
+                                    creator.send(canvas_id).unwrap();
                                 },
-                            },
-                            CanvasMsg::FromLayout(message, canvas_id) => match message {
-                                FromLayoutMsg::SendData(chan) => {
-                                    canvas_paint_thread.canvas(canvas_id).send_data(chan);
+                                Ok(ConstellationCanvasMsg::Exit) => break,
+                                Err(e) => {
+                                    warn!("Error on CanvasPaintThread receive ({})", e);
                                 },
-                            },
-                            CanvasMsg::Exit => break,
-                        },
-                        Err(e) => {
-                            warn!("Error on CanvasPaintThread receive ({})", e);
-                        },
+                            }
+                        }
                     }
                 }
             })
             .expect("Thread spawning failed");
 
-        sender
+        (create_sender, ipc_sender)
     }
 
     pub fn create_canvas(

components/canvas/lib.rs

@@ -4,6 +4,10 @@
 
 #![deny(unsafe_code)]
 
+use canvas_traits::canvas::CanvasId;
+use crossbeam_channel::Sender;
+use euclid::default::Size2D;
+
 #[macro_use]
 extern crate bitflags;
 #[macro_use]
@@ -22,3 +26,13 @@ pub mod canvas_paint_thread;
 mod webgl_limits;
 mod webgl_mode;
 pub mod webgl_thread;
+
+pub enum ConstellationCanvasMsg {
+    Create {
+        id_sender: Sender<CanvasId>,
+        size: Size2D<u64>,
+        webrender_sender: webrender_api::RenderApiSender,
+        antialias: bool,
+    },
+    Exit,
+}

components/canvas/webgl_mode/inprocess.rs

@@ -28,7 +28,7 @@ pub struct WebGLComm {
     pub webgl_threads: WebGLThreads,
     pub webxr_swap_chains: SwapChains<WebXRSwapChainId>,
     pub image_handler: Box<dyn WebrenderExternalImageApi>,
-    pub output_handler: Option<Box<dyn webrender::OutputImageHandler>>,
+    pub output_handler: Option<Box<dyn webrender_api::OutputImageHandler>>,
 }
 
 impl WebGLComm {
@@ -168,7 +168,7 @@ impl OutputHandler {
 }
 
 /// Bridge between the WR frame outputs and WebGL to implement DOMToTexture synchronization.
-impl webrender::OutputImageHandler for OutputHandler {
+impl webrender_api::OutputImageHandler for OutputHandler {
     fn lock(
         &mut self,
         id: webrender_api::PipelineId,

components/canvas_traits/Cargo.toml

@@ -25,6 +25,6 @@ serde = "1.0"
 serde_bytes = "0.11"
 servo_config = {path = "../config"}
 sparkle = "0.1"
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender"}
 webvr_traits = {path = "../webvr_traits"}
 webxr-api = {git = "https://github.com/servo/webxr", features = ["ipc"]}

components/canvas_traits/canvas.rs

@@ -21,17 +21,10 @@ pub struct CanvasId(pub u64);
 #[derive(Deserialize, Serialize)]
 pub enum CanvasMsg {
     Canvas2d(Canvas2dMsg, CanvasId),
-    Create(
-        IpcSender<CanvasId>,
-        Size2D<u64>,
-        webrender_api::RenderApiSender,
-        bool,
-    ),
     FromLayout(FromLayoutMsg, CanvasId),
     FromScript(FromScriptMsg, CanvasId),
     Recreate(Size2D<u64>, CanvasId),
     Close(CanvasId),
-    Exit,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]

components/compositing/Cargo.toml

@@ -38,7 +38,7 @@ servo_url = {path = "../url"}
 style_traits = {path = "../style_traits"}
 time = "0.1.17"
 webrender = {git = "https://github.com/servo/webrender", features = ["capture"]}
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender"}
 webvr_traits = {path = "../webvr_traits"}
 webvr = {path = "../webvr"}
 webxr = {git = "https://github.com/servo/webxr"}

components/constellation/Cargo.toml

@@ -49,7 +49,7 @@ servo_remutex = {path = "../remutex"}
 servo_url = {path = "../url"}
 webgpu = {path = "../webgpu"}
 webvr_traits = {path = "../webvr_traits"}
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
+webrender_api = {git = "https://github.com/servo/webrender"}
 webxr-api = {git = "https://github.com/servo/webxr", features = ["ipc"]}
 
 [target.'cfg(all(not(target_os = "windows"), not(target_os = "ios"), not(target_os="android"), not(target_arch="arm"), not(target_arch="aarch64")))'.dependencies]