Store a reference to the WebGLRenderingContext in WebGLObject

components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs

@@ -48,15 +48,7 @@ impl OESVertexArrayObjectMethods for OESVertexArrayObject {
     fn CreateVertexArrayOES(&self) -> Option<DomRoot<WebGLVertexArrayObjectOES>> {
         let (sender, receiver) = webgl_channel().unwrap();
         self.ctx.send_command(WebGLCommand::CreateVertexArray(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLVertexArrayObjectOES::new(&self.ctx, id))
-        let result = receiver.recv().unwrap();
-        result.map(|vao_id| {
-            WebGLVertexArrayObjectOES::new(
-                &self.global(),
-                vao_id,
-                self.ctx.limits().max_vertex_attribs,
-            )
-        })
     }
 
     // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/

components/script/dom/webglbuffer.rs

@@ -3,15 +3,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
-use canvas_traits::webgl::{WebGLBufferId, WebGLCommand, WebGLError, WebGLMsgSender, WebGLResult, WebGLVertexArrayId};
+use canvas_traits::webgl::{WebGLBufferId, WebGLCommand, WebGLError, WebGLResult, WebGLVertexArrayId};
 use canvas_traits::webgl::webgl_channel;
 use dom::bindings::cell::DomRefCell;
 use dom::bindings::codegen::Bindings::WebGLBufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::DomRoot;
 use dom::webglobject::WebGLObject;
-use dom::window::Window;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;
 use std::cell::Cell;
 use std::collections::HashSet;
@@ -28,44 +29,36 @@ pub struct WebGLBuffer {
     // The Vertex Array Objects that are referencing this buffer
     vao_references: DomRefCell<Option<HashSet<WebGLVertexArrayId>>>,
     pending_delete: Cell<bool>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
     /// https://www.khronos.org/registry/OpenGL-Refpages/es2.0/xhtml/glGetBufferParameteriv.xml
     usage: Cell<u32>,
 }
 
 impl WebGLBuffer {
-    fn new_inherited(renderer: WebGLMsgSender,
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLBufferId) -> Self {
-                     id: WebGLBufferId)
+        Self {
-                     -> WebGLBuffer {
+            webgl_object: WebGLObject::new_inherited(context),
-        WebGLBuffer {
-            webgl_object: WebGLObject::new_inherited(),
             id: id,
             target: Cell::new(None),
             capacity: Cell::new(0),
             is_deleted: Cell::new(false),
             vao_references: DomRefCell::new(None),
             pending_delete: Cell::new(false),
-            renderer: renderer,
             usage: Cell::new(WebGLRenderingContextConstants::STATIC_DRAW),
         }
     }
 
-    pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
-                     -> Option<DomRoot<WebGLBuffer>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateBuffer(sender)).unwrap();
+        context.send_command(WebGLCommand::CreateBuffer(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLBuffer::new(context, id))
-        let result = receiver.recv().unwrap();
-        result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(context: &WebGLRenderingContext, id: WebGLBufferId) -> DomRoot<Self> {
-               renderer: WebGLMsgSender,
+        reflect_dom_object(
-               id: WebGLBufferId)
+            Box::new(WebGLBuffer::new_inherited(context, id)),
-              -> DomRoot<WebGLBuffer> {
+            &*context.global(),
-        reflect_dom_object(Box::new(WebGLBuffer::new_inherited(renderer, id)),
+            WebGLBufferBinding::Wrap,
-                           window, WebGLBufferBinding::Wrap)
+        )
     }
 }
 
@@ -87,9 +80,9 @@ impl WebGLBuffer {
         } else {
             self.target.set(Some(target));
         }
-        let msg = WebGLCommand::BindBuffer(target, Some(self.id));
+        self.upcast::<WebGLObject>()
-        self.renderer.send(msg).unwrap();
+            .context()
-
+            .send_command(WebGLCommand::BindBuffer(target, Some(self.id)));
         Ok(())
     }
 
@@ -112,8 +105,9 @@ impl WebGLBuffer {
         let data = data.into();
         self.capacity.set(data.len());
         self.usage.set(usage);
-        self.renderer.send(WebGLCommand::BufferData(target, data.into(), usage)).unwrap();
+        self.upcast::<WebGLObject>()
-
+            .context()
+            .send_command(WebGLCommand::BufferData(target, data.into(), usage));
         Ok(())
     }
 
@@ -124,7 +118,9 @@ impl WebGLBuffer {
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
-            let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id));
+            self.upcast::<WebGLObject>()
+                .context()
+                .send_command(WebGLCommand::DeleteBuffer(self.id));
         }
     }
 
