diff --git a/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs b/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs
index 9ec3065af49..6ae83c401ba 100644
--- a/components/script/dom/webgl_extensions/ext/oesvertexarrayobject.rs
+++ b/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));
-
-        let result = receiver.recv().unwrap();
-        result.map(|vao_id| {
-            WebGLVertexArrayObjectOES::new(
-                &self.global(),
-                vao_id,
-                self.ctx.limits().max_vertex_attribs,
-            )
-        })
+        receiver.recv().unwrap().map(|id| WebGLVertexArrayObjectOES::new(&self.ctx, id))
     }
 
     // https://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
diff --git a/components/script/dom/webglbuffer.rs b/components/script/dom/webglbuffer.rs
index 8c993d6bd7d..27fe415e8f8 100644
--- a/components/script/dom/webglbuffer.rs
+++ b/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,
-                     id: WebGLBufferId)
-                     -> WebGLBuffer {
-        WebGLBuffer {
-            webgl_object: WebGLObject::new_inherited(),
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLBufferId) -> Self {
+        Self {
+            webgl_object: WebGLObject::new_inherited(context),
             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)
-                     -> Option<DomRoot<WebGLBuffer>> {
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateBuffer(sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id))
+        context.send_command(WebGLCommand::CreateBuffer(sender));
+        receiver.recv().unwrap().map(|id| WebGLBuffer::new(context, id))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLBufferId)
-              -> DomRoot<WebGLBuffer> {
-        reflect_dom_object(Box::new(WebGLBuffer::new_inherited(renderer, id)),
-                           window, WebGLBufferBinding::Wrap)
+    pub fn new(context: &WebGLRenderingContext, id: WebGLBufferId) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLBuffer::new_inherited(context, id)),
+            &*context.global(),
+            WebGLBufferBinding::Wrap,
+        )
     }
 }
 
@@ -87,9 +80,9 @@ impl WebGLBuffer {
         } else {
             self.target.set(Some(target));
         }
-        let msg = WebGLCommand::BindBuffer(target, Some(self.id));
-        self.renderer.send(msg).unwrap();
-
+        self.upcast::<WebGLObject>()
+            .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);
             }
         }
diff --git a/components/script/dom/webglframebuffer.rs b/components/script/dom/webglframebuffer.rs
index ccea1efec7b..f71a2104cf5 100644
--- a/components/script/dom/webglframebuffer.rs
+++ b/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::webgl_channel;
+use canvas_traits::webgl::{WebGLResult, WebGLError, 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,
-                     id: WebGLFramebufferId)
-                     -> WebGLFramebuffer {
-        WebGLFramebuffer {
-            webgl_object: WebGLObject::new_inherited(),
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLFramebufferId) -> Self {
+        Self {
+            webgl_object: WebGLObject::new_inherited(context),
             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)
-                     -> Option<DomRoot<WebGLFramebuffer>> {
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateFramebuffer(sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id))
+        context.send_command(WebGLCommand::CreateFramebuffer(sender));
+        receiver.recv().unwrap().map(|id| WebGLFramebuffer::new(context, id))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLFramebufferId)
-               -> DomRoot<WebGLFramebuffer> {
-        reflect_dom_object(Box::new(WebGLFramebuffer::new_inherited(renderer, id)),
-                           window,
-                           WebGLFramebufferBinding::Wrap)
+    pub fn new(
+        context: &WebGLRenderingContext,
+        id: WebGLFramebufferId,
+    ) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLFramebuffer::new_inherited(context, id)),
+            &*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.renderer.send(cmd).unwrap();
+        self.upcast::<WebGLObject>().context().send_command(
+            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,
-                                                                 attachment,
-                                                                 constants::RENDERBUFFER,
-                                                                 rb_id)).unwrap();
+        self.upcast::<WebGLObject>().context().send_command(
+            WebGLCommand::FramebufferRenderbuffer(
+                constants::FRAMEBUFFER,
+                attachment,
+                constants::RENDERBUFFER,
+                rb_id,
+            ),
+        );
 
         self.update_status();
         Ok(())
@@ -305,11 +305,15 @@ impl WebGLFramebuffer {
             }
         };
 
