Bug 1168845 - Update WebGL interface names to follow the spec. r=smaug, r=dglastonbury
authorAndrew Comminos <acomminos@mozilla.com>
Mon, 01 Jun 2015 10:17:00 -0400
changeset 277767 524a9ccacb05e7bd68256aa4c5902d83a6ff5de6
parent 277766 f59311a17ec52cbce1b2148f8b398afd83a81170
child 277768 d790f81f9f24f83762f888ea52850a9144d8e52d
push id4932
push userjlund@mozilla.com
push dateMon, 10 Aug 2015 18:23:06 +0000
treeherdermozilla-beta@6dd5a4f5f745 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssmaug, dglastonbury
bugs1168845
milestone41.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1168845 - Update WebGL interface names to follow the spec. r=smaug, r=dglastonbury
dom/bindings/Bindings.conf
dom/canvas/WebGLExtensionBlendMinMax.cpp
dom/canvas/WebGLExtensionColorBufferFloat.cpp
dom/canvas/WebGLExtensionColorBufferHalfFloat.cpp
dom/canvas/WebGLExtensionCompressedTextureATC.cpp
dom/canvas/WebGLExtensionCompressedTextureETC1.cpp
dom/canvas/WebGLExtensionCompressedTexturePVRTC.cpp
dom/canvas/WebGLExtensionCompressedTextureS3TC.cpp
dom/canvas/WebGLExtensionDebugRendererInfo.cpp
dom/canvas/WebGLExtensionDebugShaders.cpp
dom/canvas/WebGLExtensionDepthTexture.cpp
dom/canvas/WebGLExtensionDisjointTimerQuery.cpp
dom/canvas/WebGLExtensionDrawBuffers.cpp
dom/canvas/WebGLExtensionElementIndexUint.cpp
dom/canvas/WebGLExtensionFragDepth.cpp
dom/canvas/WebGLExtensionInstancedArrays.cpp
dom/canvas/WebGLExtensionLoseContext.cpp
dom/canvas/WebGLExtensionSRGB.cpp
dom/canvas/WebGLExtensionShaderTextureLod.cpp
dom/canvas/WebGLExtensionStandardDerivatives.cpp
dom/canvas/WebGLExtensionTextureFilterAnisotropic.cpp
dom/canvas/WebGLExtensionTextureFloat.cpp
dom/canvas/WebGLExtensionTextureFloatLinear.cpp
dom/canvas/WebGLExtensionTextureHalfFloat.cpp
dom/canvas/WebGLExtensionTextureHalfFloatLinear.cpp
dom/canvas/WebGLExtensionVertexArray.cpp
dom/canvas/WebGLExtensions.h
dom/canvas/WebGLTimerQuery.cpp
dom/canvas/WebGLVertexArray.cpp
dom/tests/mochitest/general/test_interfaces.html
dom/webidl/WebGL2RenderingContext.webidl
dom/webidl/WebGLRenderingContext.webidl
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -1331,137 +1331,137 @@ DOMInterfaces = {
     'headerFile': 'WebGLActiveInfo.h'
 },
 
 'WebGLBuffer': {
     'nativeType': 'mozilla::WebGLBuffer',
     'headerFile': 'WebGLBuffer.h'
 },
 