@@ -164,7 +160,9 @@ impl WebGLBuffer {
         if let Some(ref mut vao_refs) = *self.vao_references.borrow_mut() {
             if vao_refs.take(&id).is_some() && self.pending_delete.get() {
                 // WebGL spec: The deleted buffers should no longer be valid when the VAOs are deleted
-                let _ = self.renderer.send(WebGLCommand::DeleteBuffer(self.id));
+                self.upcast::<WebGLObject>()
+                    .context()
+                    .send_command(WebGLCommand::DeleteBuffer(self.id));
                 self.is_deleted.set(true);
             }
         }

components/script/dom/webglframebuffer.rs

@@ -4,17 +4,17 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use canvas_traits::webgl::{WebGLCommand, WebGLFramebufferBindingRequest, WebGLFramebufferId};
-use canvas_traits::webgl::{WebGLMsgSender, WebGLResult, WebGLError};
+use canvas_traits::webgl::{WebGLResult, WebGLError, webgl_channel};
-use canvas_traits::webgl::webgl_channel;
 use dom::bindings::cell::DomRefCell;
 use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::{Dom, DomRoot};
 use dom::webglobject::WebGLObject;
 use dom::webglrenderbuffer::WebGLRenderbuffer;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom::webgltexture::WebGLTexture;
-use dom::window::Window;
 use dom_struct::dom_struct;
 use std::cell::Cell;
 
@@ -40,9 +40,6 @@ pub struct WebGLFramebuffer {
     is_deleted: Cell<bool>,
     size: Cell<Option<(i32, i32)>>,
     status: Cell<u32>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
-
     // The attachment points for textures and renderbuffers on this
     // FBO.
     color: DomRefCell<Option<WebGLFramebufferAttachment>>,
@@ -52,15 +49,12 @@ pub struct WebGLFramebuffer {
 }
 
 impl WebGLFramebuffer {
-    fn new_inherited(renderer: WebGLMsgSender,
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLFramebufferId) -> Self {
-                     id: WebGLFramebufferId)
+        Self {
-                     -> WebGLFramebuffer {
+            webgl_object: WebGLObject::new_inherited(context),
-        WebGLFramebuffer {
-            webgl_object: WebGLObject::new_inherited(),
             id: id,
             target: Cell::new(None),
             is_deleted: Cell::new(false),
-            renderer: renderer,
             size: Cell::new(None),
             status: Cell::new(constants::FRAMEBUFFER_UNSUPPORTED),
             color: DomRefCell::new(None),
@@ -70,22 +64,21 @@ impl WebGLFramebuffer {
         }
     }
 
-    pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
-                     -> Option<DomRoot<WebGLFramebuffer>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateFramebuffer(sender)).unwrap();
+        context.send_command(WebGLCommand::CreateFramebuffer(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLFramebuffer::new(context, id))
-        let result = receiver.recv().unwrap();
-        result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(
-               renderer: WebGLMsgSender,
+        context: &WebGLRenderingContext,
-               id: WebGLFramebufferId)
+        id: WebGLFramebufferId,
-               -> DomRoot<WebGLFramebuffer> {
+    ) -> DomRoot<Self> {
-        reflect_dom_object(Box::new(WebGLFramebuffer::new_inherited(renderer, id)),
+        reflect_dom_object(
-                           window,
+            Box::new(WebGLFramebuffer::new_inherited(context, id)),
-                           WebGLFramebufferBinding::Wrap)
+            &*context.global(),
+            WebGLFramebufferBinding::Wrap,
+        )
     }
 }
 
@@ -102,14 +95,17 @@ impl WebGLFramebuffer {
         self.update_status();
 
         self.target.set(Some(target));
-        let cmd = WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Explicit(self.id));
+        self.upcast::<WebGLObject>().context().send_command(
-        self.renderer.send(cmd).unwrap();
+            WebGLCommand::BindFramebuffer(target, WebGLFramebufferBindingRequest::Explicit(self.id)),
+        );
     }
 
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
-            let _ = self.renderer.send(WebGLCommand::DeleteFramebuffer(self.id));
+            self.upcast::<WebGLObject>()
+                .context()
+                .send_command(WebGLCommand::DeleteFramebuffer(self.id));
         }
     }
 
@@ -210,10 +206,14 @@ impl WebGLFramebuffer {
             }
         };
 