-        self.renderer.send(WebGLCommand::FramebufferTexture2D(constants::FRAMEBUFFER,
-                                                              attachment,
-                                                              textarget,
-                                                              tex_id,
-                                                              level)).unwrap();
+        self.upcast::<WebGLObject>().context().send_command(
+            WebGLCommand::FramebufferTexture2D(
+                constants::FRAMEBUFFER,
+                attachment,
+                textarget,
+                tex_id,
+                level,
+            ),
+        );
 
         self.update_status();
         Ok(())
diff --git a/components/script/dom/webglobject.rs b/components/script/dom/webglobject.rs
index 123420b7cb0..7d4dbabc998 100644
--- a/components/script/dom/webglobject.rs
+++ b/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
+    }
 }
diff --git a/components/script/dom/webglprogram.rs b/components/script/dom/webglprogram.rs
index 20a8eb1957b..075672c8107 100644
--- a/components/script/dom/webglprogram.rs
+++ b/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)
-                     -> Option<DomRoot<WebGLProgram>> {
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateProgram(sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|program_id| WebGLProgram::new(window, renderer, program_id))
+        context.send_command(WebGLCommand::CreateProgram(sender));
+        receiver.recv().unwrap().map(|id| WebGLProgram::new(context, id))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLProgramId)
-               -> DomRoot<WebGLProgram> {
-        reflect_dom_object(Box::new(WebGLProgram::new_inherited(renderer, id)),
-                           window,
-                           WebGLProgramBinding::Wrap)
+    pub fn new(context: &WebGLRenderingContext, id: WebGLProgramId) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLProgram::new_inherited(context, id)),
+            &*context.global(),
+            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
-            .send(WebGLCommand::BindAttribLocation(self.id, index, name.into()))
-            .unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .send_command(WebGLCommand::BindAttribLocation(self.id, index, name.into()));
         Ok(())
     }
 
@@ -351,9 +354,9 @@ impl WebGLProgram {
         };
 
         let (sender, receiver) = webgl_channel().unwrap();
-        self.renderer
-            .send(WebGLCommand::GetUniformLocation(self.id, name.into(), sender))
-            .unwrap();
+        self.upcast::<WebGLObject>()
+            .context()
+            .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())
     }
 