-'WebGLExtensionCompressedTextureATC': {
+'WEBGL_compressed_texture_atc': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTextureATC',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionCompressedTextureETC1': {
+'WEBGL_compressed_texture_etc1': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTextureETC1',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionCompressedTexturePVRTC': {
+'WEBGL_compressed_texture_pvrtc': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTexturePVRTC',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionCompressedTextureS3TC': {
+'WEBGL_compressed_texture_s3tc': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTextureS3TC',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionDepthTexture': {
+'WEBGL_depth_texture': {
     'nativeType': 'mozilla::WebGLExtensionDepthTexture',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionDebugRendererInfo': {
+'WEBGL_debug_renderer_info': {
     'nativeType': 'mozilla::WebGLExtensionDebugRendererInfo',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionDebugShaders': {
+'WEBGL_debug_shaders': {
     'nativeType': 'mozilla::WebGLExtensionDebugShaders',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionElementIndexUint': {
+'OES_element_index_uint': {
     'nativeType': 'mozilla::WebGLExtensionElementIndexUint',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionFragDepth': {
+'EXT_frag_depth': {
     'nativeType': 'mozilla::WebGLExtensionFragDepth',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionLoseContext': {
+'WEBGL_lose_context': {
     'nativeType': 'mozilla::WebGLExtensionLoseContext',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionSRGB': {
+'EXT_sRGB': {
     'nativeType': 'mozilla::WebGLExtensionSRGB',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionStandardDerivatives': {
+'OES_standard_derivatives': {
     'nativeType': 'mozilla::WebGLExtensionStandardDerivatives',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionShaderTextureLod': {
+'EXT_shader_texture_lod': {
     'nativeType': 'mozilla::WebGLExtensionShaderTextureLod',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionTextureFilterAnisotropic': {
+'EXT_texture_filter_anisotropic': {
     'nativeType': 'mozilla::WebGLExtensionTextureFilterAnisotropic',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionTextureFloat': {
+'OES_texture_float': {
     'nativeType': 'mozilla::WebGLExtensionTextureFloat',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionTextureFloatLinear': {
+'OES_texture_float_linear': {
     'nativeType': 'mozilla::WebGLExtensionTextureFloatLinear',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionTextureHalfFloat': {
+'OES_texture_half_float': {
    'nativeType': 'mozilla::WebGLExtensionTextureHalfFloat',
    'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionTextureHalfFloatLinear': {
+'OES_texture_half_float_linear': {
    'nativeType': 'mozilla::WebGLExtensionTextureHalfFloatLinear',
    'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionColorBufferFloat': {
+'WEBGL_color_buffer_float': {
    'nativeType': 'mozilla::WebGLExtensionColorBufferFloat',
    'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionColorBufferHalfFloat': {
+'EXT_color_buffer_half_float': {
    'nativeType': 'mozilla::WebGLExtensionColorBufferHalfFloat',
    'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionDrawBuffers': {
+'WEBGL_draw_buffers': {
     'nativeType': 'mozilla::WebGLExtensionDrawBuffers',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionVertexArray': {
+'OES_vertex_array_object': {
     'nativeType': 'mozilla::WebGLExtensionVertexArray',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionInstancedArrays': {
+'ANGLE_instanced_arrays': {
     'nativeType': 'mozilla::WebGLExtensionInstancedArrays',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionBlendMinMax': {
+'EXT_blend_minmax': {
     'nativeType': 'mozilla::WebGLExtensionBlendMinMax',
     'headerFile': 'WebGLExtensions.h'
 },
 
-'WebGLExtensionDisjointTimerQuery': {
+'EXT_disjoint_timer_query': {
     'nativeType': 'mozilla::WebGLExtensionDisjointTimerQuery',
     'headerFile': 'WebGLExtensions.h'
 },
 
 'WebGLFramebuffer': {
     'nativeType': 'mozilla::WebGLFramebuffer',
     'headerFile': 'WebGLFramebuffer.h'
 },
@@ -1514,32 +1514,32 @@ DOMInterfaces = {
     'headerFile': 'WebGLSync.h'
 },
 
 'WebGLTexture': {
     'nativeType': 'mozilla::WebGLTexture',
     'headerFile': 'WebGLTexture.h'
 },
 
-'WebGLTimerQuery': {
+'WebGLTimerQueryEXT': {
     'nativeType': 'mozilla::WebGLTimerQuery',
     'headerFile': 'WebGLTimerQuery.h'
 },
 
 'WebGLTransformFeedback': {
     'nativeType': 'mozilla::WebGLTransformFeedback',
     'headerFile': 'WebGLTransformFeedback.h'
 },
 
 'WebGLUniformLocation': {
     'nativeType': 'mozilla::WebGLUniformLocation',
     'headerFile': 'WebGLUniformLocation.h'
 },
 
-'WebGLVertexArray': {
+'WebGLVertexArrayObjectOES': {
     'nativeType': 'mozilla::WebGLVertexArray',
     'headerFile': 'WebGLVertexArray.h'
 },
 
 'WebrtcGlobalInformation': {
     'nativeType': 'mozilla::dom::WebrtcGlobalInformation',
     'headerFile': 'WebrtcGlobalInformation.h',
     'wrapperCache': False,
--- a/dom/canvas/WebGLExtensionBlendMinMax.cpp
+++ b/dom/canvas/WebGLExtensionBlendMinMax.cpp
@@ -21,11 +21,11 @@ WebGLExtensionBlendMinMax::~WebGLExtensi
 }
 
 bool
 WebGLExtensionBlendMinMax::IsSupported(const WebGLContext* webgl)
 {
     return webgl->GL()->IsSupported(gl::GLFeature::blend_minmax);
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionBlendMinMax)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionBlendMinMax, EXT_blend_minmax)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionColorBufferFloat.cpp
+++ b/dom/canvas/WebGLExtensionColorBufferFloat.cpp
@@ -27,11 +27,11 @@ WebGLExtensionColorBufferFloat::IsSuppor
 
     // ANGLE supports this, but doesn't have a way to advertize its support,
     // since it's compliant with WEBGL_color_buffer_float's clamping, but not
     // EXT_color_buffer_float.
     return gl->IsSupported(gl::GLFeature::renderbuffer_color_float) ||
            gl->IsANGLE();
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionColorBufferFloat)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionColorBufferFloat, WEBGL_color_buffer_float)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionColorBufferHalfFloat.cpp
+++ b/dom/canvas/WebGLExtensionColorBufferHalfFloat.cpp
@@ -25,11 +25,11 @@ WebGLExtensionColorBufferHalfFloat::IsSu
 {
     gl::GLContext* gl = webgl->GL();
 
     // ANGLE doesn't support ReadPixels from a RGBA16F with RGBA/FLOAT.
     return gl->IsSupported(gl::GLFeature::renderbuffer_color_half_float) ||
            gl->IsANGLE();
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionColorBufferHalfFloat)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionColorBufferHalfFloat, EXT_color_buffer_half_float)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionCompressedTextureATC.cpp
+++ b/dom/canvas/WebGLExtensionCompressedTextureATC.cpp
@@ -16,11 +16,11 @@ WebGLExtensionCompressedTextureATC::WebG
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA);
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA);
 }
 
 WebGLExtensionCompressedTextureATC::~WebGLExtensionCompressedTextureATC()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureATC)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureATC, WEBGL_compressed_texture_atc)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionCompressedTextureETC1.cpp
+++ b/dom/canvas/WebGLExtensionCompressedTextureETC1.cpp
@@ -14,11 +14,11 @@ WebGLExtensionCompressedTextureETC1::Web
 {
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_ETC1_RGB8_OES);
 }
 
 WebGLExtensionCompressedTextureETC1::~WebGLExtensionCompressedTextureETC1()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureETC1)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureETC1, WEBGL_compressed_texture_etc1)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionCompressedTexturePVRTC.cpp
+++ b/dom/canvas/WebGLExtensionCompressedTexturePVRTC.cpp
@@ -17,11 +17,11 @@ WebGLExtensionCompressedTexturePVRTC::We
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1);
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1);
 }
 
 WebGLExtensionCompressedTexturePVRTC::~WebGLExtensionCompressedTexturePVRTC()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTexturePVRTC)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTexturePVRTC, WEBGL_compressed_texture_pvrtc)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionCompressedTextureS3TC.cpp
+++ b/dom/canvas/WebGLExtensionCompressedTextureS3TC.cpp
@@ -17,11 +17,11 @@ WebGLExtensionCompressedTextureS3TC::Web
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
     webgl->mCompressedTextureFormats.AppendElement(LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
 }
 
 WebGLExtensionCompressedTextureS3TC::~WebGLExtensionCompressedTextureS3TC()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureS3TC)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureS3TC, WEBGL_compressed_texture_s3tc)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionDebugRendererInfo.cpp
+++ b/dom/canvas/WebGLExtensionDebugRendererInfo.cpp
@@ -14,11 +14,11 @@ WebGLExtensionDebugRendererInfo::WebGLEx
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionDebugRendererInfo::~WebGLExtensionDebugRendererInfo()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDebugRendererInfo)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDebugRendererInfo, WEBGL_debug_renderer_info)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionDebugShaders.cpp
+++ b/dom/canvas/WebGLExtensionDebugShaders.cpp
@@ -33,11 +33,11 @@ WebGLExtensionDebugShaders::GetTranslate
                                         "getTranslatedShaderSource");
         return;
     }
 
     retval.SetIsVoid(false);
     mContext->GetShaderTranslatedSource(shader, retval);
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDebugShaders)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDebugShaders, WEBGL_debug_shaders)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionDepthTexture.cpp
+++ b/dom/canvas/WebGLExtensionDepthTexture.cpp
@@ -14,11 +14,11 @@ WebGLExtensionDepthTexture::WebGLExtensi
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionDepthTexture::~WebGLExtensionDepthTexture()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDepthTexture)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDepthTexture, WEBGL_depth_texture)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionDisjointTimerQuery.cpp
+++ b/dom/canvas/WebGLExtensionDisjointTimerQuery.cpp
@@ -237,11 +237,11 @@ WebGLExtensionDisjointTimerQuery::IsSupp
   webgl->MakeContextCurrent();
   gl::GLContext* gl = webgl->GL();
   return gl->IsSupported(gl::GLFeature::query_objects) &&
          gl->IsSupported(gl::GLFeature::get_query_object_i64v) &&
          gl->IsSupported(gl::GLFeature::query_counter); // provides GL_TIMESTAMP
 }
 
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDisjointTimerQuery)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDisjointTimerQuery, EXT_disjoint_timer_query)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionDrawBuffers.cpp
+++ b/dom/canvas/WebGLExtensionDrawBuffers.cpp
@@ -78,11 +78,11 @@ WebGLExtensionDrawBuffers::IsSupported(c
         return false;
 
     if (size_t(supportedDrawBuffers) < kMinDrawBuffers)
         return false;
 
     return true;
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDrawBuffers)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionDrawBuffers, WEBGL_draw_buffers)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionElementIndexUint.cpp
+++ b/dom/canvas/WebGLExtensionElementIndexUint.cpp
@@ -14,11 +14,11 @@ WebGLExtensionElementIndexUint::WebGLExt
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionElementIndexUint::~WebGLExtensionElementIndexUint()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionElementIndexUint)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionElementIndexUint, OES_element_index_uint)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionFragDepth.cpp
+++ b/dom/canvas/WebGLExtensionFragDepth.cpp
@@ -24,11 +24,11 @@ WebGLExtensionFragDepth::~WebGLExtension
 bool
 WebGLExtensionFragDepth::IsSupported(const WebGLContext* webgl)
 {
     gl::GLContext* gl = webgl->GL();
     return gl->IsSupported(gl::GLFeature::frag_depth);
 }
 
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionFragDepth)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionFragDepth, EXT_frag_depth)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionInstancedArrays.cpp
+++ b/dom/canvas/WebGLExtensionInstancedArrays.cpp
@@ -68,11 +68,11 @@ WebGLExtensionInstancedArrays::VertexAtt
 bool
 WebGLExtensionInstancedArrays::IsSupported(const WebGLContext* webgl)
 {
     gl::GLContext* gl = webgl->GL();
     return gl->IsSupported(gl::GLFeature::draw_instanced) &&
            gl->IsSupported(gl::GLFeature::instanced_arrays);
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionInstancedArrays)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionInstancedArrays, ANGLE_instanced_arrays)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionLoseContext.cpp
+++ b/dom/canvas/WebGLExtensionLoseContext.cpp
@@ -26,11 +26,11 @@ WebGLExtensionLoseContext::LoseContext()
 }
 
 void
 WebGLExtensionLoseContext::RestoreContext()
 {
     mContext->RestoreContext();
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionLoseContext)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionLoseContext, WEBGL_lose_context)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionSRGB.cpp
+++ b/dom/canvas/WebGLExtensionSRGB.cpp
@@ -34,11 +34,11 @@ WebGLExtensionSRGB::IsSupported(const We
 {
     gl::GLContext* gl = webgl->GL();
 
     return gl->IsSupported(gl::GLFeature::sRGB_framebuffer) &&
            gl->IsSupported(gl::GLFeature::sRGB_texture);
 }
 
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionSRGB)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionSRGB, EXT_sRGB)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionShaderTextureLod.cpp
+++ b/dom/canvas/WebGLExtensionShaderTextureLod.cpp
@@ -14,11 +14,11 @@ WebGLExtensionShaderTextureLod::WebGLExt
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionShaderTextureLod::~WebGLExtensionShaderTextureLod()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionShaderTextureLod)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionShaderTextureLod, EXT_shader_texture_lod)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionStandardDerivatives.cpp
+++ b/dom/canvas/WebGLExtensionStandardDerivatives.cpp
@@ -14,11 +14,11 @@ WebGLExtensionStandardDerivatives::WebGL
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionStandardDerivatives::~WebGLExtensionStandardDerivatives()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionStandardDerivatives)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionStandardDerivatives, OES_standard_derivatives)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionTextureFilterAnisotropic.cpp
+++ b/dom/canvas/WebGLExtensionTextureFilterAnisotropic.cpp
@@ -14,11 +14,11 @@ WebGLExtensionTextureFilterAnisotropic::
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionTextureFilterAnisotropic::~WebGLExtensionTextureFilterAnisotropic()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFilterAnisotropic)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFilterAnisotropic, EXT_texture_filter_anisotropic)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionTextureFloat.cpp
+++ b/dom/canvas/WebGLExtensionTextureFloat.cpp
@@ -13,11 +13,11 @@ WebGLExtensionTextureFloat::WebGLExtensi
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionTextureFloat::~WebGLExtensionTextureFloat()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFloat)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFloat, OES_texture_float)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionTextureFloatLinear.cpp
+++ b/dom/canvas/WebGLExtensionTextureFloatLinear.cpp
@@ -13,11 +13,11 @@ WebGLExtensionTextureFloatLinear::WebGLE
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionTextureFloatLinear::~WebGLExtensionTextureFloatLinear()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFloatLinear)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureFloatLinear, OES_texture_float_linear)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionTextureHalfFloat.cpp
+++ b/dom/canvas/WebGLExtensionTextureHalfFloat.cpp
@@ -13,11 +13,11 @@ WebGLExtensionTextureHalfFloat::WebGLExt
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionTextureHalfFloat::~WebGLExtensionTextureHalfFloat()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureHalfFloat)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureHalfFloat, OES_texture_half_float)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionTextureHalfFloatLinear.cpp
+++ b/dom/canvas/WebGLExtensionTextureHalfFloatLinear.cpp
@@ -13,11 +13,11 @@ WebGLExtensionTextureHalfFloatLinear::We
     : WebGLExtensionBase(webgl)
 {
 }
 
 WebGLExtensionTextureHalfFloatLinear::~WebGLExtensionTextureHalfFloatLinear()
 {
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureHalfFloatLinear)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionTextureHalfFloatLinear, OES_texture_half_float_linear)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensionVertexArray.cpp
+++ b/dom/canvas/WebGLExtensionVertexArray.cpp
@@ -65,11 +65,11 @@ WebGLExtensionVertexArray::BindVertexArr
         mContext->ErrorInvalidOperation("%s: Extension is lost.",
                                         "bindVertexArrayOES");
         return;
     }
 
     mContext->BindVertexArray(array);
 }
 
-IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionVertexArray)
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionVertexArray, OES_vertex_array_object)
 
 } // namespace mozilla
--- a/dom/canvas/WebGLExtensions.h
+++ b/dom/canvas/WebGLExtensions.h
@@ -40,20 +40,20 @@ protected:
     virtual ~WebGLExtensionBase();
 
     bool mIsLost;
 };
 
 #define DECL_WEBGL_EXTENSION_GOOP \
     virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override;
 
-#define IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionType)            \
+#define IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionType, WebGLBindingType)\
     JSObject*                                                    \
     WebGLExtensionType::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) {              \
-        return dom::WebGLExtensionType##Binding::Wrap(cx, this, aGivenProto); \
+        return dom::WebGLBindingType##Binding::Wrap(cx, this, aGivenProto); \
     }
 
 class WebGLExtensionCompressedTextureATC
     : public WebGLExtensionBase
 {
 public:
     explicit WebGLExtensionCompressedTextureATC(WebGLContext*);
     virtual ~WebGLExtensionCompressedTextureATC();
--- a/dom/canvas/WebGLTimerQuery.cpp
+++ b/dom/canvas/WebGLTimerQuery.cpp
@@ -11,17 +11,17 @@
 #include "nsContentUtils.h"
 #include "WebGLContext.h"
 
 namespace mozilla {
 
 JSObject*
 WebGLTimerQuery::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
 {
-  return dom::WebGLTimerQueryBinding::Wrap(cx, this, aGivenProto);
+  return dom::WebGLTimerQueryEXTBinding::Wrap(cx, this, aGivenProto);
 }
 
 WebGLTimerQuery::WebGLTimerQuery(WebGLContext* webgl, GLuint aName)
   : WebGLBindableName<QueryBinding>(aName)
   , WebGLContextBoundObject(webgl)
 {
 }
 
--- a/dom/canvas/WebGLVertexArray.cpp
+++ b/dom/canvas/WebGLVertexArray.cpp
@@ -12,17 +12,17 @@
 #include "WebGLVertexArrayGL.h"
 #include "WebGLVertexArrayFake.h"
 
 namespace mozilla {
 
 JSObject*
 WebGLVertexArray::WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto)
 {
-    return dom::WebGLVertexArrayBinding::Wrap(cx, this, aGivenProto);
+    return dom::WebGLVertexArrayObjectOESBinding::Wrap(cx, this, aGivenProto);
 }
 
 WebGLVertexArray::WebGLVertexArray(WebGLContext* webgl)
     : WebGLBindable<VAOBinding>()
     , WebGLContextBoundObject(webgl)
     , mGLName(0)
 {
     mContext->mVertexArrays.insertBack(this);
--- a/dom/tests/mochitest/general/test_interfaces.html
+++ b/dom/tests/mochitest/general/test_interfaces.html
@@ -1322,18 +1322,16 @@ var interfaceNamesInGlobalScope =
     "WebGLShader",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "WebGLShaderPrecisionFormat",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "WebGLTexture",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "WebGLUniformLocation",
 // IMPORTANT: Do not change this list without review from a DOM peer!
-    "WebGLVertexArray",
-// IMPORTANT: Do not change this list without review from a DOM peer!
     "WebSocket",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "WheelEvent",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "Window",
 // IMPORTANT: Do not change this list without review from a DOM peer!
     "Worker",
 // IMPORTANT: Do not change this list without review from a DOM peer!
--- a/dom/webidl/WebGL2RenderingContext.webidl
+++ b/dom/webidl/WebGL2RenderingContext.webidl
@@ -3,16 +3,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/.
  *
  * The source for this IDL is found at https://www.khronos.org/registry/webgl/specs/latest/2.0
  * This IDL depends on WebGLRenderingContext.webidl
  */
 
 typedef long long GLint64; // Should this be int64?
+typedef unsigned long long GLuint64;
 
 [Pref="webgl.enable-prototype-webgl2"]
 interface WebGLQuery {
 };
 
 [Pref="webgl.enable-prototype-webgl2"]
 interface WebGLSampler {
 };
--- a/dom/webidl/WebGLRenderingContext.webidl
+++ b/dom/webidl/WebGLRenderingContext.webidl
@@ -23,19 +23,19 @@ typedef short          GLshort;
 typedef long           GLint;
 typedef long           GLsizei;
 typedef long long      GLintptr;
 typedef long long      GLsizeiptr;
 // Ideally the typedef below would use 'unsigned byte', but that doesn't currently exist in Web IDL.
 typedef octet          GLubyte;        /* 'octet' should be an unsigned 8 bit type. */
 typedef unsigned short GLushort;
 typedef unsigned long  GLuint;
-typedef unsigned long long GLuint64;
 typedef unrestricted float GLfloat;
 typedef unrestricted float GLclampf;
+typedef unsigned long long GLuint64EXT;
 
 dictionary WebGLContextAttributes {
     // boolean alpha = true;
     // We deviate from the spec here.
     // If alpha isn't specified, we rely on a pref ("webgl.default-no-alpha")
     boolean alpha;
     boolean depth = true;
     boolean stencil = false;
@@ -61,17 +61,18 @@ interface WebGLShader {
 };
 
 interface WebGLTexture {
 };
 
 interface WebGLUniformLocation {
 };
 
-interface WebGLVertexArray {
+[NoInterfaceObject]
+interface WebGLVertexArrayObjectOES {
 };
 
 interface WebGLActiveInfo {
     readonly attribute GLint size;
     readonly attribute GLenum type;
     readonly attribute DOMString name;
 };
 
@@ -774,110 +775,110 @@ interface WebGLContextEvent : Event {
 /*dictionary WebGLContextEventInit : EventInit {
     DOMString statusMessage;
     };*/
 
 
 // specific extension interfaces
 
 [NoInterfaceObject]
-interface WebGLExtensionCompressedTextureS3TC
+interface WEBGL_compressed_texture_s3tc
 {
     const GLenum COMPRESSED_RGB_S3TC_DXT1_EXT  = 0x83F0;
     const GLenum COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1;
     const GLenum COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2;
     const GLenum COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionCompressedTextureATC
+interface WEBGL_compressed_texture_atc
 {
     const GLenum COMPRESSED_RGB_ATC_WEBGL                     = 0x8C92;
     const GLenum COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL     = 0x8C93;
     const GLenum COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL = 0x87EE;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionCompressedTextureETC1
+interface WEBGL_compressed_texture_etc1
 {
     const GLenum COMPRESSED_RGB_ETC1_WEBGL = 0x8D64;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionCompressedTexturePVRTC
+interface WEBGL_compressed_texture_pvrtc
 {
     const GLenum COMPRESSED_RGB_PVRTC_4BPPV1_IMG  = 0x8C00;
     const GLenum COMPRESSED_RGB_PVRTC_2BPPV1_IMG  = 0x8C01;
     const GLenum COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02;
     const GLenum COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionDebugRendererInfo
+interface WEBGL_debug_renderer_info
 {
     const GLenum UNMASKED_VENDOR_WEBGL        = 0x9245;
     const GLenum UNMASKED_RENDERER_WEBGL      = 0x9246;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionDebugShaders
+interface WEBGL_debug_shaders
 {
     DOMString getTranslatedShaderSource(WebGLShader? shader);
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionDepthTexture
+interface WEBGL_depth_texture
 {
     const GLenum UNSIGNED_INT_24_8_WEBGL = 0x84FA;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionElementIndexUint
+interface OES_element_index_uint
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionFragDepth
+interface EXT_frag_depth
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionLoseContext {
+interface WEBGL_lose_context {
     void loseContext();
     void restoreContext();
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionTextureFilterAnisotropic
+interface EXT_texture_filter_anisotropic
 {
     const GLenum TEXTURE_MAX_ANISOTROPY_EXT     = 0x84FE;
     const GLenum MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionSRGB
+interface EXT_sRGB
 {
     const GLenum SRGB_EXT                                  = 0x8C40;
     const GLenum SRGB_ALPHA_EXT                            = 0x8C42;
     const GLenum SRGB8_ALPHA8_EXT                          = 0x8C43;
     const GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT = 0x8210;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionStandardDerivatives {
+interface OES_standard_derivatives {
     const GLenum FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionTextureFloat
+interface OES_texture_float
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionDrawBuffers {
+interface WEBGL_draw_buffers {
     const GLenum COLOR_ATTACHMENT0_WEBGL     = 0x8CE0;
     const GLenum COLOR_ATTACHMENT1_WEBGL     = 0x8CE1;
     const GLenum COLOR_ATTACHMENT2_WEBGL     = 0x8CE2;
     const GLenum COLOR_ATTACHMENT3_WEBGL     = 0x8CE3;
     const GLenum COLOR_ATTACHMENT4_WEBGL     = 0x8CE4;
     const GLenum COLOR_ATTACHMENT5_WEBGL     = 0x8CE5;
     const GLenum COLOR_ATTACHMENT6_WEBGL     = 0x8CE6;
     const GLenum COLOR_ATTACHMENT7_WEBGL     = 0x8CE7;
@@ -909,96 +910,94 @@ interface WebGLExtensionDrawBuffers {
 
     const GLenum MAX_COLOR_ATTACHMENTS_WEBGL = 0x8CDF;
     const GLenum MAX_DRAW_BUFFERS_WEBGL      = 0x8824;
 
     void drawBuffersWEBGL(sequence<GLenum> buffers);
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionTextureFloatLinear
+interface OES_texture_float_linear
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionShaderTextureLod
+interface EXT_shader_texture_lod
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionTextureHalfFloat
+interface OES_texture_half_float
 {
     const GLenum HALF_FLOAT_OES = 0x8D61;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionTextureHalfFloatLinear
+interface OES_texture_half_float_linear
 {
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionColorBufferFloat
+interface WEBGL_color_buffer_float
 {
     const GLenum RGBA32F_EXT = 0x8814;
     const GLenum RGB32F_EXT = 0x8815;
     const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211;
     const GLenum UNSIGNED_NORMALIZED_EXT = 0x8C17;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionColorBufferHalfFloat
+interface EXT_color_buffer_half_float
 {
     const GLenum RGBA16F_EXT = 0x881A;
     const GLenum RGB16F_EXT = 0x881B;
     const GLenum FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211;
     const GLenum UNSIGNED_NORMALIZED_EXT = 0x8C17;
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionVertexArray {
+interface OES_vertex_array_object {
     const GLenum VERTEX_ARRAY_BINDING_OES = 0x85B5;
 
-    WebGLVertexArray? createVertexArrayOES();
-    void deleteVertexArrayOES(WebGLVertexArray? arrayObject);
-    [WebGLHandlesContextLoss] GLboolean isVertexArrayOES(WebGLVertexArray? arrayObject);
-    void bindVertexArrayOES(WebGLVertexArray? arrayObject);
+    WebGLVertexArrayObjectOES? createVertexArrayOES();
+    void deleteVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
+    [WebGLHandlesContextLoss] GLboolean isVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
+    void bindVertexArrayOES(WebGLVertexArrayObjectOES? arrayObject);
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionInstancedArrays {
+interface ANGLE_instanced_arrays {
     const GLenum VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE;
 
     void drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
     void drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, GLintptr offset, GLsizei primcount);
     void vertexAttribDivisorANGLE(GLuint index, GLuint divisor);
 };
 
 [NoInterfaceObject]
-interface WebGLExtensionBlendMinMax {
+interface EXT_blend_minmax {
     const GLenum MIN_EXT = 0x8007;
     const GLenum MAX_EXT = 0x8008;
 };
 
-// FIXME: Spec interface name is WebGLTimerQueryEXT.
 [NoInterfaceObject]
-interface WebGLTimerQuery {
+interface WebGLTimerQueryEXT {
 };
 
-// FIXME: Spec interface name is EXT_disjoint_timer_query.
 [NoInterfaceObject]
-interface WebGLExtensionDisjointTimerQuery {
+interface EXT_disjoint_timer_query {
     const GLenum QUERY_COUNTER_BITS_EXT = 0x8864;
     const GLenum CURRENT_QUERY_EXT = 0x8865;
     const GLenum QUERY_RESULT_EXT = 0x8866;
     const GLenum QUERY_RESULT_AVAILABLE_EXT = 0x8867;
     const GLenum TIME_ELAPSED_EXT = 0x88BF;
     const GLenum TIMESTAMP_EXT = 0x8E28;
     const GLenum GPU_DISJOINT_EXT = 0x8FBB;
 
-    WebGLTimerQuery? createQueryEXT();
-    void deleteQueryEXT(WebGLTimerQuery? query);
-    [WebGLHandlesContextLoss] boolean isQueryEXT(WebGLTimerQuery? query);
-    void beginQueryEXT(GLenum target, WebGLTimerQuery? query);
+    WebGLTimerQueryEXT? createQueryEXT();
+    void deleteQueryEXT(WebGLTimerQueryEXT? query);
+    [WebGLHandlesContextLoss] boolean isQueryEXT(WebGLTimerQueryEXT? query);
+    void beginQueryEXT(GLenum target, WebGLTimerQueryEXT? query);
     void endQueryEXT(GLenum target);
-    void queryCounterEXT(WebGLTimerQuery? query, GLenum target);
+    void queryCounterEXT(WebGLTimerQueryEXT? query, GLenum target);
     any getQueryEXT(GLenum target, GLenum pname);
-    any getQueryObjectEXT(WebGLTimerQuery? query, GLenum pname);
+    any getQueryObjectEXT(WebGLTimerQueryEXT? query, GLenum pname);
 };