-        self.renderer.send(WebGLCommand::FramebufferRenderbuffer(constants::FRAMEBUFFER,
+        self.upcast::<WebGLObject>().context().send_command(
+            WebGLCommand::FramebufferRenderbuffer(
+                constants::FRAMEBUFFER,
                 attachment,
                 constants::RENDERBUFFER,
-                                                                 rb_id)).unwrap();
+                rb_id,
+            ),
+        );
 
         self.update_status();
         Ok(())
@@ -305,11 +305,15 @@ impl WebGLFramebuffer {
             }
         };
 
-        self.renderer.send(WebGLCommand::FramebufferTexture2D(constants::FRAMEBUFFER,
+        self.upcast::<WebGLObject>().context().send_command(
+            WebGLCommand::FramebufferTexture2D(
+                constants::FRAMEBUFFER,
                 attachment,
                 textarget,
                 tex_id,
-                                                              level)).unwrap();
+                level,
+            ),
+        );
 
         self.update_status();
         Ok(())

components/script/dom/webglobject.rs

@@ -4,17 +4,25 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use dom::bindings::reflector::Reflector;
+use dom::bindings::root::Dom;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;
 
 #[dom_struct]
 pub struct WebGLObject {
     reflector_: Reflector,
+    context: Dom<WebGLRenderingContext>,
 }
 
 impl WebGLObject {
-    pub fn new_inherited() -> WebGLObject {
+    pub fn new_inherited(context: &WebGLRenderingContext) -> WebGLObject {
         WebGLObject {
             reflector_: Reflector::new(),
+            context: Dom::from_ref(context),
         }
     }
+
+    pub fn context(&self) -> &WebGLRenderingContext {
+        &self.context
+    }
 }

components/script/dom/webglprogram.rs

@@ -4,19 +4,19 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 use canvas_traits::webgl::{ActiveAttribInfo, ActiveUniformInfo, WebGLCommand, WebGLError};
-use canvas_traits::webgl::{WebGLMsgSender, WebGLProgramId, WebGLResult, webgl_channel};
+use canvas_traits::webgl::{WebGLProgramId, WebGLResult, webgl_channel};
 use dom::bindings::cell::DomRefCell;
 use dom::bindings::codegen::Bindings::WebGLProgramBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
+use dom::bindings::inheritance::Castable;
 use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::{DomRoot, MutNullableDom};
 use dom::bindings::str::DOMString;
 use dom::webglactiveinfo::WebGLActiveInfo;
 use dom::webglobject::WebGLObject;
-use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
+use dom::webglrenderingcontext::{MAX_UNIFORM_AND_ATTRIBUTE_LEN, WebGLRenderingContext};
 use dom::webglshader::WebGLShader;
 use dom::webgluniformlocation::WebGLUniformLocation;
-use dom::window::Window;
 use dom_struct::dom_struct;
 use fnv::FnvHashSet;
 use std::cell::{Cell, Ref};
@@ -31,16 +31,14 @@ pub struct WebGLProgram {
     link_generation: Cell<u64>,
     fragment_shader: MutNullableDom<WebGLShader>,
     vertex_shader: MutNullableDom<WebGLShader>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
     active_attribs: DomRefCell<Box<[ActiveAttribInfo]>>,
     active_uniforms: DomRefCell<Box<[ActiveUniformInfo]>>,
 }
 
 impl WebGLProgram {
-    fn new_inherited(renderer: WebGLMsgSender, id: WebGLProgramId) -> Self {
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLProgramId) -> Self {
         Self {
-            webgl_object: WebGLObject::new_inherited(),
+            webgl_object: WebGLObject::new_inherited(context),
             id: id,
             is_deleted: Cell::new(false),
             link_called: Cell::new(false),
@@ -48,28 +46,23 @@ impl WebGLProgram {
             link_generation: Default::default(),
             fragment_shader: Default::default(),
             vertex_shader: Default::default(),
-            renderer: renderer,
             active_attribs: DomRefCell::new(vec![].into()),
             active_uniforms: DomRefCell::new(vec![].into()),
         }
     }
 
-    pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
-                     -> Option<DomRoot<WebGLProgram>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateProgram(sender)).unwrap();
+        context.send_command(WebGLCommand::CreateProgram(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLProgram::new(context, id))
-        let result = receiver.recv().unwrap();
-        result.map(|program_id| WebGLProgram::new(window, renderer, program_id))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(context: &WebGLRenderingContext, id: WebGLProgramId) -> DomRoot<Self> {
-               renderer: WebGLMsgSender,
+        reflect_dom_object(
-               id: WebGLProgramId)
+            Box::new(WebGLProgram::new_inherited(context, id)),
-               -> DomRoot<WebGLProgram> {
+            &*context.global(),
-        reflect_dom_object(Box::new(WebGLProgram::new_inherited(renderer, id)),
+            WebGLProgramBinding::Wrap,
-                           window,
+        )
-                           WebGLProgramBinding::Wrap)
     }
 }
 
@@ -83,7 +76,9 @@ impl WebGLProgram {
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
-            let _ = self.renderer.send(WebGLCommand::DeleteProgram(self.id));
+            self.upcast::<WebGLObject>()
+                .context()
+                .send_command(WebGLCommand::DeleteProgram(self.id));
 
             if let Some(shader) = self.fragment_shader.get() {
                 shader.decrement_attached_counter();
@@ -124,7 +119,9 @@ impl WebGLProgram {
         }
 
         let (sender, receiver) = webgl_channel().unwrap();
-        self.renderer.send(WebGLCommand::LinkProgram(self.id, sender)).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::LinkProgram(self.id, sender));
         let link_info = receiver.recv().unwrap();
 
         {
@@ -175,7 +172,9 @@ impl WebGLProgram {
         if self.is_deleted() {
             return Err(WebGLError::InvalidOperation);
         }
-        self.renderer.send(WebGLCommand::ValidateProgram(self.id)).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::ValidateProgram(self.id));
         Ok(())
     }
 
@@ -202,7 +201,9 @@ impl WebGLProgram {
         shader_slot.set(Some(shader));
         shader.increment_attached_counter();
 
-        self.renderer.send(WebGLCommand::AttachShader(self.id, shader.id())).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::AttachShader(self.id, shader.id()));
 
         Ok(())
     }
@@ -232,7 +233,9 @@ impl WebGLProgram {
         shader_slot.set(None);
         shader.decrement_attached_counter();
 
-        self.renderer.send(WebGLCommand::DetachShader(self.id, shader.id())).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::DetachShader(self.id, shader.id()));
 
         Ok(())
     }
@@ -251,9 +254,9 @@ impl WebGLProgram {
             return Err(WebGLError::InvalidOperation);
         }
 
-        self.renderer
+        self.upcast::<WebGLObject>()
-            .send(WebGLCommand::BindAttribLocation(self.id, index, name.into()))
+            .context()
-            .unwrap();
+            .send_command(WebGLCommand::BindAttribLocation(self.id, index, name.into()));
         Ok(())
     }
 
