Expose WebGL-related interfaces only in Window

components/script/dom/document.rs

@@ -2426,7 +2426,7 @@ impl DocumentMethods for Document {
                     )
                 )),
             "webglcontextevent" =>
-                Ok(Root::upcast(WebGLContextEvent::new_uninitialized(self.window.upcast()))),
+                Ok(Root::upcast(WebGLContextEvent::new_uninitialized(&self.window))),
             "storageevent" => {
                 let USVString(url) = self.URL();
                 Ok(Root::upcast(StorageEvent::new_uninitialized(&self.window, DOMString::from(url))))

components/script/dom/htmlcanvaselement.rs

@@ -177,7 +177,7 @@ impl HTMLCanvasElement {
                 GLContextAttributes::default()
             };
 
-            let maybe_ctx = WebGLRenderingContext::new(window.upcast(), self, size, attrs);
+            let maybe_ctx = WebGLRenderingContext::new(&window, self, size, attrs);
 
             *self.context.borrow_mut() = maybe_ctx.map( |ctx| CanvasContext::WebGL(JS::from_ref(&*ctx)));
         }

components/script/dom/webglactiveinfo.rs

@@ -8,7 +8,7 @@ use dom::bindings::codegen::Bindings::WebGLActiveInfoBinding::WebGLActiveInfoMet
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
-use dom::globalscope::GlobalScope;
+use dom::window::Window;
 
 #[dom_struct]
 pub struct WebGLActiveInfo {
@@ -29,8 +29,8 @@ impl WebGLActiveInfo {
         }
     }
 
-    pub fn new(global: &GlobalScope, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
+    pub fn new(window: &Window, size: i32, ty: u32, name: DOMString) -> Root<WebGLActiveInfo> {
-        reflect_dom_object(box WebGLActiveInfo::new_inherited(size, ty, name), global, WebGLActiveInfoBinding::Wrap)
+        reflect_dom_object(box WebGLActiveInfo::new_inherited(size, ty, name), window, WebGLActiveInfoBinding::Wrap)
     }
 }
 

components/script/dom/webglbuffer.rs

@@ -7,8 +7,8 @@ use canvas_traits::CanvasMsg;
 use dom::bindings::codegen::Bindings::WebGLBufferBinding;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
-use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use webrender_traits;
@@ -40,21 +40,21 @@ impl WebGLBuffer {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLBuffer>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateBuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|buffer_id| WebGLBuffer::new(global, renderer, buffer_id))
+        result.map(|buffer_id| WebGLBuffer::new(window, renderer, buffer_id))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLBufferId)
               -> Root<WebGLBuffer> {
         reflect_dom_object(box WebGLBuffer::new_inherited(renderer, id),
-                           global, WebGLBufferBinding::Wrap)
+                           window, WebGLBufferBinding::Wrap)
     }
 }
 

components/script/dom/webglcontextevent.rs

@@ -13,6 +13,7 @@ use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
 use dom::event::{Event, EventBubbles, EventCancelable};
 use dom::globalscope::GlobalScope;
+use dom::window::Window;
 use servo_atoms::Atom;
 
 #[dom_struct]
@@ -41,25 +42,25 @@ impl WebGLContextEvent {
         }
     }
 
