4 files changed, 51 insertions, 32 deletions

diff --git a/components/canvas_traits/webgl.rs b/components/canvas_traits/webgl.rs
index bdffd586287..57647204910 100644
--- a/components/canvas_traits/webgl.rs
+++ b/components/canvas_traits/webgl.rs
@@ -4,6 +4,7 @@
 
 use euclid::Size2D;
 use gleam::gl;
+use ipc_channel::ipc::{IpcBytesReceiver, IpcBytesSender};
 use offscreen_gl_context::{GLContextAttributes, GLLimits};
 use serde_bytes::ByteBuf;
 use std::borrow::Cow;
@@ -24,7 +25,7 @@ pub use ::webgl_channel::WebGLPipeline;
 pub use ::webgl_channel::WebGLChan;
 
 /// WebGL Message API
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Deserialize, Serialize)]
 pub enum WebGLMsg {
     /// Creates a new WebGLContext.
     CreateContext(WebGLVersion, Size2D<i32>, GLContextAttributes,
@@ -155,7 +156,7 @@ impl WebGLMsgSender {
 }
 
 /// WebGL Commands for a specific WebGLContext
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize)]
 pub enum WebGLCommand {
     GetContextAttributes(WebGLSender<GLContextAttributes>),
     ActiveTexture(u32),
@@ -167,8 +168,8 @@ pub enum WebGLCommand {
     AttachShader(WebGLProgramId, WebGLShaderId),
     DetachShader(WebGLProgramId, WebGLShaderId),
     BindAttribLocation(WebGLProgramId, u32, String),
-    BufferData(u32, ByteBuf, u32),
-    BufferSubData(u32, isize, ByteBuf),
+    BufferData(u32, IpcBytesReceiver, u32),
+    BufferSubData(u32, isize, IpcBytesReceiver),
     Clear(u32),
     ClearColor(f32, f32, f32, f32),
     ClearDepth(f32),
@@ -213,7 +214,7 @@ pub enum WebGLCommand {
     GetRenderbufferParameter(u32, u32, WebGLSender<i32>),
     PolygonOffset(f32, f32),
     RenderbufferStorage(u32, u32, i32, i32),
-    ReadPixels(i32, i32, i32, i32, u32, u32, WebGLSender<ByteBuf>),
+    ReadPixels(i32, i32, i32, i32, u32, u32, IpcBytesSender),
     SampleCoverage(f32, bool),
     Scissor(i32, i32, i32, i32),
     StencilFunc(u32, i32, u32),
@@ -251,8 +252,8 @@ pub enum WebGLCommand {
     VertexAttribPointer(u32, i32, u32, bool, i32, u32),
     VertexAttribPointer2f(u32, i32, bool, i32, u32),
     SetViewport(i32, i32, i32, i32),
-    TexImage2D(u32, i32, i32, i32, i32, u32, u32, ByteBuf),
-    TexSubImage2D(u32, i32, i32, i32, i32, i32, u32, u32, ByteBuf),
+    TexImage2D(u32, i32, i32, i32, i32, u32, u32, IpcBytesReceiver),
+    TexSubImage2D(u32, i32, i32, i32, i32, i32, u32, u32, IpcBytesReceiver),
     DrawingBufferWidth(WebGLSender<i32>),
     DrawingBufferHeight(WebGLSender<i32>),
     Finish(WebGLSender<()>),
diff --git a/components/canvas_traits/webgl_channel/ipc.rs b/components/canvas_traits/webgl_channel/ipc.rs
index ac3020bbc7a..a00ceda75ed 100644
--- a/components/canvas_traits/webgl_channel/ipc.rs
+++ b/components/canvas_traits/webgl_channel/ipc.rs
@@ -9,7 +9,7 @@ use std::io;
 pub type WebGLSender<T> = ipc_channel::ipc::IpcSender<T>;
 pub type WebGLReceiver<T> = ipc_channel::ipc::IpcReceiver<T>;
 
-pub fn webgl_channel<T: Serialize + for<'de> Deserialize<'de>>()
-        -> Result<(WebGLSender<T>, WebGLReceiver<T>), io::Error> {
+pub fn webgl_channel<T: Serialize + for<'de> Deserialize<'de>>(
+) -> Result<(WebGLSender<T>, WebGLReceiver<T>), io::Error> {
     ipc_channel::ipc::channel()
 }
diff --git a/components/canvas_traits/webgl_channel/mod.rs b/components/canvas_traits/webgl_channel/mod.rs
index c7376501049..3c6bd1690b0 100644
--- a/components/canvas_traits/webgl_channel/mod.rs
+++ b/components/canvas_traits/webgl_channel/mod.rs
@@ -13,17 +13,27 @@ use servo_config::opts;
 use std::fmt;
 
 lazy_static! {
-    static ref IS_MULTIPROCESS: bool = {
-        opts::multiprocess()
-    };
+    static ref IS_MULTIPROCESS: bool = { opts::multiprocess() };
 }
 
-#[derive(Clone, Deserialize, Serialize)]
+#[derive(Deserialize, Serialize)]
 pub enum WebGLSender<T: Serialize> {
     Ipc(ipc::WebGLSender<T>),
     Mpsc(mpsc::WebGLSender<T>),
 }
 
+impl<T> Clone for WebGLSender<T>
+where
+    T: Serialize,
+{
+    fn clone(&self) -> Self {
+        match *self {
+            WebGLSender::Ipc(ref chan) => WebGLSender::Ipc(chan.clone()),
+            WebGLSender::Mpsc(ref chan) => WebGLSender::Mpsc(chan.clone()),
+        }
+    }
+}
+
 impl<T: Serialize> fmt::Debug for WebGLSender<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "WebGLSender(..)")
@@ -34,41 +44,42 @@ impl<T: Serialize> WebGLSender<T> {
     #[inline]
     pub fn send(&self, msg: T) -> WebGLSendResult {
         match *self {
-            WebGLSender::Ipc(ref sender) => {
-                sender.send(msg).map_err(|_| ())
-            },
-            WebGLSender::Mpsc(ref sender) => {
-                sender.send(msg).map_err(|_| ())
-            }
+            WebGLSender::Ipc(ref sender) => sender.send(msg).map_err(|_| ()),
+            WebGLSender::Mpsc(ref sender) => sender.send(msg).map_err(|_| ()),
         }
     }
 }
 
 pub type WebGLSendResult = Result<(), ()>;
 
-pub enum WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
+pub enum WebGLReceiver<T>
+where
+    T: for<'de> Deserialize<'de> + Serialize,
+{
     Ipc(ipc::WebGLReceiver<T>),
     Mpsc(mpsc::WebGLReceiver<T>),
 }
 
-impl<T> WebGLReceiver<T> where T: for<'de> Deserialize<'de> + Serialize {
+impl<T> WebGLReceiver<T>
+where
+    T: for<'de> Deserialize<'de> + Serialize,
+{
     pub fn recv(&self) -> Result<T, ()> {
         match *self {
-            WebGLReceiver::Ipc(ref receiver) => {
-                receiver.recv().map_err(|_| ())
-            },
-            WebGLReceiver::Mpsc(ref receiver) => {
-                receiver.recv().map_err(|_| ())
-            }
+            WebGLReceiver::Ipc(ref receiver) => receiver.recv().map_err(|_| ()),
+            WebGLReceiver::Mpsc(ref receiver) => receiver.recv().map_err(|_| ()),
         }
     }
 }
 
 pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()>
-                             where T: for<'de> Deserialize<'de> + Serialize {
+where
+    T: for<'de> Deserialize<'de> + Serialize,
+{
     if *IS_MULTIPROCESS {
-        ipc::webgl_channel().map(|(tx, rx)| (WebGLSender::Ipc(tx), WebGLReceiver::Ipc(rx)))
-                            .map_err(|_| ())
+        ipc::webgl_channel()
+            .map(|(tx, rx)| (WebGLSender::Ipc(tx), WebGLReceiver::Ipc(rx)))
+            .map_err(|_| ())
     } else {
         mpsc::webgl_channel().map(|(tx, rx)| (WebGLSender::Mpsc(tx), WebGLReceiver::Mpsc(rx)))
     }
diff --git a/components/canvas_traits/webgl_channel/mpsc.rs b/components/canvas_traits/webgl_channel/mpsc.rs
index b0fe29241f3..92b83791d36 100644
--- a/components/canvas_traits/webgl_channel/mpsc.rs
+++ b/components/canvas_traits/webgl_channel/mpsc.rs
@@ -17,17 +17,24 @@ macro_rules! unreachable_serializable {
 
         impl<'a, T> Deserialize<'a> for $name<T> {
             fn deserialize<D>(_: D) -> Result<$name<T>, D::Error>
-                            where D: Deserializer<'a> {
+            where
+                D: Deserializer<'a>,
+            {
                 unreachable!();
             }
         }
     };
 }
 
-#[derive(Clone)]
 pub struct WebGLSender<T>(mpsc::Sender<T>);
 pub struct WebGLReceiver<T>(mpsc::Receiver<T>);
 
+impl<T> Clone for WebGLSender<T> {
+    fn clone(&self) -> Self {
+        WebGLSender(self.0.clone())
+    }
+}
+
 impl<T> WebGLSender<T> {
     #[inline]
     pub fn send(&self, data: T) -> Result<(), mpsc::SendError<T>> {