@@ -351,9 +354,9 @@ impl WebGLProgram {
         };
 
         let (sender, receiver) = webgl_channel().unwrap();
-        self.renderer
+        self.upcast::<WebGLObject>()
-            .send(WebGLCommand::GetUniformLocation(self.id, name.into(), sender))
+            .context()
-            .unwrap();
+            .send_command(WebGLCommand::GetUniformLocation(self.id, name.into(), sender));
         let location = receiver.recv().unwrap();
 
         Ok(Some(WebGLUniformLocation::new(
@@ -381,7 +384,9 @@ impl WebGLProgram {
             }
         }
         let (sender, receiver) = webgl_channel().unwrap();
-        self.renderer.send(WebGLCommand::GetProgramInfoLog(self.id, sender)).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::GetProgramInfoLog(self.id, sender));
         Ok(receiver.recv().unwrap())
     }
 

components/script/dom/webglrenderbuffer.rs

@@ -3,13 +3,14 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
-use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLMsgSender, WebGLRenderbufferId, WebGLResult};
+use canvas_traits::webgl::{webgl_channel, WebGLCommand, WebGLError, WebGLRenderbufferId, WebGLResult};
 use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::DomRoot;
 use dom::webglobject::WebGLObject;
-use dom::window::Window;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;
 use std::cell::Cell;
 