diff --git a/components/script/dom/webglrenderbuffer.rs b/components/script/dom/webglrenderbuffer.rs
index 9e21d78fe5a..1074f9797e0 100644
--- a/components/script/dom/webglrenderbuffer.rs
+++ b/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,
-                     id: WebGLRenderbufferId)
-                     -> WebGLRenderbuffer {
-        WebGLRenderbuffer {
-            webgl_object: WebGLObject::new_inherited(),
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> Self {
+        Self {
+            webgl_object: WebGLObject::new_inherited(context),
             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)
-                     -> Option<DomRoot<WebGLRenderbuffer>> {
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateRenderbuffer(sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id))
+        context.send_command(WebGLCommand::CreateRenderbuffer(sender));
+        receiver.recv().unwrap().map(|id| WebGLRenderbuffer::new(context, id))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLRenderbufferId)
-               -> DomRoot<WebGLRenderbuffer> {
-        reflect_dom_object(Box::new(WebGLRenderbuffer::new_inherited(renderer, id)),
-                           window,
-                           WebGLRenderbufferBinding::Wrap)
+    pub fn new(context: &WebGLRenderingContext, id: WebGLRenderbufferId) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLRenderbuffer::new_inherited(context, id)),
+            &*context.global(),
+            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.renderer.send(msg).unwrap();
+        self.upcast::<WebGLObject>()
+            .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.renderer.send(msg).unwrap();
+        self.upcast::<WebGLObject>().context().send_command(
+            WebGLCommand::RenderbufferStorage(
+                constants::RENDERBUFFER,
+                internal_format,
+                width,
+                height,
+            )
+        );
 
         self.size.set(Some((width, height)));
 
diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs
index 5e2f26748ac..627eb29dff6 100644
--- a/components/script/dom/webglrenderingcontext.rs
+++ b/components/script/dom/webglrenderingcontext.rs
@@ -21,7 +21,7 @@ use dom::bindings::codegen::UnionTypes::ArrayBufferViewOrArrayBuffer;
 use dom::bindings::codegen::UnionTypes::Float32ArrayOrUnrestrictedFloatSequence;
 use dom::bindings::codegen::UnionTypes::ImageDataOrHTMLImageElementOrHTMLCanvasElementOrHTMLVideoElement;
 use dom::bindings::codegen::UnionTypes::Int32ArrayOrLongSequence;
-use dom::bindings::conversions::ToJSValConvertible;
+use dom::bindings::conversions::{DerivedFrom, ToJSValConvertible};
 use dom::bindings::error::{Error, ErrorResult};
 use dom::bindings::inheritance::Castable;
 use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
@@ -41,6 +41,7 @@ use dom::webglactiveinfo::WebGLActiveInfo;
 use dom::webglbuffer::WebGLBuffer;
 use dom::webglcontextevent::WebGLContextEvent;
 use dom::webglframebuffer::{WebGLFramebuffer, WebGLFramebufferAttachmentRoot};
+use dom::webglobject::WebGLObject;
 use dom::webglprogram::WebGLProgram;
 use dom::webglrenderbuffer::WebGLRenderbuffer;
 use dom::webglshader::WebGLShader;
@@ -427,6 +428,16 @@ impl WebGLRenderingContext {
         }
     }
 
+    fn validate_ownership<T>(&self, object: &T) -> WebGLResult<()>
+    where
+        T: DerivedFrom<WebGLObject>,
+    {
+        if self != object.upcast().context() {
+            return Err(InvalidOperation);
+        }
+        Ok(())
+    }
+
     fn with_location<F>(&self, location: Option<&WebGLUniformLocation>, f: F)
     where
         F: FnOnce(&WebGLUniformLocation) -> WebGLResult<()>,
@@ -1766,21 +1777,30 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn AttachShader(&self, program: &WebGLProgram, shader: &WebGLShader) {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return);
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
         handle_potential_webgl_error!(self, program.attach_shader(shader));
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn DetachShader(&self, program: &WebGLProgram, shader: &WebGLShader) {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return);
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
         handle_potential_webgl_error!(self, program.detach_shader(shader));
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn BindAttribLocation(&self, program: &WebGLProgram, index: u32, name: DOMString) {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return);
         handle_potential_webgl_error!(self, program.bind_attrib_location(index, name));
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
     fn BindBuffer(&self, target: u32, buffer: Option<&WebGLBuffer>) {
+        if let Some(buffer) = buffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(buffer), return);
+        }
+
         let slot = match target {
             constants::ARRAY_BUFFER => &self.bound_buffer_array,
             constants::ELEMENT_ARRAY_BUFFER => &self.bound_buffer_element_array,
@@ -1802,6 +1822,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn BindFramebuffer(&self, target: u32, framebuffer: Option<&WebGLFramebuffer>) {
+        if let Some(fb) = framebuffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(fb), return);
+        }
+
         if target != constants::FRAMEBUFFER {
             return self.webgl_error(InvalidEnum);
         }
@@ -1828,6 +1852,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
     fn BindRenderbuffer(&self, target: u32, renderbuffer: Option<&WebGLRenderbuffer>) {
+        if let Some(rb) = renderbuffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(rb), return);
+        }
+
         if target != constants::RENDERBUFFER {
             return self.webgl_error(InvalidEnum);
         }
