Bug 943190 - Implement WEBGL_compressed_texture_et1. - r=kamidphish
authorJeff Gilbert <jgilbert@mozilla.com>
Mon, 10 Mar 2014 15:42:58 -0700
changeset 191100 636a4f14af757b845d554d89d9799d87c683c802
parent 191099 84e4b2ecb19ba5d12b6109a6790e76c39ebac67d
child 191101 91c5ede1cb080f788c03cb77a855199b9a5b8b7d
push id474
push userasasaki@mozilla.com
push dateMon, 02 Jun 2014 21:01:02 +0000
treeherdermozilla-release@967f4cf1b31c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerskamidphish
bugs943190
milestone30.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 943190 - Implement WEBGL_compressed_texture_et1. - r=kamidphish
content/canvas/src/WebGLContext.h
content/canvas/src/WebGLContextExtensions.cpp
content/canvas/src/WebGLContextUtils.cpp
content/canvas/src/WebGLContextValidate.cpp
content/canvas/src/WebGLExtensionCompressedTextureETC1.cpp
content/canvas/src/WebGLExtensions.h
content/canvas/src/moz.build
dom/bindings/Bindings.conf
dom/webidl/WebGLRenderingContext.webidl
gfx/gl/GLContext.cpp
gfx/gl/GLContext.h
gfx/gl/GfxTexturesReporter.cpp
--- a/content/canvas/src/WebGLContext.h
+++ b/content/canvas/src/WebGLContext.h
@@ -117,25 +117,26 @@ struct WebGLContextOptions {
 class WebGLContext :
     public nsIDOMWebGLRenderingContext,
     public nsICanvasRenderingContextInternal,
     public nsSupportsWeakReference,
     public WebGLRectangleObject,
     public nsWrapperCache
 {
     friend class WebGLContextUserData;
+    friend class WebGLExtensionCompressedTextureATC;
+    friend class WebGLExtensionCompressedTextureETC1;
+    friend class WebGLExtensionCompressedTexturePVRTC;
+    friend class WebGLExtensionCompressedTextureS3TC;
+    friend class WebGLExtensionDepthTexture;
+    friend class WebGLExtensionDrawBuffers;
+    friend class WebGLExtensionLoseContext;
+    friend class WebGLExtensionVertexArray;
     friend class WebGLMemoryPressureObserver;
     friend class WebGLMemoryTracker;
-    friend class WebGLExtensionLoseContext;
-    friend class WebGLExtensionCompressedTextureS3TC;
-    friend class WebGLExtensionCompressedTextureATC;
-    friend class WebGLExtensionCompressedTexturePVRTC;
-    friend class WebGLExtensionDepthTexture;
-    friend class WebGLExtensionDrawBuffers;
-    friend class WebGLExtensionVertexArray;
 
     enum {
         UNPACK_FLIP_Y_WEBGL = 0x9240,
         UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241,
         CONTEXT_LOST_WEBGL = 0x9242,
         UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243,
         BROWSER_DEFAULT_WEBGL = 0x9244,
         UNMASKED_VENDOR_WEBGL = 0x9245,
@@ -904,16 +905,17 @@ protected:
         OES_standard_derivatives,
         OES_texture_float,
         OES_texture_float_linear,
         OES_texture_half_float,
         OES_texture_half_float_linear,
         OES_vertex_array_object,
         WEBGL_color_buffer_float,
         WEBGL_compressed_texture_atc,
+        WEBGL_compressed_texture_etc1,
         WEBGL_compressed_texture_pvrtc,
         WEBGL_compressed_texture_s3tc,
         WEBGL_debug_renderer_info,
         WEBGL_debug_shaders,
         WEBGL_depth_texture,
         WEBGL_lose_context,
         WEBGL_draw_buffers,
         ANGLE_instanced_arrays,
--- a/content/canvas/src/WebGLContextExtensions.cpp
+++ b/content/canvas/src/WebGLContextExtensions.cpp
@@ -25,16 +25,17 @@ static const char *sExtensionNames[] = {
     "OES_standard_derivatives",
     "OES_texture_float",
     "OES_texture_float_linear",
     "OES_texture_half_float",
     "OES_texture_half_float_linear",
     "OES_vertex_array_object",
     "WEBGL_color_buffer_float",
     "WEBGL_compressed_texture_atc",
+    "WEBGL_compressed_texture_etc1",
     "WEBGL_compressed_texture_pvrtc",
     "WEBGL_compressed_texture_s3tc",
     "WEBGL_debug_renderer_info",
     "WEBGL_debug_shaders",
     "WEBGL_depth_texture",
     "WEBGL_lose_context",
     "WEBGL_draw_buffers",
     "ANGLE_instanced_arrays"
@@ -126,16 +127,18 @@ bool WebGLContext::IsExtensionSupported(
                      gl->IsExtensionSupported(GLContext::ANGLE_texture_compression_dxt3) &&
                      gl->IsExtensionSupported(GLContext::ANGLE_texture_compression_dxt5))
             {
                 return true;
             }
             return false;
         case WEBGL_compressed_texture_atc:
             return gl->IsExtensionSupported(GLContext::AMD_compressed_ATC_texture);
+        case WEBGL_compressed_texture_etc1:
+            return gl->IsExtensionSupported(GLContext::OES_compressed_ETC1_RGB8_texture);
         case WEBGL_compressed_texture_pvrtc:
             return gl->IsExtensionSupported(GLContext::IMG_texture_compression_pvrtc);
         case WEBGL_depth_texture:
             // WEBGL_depth_texture supports DEPTH_STENCIL textures
             if (!gl->IsSupported(GLFeature::packed_depth_stencil)) {
                 return false;
             }
             return gl->IsSupported(GLFeature::depth_texture) ||
@@ -263,16 +266,19 @@ WebGLContext::EnableExtension(WebGLExten
             obj = new WebGLExtensionLoseContext(this);
             break;
         case WEBGL_compressed_texture_s3tc:
             obj = new WebGLExtensionCompressedTextureS3TC(this);
             break;
         case WEBGL_compressed_texture_atc:
             obj = new WebGLExtensionCompressedTextureATC(this);
             break;
+        case WEBGL_compressed_texture_etc1:
+            obj = new WebGLExtensionCompressedTextureETC1(this);
+            break;
         case WEBGL_compressed_texture_pvrtc:
             obj = new WebGLExtensionCompressedTexturePVRTC(this);
             break;
         case WEBGL_debug_renderer_info:
             obj = new WebGLExtensionDebugRendererInfo(this);
             break;
         case WEBGL_debug_shaders:
             obj = new WebGLExtensionDebugShaders(this);
--- a/content/canvas/src/WebGLContextUtils.cpp
+++ b/content/canvas/src/WebGLContextUtils.cpp
@@ -220,16 +220,17 @@ WebGLContext::IsTextureFormatCompressed(
         case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
         case LOCAL_GL_ATC_RGB:
         case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
         case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
         case LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1:
         case LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1:
         case LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1:
         case LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1:
+        case LOCAL_GL_ETC1_RGB8_OES:
             return true;
         default:
             return false;
     }
 }
 
 GLenum
 WebGLContext::GetAndFlushUnderlyingGLErrors()
--- a/content/canvas/src/WebGLContextValidate.cpp
+++ b/content/canvas/src/WebGLContextValidate.cpp
@@ -47,16 +47,19 @@ BlockSizeFor(GLenum format, GLint* block
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
         if (blockWidth)
             *blockWidth = 4;
         if (blockHeight)
             *blockHeight = 4;
         break;
+
+    case LOCAL_GL_ETC1_RGB8_OES:
+        // 4x4 blocks, but no 4-multiple requirement.
     default:
         break;
     }
 }
 
 /**
  * Return the displayable name for the texture function that is the
  * source for validation.
@@ -100,16 +103,17 @@ NameFrom(GLenum glenum)
         XX(COMPRESSED_RGB_PVRTC_2BPPV1);
         XX(COMPRESSED_RGB_PVRTC_4BPPV1);
         XX(COMPRESSED_RGB_S3TC_DXT1_EXT);
         XX(DEPTH_COMPONENT);
         XX(DEPTH_COMPONENT16);
         XX(DEPTH_COMPONENT32);
         XX(DEPTH_STENCIL);
         XX(DEPTH24_STENCIL8);
+        XX(ETC1_RGB8_OES);
         XX(FLOAT);
         XX(HALF_FLOAT);
         XX(LUMINANCE);
         XX(LUMINANCE_ALPHA);
         XX(RGB);
         XX(RGB16F);
         XX(RGB32F);
         XX(RGBA);
@@ -169,16 +173,17 @@ IsAllowedFromSource(GLenum format, WebGL
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1:
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1:
         return (func == WebGLTexImageFunc::CompTexImage ||
                 func == WebGLTexImageFunc::CompTexSubImage);
 
     case LOCAL_GL_ATC_RGB:
     case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
     case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
+    case LOCAL_GL_ETC1_RGB8_OES:
         return func == WebGLTexImageFunc::CompTexImage;
     }
 
     return true;
 }
 
 /**
  * Returns true if func is a CopyTexImage variant.
@@ -321,16 +326,21 @@ WebGLContext::BaseTexFormat(GLenum inter
 
         if (internalFormat == LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA ||
             internalFormat == LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA)
         {
             return LOCAL_GL_RGBA;
         }
     }
 
+    if (IsExtensionEnabled(WEBGL_compressed_texture_etc1)) {
+        if (internalFormat == LOCAL_GL_ETC1_RGB8_OES)
+            return LOCAL_GL_RGB;
+    }
+
     if (IsExtensionEnabled(WEBGL_compressed_texture_pvrtc)) {
         if (internalFormat == LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1 ||
             internalFormat == LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1)
         {
             return LOCAL_GL_RGB;
         }
 
         if (internalFormat == LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1 ||
@@ -616,16 +626,25 @@ WebGLContext::ValidateTexImageFormat(GLe
     {
         bool validFormat = IsExtensionEnabled(WEBGL_compressed_texture_atc);
         if (!validFormat)
             ErrorInvalidEnum("%s: invalid format %s: need WEBGL_compressed_texture_atc enabled",
                              InfoFrom(func), NameFrom(format));
         return validFormat;
     }
 
+    // WEBGL_compressed_texture_etc1
+    if (format == LOCAL_GL_ETC1_RGB8_OES) {
+        bool validFormat = IsExtensionEnabled(WEBGL_compressed_texture_etc1);
+        if (!validFormat)
+            ErrorInvalidEnum("%s: invalid format %s: need WEBGL_compressed_texture_etc1 enabled",
+                             InfoFrom(func), NameFrom(format));
+        return validFormat;
+    }
+
 
     if (format == LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1 ||
         format == LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1 ||
         format == LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1 ||
         format == LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1)
     {
         bool validFormat = IsExtensionEnabled(WEBGL_compressed_texture_pvrtc);
         if (!validFormat)
@@ -857,16 +876,17 @@ WebGLContext::ValidateCompTexImageDataSi
     MOZ_ASSERT(width >= 0 && height >= 0);
 
     CheckedUint32 required_byteLength = 0;
 
     switch (format) {
         case LOCAL_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
         case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
         case LOCAL_GL_ATC_RGB:
+        case LOCAL_GL_ETC1_RGB8_OES:
         {
             required_byteLength = ((CheckedUint32(width) + 3) / 4) * ((CheckedUint32(height) + 3) / 4) * 8;
             break;
         }
         case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
         case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
         case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
         case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
@@ -1110,16 +1130,17 @@ WebGLContext::GetBitsPerTexel(GLenum for
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1:
         return 2;
 
     case LOCAL_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
     case LOCAL_GL_ATC_RGB:
     case LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1:
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1:
+    case LOCAL_GL_ETC1_RGB8_OES:
         return 4;
 
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
     case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
     case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
         return 8;
 
@@ -1179,16 +1200,17 @@ WebGLContext::ValidateTexImageFormatAndT
 
     case LOCAL_GL_DEPTH_STENCIL:
         validCombo = (type == LOCAL_GL_UNSIGNED_INT_24_8);
         break;
 
     case LOCAL_GL_ATC_RGB:
     case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
     case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
+    case LOCAL_GL_ETC1_RGB8_OES:
     case LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1:
     case LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1:
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1:
     case LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1:
     case LOCAL_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
     case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
new file mode 100644
--- /dev/null
+++ b/content/canvas/src/WebGLExtensionCompressedTextureETC1.cpp
@@ -0,0 +1,22 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+#include "WebGLExtensions.h"
+
+#include "mozilla/dom/WebGLRenderingContextBinding.h"
+#include "WebGLContext.h"
+
+using namespace mozilla;
+
+WebGLExtensionCompressedTextureETC1::WebGLExtensionCompressedTextureETC1(WebGLContext* context)
+    : WebGLExtensionBase(context)
+{
+    context->mCompressedTextureFormats.AppendElement(LOCAL_GL_ETC1_RGB8_OES);
+}
+
+WebGLExtensionCompressedTextureETC1::~WebGLExtensionCompressedTextureETC1()
+{
+}
+
+IMPL_WEBGL_EXTENSION_GOOP(WebGLExtensionCompressedTextureETC1)
--- a/content/canvas/src/WebGLExtensions.h
+++ b/content/canvas/src/WebGLExtensions.h
@@ -49,16 +49,26 @@ class WebGLExtensionCompressedTextureATC
 {
 public:
     WebGLExtensionCompressedTextureATC(WebGLContext*);
     virtual ~WebGLExtensionCompressedTextureATC();
 
     DECL_WEBGL_EXTENSION_GOOP
 };
 
+class WebGLExtensionCompressedTextureETC1
+    : public WebGLExtensionBase
+{
+public:
+    WebGLExtensionCompressedTextureETC1(WebGLContext*);
+    virtual ~WebGLExtensionCompressedTextureETC1();
+
+    DECL_WEBGL_EXTENSION_GOOP
+};
+
 class WebGLExtensionCompressedTexturePVRTC
     : public WebGLExtensionBase
 {
 public:
     WebGLExtensionCompressedTexturePVRTC(WebGLContext*);
     virtual ~WebGLExtensionCompressedTexturePVRTC();
 
     DECL_WEBGL_EXTENSION_GOOP
--- a/content/canvas/src/moz.build
+++ b/content/canvas/src/moz.build
@@ -42,16 +42,17 @@ if CONFIG['MOZ_WEBGL']:
         'WebGLContextValidate.cpp',
         'WebGLContextVertexArray.cpp',
         'WebGLContextVertices.cpp',
         'WebGLElementArrayCache.cpp',
         'WebGLExtensionBase.cpp',
         'WebGLExtensionColorBufferFloat.cpp',
         'WebGLExtensionColorBufferHalfFloat.cpp',
         'WebGLExtensionCompressedTextureATC.cpp',
+        'WebGLExtensionCompressedTextureETC1.cpp',
         'WebGLExtensionCompressedTexturePVRTC.cpp',
         'WebGLExtensionCompressedTextureS3TC.cpp',
         'WebGLExtensionDebugRendererInfo.cpp',
         'WebGLExtensionDebugShaders.cpp',
         'WebGLExtensionDepthTexture.cpp',
         'WebGLExtensionDrawBuffers.cpp',
         'WebGLExtensionElementIndexUint.cpp',
         'WebGLExtensionFragDepth.cpp',
--- a/dom/bindings/Bindings.conf
+++ b/dom/bindings/Bindings.conf
@@ -1262,16 +1262,21 @@ DOMInterfaces = {
     'headerFile': 'WebGLBuffer.h'
 },
 
 'WebGLExtensionCompressedTextureATC': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTextureATC',
     'headerFile': 'WebGLExtensions.h'
 },
 
+'WebGLExtensionCompressedTextureETC1': {
+    'nativeType': 'mozilla::WebGLExtensionCompressedTextureETC1',
+    'headerFile': 'WebGLExtensions.h'
+},
+
 'WebGLExtensionCompressedTexturePVRTC': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTexturePVRTC',
     'headerFile': 'WebGLExtensions.h'
 },
 
 'WebGLExtensionCompressedTextureS3TC': {
     'nativeType': 'mozilla::WebGLExtensionCompressedTextureS3TC',
     'headerFile': 'WebGLExtensions.h'
--- a/dom/webidl/WebGLRenderingContext.webidl
+++ b/dom/webidl/WebGLRenderingContext.webidl
@@ -24,17 +24,17 @@ 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 unrestricted float GLfloat;
-typedef unrestricted float GLclampf;  
+typedef unrestricted float GLclampf;
 
 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;
@@ -80,131 +80,131 @@ interface WebGLShaderPrecisionFormat {
 };
 
 interface WebGLRenderingContext {
 
     /* ClearBufferMask */
     const GLenum DEPTH_BUFFER_BIT               = 0x00000100;
     const GLenum STENCIL_BUFFER_BIT             = 0x00000400;
     const GLenum COLOR_BUFFER_BIT               = 0x00004000;
-    
+
     /* BeginMode */
     const GLenum POINTS                         = 0x0000;
     const GLenum LINES                          = 0x0001;
     const GLenum LINE_LOOP                      = 0x0002;
     const GLenum LINE_STRIP                     = 0x0003;
     const GLenum TRIANGLES                      = 0x0004;
     const GLenum TRIANGLE_STRIP                 = 0x0005;
     const GLenum TRIANGLE_FAN                   = 0x0006;
-    
+
     /* AlphaFunction (not supported in ES20) */
     /*      NEVER */
     /*      LESS */
     /*      EQUAL */
     /*      LEQUAL */
     /*      GREATER */
     /*      NOTEQUAL */
     /*      GEQUAL */
     /*      ALWAYS */
-    
+
     /* BlendingFactorDest */
     const GLenum ZERO                           = 0;
     const GLenum ONE                            = 1;
     const GLenum SRC_COLOR                      = 0x0300;
     const GLenum ONE_MINUS_SRC_COLOR            = 0x0301;
     const GLenum SRC_ALPHA                      = 0x0302;
     const GLenum ONE_MINUS_SRC_ALPHA            = 0x0303;
     const GLenum DST_ALPHA                      = 0x0304;
     const GLenum ONE_MINUS_DST_ALPHA            = 0x0305;
-    
+
     /* BlendingFactorSrc */
     /*      ZERO */
     /*      ONE */
     const GLenum DST_COLOR                      = 0x0306;
     const GLenum ONE_MINUS_DST_COLOR            = 0x0307;
     const GLenum SRC_ALPHA_SATURATE             = 0x0308;
     /*      SRC_ALPHA */
     /*      ONE_MINUS_SRC_ALPHA */
     /*      DST_ALPHA */
     /*      ONE_MINUS_DST_ALPHA */
-    
+
     /* BlendEquationSeparate */
     const GLenum FUNC_ADD                       = 0x8006;
     const GLenum BLEND_EQUATION                 = 0x8009;
     const GLenum BLEND_EQUATION_RGB             = 0x8009;   /* same as BLEND_EQUATION */
     const GLenum BLEND_EQUATION_ALPHA           = 0x883D;
-    
+
     /* BlendSubtract */
     const GLenum FUNC_SUBTRACT                  = 0x800A;
     const GLenum FUNC_REVERSE_SUBTRACT          = 0x800B;
-    
+
     /* Separate Blend Functions */
     const GLenum BLEND_DST_RGB                  = 0x80C8;
     const GLenum BLEND_SRC_RGB                  = 0x80C9;
     const GLenum BLEND_DST_ALPHA                = 0x80CA;
     const GLenum BLEND_SRC_ALPHA                = 0x80CB;
     const GLenum CONSTANT_COLOR                 = 0x8001;
     const GLenum ONE_MINUS_CONSTANT_COLOR       = 0x8002;
     const GLenum CONSTANT_ALPHA                 = 0x8003;
     const GLenum ONE_MINUS_CONSTANT_ALPHA       = 0x8004;
     const GLenum BLEND_COLOR                    = 0x8005;
-    
+
     /* Buffer Objects */
     const GLenum ARRAY_BUFFER                   = 0x8892;
     const GLenum ELEMENT_ARRAY_BUFFER           = 0x8893;
     const GLenum ARRAY_BUFFER_BINDING           = 0x8894;
     const GLenum ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;
-    
+
     const GLenum STREAM_DRAW                    = 0x88E0;
     const GLenum STATIC_DRAW                    = 0x88E4;
     const GLenum DYNAMIC_DRAW                   = 0x88E8;
-    
+
     const GLenum BUFFER_SIZE                    = 0x8764;
     const GLenum BUFFER_USAGE                   = 0x8765;
-    
+
     const GLenum CURRENT_VERTEX_ATTRIB          = 0x8626;
-    
+
     /* CullFaceMode */
     const GLenum FRONT                          = 0x0404;
     const GLenum BACK                           = 0x0405;
     const GLenum FRONT_AND_BACK                 = 0x0408;
-    
+
     /* DepthFunction */
     /*      NEVER */
     /*      LESS */
     /*      EQUAL */
     /*      LEQUAL */
     /*      GREATER */
     /*      NOTEQUAL */
     /*      GEQUAL */
     /*      ALWAYS */
-    
+
     /* EnableCap */
     /* TEXTURE_2D */
     const GLenum CULL_FACE                      = 0x0B44;
     const GLenum BLEND                          = 0x0BE2;
     const GLenum DITHER                         = 0x0BD0;
     const GLenum STENCIL_TEST                   = 0x0B90;
     const GLenum DEPTH_TEST                     = 0x0B71;
     const GLenum SCISSOR_TEST                   = 0x0C11;
     const GLenum POLYGON_OFFSET_FILL            = 0x8037;
     const GLenum SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;
     const GLenum SAMPLE_COVERAGE                = 0x80A0;
-    
+
     /* ErrorCode */
     const GLenum NO_ERROR                       = 0;
     const GLenum INVALID_ENUM                   = 0x0500;
     const GLenum INVALID_VALUE                  = 0x0501;
     const GLenum INVALID_OPERATION              = 0x0502;
     const GLenum OUT_OF_MEMORY                  = 0x0505;
-    
+
     /* FrontFaceDirection */
     const GLenum CW                             = 0x0900;
     const GLenum CCW                            = 0x0901;
-    
+
     /* GetPName */
     const GLenum LINE_WIDTH                     = 0x0B21;
     const GLenum ALIASED_POINT_SIZE_RANGE       = 0x846D;
     const GLenum ALIASED_LINE_WIDTH_RANGE       = 0x846E;
     const GLenum CULL_FACE_MODE                 = 0x0B45;
     const GLenum FRONT_FACE                     = 0x0B46;
     const GLenum DEPTH_RANGE                    = 0x0B70;
     const GLenum DEPTH_WRITEMASK                = 0x0B72;
@@ -244,56 +244,56 @@ interface WebGLRenderingContext {
     const GLenum POLYGON_OFFSET_UNITS           = 0x2A00;
     /*      POLYGON_OFFSET_FILL */
     const GLenum POLYGON_OFFSET_FACTOR          = 0x8038;
     const GLenum TEXTURE_BINDING_2D             = 0x8069;
     const GLenum SAMPLE_BUFFERS                 = 0x80A8;
     const GLenum SAMPLES                        = 0x80A9;
     const GLenum SAMPLE_COVERAGE_VALUE          = 0x80AA;
     const GLenum SAMPLE_COVERAGE_INVERT         = 0x80AB;
-    
+
     /* GetTextureParameter */
     /*      TEXTURE_MAG_FILTER */
     /*      TEXTURE_MIN_FILTER */
     /*      TEXTURE_WRAP_S */
     /*      TEXTURE_WRAP_T */
-    
+
     const GLenum COMPRESSED_TEXTURE_FORMATS     = 0x86A3;
-    
+
     /* HintMode */
     const GLenum DONT_CARE                      = 0x1100;
     const GLenum FASTEST                        = 0x1101;
     const GLenum NICEST                         = 0x1102;
-    
+
     /* HintTarget */
     const GLenum GENERATE_MIPMAP_HINT            = 0x8192;
-    
+
     /* DataType */
     const GLenum BYTE                           = 0x1400;
     const GLenum UNSIGNED_BYTE                  = 0x1401;
     const GLenum SHORT                          = 0x1402;
     const GLenum UNSIGNED_SHORT                 = 0x1403;
     const GLenum INT                            = 0x1404;
     const GLenum UNSIGNED_INT                   = 0x1405;
     const GLenum FLOAT                          = 0x1406;
-    
+
     /* PixelFormat */
     const GLenum DEPTH_COMPONENT                = 0x1902;
     const GLenum ALPHA                          = 0x1906;
     const GLenum RGB                            = 0x1907;
     const GLenum RGBA                           = 0x1908;
     const GLenum LUMINANCE                      = 0x1909;
     const GLenum LUMINANCE_ALPHA                = 0x190A;
-    
+
     /* PixelType */
     /*      UNSIGNED_BYTE */
     const GLenum UNSIGNED_SHORT_4_4_4_4         = 0x8033;
     const GLenum UNSIGNED_SHORT_5_5_5_1         = 0x8034;
     const GLenum UNSIGNED_SHORT_5_6_5           = 0x8363;
-    
+
     /* Shaders */
     const GLenum FRAGMENT_SHADER                  = 0x8B30;
     const GLenum VERTEX_SHADER                    = 0x8B31;
     const GLenum MAX_VERTEX_ATTRIBS               = 0x8869;
     const GLenum MAX_VERTEX_UNIFORM_VECTORS       = 0x8DFB;
     const GLenum MAX_VARYING_VECTORS              = 0x8DFC;
     const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
     const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C;
@@ -303,74 +303,74 @@ interface WebGLRenderingContext {
     const GLenum DELETE_STATUS                    = 0x8B80;
     const GLenum LINK_STATUS                      = 0x8B82;
     const GLenum VALIDATE_STATUS                  = 0x8B83;
     const GLenum ATTACHED_SHADERS                 = 0x8B85;
     const GLenum ACTIVE_UNIFORMS                  = 0x8B86;
     const GLenum ACTIVE_ATTRIBUTES                = 0x8B89;
     const GLenum SHADING_LANGUAGE_VERSION         = 0x8B8C;
     const GLenum CURRENT_PROGRAM                  = 0x8B8D;
-    
+
     /* StencilFunction */
     const GLenum NEVER                          = 0x0200;
     const GLenum LESS                           = 0x0201;
     const GLenum EQUAL                          = 0x0202;
     const GLenum LEQUAL                         = 0x0203;
     const GLenum GREATER                        = 0x0204;
     const GLenum NOTEQUAL                       = 0x0205;
     const GLenum GEQUAL                         = 0x0206;
     const GLenum ALWAYS                         = 0x0207;
-    
+
     /* StencilOp */
     /*      ZERO */
     const GLenum KEEP                           = 0x1E00;
     const GLenum REPLACE                        = 0x1E01;
     const GLenum INCR                           = 0x1E02;
     const GLenum DECR                           = 0x1E03;
     const GLenum INVERT                         = 0x150A;
     const GLenum INCR_WRAP                      = 0x8507;
     const GLenum DECR_WRAP                      = 0x8508;
-    
+
     /* StringName */
     const GLenum VENDOR                         = 0x1F00;
     const GLenum RENDERER                       = 0x1F01;
     const GLenum VERSION                        = 0x1F02;
-    
+
     /* TextureMagFilter */
     const GLenum NEAREST                        = 0x2600;
     const GLenum LINEAR                         = 0x2601;
-    
+
     /* TextureMinFilter */
     /*      NEAREST */
     /*      LINEAR */
     const GLenum NEAREST_MIPMAP_NEAREST         = 0x2700;
     const GLenum LINEAR_MIPMAP_NEAREST          = 0x2701;
     const GLenum NEAREST_MIPMAP_LINEAR          = 0x2702;
     const GLenum LINEAR_MIPMAP_LINEAR           = 0x2703;
-    
+
     /* TextureParameterName */
     const GLenum TEXTURE_MAG_FILTER             = 0x2800;
     const GLenum TEXTURE_MIN_FILTER             = 0x2801;
     const GLenum TEXTURE_WRAP_S                 = 0x2802;
     const GLenum TEXTURE_WRAP_T                 = 0x2803;
-    
+
     /* TextureTarget */
     const GLenum TEXTURE_2D                     = 0x0DE1;
     const GLenum TEXTURE                        = 0x1702;
-    
+
     const GLenum TEXTURE_CUBE_MAP               = 0x8513;
     const GLenum TEXTURE_BINDING_CUBE_MAP       = 0x8514;
     const GLenum TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;
     const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;
     const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;
     const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;
     const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;
     const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;
     const GLenum MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;
-    
+
     /* TextureUnit */
     const GLenum TEXTURE0                       = 0x84C0;
     const GLenum TEXTURE1                       = 0x84C1;
     const GLenum TEXTURE2                       = 0x84C2;
     const GLenum TEXTURE3                       = 0x84C3;
     const GLenum TEXTURE4                       = 0x84C4;
     const GLenum TEXTURE5                       = 0x84C5;
     const GLenum TEXTURE6                       = 0x84C6;
@@ -395,105 +395,105 @@ interface WebGLRenderingContext {
     const GLenum TEXTURE25                      = 0x84D9;
     const GLenum TEXTURE26                      = 0x84DA;
     const GLenum TEXTURE27                      = 0x84DB;
     const GLenum TEXTURE28                      = 0x84DC;
     const GLenum TEXTURE29                      = 0x84DD;
     const GLenum TEXTURE30                      = 0x84DE;
     const GLenum TEXTURE31                      = 0x84DF;
     const GLenum ACTIVE_TEXTURE                 = 0x84E0;
-    
+
     /* TextureWrapMode */
     const GLenum REPEAT                         = 0x2901;
     const GLenum CLAMP_TO_EDGE                  = 0x812F;
     const GLenum MIRRORED_REPEAT                = 0x8370;
-    
+
     /* Uniform Types */
     const GLenum FLOAT_VEC2                     = 0x8B50;
     const GLenum FLOAT_VEC3                     = 0x8B51;
     const GLenum FLOAT_VEC4                     = 0x8B52;
     const GLenum INT_VEC2                       = 0x8B53;
     const GLenum INT_VEC3                       = 0x8B54;
     const GLenum INT_VEC4                       = 0x8B55;
     const GLenum BOOL                           = 0x8B56;
     const GLenum BOOL_VEC2                      = 0x8B57;
     const GLenum BOOL_VEC3                      = 0x8B58;
     const GLenum BOOL_VEC4                      = 0x8B59;
     const GLenum FLOAT_MAT2                     = 0x8B5A;
     const GLenum FLOAT_MAT3                     = 0x8B5B;
     const GLenum FLOAT_MAT4                     = 0x8B5C;
     const GLenum SAMPLER_2D                     = 0x8B5E;
     const GLenum SAMPLER_CUBE                   = 0x8B60;
-    
+
     /* Vertex Arrays */
     const GLenum VERTEX_ATTRIB_ARRAY_ENABLED        = 0x8622;
     const GLenum VERTEX_ATTRIB_ARRAY_SIZE           = 0x8623;
     const GLenum VERTEX_ATTRIB_ARRAY_STRIDE         = 0x8624;
     const GLenum VERTEX_ATTRIB_ARRAY_TYPE           = 0x8625;
     const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED     = 0x886A;
     const GLenum VERTEX_ATTRIB_ARRAY_POINTER        = 0x8645;
     const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
-    
+
     /* Shader Source */
     const GLenum COMPILE_STATUS                 = 0x8B81;
-    
+
     /* Shader Precision-Specified Types */
     const GLenum LOW_FLOAT                      = 0x8DF0;
     const GLenum MEDIUM_FLOAT                   = 0x8DF1;
     const GLenum HIGH_FLOAT                     = 0x8DF2;
     const GLenum LOW_INT                        = 0x8DF3;
     const GLenum MEDIUM_INT                     = 0x8DF4;
     const GLenum HIGH_INT                       = 0x8DF5;
-    
+
     /* Framebuffer Object. */
     const GLenum FRAMEBUFFER                    = 0x8D40;
     const GLenum RENDERBUFFER                   = 0x8D41;
-    
+
     const GLenum RGBA4                          = 0x8056;
     const GLenum RGB5_A1                        = 0x8057;
     const GLenum RGB565                         = 0x8D62;
     const GLenum DEPTH_COMPONENT16              = 0x81A5;
     const GLenum STENCIL_INDEX                  = 0x1901;
     const GLenum STENCIL_INDEX8                 = 0x8D48;
     const GLenum DEPTH_STENCIL                  = 0x84F9;
-    
+
     const GLenum RENDERBUFFER_WIDTH             = 0x8D42;
     const GLenum RENDERBUFFER_HEIGHT            = 0x8D43;
     const GLenum RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;
     const GLenum RENDERBUFFER_RED_SIZE          = 0x8D50;
     const GLenum RENDERBUFFER_GREEN_SIZE        = 0x8D51;
     const GLenum RENDERBUFFER_BLUE_SIZE         = 0x8D52;
     const GLenum RENDERBUFFER_ALPHA_SIZE        = 0x8D53;
     const GLenum RENDERBUFFER_DEPTH_SIZE        = 0x8D54;
     const GLenum RENDERBUFFER_STENCIL_SIZE      = 0x8D55;
-    
+
     const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           = 0x8CD0;
     const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           = 0x8CD1;
     const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         = 0x8CD2;
     const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
-    
+
     const GLenum COLOR_ATTACHMENT0              = 0x8CE0;
     const GLenum DEPTH_ATTACHMENT               = 0x8D00;
     const GLenum STENCIL_ATTACHMENT             = 0x8D20;
     const GLenum DEPTH_STENCIL_ATTACHMENT       = 0x821A;
-    
+
     const GLenum NONE                           = 0;
-    
+
     const GLenum FRAMEBUFFER_COMPLETE                      = 0x8CD5;
     const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT         = 0x8CD6;
     const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
     const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS         = 0x8CD9;
     const GLenum FRAMEBUFFER_UNSUPPORTED                   = 0x8CDD;
-    
+
     const GLenum FRAMEBUFFER_BINDING            = 0x8CA6;
     const GLenum RENDERBUFFER_BINDING           = 0x8CA7;
     const GLenum MAX_RENDERBUFFER_SIZE          = 0x84E8;
-    
+
     const GLenum INVALID_FRAMEBUFFER_OPERATION  = 0x0506;
-    
+
     /* WebGL-specific enums */
     const GLenum UNPACK_FLIP_Y_WEBGL            = 0x9240;
     const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241;
     const GLenum CONTEXT_LOST_WEBGL             = 0x9242;
     const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;
     const GLenum BROWSER_DEFAULT_WEBGL          = 0x9244;
 
     // The canvas might actually be null in some cases, apparently.
@@ -515,17 +515,17 @@ interface WebGLRenderingContext {
     void bindBuffer(GLenum target, WebGLBuffer? buffer);
     void bindFramebuffer(GLenum target, WebGLFramebuffer? framebuffer);
     void bindRenderbuffer(GLenum target, WebGLRenderbuffer? renderbuffer);
     void bindTexture(GLenum target, WebGLTexture? texture);
     void blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
     void blendEquation(GLenum mode);
     void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
     void blendFunc(GLenum sfactor, GLenum dfactor);
-    void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, 
+    void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
                            GLenum srcAlpha, GLenum dstAlpha);
 
     void bufferData(GLenum target, GLsizeiptr size, GLenum usage);
     void bufferData(GLenum target, ArrayBufferView data, GLenum usage);
     void bufferData(GLenum target, ArrayBuffer? data, GLenum usage);
     void bufferSubData(GLenum target, GLintptr offset, ArrayBufferView data);
     void bufferSubData(GLenum target, GLintptr offset, ArrayBuffer? data);
 
@@ -540,20 +540,20 @@ interface WebGLRenderingContext {
     void compressedTexImage2D(GLenum target, GLint level, GLenum internalformat,
                               GLsizei width, GLsizei height, GLint border,
                               ArrayBufferView data);
     void compressedTexSubImage2D(GLenum target, GLint level,
                                  GLint xoffset, GLint yoffset,
                                  GLsizei width, GLsizei height, GLenum format,
                                  ArrayBufferView data);
 
-    void copyTexImage2D(GLenum target, GLint level, GLenum internalformat, 
-                        GLint x, GLint y, GLsizei width, GLsizei height, 
+    void copyTexImage2D(GLenum target, GLint level, GLenum internalformat,
+                        GLint x, GLint y, GLsizei width, GLsizei height,
                         GLint border);
-    void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
+    void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                            GLint x, GLint y, GLsizei width, GLsizei height);
 
     WebGLBuffer? createBuffer();
     WebGLFramebuffer? createFramebuffer();
     WebGLProgram? createProgram();
     WebGLRenderbuffer? createRenderbuffer();
     WebGLShader? createShader(GLenum type);
     WebGLTexture? createTexture();
@@ -575,20 +575,20 @@ interface WebGLRenderingContext {
     void disableVertexAttribArray(GLuint index);
     void drawArrays(GLenum mode, GLint first, GLsizei count);
     void drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);
 
     void enable(GLenum cap);
     void enableVertexAttribArray(GLuint index);
     void finish();
     void flush();
-    void framebufferRenderbuffer(GLenum target, GLenum attachment, 
-                                 GLenum renderbuffertarget, 
+    void framebufferRenderbuffer(GLenum target, GLenum attachment,
+                                 GLenum renderbuffertarget,
                                  WebGLRenderbuffer? renderbuffer);
-    void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, 
+    void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget,
                               WebGLTexture? texture, GLint level);
     void frontFace(GLenum mode);
 
     void generateMipmap(GLenum target);
 
     [NewObject]
     WebGLActiveInfo? getActiveAttrib(WebGLProgram? program, GLuint index);
     [NewObject]
@@ -600,17 +600,17 @@ interface WebGLRenderingContext {
 
     any getBufferParameter(GLenum target, GLenum pname);
     [Throws]
     any getParameter(GLenum pname);
 
     [WebGLHandlesContextLoss] GLenum getError();
 
     [Throws]
-    any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, 
+    any getFramebufferAttachmentParameter(GLenum target, GLenum attachment,
                                           GLenum pname);
     any getProgramParameter(WebGLProgram? program, GLenum pname);
     DOMString? getProgramInfoLog(WebGLProgram? program);
     any getRenderbufferParameter(GLenum target, GLenum pname);
     any getShaderParameter(WebGLShader? shader, GLenum pname);
 
     [NewObject]
     WebGLShaderPrecisionFormat? getShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype);
@@ -640,37 +640,37 @@ interface WebGLRenderingContext {
     [WebGLHandlesContextLoss] GLboolean isShader(WebGLShader? shader);
     [WebGLHandlesContextLoss] GLboolean isTexture(WebGLTexture? texture);
     void lineWidth(GLfloat width);
     void linkProgram(WebGLProgram? program);
     void pixelStorei(GLenum pname, GLint param);
     void polygonOffset(GLfloat factor, GLfloat units);
 
     [Throws]
-    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, 
+    void readPixels(GLint x, GLint y, GLsizei width, GLsizei height,
                     GLenum format, GLenum type, ArrayBufferView? pixels);
 
-    void renderbufferStorage(GLenum target, GLenum internalformat, 
+    void renderbufferStorage(GLenum target, GLenum internalformat,
                              GLsizei width, GLsizei height);
     void sampleCoverage(GLclampf value, GLboolean invert);
     void scissor(GLint x, GLint y, GLsizei width, GLsizei height);
 
     void shaderSource(WebGLShader? shader, DOMString source);
 
     void stencilFunc(GLenum func, GLint ref, GLuint mask);
     void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
     void stencilMask(GLuint mask);
     void stencilMaskSeparate(GLenum face, GLuint mask);
     void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);
     void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
 
 
     [Throws]
-    void texImage2D(GLenum target, GLint level, GLenum internalformat, 
-                    GLsizei width, GLsizei height, GLint border, GLenum format, 
+    void texImage2D(GLenum target, GLint level, GLenum internalformat,
+                    GLsizei width, GLsizei height, GLint border, GLenum format,
                     GLenum type, ArrayBufferView? pixels);
     [Throws]
     void texImage2D(GLenum target, GLint level, GLenum internalformat,
                     GLenum format, GLenum type, ImageData? pixels);
     [Throws]
     void texImage2D(GLenum target, GLint level, GLenum internalformat,
                     GLenum format, GLenum type, HTMLImageElement image); // May throw DOMException
     [Throws]
@@ -679,30 +679,30 @@ interface WebGLRenderingContext {
     [Throws]
     void texImage2D(GLenum target, GLint level, GLenum internalformat,
                     GLenum format, GLenum type, HTMLVideoElement video); // May throw DOMException
 
     void texParameterf(GLenum target, GLenum pname, GLfloat param);
     void texParameteri(GLenum target, GLenum pname, GLint param);
 
     [Throws]
-    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
-                       GLsizei width, GLsizei height, 
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
+                       GLsizei width, GLsizei height,
                        GLenum format, GLenum type, ArrayBufferView? pixels);
     [Throws]
-    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                        GLenum format, GLenum type, ImageData? pixels);
     [Throws]
-    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                        GLenum format, GLenum type, HTMLImageElement image); // May throw DOMException
     [Throws]
-    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                        GLenum format, GLenum type, HTMLCanvasElement canvas); // May throw DOMException
     [Throws]
-    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 
+    void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
                        GLenum format, GLenum type, HTMLVideoElement video); // May throw DOMException
 
     void uniform1f(WebGLUniformLocation? location, GLfloat x);
     void uniform1fv(WebGLUniformLocation? location, Float32Array v);
     void uniform1fv(WebGLUniformLocation? location, sequence<GLfloat> v);
     void uniform1i(WebGLUniformLocation? location, GLint x);
     void uniform1iv(WebGLUniformLocation? location, Int32Array v);
     void uniform1iv(WebGLUniformLocation? location, sequence<long> v);
@@ -720,27 +720,27 @@ interface WebGLRenderingContext {
     void uniform3iv(WebGLUniformLocation? location, sequence<long> v);
     void uniform4f(WebGLUniformLocation? location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
     void uniform4fv(WebGLUniformLocation? location, Float32Array v);
     void uniform4fv(WebGLUniformLocation? location, sequence<GLfloat> v);
     void uniform4i(WebGLUniformLocation? location, GLint x, GLint y, GLint z, GLint w);
     void uniform4iv(WebGLUniformLocation? location, Int32Array v);
     void uniform4iv(WebGLUniformLocation? location, sequence<long> v);
 
-    void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose,
                           Float32Array value);
-    void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix2fv(WebGLUniformLocation? location, GLboolean transpose,
                           sequence<GLfloat> value);
-    void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose,
                           Float32Array value);
-    void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix3fv(WebGLUniformLocation? location, GLboolean transpose,
                           sequence<GLfloat> value);
-    void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose,
                           Float32Array value);
-    void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose, 
+    void uniformMatrix4fv(WebGLUniformLocation? location, GLboolean transpose,
                           sequence<GLfloat> value);
 
     void useProgram(WebGLProgram? program);
     void validateProgram(WebGLProgram? program);
 
     void vertexAttrib1f(GLuint indx, GLfloat x);
     void vertexAttrib1fv(GLuint indx, Float32Array values);
     void vertexAttrib1fv(GLuint indx, sequence<GLfloat> values);
@@ -748,17 +748,17 @@ interface WebGLRenderingContext {
     void vertexAttrib2fv(GLuint indx, Float32Array values);
     void vertexAttrib2fv(GLuint indx, sequence<GLfloat> values);
     void vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
     void vertexAttrib3fv(GLuint indx, Float32Array values);
     void vertexAttrib3fv(GLuint indx, sequence<GLfloat> values);
     void vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
     void vertexAttrib4fv(GLuint indx, Float32Array values);
     void vertexAttrib4fv(GLuint indx, sequence<GLfloat> values);
-    void vertexAttribPointer(GLuint indx, GLint size, GLenum type, 
+    void vertexAttribPointer(GLuint indx, GLint size, GLenum type,
                              GLboolean normalized, GLsizei stride, GLintptr offset);
 
     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
 };
 
 /*[Constructor(DOMString type, optional WebGLContextEventInit eventInit)]
 interface WebGLContextEvent : Event {
     readonly attribute DOMString statusMessage;
@@ -785,16 +785,22 @@ interface WebGLExtensionCompressedTextur
 interface WebGLExtensionCompressedTextureATC
 {
     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
+{
+    const GLenum COMPRESSED_RGB_ETC1_WEBGL = 0x8D64;
+};
+
+[NoInterfaceObject]
 interface WebGLExtensionCompressedTexturePVRTC
 {
     const GLenum COMPRESSED_RGB_PVRTC_4BPPV1  = 0x8C00;
     const GLenum COMPRESSED_RGB_PVRTC_2BPPV1  = 0x8C01;
     const GLenum COMPRESSED_RGBA_PVRTC_4BPPV1 = 0x8C02;
     const GLenum COMPRESSED_RGBA_PVRTC_2BPPV1 = 0x8C03;
 };
 
--- a/gfx/gl/GLContext.cpp
+++ b/gfx/gl/GLContext.cpp
@@ -131,16 +131,17 @@ static const char *sExtensionNames[] = {
     "GL_ANGLE_depth_texture",
     "GL_EXT_sRGB",
     "GL_EXT_texture_sRGB",
     "GL_ARB_framebuffer_sRGB",
     "GL_EXT_framebuffer_sRGB",
     "GL_KHR_debug",
     "GL_ARB_half_float_pixel",
     "GL_EXT_frag_depth",
+    "GL_OES_compressed_ETC1_RGB8_texture",
     nullptr
 };
 
 static bool
 ParseGLVersion(GLContext* gl, unsigned int* version)
 {
     GLenum error = gl->fGetError();
     if (error != LOCAL_GL_NO_ERROR) {
--- a/gfx/gl/GLContext.h
+++ b/gfx/gl/GLContext.h
@@ -413,16 +413,17 @@ public:
         ANGLE_depth_texture,
         EXT_sRGB,
         EXT_texture_sRGB,
         ARB_framebuffer_sRGB,
         EXT_framebuffer_sRGB,
         KHR_debug,
         ARB_half_float_pixel,
         EXT_frag_depth,
+        OES_compressed_ETC1_RGB8_texture,
         Extensions_Max,
         Extensions_End
     };
 
     bool IsExtensionSupported(GLExtensions aKnownExtension) const {
         return mAvailableExtensions[aKnownExtension];
     }
 
--- a/gfx/gl/GfxTexturesReporter.cpp
+++ b/gfx/gl/GfxTexturesReporter.cpp
@@ -47,16 +47,17 @@ GetBitsPerTexel(GLenum format, GLenum ty
             case LOCAL_GL_COMPRESSED_RGB_PVRTC_2BPPV1:
             case LOCAL_GL_COMPRESSED_RGBA_PVRTC_2BPPV1:
                 return 2;
             case LOCAL_GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
             case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
             case LOCAL_GL_ATC_RGB:
             case LOCAL_GL_COMPRESSED_RGB_PVRTC_4BPPV1:
             case LOCAL_GL_COMPRESSED_RGBA_PVRTC_4BPPV1:
+            case LOCAL_GL_ETC1_RGB8_OES:
                 return 4;
             case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
             case LOCAL_GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
             case LOCAL_GL_ATC_RGBA_EXPLICIT_ALPHA:
             case LOCAL_GL_ATC_RGBA_INTERPOLATED_ALPHA:
                 return 8;
             default:
                 break;