@@ -21,41 +22,32 @@ pub struct WebGLRenderbuffer {
     is_deleted: Cell<bool>,
     size: Cell<Option<(i32, i32)>>,
     internal_format: Cell<Option<u32>>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
 }
 
 impl WebGLRenderbuffer {
-    fn new_inherited(renderer: WebGLMsgSender,
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> Self {
-                     id: WebGLRenderbufferId)
+        Self {
-                     -> WebGLRenderbuffer {
+            webgl_object: WebGLObject::new_inherited(context),
-        WebGLRenderbuffer {
-            webgl_object: WebGLObject::new_inherited(),
             id: id,
             ever_bound: Cell::new(false),
             is_deleted: Cell::new(false),
-            renderer: renderer,
             internal_format: Cell::new(None),
             size: Cell::new(None),
         }
     }
 
-    pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
-                     -> Option<DomRoot<WebGLRenderbuffer>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateRenderbuffer(sender)).unwrap();
+        context.send_command(WebGLCommand::CreateRenderbuffer(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLRenderbuffer::new(context, id))
-        let result = receiver.recv().unwrap();
-        result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> DomRoot<Self> {
-               renderer: WebGLMsgSender,
+        reflect_dom_object(
-               id: WebGLRenderbufferId)
+            Box::new(WebGLRenderbuffer::new_inherited(context, id)),
-               -> DomRoot<WebGLRenderbuffer> {
+            &*context.global(),
-        reflect_dom_object(Box::new(WebGLRenderbuffer::new_inherited(renderer, id)),
+            WebGLRenderbufferBinding::Wrap,
-                           window,
+        )
-                           WebGLRenderbufferBinding::Wrap)
     }
 }
 
@@ -71,14 +63,17 @@ impl WebGLRenderbuffer {
 
     pub fn bind(&self, target: u32) {
         self.ever_bound.set(true);
-        let msg = WebGLCommand::BindRenderbuffer(target, Some(self.id));
+        self.upcast::<WebGLObject>()
-        self.renderer.send(msg).unwrap();
+            .context()
+            .send_command(WebGLCommand::BindRenderbuffer(target, Some(self.id)));
     }
 
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
-            let _ = self.renderer.send(WebGLCommand::DeleteRenderbuffer(self.id));
+            self.upcast::<WebGLObject>()
+                .context()
+                .send_command(WebGLCommand::DeleteRenderbuffer(self.id));
         }
     }
 
@@ -108,8 +103,14 @@ impl WebGLRenderbuffer {
 
         // FIXME: Invalidate completeness after the call
 
-        let msg = WebGLCommand::RenderbufferStorage(constants::RENDERBUFFER, internal_format, width, height);
+        self.upcast::<WebGLObject>().context().send_command(
-        self.renderer.send(msg).unwrap();
+            WebGLCommand::RenderbufferStorage(
+                constants::RENDERBUFFER,
+                internal_format,
+                width,
+                height,
+            )
+        );
 
         self.size.set(Some((width, height)));
 

components/script/dom/webglrenderingcontext.rs

@@ -2186,31 +2186,29 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         )
     }
 
