--- 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);
 };