-    pub fn new_uninitialized(global_ref: &GlobalScope) -> Root<WebGLContextEvent> {
+    pub fn new_uninitialized(window: &Window) -> Root<WebGLContextEvent> {
         // according to https://www.khronos.org/registry/webgl/specs/1.0/#5.15 this is
         // additional information or the empty string if no additional information is
         // available.
         let status_message = DOMString::new();
         reflect_dom_object(
                         box WebGLContextEvent::new_inherited(status_message),
-                        global_ref,
+                        window,
                         WebGLContextEventBinding::Wrap)
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                type_: Atom,
                bubbles: EventBubbles,
                cancelable: EventCancelable,
                status_message: DOMString) -> Root<WebGLContextEvent> {
         let event = reflect_dom_object(
                         box WebGLContextEvent::new_inherited(status_message),
-                        global,
+                        window,
                         WebGLContextEventBinding::Wrap);
 
         {
@@ -82,7 +83,7 @@ impl WebGLContextEvent {
 
         let cancelable = EventCancelable::from(init.parent.cancelable);
 
-        Ok(WebGLContextEvent::new(global,
+        Ok(WebGLContextEvent::new(global.as_window(),
                                   Atom::from(type_),
                                   bubbles,
                                   cancelable,

components/script/dom/webglframebuffer.rs

@@ -9,10 +9,10 @@ use dom::bindings::codegen::Bindings::WebGLFramebufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
 use dom::bindings::js::{HeapGCValue, JS, Root};
 use dom::bindings::reflector::reflect_dom_object;
-use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
 use dom::webglrenderbuffer::WebGLRenderbuffer;
 use dom::webgltexture::WebGLTexture;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use webrender_traits;
@@ -66,21 +66,21 @@ impl WebGLFramebuffer {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLFramebuffer>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateFramebuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|fb_id| WebGLFramebuffer::new(global, renderer, fb_id))
+        result.map(|fb_id| WebGLFramebuffer::new(window, renderer, fb_id))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLFramebufferId)
                -> Root<WebGLFramebuffer> {
         reflect_dom_object(box WebGLFramebuffer::new_inherited(renderer, id),
-                           global,
+                           window,
                            WebGLFramebufferBinding::Wrap)
     }
 }

components/script/dom/webglobject.rs

@@ -6,7 +6,7 @@
 use dom::bindings::codegen::Bindings::WebGLObjectBinding;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
-use dom::globalscope::GlobalScope;
+use dom::window::Window;
 
 #[dom_struct]
 pub struct WebGLObject {
@@ -20,7 +20,7 @@ impl WebGLObject {
         }
     }
 
-    pub fn new(global: &GlobalScope) -> Root<WebGLObject> {
+    pub fn new(window: &Window) -> Root<WebGLObject> {
-        reflect_dom_object(box WebGLObject::new_inherited(), global, WebGLObjectBinding::Wrap)
+        reflect_dom_object(box WebGLObject::new_inherited(), window, WebGLObjectBinding::Wrap)
     }
 }

components/script/dom/webglprogram.rs

@@ -9,11 +9,11 @@ use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderi
 use dom::bindings::js::{JS, MutNullableHeap, Root};
 use dom::bindings::reflector::{Reflectable, reflect_dom_object};
 use dom::bindings::str::DOMString;
-use dom::globalscope::GlobalScope;
 use dom::webglactiveinfo::WebGLActiveInfo;
 use dom::webglobject::WebGLObject;
 use dom::webglrenderingcontext::MAX_UNIFORM_AND_ATTRIBUTE_LEN;
 use dom::webglshader::WebGLShader;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use webrender_traits;
@@ -49,21 +49,21 @@ impl WebGLProgram {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLProgram>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateProgram(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|program_id| WebGLProgram::new(global, renderer, program_id))
+        result.map(|program_id| WebGLProgram::new(window, renderer, program_id))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLProgramId)
                -> Root<WebGLProgram> {
         reflect_dom_object(box WebGLProgram::new_inherited(renderer, id),
-                           global,
+                           window,
                            WebGLProgramBinding::Wrap)
     }
 }
@@ -231,7 +231,7 @@ impl WebGLProgram {
             .unwrap();
 
         receiver.recv().unwrap().map(|(size, ty, name)|
-            WebGLActiveInfo::new(&self.global(), size, ty, DOMString::from(name)))
+            WebGLActiveInfo::new(self.global().as_window(), size, ty, DOMString::from(name)))
     }
 
     /// glGetActiveAttrib
@@ -245,7 +245,7 @@ impl WebGLProgram {
             .unwrap();
 
         receiver.recv().unwrap().map(|(size, ty, name)|
-            WebGLActiveInfo::new(&self.global(), size, ty, DOMString::from(name)))
+            WebGLActiveInfo::new(self.global().as_window(), size, ty, DOMString::from(name)))
     }
 
     /// glGetAttribLocation

components/script/dom/webglrenderbuffer.rs

@@ -8,8 +8,8 @@ use dom::bindings::codegen::Bindings::WebGLRenderbufferBinding;
 use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
-use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use webrender_traits;
@@ -42,21 +42,21 @@ impl WebGLRenderbuffer {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLRenderbuffer>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateRenderbuffer(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|renderbuffer_id| WebGLRenderbuffer::new(global, renderer, renderbuffer_id))
+        result.map(|renderbuffer_id| WebGLRenderbuffer::new(window, renderer, renderbuffer_id))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLRenderbufferId)
                -> Root<WebGLRenderbuffer> {
         reflect_dom_object(box WebGLRenderbuffer::new_inherited(renderer, id),
-                           global,
+                           window,
                            WebGLRenderbufferBinding::Wrap)
     }
 }

components/script/dom/webglrenderingcontext.rs

@@ -34,6 +34,7 @@ use dom::webglrenderbuffer::WebGLRenderbuffer;
 use dom::webglshader::WebGLShader;
 use dom::webgltexture::{TexParameterValue, WebGLTexture};
 use dom::webgluniformlocation::WebGLUniformLocation;
+use dom::window::Window;
 use euclid::size::Size2D;
 use ipc_channel::ipc::{self, IpcSender};
 use js::conversions::ConversionBehavior;
@@ -135,13 +136,13 @@ pub struct WebGLRenderingContext {
 }
 
 impl WebGLRenderingContext {
-    fn new_inherited(global: &GlobalScope,
+    fn new_inherited(window: &Window,
                      canvas: &HTMLCanvasElement,
                      size: Size2D<i32>,
                      attrs: GLContextAttributes)
                      -> Result<WebGLRenderingContext, String> {
         let (sender, receiver) = ipc::channel().unwrap();
-        let constellation_chan = global.constellation_chan();
+        let constellation_chan = window.upcast::<GlobalScope>().constellation_chan();
         constellation_chan.send(ConstellationMsg::CreateWebGLPaintThread(size, attrs, sender))
                           .unwrap();
         let result = receiver.recv().unwrap();
@@ -167,13 +168,13 @@ impl WebGLRenderingContext {
     }
 
     #[allow(unrooted_must_root)]
-    pub fn new(global: &GlobalScope, canvas: &HTMLCanvasElement, size: Size2D<i32>, attrs: GLContextAttributes)
+    pub fn new(window: &Window, canvas: &HTMLCanvasElement, size: Size2D<i32>, attrs: GLContextAttributes)
                -> Option<Root<WebGLRenderingContext>> {
-        match WebGLRenderingContext::new_inherited(global, canvas, size, attrs) {
+        match WebGLRenderingContext::new_inherited(window, canvas, size, attrs) {
-            Ok(ctx) => Some(reflect_dom_object(box ctx, global, WebGLRenderingContextBinding::Wrap)),
+            Ok(ctx) => Some(reflect_dom_object(box ctx, window, WebGLRenderingContextBinding::Wrap)),
             Err(msg) => {
                 error!("Couldn't create WebGLRenderingContext: {}", msg);
-                let event = WebGLContextEvent::new(global,
+                let event = WebGLContextEvent::new(window,
                                                    atom!("webglcontextcreationerror"),
                                                    EventBubbles::DoesNotBubble,
                                                    EventCancelable::Cancelable,
@@ -1248,27 +1249,27 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
     // 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<Root<WebGLBuffer>> {
-        WebGLBuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
+        WebGLBuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.6
     fn CreateFramebuffer(&self) -> Option<Root<WebGLFramebuffer>> {
-        WebGLFramebuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
+        WebGLFramebuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.7
     fn CreateRenderbuffer(&self) -> Option<Root<WebGLRenderbuffer>> {
-        WebGLRenderbuffer::maybe_new(&self.global(), self.ipc_renderer.clone())
+        WebGLRenderbuffer::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.8
     fn CreateTexture(&self) -> Option<Root<WebGLTexture>> {
-        WebGLTexture::maybe_new(&self.global(), self.ipc_renderer.clone())
+        WebGLTexture::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
     fn CreateProgram(&self) -> Option<Root<WebGLProgram>> {
-        WebGLProgram::maybe_new(&self.global(), self.ipc_renderer.clone())
+        WebGLProgram::maybe_new(self.global().as_window(), self.ipc_renderer.clone())
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.9
@@ -1280,7 +1281,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                 return None;
             }
         }
-        WebGLShader::maybe_new(&self.global(), self.ipc_renderer.clone(), shader_type)
+        WebGLShader::maybe_new(self.global().as_window(), self.ipc_renderer.clone(), shader_type)
     }
 
     // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.14.5
@@ -1612,7 +1613,7 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
                           name: DOMString) -> Option<Root<WebGLUniformLocation>> {
         program.and_then(|p| {
             handle_potential_webgl_error!(self, p.get_uniform_location(name), None)
-                .map(|location| WebGLUniformLocation::new(&self.global(), location, p.id()))
+                .map(|location| WebGLUniformLocation::new(self.global().as_window(), location, p.id()))
         })
     }
 

components/script/dom/webglshader.rs

@@ -10,8 +10,8 @@ use dom::bindings::codegen::Bindings::WebGLShaderBinding;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
 use dom::bindings::str::DOMString;
-use dom::globalscope::GlobalScope;
 use dom::webglobject::WebGLObject;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use std::sync::{ONCE_INIT, Once};
@@ -66,23 +66,24 @@ impl WebGLShader {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope,
+    pub fn maybe_new(window: &Window,
                      renderer: IpcSender<CanvasMsg>,
-                     shader_type: u32) -> Option<Root<WebGLShader>> {
+                     shader_type: u32)
+                     -> Option<Root<WebGLShader>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateShader(shader_type, sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|shader_id| WebGLShader::new(global, renderer, shader_id, shader_type))
+        result.map(|shader_id| WebGLShader::new(window, renderer, shader_id, shader_type))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLShaderId,
                shader_type: u32)
                -> Root<WebGLShader> {
         reflect_dom_object(box WebGLShader::new_inherited(renderer, id, shader_type),
-                           global,
+                           window,
                            WebGLShaderBinding::Wrap)
     }
 }

components/script/dom/webglshaderprecisionformat.rs

@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding;
 use dom::bindings::codegen::Bindings::WebGLShaderPrecisionFormatBinding::WebGLShaderPrecisionFormatMethods;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
-use dom::globalscope::GlobalScope;
+use dom::window::Window;
 
 #[dom_struct]
 pub struct WebGLShaderPrecisionFormat {
@@ -27,13 +27,13 @@ impl WebGLShaderPrecisionFormat {
         }
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                range_min: i32,
                range_max: i32,
                precision: i32) -> Root<WebGLShaderPrecisionFormat> {
         reflect_dom_object(
             box WebGLShaderPrecisionFormat::new_inherited(range_min, range_max, precision),
-            global,
+            window,
             WebGLShaderPrecisionFormatBinding::Wrap)
     }
 }

components/script/dom/webgltexture.rs

@@ -9,9 +9,9 @@ use dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderi
 use dom::bindings::codegen::Bindings::WebGLTextureBinding;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::reflect_dom_object;
-use dom::globalscope::GlobalScope;
 use dom::webgl_validations::types::{TexImageTarget, TexFormat, TexDataType};
 use dom::webglobject::WebGLObject;
+use dom::window::Window;
 use ipc_channel::ipc::IpcSender;
 use std::cell::Cell;
 use std::cmp;
@@ -61,21 +61,21 @@ impl WebGLTexture {
         }
     }
 
-    pub fn maybe_new(global: &GlobalScope, renderer: IpcSender<CanvasMsg>)
+    pub fn maybe_new(window: &Window, renderer: IpcSender<CanvasMsg>)
                      -> Option<Root<WebGLTexture>> {
         let (sender, receiver) = webrender_traits::channel::msg_channel().unwrap();
         renderer.send(CanvasMsg::WebGL(WebGLCommand::CreateTexture(sender))).unwrap();
 
         let result = receiver.recv().unwrap();
-        result.map(|texture_id| WebGLTexture::new(global, renderer, texture_id))
+        result.map(|texture_id| WebGLTexture::new(window, renderer, texture_id))
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                renderer: IpcSender<CanvasMsg>,
                id: WebGLTextureId)
                -> Root<WebGLTexture> {
         reflect_dom_object(box WebGLTexture::new_inherited(renderer, id),
-                           global,
+                           window,
                            WebGLTextureBinding::Wrap)
     }
 }

components/script/dom/webgluniformlocation.rs

@@ -6,7 +6,7 @@
 use dom::bindings::codegen::Bindings::WebGLUniformLocationBinding;
 use dom::bindings::js::Root;
 use dom::bindings::reflector::{Reflector, reflect_dom_object};
-use dom::globalscope::GlobalScope;
+use dom::window::Window;
 use webrender_traits::WebGLProgramId;
 
 #[dom_struct]
@@ -27,12 +27,12 @@ impl WebGLUniformLocation {
         }
     }
 
-    pub fn new(global: &GlobalScope,
+    pub fn new(window: &Window,
                id: i32,
                program_id: WebGLProgramId)
                -> Root<WebGLUniformLocation> {
         reflect_dom_object(box WebGLUniformLocation::new_inherited(id, program_id),
-                           global,
+                           window,
                            WebGLUniformLocationBinding::Wrap)
     }
 

components/script/dom/webidls/WebGLActiveInfo.webidl

@@ -6,6 +6,7 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
 //
 
+[Exposed=Window]
 interface WebGLActiveInfo {
     readonly attribute GLint size;
     readonly attribute GLenum type;

components/script/dom/webidls/WebGLBuffer.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.4
 //
 
+[Exposed=Window]
 interface WebGLBuffer : WebGLObject {
 };

components/script/dom/webidls/WebGLContextEvent.webidl

@@ -3,7 +3,8 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15
-[Constructor(DOMString type, optional WebGLContextEventInit eventInit)]
+[Constructor(DOMString type, optional WebGLContextEventInit eventInit),
+ Exposed=Window]
 interface WebGLContextEvent : Event {
     readonly attribute DOMString statusMessage;
 };

components/script/dom/webidls/WebGLFramebuffer.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
 //
 
+[Exposed=Window]
 interface WebGLFramebuffer : WebGLObject {
 };

components/script/dom/webidls/WebGLObject.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.3
 //
 
+[Exposed=Window]
 interface WebGLObject {
 };

components/script/dom/webidls/WebGLProgram.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.6
 //
 
+[Exposed=Window]
 interface WebGLProgram : WebGLObject {
 };

components/script/dom/webidls/WebGLRenderbuffer.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.5
 //
 
+[Exposed=Window]
 interface WebGLRenderbuffer : WebGLObject {
 };

components/script/dom/webidls/WebGLRenderingContext.webidl

@@ -41,7 +41,7 @@ dictionary WebGLContextAttributes {
     GLboolean failIfMajorPerformanceCaveat = false;
 };
 
-[NoInterfaceObject]
+[Exposed=Window, NoInterfaceObject]
 interface WebGLRenderingContextBase
 {
 
@@ -762,6 +762,7 @@ interface WebGLRenderingContextBase
     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
 };
 
+[Exposed=Window]
 interface WebGLRenderingContext
 {
 };

components/script/dom/webidls/WebGLShader.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.8
 //
 
+[Exposed=Window]
 interface WebGLShader : WebGLObject {
 };

components/script/dom/webidls/WebGLShaderPrecisionFormat.webidl

@@ -6,6 +6,7 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.7
 //
 
+[Exposed=Window]
 interface WebGLShaderPrecisionFormat {
     readonly attribute GLint rangeMin;
     readonly attribute GLint rangeMax;

components/script/dom/webidls/WebGLTexture.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/#5.9
 //
 
+[Exposed=Window]
 interface WebGLTexture : WebGLObject {
 };

components/script/dom/webidls/WebGLUniformLocation.webidl

@@ -6,5 +6,6 @@
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.10
 //
 
+[Exposed=Window]
 interface WebGLUniformLocation {
 };