-    // TODO(emilio): Probably in the future we should keep track of the
-    // generated objects, either here or in the webgl thread
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
     fn CreateBuffer(&self) -> Option<DomRoot<WebGLBuffer>> {
-        WebGLBuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
+        WebGLBuffer::maybe_new(self)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn CreateFramebuffer(&self) -> Option<DomRoot<WebGLFramebuffer>> {
-        WebGLFramebuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
+        WebGLFramebuffer::maybe_new(self)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
     fn CreateRenderbuffer(&self) -> Option<DomRoot<WebGLRenderbuffer>> {
-        WebGLRenderbuffer::maybe_new(self.global().as_window(), self.webgl_sender.clone())
+        WebGLRenderbuffer::maybe_new(self)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     fn CreateTexture(&self) -> Option<DomRoot<WebGLTexture>> {
-        WebGLTexture::maybe_new(self.global().as_window(), self.webgl_sender.clone())
+        WebGLTexture::maybe_new(self)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CreateProgram(&self) -> Option<DomRoot<WebGLProgram>> {
-        WebGLProgram::maybe_new(self.global().as_window(), self.webgl_sender.clone())
+        WebGLProgram::maybe_new(self)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
@@ -2222,7 +2220,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                 return None;
             }
         }
-        WebGLShader::maybe_new(self.global().as_window(), self.webgl_sender.clone(), shader_type)
+        WebGLShader::maybe_new(self, shader_type)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5

components/script/dom/webglshader.rs

@@ -3,19 +3,20 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
-use canvas_traits::webgl::{WebGLCommand, WebGLError, WebGLMsgSender};
+use canvas_traits::webgl::{WebGLCommand, WebGLError};
 use canvas_traits::webgl::{WebGLResult, WebGLSLVersion, WebGLShaderId};
 use canvas_traits::webgl::{WebGLVersion, webgl_channel};
 use dom::bindings::cell::DomRefCell;
 use dom::bindings::codegen::Bindings::WebGLShaderBinding;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::DomRoot;
 use dom::bindings::str::DOMString;
 use dom::webgl_extensions::WebGLExtensions;
 use dom::webgl_extensions::ext::extshadertexturelod::EXTShaderTextureLod;
 use dom::webgl_extensions::ext::oesstandardderivatives::OESStandardDerivatives;
 use dom::webglobject::WebGLObject;
-use dom::window::Window;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;
 use mozangle::shaders::{BuiltInResources, Output, ShaderValidator};
 use offscreen_gl_context::GLLimits;
@@ -40,20 +41,19 @@ pub struct WebGLShader {
     is_deleted: Cell<bool>,
     attached_counter: Cell<u32>,
     compilation_status: Cell<ShaderCompilationStatus>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
 }
 
 static GLSLANG_INITIALIZATION: Once = ONCE_INIT;
 
 impl WebGLShader {
-    fn new_inherited(renderer: WebGLMsgSender,
+    fn new_inherited(
+        context: &WebGLRenderingContext,
         id: WebGLShaderId,
-                     shader_type: u32)
+        shader_type: u32,
-                     -> WebGLShader {
+    ) -> Self {
         GLSLANG_INITIALIZATION.call_once(|| ::mozangle::shaders::initialize().unwrap());
-        WebGLShader {
+        Self {
-            webgl_object: WebGLObject::new_inherited(),
+            webgl_object: WebGLObject::new_inherited(context),
             id: id,
             gl_type: shader_type,
             source: Default::default(),
@@ -61,29 +61,25 @@ impl WebGLShader {
             is_deleted: Cell::new(false),
             attached_counter: Cell::new(0),
             compilation_status: Cell::new(ShaderCompilationStatus::NotCompiled),
-            renderer: renderer,
         }
     }
 
-    pub fn maybe_new(window: &Window,
+    pub fn maybe_new(context: &WebGLRenderingContext, shader_type: u32) -> Option<DomRoot<Self>> {
-                     renderer: WebGLMsgSender,
-                     shader_type: u32)
-                     -> Option<DomRoot<WebGLShader>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateShader(shader_type, sender)).unwrap();
+        context.send_command(WebGLCommand::CreateShader(shader_type, sender));
-
+        receiver.recv().unwrap().map(|id| WebGLShader::new(context, id, shader_type))
-        let result = receiver.recv().unwrap();
-        result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(
-               renderer: WebGLMsgSender,
+        context: &WebGLRenderingContext,
         id: WebGLShaderId,
-               shader_type: u32)
+        shader_type: u32,
-               -> DomRoot<WebGLShader> {
+    ) -> DomRoot<Self> {
-        reflect_dom_object(Box::new(WebGLShader::new_inherited(renderer, id, shader_type)),
+        reflect_dom_object(
-                           window,
+            Box::new(WebGLShader::new_inherited(context, id, shader_type)),
-                           WebGLShaderBinding::Wrap)
+            &*context.global(),
+            WebGLShaderBinding::Wrap,
+        )
     }
 }
 
@@ -168,8 +164,9 @@ impl WebGLShader {
                 // NOTE: At this point we should be pretty sure that the compilation in the paint thread
                 // will succeed.
                 // It could be interesting to retrieve the info log from the paint thread though
-                let msg = WebGLCommand::CompileShader(self.id, translated_source);
+                self.upcast::<WebGLObject>()
-                self.renderer.send(msg).unwrap();
+                    .context()
+                    .send_command(WebGLCommand::CompileShader(self.id, translated_source));
                 self.compilation_status.set(ShaderCompilationStatus::Succeeded);
             },
             Err(error) => {
@@ -194,7 +191,9 @@ impl WebGLShader {
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
-            let _ = self.renderer.send(WebGLCommand::DeleteShader(self.id));
+            self.upcast::<WebGLObject>()
+                .context()
+                .send_command(WebGLCommand::DeleteShader(self.id));
         }
     }
 

components/script/dom/webgltexture.rs

@@ -5,16 +5,17 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 
 use canvas_traits::webgl::{DOMToTextureCommand, TexParameter, TexParameterFloat};
-use canvas_traits::webgl::{TexParameterInt, WebGLCommand, WebGLError, WebGLMsgSender};
+use canvas_traits::webgl::{TexParameterInt, WebGLCommand, WebGLError};
 use canvas_traits::webgl::{WebGLResult, WebGLTextureId, webgl_channel};
 use dom::bindings::cell::DomRefCell;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
 use dom::bindings::codegen::Bindings::WebGLTextureBinding;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::inheritance::Castable;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::DomRoot;
 use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType};
 use dom::webglobject::WebGLObject;
-use dom::window::Window;
+use dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;
 use std::cell::Cell;
 use std::cmp;
@@ -45,18 +46,14 @@ pub struct WebGLTexture {
     // Store information for min and mag filters
     min_filter: Cell<Option<u32>>,
     mag_filter: Cell<Option<u32>>,
-    #[ignore_malloc_size_of = "Defined in ipc-channel"]
-    renderer: WebGLMsgSender,
     /// True if this texture is used for the DOMToTexture feature.
     attached_to_dom: Cell<bool>,
 }
 
 impl WebGLTexture {
-    fn new_inherited(renderer: WebGLMsgSender,
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLTextureId) -> Self {
-                     id: WebGLTextureId)
+        Self {
-                     -> WebGLTexture {
+            webgl_object: WebGLObject::new_inherited(context),
-        WebGLTexture {
-            webgl_object: WebGLObject::new_inherited(),
             id: id,
             target: Cell::new(None),
             is_deleted: Cell::new(false),
@@ -65,27 +62,22 @@ impl WebGLTexture {
             min_filter: Cell::new(None),
             mag_filter: Cell::new(None),
             image_info_array: DomRefCell::new([ImageInfo::new(); MAX_LEVEL_COUNT * MAX_FACE_COUNT]),
-            renderer: renderer,
             attached_to_dom: Cell::new(false),
         }
     }
 
-    pub fn maybe_new(window: &Window, renderer: WebGLMsgSender)
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
-                     -> Option<DomRoot<WebGLTexture>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateTexture(sender)).unwrap();
+        context.send_command(WebGLCommand::CreateTexture(sender));
-
+        receiver.recv().unwrap().map(|id| WebGLTexture::new(context, id))
-        let result = receiver.recv().unwrap();
-        result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id))
     }
 
-    pub fn new(window: &Window,
+    pub fn new(context: &WebGLRenderingContext, id: WebGLTextureId) -> DomRoot<Self> {
-               renderer: WebGLMsgSender,
+        reflect_dom_object(
-               id: WebGLTextureId)
+            Box::new(WebGLTexture::new_inherited(context, id)),
-               -> DomRoot<WebGLTexture> {
+            &*context.global(),
-        reflect_dom_object(Box::new(WebGLTexture::new_inherited(renderer, id)),
+            WebGLTextureBinding::Wrap,
-                           window,
+        )
-                           WebGLTextureBinding::Wrap)
     }
 }
 
@@ -116,8 +108,9 @@ impl WebGLTexture {
             self.target.set(Some(target));
         }
 
-        let msg = WebGLCommand::BindTexture(target, Some(self.id));
+        self.upcast::<WebGLObject>()
-        self.renderer.send(msg).unwrap();
+            .context()
+            .send_command(WebGLCommand::BindTexture(target, Some(self.id)));
 
         Ok(())
     }
@@ -171,7 +164,9 @@ impl WebGLTexture {
             return Err(WebGLError::InvalidOperation);
         }
 
-        self.renderer.send(WebGLCommand::GenerateMipmap(target)).unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::GenerateMipmap(target));
 
         if self.base_mipmap_level + base_image_info.get_max_mimap_levels() == 0 {
             return Err(WebGLError::InvalidOperation);
@@ -184,11 +179,14 @@ impl WebGLTexture {
     pub fn delete(&self) {
         if !self.is_deleted.get() {
             self.is_deleted.set(true);
+            let context = self.upcast::<WebGLObject>().context();
             // Notify WR to release the frame output when using DOMToTexture feature
             if self.attached_to_dom.get() {
-                let _ = self.renderer.send_dom_to_texture(DOMToTextureCommand::Detach(self.id));
+                let _ = context.webgl_sender().send_dom_to_texture(
+                    DOMToTextureCommand::Detach(self.id),
+                );
             }
-            let _ = self.renderer.send(WebGLCommand::DeleteTexture(self.id));
+            context.send_command(WebGLCommand::DeleteTexture(self.id));
         }
     }
 
@@ -227,9 +225,9 @@ impl WebGLTexture {
                             constants::NEAREST_MIPMAP_LINEAR |
                             constants::LINEAR_MIPMAP_LINEAR => {
                                 self.min_filter.set(Some(int_value as u32));
-                                self.renderer
+                                self.upcast::<WebGLObject>()
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
+                                    .context()
-                                    .unwrap();
+                                    .send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
                                 Ok(())
                             }
                             _ => Err(WebGLError::InvalidEnum),
@@ -239,9 +237,9 @@ impl WebGLTexture {
                         match int_value as u32 {
                             constants::NEAREST | constants::LINEAR => {
                                 self.mag_filter.set(Some(int_value as u32));
-                                self.renderer
+                                self.upcast::<WebGLObject>()
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
+                                    .context()
-                                    .unwrap();
+                                    .send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
                                 Ok(())
                             }
                             _ => return Err(WebGLError::InvalidEnum),
@@ -252,9 +250,9 @@ impl WebGLTexture {
                             constants::CLAMP_TO_EDGE |
                             constants::MIRRORED_REPEAT |
                             constants::REPEAT => {
-                                self.renderer
+                                self.upcast::<WebGLObject>()
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
+                                    .context()
-                                    .unwrap();
+                                    .send_command(WebGLCommand::TexParameteri(target, int_param, int_value));
                                 Ok(())
                             }
                             _ => Err(WebGLError::InvalidEnum),
@@ -264,9 +262,9 @@ impl WebGLTexture {
             }
             TexParameter::Float(float_param @ TexParameterFloat::TextureMaxAnisotropyExt) => {
                 if float_value >= 1. {
-                    self.renderer
+                    self.upcast::<WebGLObject>()
-                        .send(WebGLCommand::TexParameterf(target, float_param, float_value))
+                        .context()
-                        .unwrap();
+                        .send_command(WebGLCommand::TexParameterf(target, float_param, float_value));
                     Ok(())
                 } else {
                     Err(WebGLError::InvalidValue)

components/script/dom/webglvertexarrayobjectoes.rs

@@ -4,12 +4,11 @@
 
 use canvas_traits::webgl::WebGLVertexArrayId;
 use dom::bindings::codegen::Bindings::WebGLVertexArrayObjectOESBinding;
-use dom::bindings::reflector::reflect_dom_object;
+use dom::bindings::reflector::{DomObject, reflect_dom_object};
 use dom::bindings::root::{DomRoot, MutNullableDom};
-use dom::globalscope::GlobalScope;
 use dom::webglbuffer::WebGLBuffer;
 use dom::webglobject::WebGLObject;
-use dom::webglrenderingcontext::VertexAttribs;
+use dom::webglrenderingcontext::{VertexAttribs, WebGLRenderingContext};
 use dom_struct::dom_struct;
 use std::cell::Cell;
 
@@ -24,25 +23,21 @@ pub struct WebGLVertexArrayObjectOES {
 }
 
 impl WebGLVertexArrayObjectOES {
-    fn new_inherited(id: WebGLVertexArrayId, max_vertex_attribs: u32) -> Self {
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLVertexArrayId) -> Self {
         Self {
-            webgl_object_: WebGLObject::new_inherited(),
+            webgl_object_: WebGLObject::new_inherited(context),
             id: id,
             ever_bound: Cell::new(false),
             is_deleted: Cell::new(false),
-            vertex_attribs: VertexAttribs::new(max_vertex_attribs),
+            vertex_attribs: VertexAttribs::new(context.limits().max_vertex_attribs),
             bound_buffer_element_array: MutNullableDom::new(None),
         }
     }
 
-    pub fn new(
+    pub fn new(context: &WebGLRenderingContext, id: WebGLVertexArrayId) -> DomRoot<Self> {
-        global: &GlobalScope,
-        id: WebGLVertexArrayId,
-        max_vertex_attribs: u32,
-    ) -> DomRoot<Self> {
         reflect_dom_object(
-            Box::new(WebGLVertexArrayObjectOES::new_inherited(id, max_vertex_attribs)),
+            Box::new(WebGLVertexArrayObjectOES::new_inherited(context, id)),
-            global,
+            &*context.global(),
             WebGLVertexArrayObjectOESBinding::Wrap,
         )
     }