Moved Canvas rendering to a single thread.

components/canvas/lib.rs

@@ -20,6 +20,7 @@ extern crate servo_config;
 extern crate webrender;
 extern crate webrender_api;
 
+pub mod canvas_data;
 pub mod canvas_paint_thread;
 pub mod gl_context;
 mod webgl_mode;

components/canvas_traits/canvas.rs

@@ -16,12 +16,13 @@ pub enum FillRule {
     Evenodd,
 }
 
-#[derive(Clone, Deserialize, MallocSizeOf, PartialEq, Serialize)]
+#[derive(Clone, Copy, Deserialize, Eq, Hash, MallocSizeOf, PartialEq, Serialize)]
 pub struct CanvasId(pub u64);
 
 #[derive(Clone, Deserialize, Serialize)]
 pub enum CanvasMsg {
     Canvas2d(Canvas2dMsg, CanvasId),
+    Create(IpcSender<CanvasId>, Size2D<i32>, webrender_api::RenderApiSender, bool),
     FromLayout(FromLayoutMsg, CanvasId),
     FromScript(FromScriptMsg, CanvasId),
     Recreate(Size2D<i32>, CanvasId),
@@ -40,7 +41,7 @@ pub enum Canvas2dMsg {
     DrawImage(ByteBuf, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
     DrawImageSelf(Size2D<f64>, Rect<f64>, Rect<f64>, bool),
     DrawImageInOther(
-        IpcSender<CanvasMsg>, CanvasId, Size2D<f64>, Rect<f64>, Rect<f64>, bool, IpcSender<()>),
+        CanvasId, Size2D<f64>, Rect<f64>, Rect<f64>, bool),
     BeginPath,
     BezierCurveTo(Point2D<f32>, Point2D<f32>, Point2D<f32>),
     ClearRect(Rect<f32>),

components/constellation/constellation.rs

@@ -330,8 +330,8 @@ pub struct Constellation<Message, LTF, STF> {
     /// A channel through which messages can be sent to the webvr thread.
     webvr_chan: Option<IpcSender<WebVRMsg>>,
 
-    /// An Id for the next canvas to use.
+    /// A channel through which messages can be sent to the canvas paint thread.
-    canvas_id: CanvasId,
+    canvas_chan: IpcSender<CanvasMsg>,
 }
 
 /// State needed to construct a constellation.
@@ -630,7 +630,7 @@ impl<Message, LTF, STF> Constellation<Message, LTF, STF>
                 }),
                 webgl_threads: state.webgl_threads,
                 webvr_chan: state.webvr_chan,
-                canvas_id: CanvasId(0),
+                canvas_chan: CanvasPaintThread::start(),
             };
 
             constellation.run();
@@ -2286,11 +2286,25 @@ impl<Message, LTF, STF> Constellation<Message, LTF, STF>
             &mut self,
             size: &Size2D<i32>,
             response_sender: IpcSender<(IpcSender<CanvasMsg>, CanvasId)>) {
-        self.canvas_id.0 += 1;
         let webrender_api = self.webrender_api_sender.clone();
-        let sender = CanvasPaintThread::start(*size, webrender_api,
+        let sender = self.canvas_chan.clone();
-                                              opts::get().enable_canvas_antialiasing, self.canvas_id.clone());
+        let (canvas_id_sender, canvas_id_receiver) = ipc::channel::<CanvasId>().expect("ipc channel failure");
-        if let Err(e) = response_sender.send((sender, self.canvas_id.clone())) {
+
+        if let Err(e) = sender.send(
+            CanvasMsg::Create(
+                canvas_id_sender,
+                *size,
+                webrender_api,
+                opts::get().enable_canvas_antialiasing
+            )
+        ) {
+            return warn!("Create canvas paint thread failed ({})", e);
+        }
+        let canvas_id = match canvas_id_receiver.recv() {
+            Ok(canvas_id) => canvas_id,
+            Err(e) => return warn!("Create canvas paint thread id response failed ({})", e),
+        };
+        if let Err(e) = response_sender.send((sender, canvas_id.clone())) {
             warn!("Create canvas paint thread response failed ({})", e);
         }
     }

components/script/dom/canvasrenderingcontext2d.rs

@@ -371,20 +371,19 @@ impl CanvasRenderingContext2D {
                 None => return Err(Error::InvalidState),
             };
 
-            let (sender, receiver) = ipc::channel(self.global().time_profiler_chan().clone()).unwrap();
+            let msg = CanvasMsg::Canvas2d(
-            let msg = CanvasMsg::Canvas2d(Canvas2dMsg::DrawImageInOther(
+                Canvas2dMsg::DrawImageInOther(
-                self.ipc_renderer.clone(),
+                    self.get_canvas_id(),
-                self.get_canvas_id(),
+                    image_size,
-                image_size,
+                    dest_rect,
-                dest_rect,
+                    source_rect,
-                source_rect,
+                    smoothing_enabled
-                smoothing_enabled,
+                ),
-                sender),
+                context.get_canvas_id()
-                context.get_canvas_id());
+            );
 
             let renderer = context.get_ipc_renderer();
             renderer.send(msg).unwrap();
-            receiver.recv().unwrap();
         };
 
         self.mark_as_dirty();