@@ -1850,6 +1878,10 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     fn BindTexture(&self, target: u32, texture: Option<&WebGLTexture>) {
+        if let Some(texture) = texture {
+            handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
+        }
+
         let mut bound_textures = self.bound_textures.borrow_mut();
         let binding = bound_textures.entry(self.bound_texture_unit.get())
                                     .or_insert(TextureUnitBindings::new());
@@ -2175,6 +2207,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CompileShader(&self, shader: &WebGLShader) {
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
         handle_potential_webgl_error!(
             self,
             shader.compile(
@@ -2186,31 +2219,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,12 +2253,14 @@ 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
     fn DeleteBuffer(&self, buffer: Option<&WebGLBuffer>) {
         if let Some(buffer) = buffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(buffer), return);
+
             if buffer.is_attached_to_vao() {
                 // WebGL spec: The buffers attached to VAOs should still not be deleted.
                 // They are deleted after the VAO is deleted.
@@ -2250,6 +2283,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn DeleteFramebuffer(&self, framebuffer: Option<&WebGLFramebuffer>) {
         if let Some(framebuffer) = framebuffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(framebuffer), return);
             handle_object_deletion!(self, self.bound_framebuffer, framebuffer,
                                     Some(WebGLCommand::BindFramebuffer(constants::FRAMEBUFFER,
                                                                        WebGLFramebufferBindingRequest::Default)));
@@ -2260,6 +2294,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
     fn DeleteRenderbuffer(&self, renderbuffer: Option<&WebGLRenderbuffer>) {
         if let Some(renderbuffer) = renderbuffer {
+            handle_potential_webgl_error!(self, self.validate_ownership(renderbuffer), return);
             handle_object_deletion!(self, self.bound_renderbuffer, renderbuffer,
                                     Some(WebGLCommand::BindRenderbuffer(constants::RENDERBUFFER, None)));
             // From the GLES 2.0.25 spec, page 113:
@@ -2283,6 +2318,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     fn DeleteTexture(&self, texture: Option<&WebGLTexture>) {
         if let Some(texture) = texture {
+            handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
+
             // From the GLES 2.0.25 spec, page 85:
             //
             //     "If a texture that is currently bound to one of the targets
@@ -2325,6 +2362,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn DeleteProgram(&self, program: Option<&WebGLProgram>) {
         if let Some(program) = program {
+            handle_potential_webgl_error!(self, self.validate_ownership(program), return);
             // FIXME: We should call glUseProgram(0), but
             // WebGLCommand::UseProgram() doesn't take an Option
             // currently.  This is also a problem for useProgram(null)
@@ -2336,6 +2374,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn DeleteShader(&self, shader: Option<&WebGLShader>) {
         if let Some(shader) = shader {
+            handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
             shader.delete()
         }
     }
@@ -2477,6 +2516,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
     fn GetActiveUniform(&self, program: &WebGLProgram, index: u32) -> Option<DomRoot<WebGLActiveInfo>> {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         match program.get_active_uniform(index) {
             Ok(ret) => Some(ret),
             Err(e) => {
@@ -2488,11 +2528,13 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
     fn GetActiveAttrib(&self, program: &WebGLProgram, index: u32) -> Option<DomRoot<WebGLActiveInfo>> {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         handle_potential_webgl_error!(self, program.get_active_attrib(index).map(Some), None)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.10
     fn GetAttribLocation(&self, program: &WebGLProgram, name: DOMString) -> i32 {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return -1);
         handle_potential_webgl_error!(self, program.get_attrib_location(name), -1)
     }
 
@@ -2653,6 +2695,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn GetProgramInfoLog(&self, program: &WebGLProgram) -> Option<DOMString> {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         match program.get_info_log() {
             Ok(value) => Some(DOMString::from(value)),
             Err(e) => {
@@ -2665,7 +2708,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     #[allow(unsafe_code)]
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     unsafe fn GetProgramParameter(&self, _: *mut JSContext, program: &WebGLProgram, param: u32) -> JSVal {
-        // FIXME(nox): INVALID_OPERATION if program comes from a different context.
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return NullValue());
         match param {
             constants::DELETE_STATUS => BooleanValue(program.is_deleted()),
             constants::LINK_STATUS => BooleanValue(program.is_linked()),
@@ -2691,13 +2734,14 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn GetShaderInfoLog(&self, shader: &WebGLShader) -> Option<DOMString> {
-        // TODO(nox): https://github.com/servo/servo/issues/21133
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return None);
         Some(shader.info_log())
     }
 
     #[allow(unsafe_code)]
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     unsafe fn GetShaderParameter(&self, _: *mut JSContext, shader: &WebGLShader, param: u32) -> JSVal {
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return NullValue());
         if shader.is_deleted() && !shader.is_attached() {
             self.webgl_error(InvalidValue);
             return NullValue();
@@ -2750,6 +2794,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         program: &WebGLProgram,
         name: DOMString,
     ) -> Option<DomRoot<WebGLUniformLocation>> {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         handle_potential_webgl_error!(self, program.get_uniform_location(name), None)
     }
 
@@ -3136,18 +3181,19 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn LinkProgram(&self, program: &WebGLProgram) {
-        // FIXME(nox): INVALID_OPERATION if program comes from a different context.
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return);
         handle_potential_webgl_error!(self, program.link());
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn ShaderSource(&self, shader: &WebGLShader, source: DOMString) {
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return);
         shader.set_source(source)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn GetShaderSource(&self, shader: &WebGLShader) -> Option<DOMString> {
-        // TODO(nox): https://github.com/servo/servo/issues/21133
+        handle_potential_webgl_error!(self, self.validate_ownership(shader), return None);
         Some(shader.source())
     }
 
@@ -3613,7 +3659,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         program: &WebGLProgram,
         location: &WebGLUniformLocation,
     ) -> JSVal {
-        // FIXME(nox): https://github.com/servo/servo/issues/21133
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return NullValue());
 
         if
             program.is_deleted() ||
@@ -3687,6 +3733,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn UseProgram(&self, program: Option<&WebGLProgram>) {
         if let Some(program) = program {
+            handle_potential_webgl_error!(self, self.validate_ownership(program), return);
             if program.is_deleted() || !program.is_linked() {
                 return self.webgl_error(InvalidOperation);
             }
@@ -3697,6 +3744,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn ValidateProgram(&self, program: &WebGLProgram) {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return);
         if let Err(e) = program.validate() {
             self.webgl_error(e);
         }
@@ -4135,9 +4183,17 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
-    fn FramebufferRenderbuffer(&self, target: u32, attachment: u32,
-                               renderbuffertarget: u32,
-                               rb: Option<&WebGLRenderbuffer>) {
+    fn FramebufferRenderbuffer(
+        &self,
+        target: u32,
+        attachment: u32,
+        renderbuffertarget: u32,
+        rb: Option<&WebGLRenderbuffer>,
+    ) {
+        if let Some(rb) = rb {
+            handle_potential_webgl_error!(self, self.validate_ownership(rb), return);
+        }
+
         if target != constants::FRAMEBUFFER || renderbuffertarget != constants::RENDERBUFFER {
             return self.webgl_error(InvalidEnum);
         }
@@ -4149,9 +4205,18 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
-    fn FramebufferTexture2D(&self, target: u32, attachment: u32,
-                            textarget: u32, texture: Option<&WebGLTexture>,
-                            level: i32) {
+    fn FramebufferTexture2D(
+        &self,
+        target: u32,
+        attachment: u32,
+        textarget: u32,
+        texture: Option<&WebGLTexture>,
+        level: i32,
+    ) {
+        if let Some(texture) = texture {
+            handle_potential_webgl_error!(self, self.validate_ownership(texture), return);
+        }
+
         if target != constants::FRAMEBUFFER {
             return self.webgl_error(InvalidEnum);
         }
@@ -4163,10 +4228,8 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     }
 
     /// https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
-    fn GetAttachedShaders(
-        &self,
-        program: &WebGLProgram,
-    ) -> Option<Vec<DomRoot<WebGLShader>>> {
+    fn GetAttachedShaders(&self, program: &WebGLProgram) -> Option<Vec<DomRoot<WebGLShader>>> {
+        handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         handle_potential_webgl_error!(self, program.attached_shaders().map(Some), None)
     }
 }
diff --git a/components/script/dom/webglshader.rs b/components/script/dom/webglshader.rs
index 1feb73d2d3a..bac2f65d1e1 100644
--- a/components/script/dom/webglshader.rs
+++ b/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,
-                     id: WebGLShaderId,
-                     shader_type: u32)
-                     -> WebGLShader {
+    fn new_inherited(
+        context: &WebGLRenderingContext,
+        id: WebGLShaderId,
+        shader_type: u32,
+    ) -> Self {
         GLSLANG_INITIALIZATION.call_once(|| ::mozangle::shaders::initialize().unwrap());
-        WebGLShader {
-            webgl_object: WebGLObject::new_inherited(),
+        Self {
+            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,
-                     renderer: WebGLMsgSender,
-                     shader_type: u32)
-                     -> Option<DomRoot<WebGLShader>> {
+    pub fn maybe_new(context: &WebGLRenderingContext, shader_type: u32) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateShader(shader_type, sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type))
+        context.send_command(WebGLCommand::CreateShader(shader_type, sender));
+        receiver.recv().unwrap().map(|id| WebGLShader::new(context, id, shader_type))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLShaderId,
-               shader_type: u32)
-               -> DomRoot<WebGLShader> {
-        reflect_dom_object(Box::new(WebGLShader::new_inherited(renderer, id, shader_type)),
-                           window,
-                           WebGLShaderBinding::Wrap)
+    pub fn new(
+        context: &WebGLRenderingContext,
+        id: WebGLShaderId,
+        shader_type: u32,
+    ) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLShader::new_inherited(context, id, shader_type)),
+            &*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.renderer.send(msg).unwrap();
+                self.upcast::<WebGLObject>()
+                    .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));
         }
     }
 
diff --git a/components/script/dom/webgltexture.rs b/components/script/dom/webgltexture.rs
index 9fe77197825..60c8487676b 100644
--- a/components/script/dom/webgltexture.rs
+++ b/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,
-                     id: WebGLTextureId)
-                     -> WebGLTexture {
-        WebGLTexture {
-            webgl_object: WebGLObject::new_inherited(),
+    fn new_inherited(context: &WebGLRenderingContext, id: WebGLTextureId) -> Self {
+        Self {
+            webgl_object: WebGLObject::new_inherited(context),
             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)
-                     -> Option<DomRoot<WebGLTexture>> {
+    pub fn maybe_new(context: &WebGLRenderingContext) -> Option<DomRoot<Self>> {
         let (sender, receiver) = webgl_channel().unwrap();
-        renderer.send(WebGLCommand::CreateTexture(sender)).unwrap();
-
-        let result = receiver.recv().unwrap();
-        result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id))
+        context.send_command(WebGLCommand::CreateTexture(sender));
+        receiver.recv().unwrap().map(|id| WebGLTexture::new(context, id))
     }
 
-    pub fn new(window: &Window,
-               renderer: WebGLMsgSender,
-               id: WebGLTextureId)
-               -> DomRoot<WebGLTexture> {
-        reflect_dom_object(Box::new(WebGLTexture::new_inherited(renderer, id)),
-                           window,
-                           WebGLTextureBinding::Wrap)
+    pub fn new(context: &WebGLRenderingContext, id: WebGLTextureId) -> DomRoot<Self> {
+        reflect_dom_object(
+            Box::new(WebGLTexture::new_inherited(context, id)),
+            &*context.global(),
+            WebGLTextureBinding::Wrap,
+        )
     }
 }
 
@@ -116,8 +108,9 @@ impl WebGLTexture {
             self.target.set(Some(target));
         }
 
-        let msg = WebGLCommand::BindTexture(target, Some(self.id));
-        self.renderer.send(msg).unwrap();
+        self.upcast::<WebGLObject>()
+            .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
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
-                                    .unwrap();
+                                self.upcast::<WebGLObject>()
+                                    .context()
+                                    .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
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
-                                    .unwrap();
+                                self.upcast::<WebGLObject>()
+                                    .context()
+                                    .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
-                                    .send(WebGLCommand::TexParameteri(target, int_param, int_value))
-                                    .unwrap();
+                                self.upcast::<WebGLObject>()
+                                    .context()
+                                    .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
-                        .send(WebGLCommand::TexParameterf(target, float_param, float_value))
-                        .unwrap();
+                    self.upcast::<WebGLObject>()
+                        .context()
+                        .send_command(WebGLCommand::TexParameterf(target, float_param, float_value));
                     Ok(())
                 } else {
                     Err(WebGLError::InvalidValue)
diff --git a/components/script/dom/webglvertexarrayobjectoes.rs b/components/script/dom/webglvertexarrayobjectoes.rs
index 883559f8ac2..029cb30bea5 100644
--- a/components/script/dom/webglvertexarrayobjectoes.rs
+++ b/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(
-        global: &GlobalScope,
-        id: WebGLVertexArrayId,
-        max_vertex_attribs: u32,
-    ) -> DomRoot<Self> {
+    pub fn new(context: &WebGLRenderingContext, id: WebGLVertexArrayId) -> DomRoot<Self> {
         reflect_dom_object(
-            Box::new(WebGLVertexArrayObjectOES::new_inherited(id, max_vertex_attribs)),
-            global,
+            Box::new(WebGLVertexArrayObjectOES::new_inherited(context, id)),
+            &*context.global(),
             WebGLVertexArrayObjectOESBinding::Wrap,
         )
     }
diff --git a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/incorrect-context-object-behaviour.html.ini b/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/incorrect-context-object-behaviour.html.ini
deleted file mode 100644
index 7bf7795c56a..00000000000
--- a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/incorrect-context-object-behaviour.html.ini
+++ /dev/null
@@ -1,48 +0,0 @@
-[incorrect-context-object-behaviour.html]
-  bug: https://github.com/servo/servo/issues/21133
-  type: testharness
-  [WebGL test #0: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.compileShader(shaderB)]
-    expected: FAIL
-
-  [WebGL test #1: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.linkProgram(programB)]
-    expected: FAIL
-
-  [WebGL test #8: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.shaderSource(shaderB, 'foo')]
-    expected: FAIL
-
-  [WebGL test #9: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindAttribLocation(programB, 0, 'foo')]
-    expected: FAIL
-
-  [WebGL test #10: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindFramebuffer(contextA.FRAMEBUFFER, frameBufferB)]
-    expected: FAIL
-
-  [WebGL test #11: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindRenderbuffer(contextA.RENDERBUFFER, renderBufferB)]
-    expected: FAIL
-
-  [WebGL test #12: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.bindTexture(contextA.TEXTURE_2D, textureB)]
-    expected: FAIL
-
-  [WebGL test #13: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.framebufferRenderbuffer(contextA.FRAMEBUFFER, contextA.DEPTH_ATTACHMENT, contextA.RENDERBUFFER, renderBufferB)]
-    expected: FAIL
-
-  [WebGL test #14: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.framebufferTexture2D(contextA.FRAMEBUFFER, contextA.COLOR_ATTACHMENT0, contextA.TEXTURE_2D, textureB, 0)]
-    expected: FAIL
-
-  [WebGL test #15: getError expected: INVALID_OPERATION. Was INVALID_ENUM : after evaluating: contextA.getProgramParameter(programB, 0)]
-    expected: FAIL
-
-  [WebGL test #16: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getProgramInfoLog(programB, 0)]
-    expected: FAIL
-
-  [WebGL test #17: getError expected: INVALID_OPERATION. Was INVALID_ENUM : after evaluating: contextA.getShaderParameter(shaderB, 0)]
-    expected: FAIL
-
-  [WebGL test #18: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getShaderInfoLog(shaderB, 0)]
-    expected: FAIL
-
-  [WebGL test #19: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getShaderSource(shaderB)]
-    expected: FAIL
-
-  [WebGL test #21: getError expected: INVALID_OPERATION. Was NO_ERROR : after evaluating: contextA.getUniformLocation(programB, 'u_modelViewProjMatrix')]
-    expected: FAIL
-
diff --git a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/resource-sharing-test.html.ini b/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/resource-sharing-test.html.ini
deleted file mode 100644
index f25116ddccd..00000000000
--- a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/context/resource-sharing-test.html.ini
+++ /dev/null
@@ -1,5 +0,0 @@
-[resource-sharing-test.html]
-  type: testharness
-  [WebGL test #1: attempt to use a resource from the wrong context should fail with INVALID_OPERATION]
-    expected: FAIL
-
diff --git a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/programs/get-active-test.html.ini b/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/programs/get-active-test.html.ini
deleted file mode 100644
index 6708fb9cc83..00000000000
--- a/tests/wpt/mozilla/meta/webgl/conformance-1.0.3/conformance/programs/get-active-test.html.ini
+++ /dev/null
@@ -1,15 +0,0 @@
-[get-active-test.html]
-  bug: https://github.com/servo/servo/issues/21133
-  type: testharness
-  [WebGL test #31: context2.getActiveAttrib(program, 0) should be null. Was [object WebGLActiveInfo\].]
-    expected: FAIL
-
-  [WebGL test #32: getError expected: INVALID_OPERATION. Was NO_ERROR : ]
-    expected: FAIL
-
-  [WebGL test #33: context2.getActiveUniform(program, 0) should be null. Was [object WebGLActiveInfo\].]
-    expected: FAIL
-
-  [WebGL test #34: getError expected: INVALID_OPERATION. Was NO_ERROR : ]
-    expected: FAIL
-