diff --git a/components/canvas/canvas_paint_thread.rs b/components/canvas/canvas_paint_thread.rs
index 1bcf294d3b6..85d92ee1e8f 100644
--- a/components/canvas/canvas_paint_thread.rs
+++ b/components/canvas/canvas_paint_thread.rs
@@ -125,12 +125,12 @@ impl<'a> CanvasPaintThread<'a> {
     /// sender for it.
     pub fn start(size: Size2D<i32>,
                  webrender_api_sender: Option<webrender_traits::RenderApiSender>)
-                    -> (IpcSender<CanvasMsg>, Sender<CanvasMsg>) {
+                 -> IpcSender<CanvasMsg> {
         // TODO(pcwalton): Ask the pipeline to create this for us instead of spawning it directly.
         // This will be needed for multiprocess Servo.
         let (out_of_process_chan, out_of_process_port) = ipc::channel::<CanvasMsg>().unwrap();
         let (in_process_chan, in_process_port) = channel();
-        ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan.clone());
+        ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan);
         spawn_named("CanvasThread".to_owned(), move || {
             let mut painter = CanvasPaintThread::new(size, webrender_api_sender);
             loop {
@@ -217,7 +217,7 @@ impl<'a> CanvasPaintThread<'a> {
             }
         });
 
-        (out_of_process_chan, in_process_chan)
+        out_of_process_chan
     }
 
     fn save_context_state(&mut self) {
diff --git a/components/canvas/webgl_paint_thread.rs b/components/canvas/webgl_paint_thread.rs
index f1bce9343bf..08d8ea2f4b6 100644
--- a/components/canvas/webgl_paint_thread.rs
+++ b/components/canvas/webgl_paint_thread.rs
@@ -62,7 +62,7 @@ impl WebGLPaintThread {
     pub fn start(size: Size2D<i32>,
                  attrs: GLContextAttributes,
                  webrender_api_sender: Option<webrender_traits::RenderApiSender>)
-                 -> Result<(IpcSender<CanvasMsg>, Sender<CanvasMsg>), String> {
+                 -> Result<IpcSender<CanvasMsg>, String> {
         let (in_process_chan, in_process_port) = channel();
         let (result_chan, result_port) = channel();
         spawn_named("WebGLThread".to_owned(), move || {
@@ -106,8 +106,8 @@ impl WebGLPaintThread {
 
         result_port.recv().unwrap().map(|_| {
              let (out_of_process_chan, out_of_process_port) = ipc::channel::<CanvasMsg>().unwrap();
-             ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan.clone());
-             (out_of_process_chan, in_process_chan)
+             ROUTER.route_ipc_receiver_to_mpsc_sender(out_of_process_port, in_process_chan);
+             out_of_process_chan
         })
     }
 
diff --git a/components/compositing/constellation.rs b/components/compositing/constellation.rs
index dc757202a38..6b5b6cb5d7f 100644
--- a/components/compositing/constellation.rs
+++ b/components/compositing/constellation.rs
@@ -1200,8 +1200,8 @@ impl<LTF: LayoutThreadFactory, STF: ScriptThreadFactory> Constellation<LTF, STF>
             size: &Size2D<i32>,
             response_sender: IpcSender<IpcSender<CanvasMsg>>) {
         let webrender_api = self.webrender_api_sender.clone();
-        let (out_of_process_sender, _) = CanvasPaintThread::start(*size, webrender_api);
-        response_sender.send(out_of_process_sender).unwrap()
+        let sender = CanvasPaintThread::start(*size, webrender_api);
+        response_sender.send(sender).unwrap()
     }
 
     fn handle_create_webgl_paint_thread_msg(
@@ -1210,14 +1210,9 @@ impl<LTF: LayoutThreadFactory, STF: ScriptThreadFactory> Constellation<LTF, STF>
             attributes: GLContextAttributes,
             response_sender: IpcSender<Result<IpcSender<CanvasMsg>, String>>) {
         let webrender_api = self.webrender_api_sender.clone();
-        let response = match WebGLPaintThread::start(*size, attributes, webrender_api) {
-            Ok((out_of_process_sender, _)) => {
-                Ok(out_of_process_sender)
-            },
-            Err(msg) => Err(msg),
-        };
+        let sender = WebGLPaintThread::start(*size, attributes, webrender_api);
 
-        response_sender.send(response).unwrap()
+        response_sender.send(sender).unwrap()
     }
 
     fn handle_webdriver_msg(&mut self, msg: WebDriverCommandMsg) {