Add m-esr52 at 52.6.0

1 files changed, 877 insertions, 0 deletions

diff --git a/dom/canvas/WebGLContextUtils.cpp b/dom/canvas/WebGLContextUtils.cpp
new file mode 100644
index 000000000..9c0d34939
--- /dev/null
+++ b/dom/canvas/WebGLContextUtils.cpp
@@ -0,0 +1,877 @@
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "WebGLContextUtils.h"
+#include "WebGLContext.h"
+
+#include "GLContext.h"
+#include "jsapi.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/Preferences.h"
+#include "nsIDOMDataContainerEvent.h"
+#include "nsIDOMEvent.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsIVariant.h"
+#include "nsPrintfCString.h"
+#include "nsServiceManagerUtils.h"
+#include "prprf.h"
+#include <stdarg.h>
+#include "WebGLBuffer.h"
+#include "WebGLExtensions.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLProgram.h"
+#include "WebGLTexture.h"
+#include "WebGLVertexArray.h"
+
+namespace mozilla {
+
+TexTarget
+TexImageTargetToTexTarget(TexImageTarget texImageTarget)
+{
+    switch (texImageTarget.get()) {
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+        return LOCAL_GL_TEXTURE_CUBE_MAP;
+
+    default:
+        return texImageTarget.get();
+    }
+}
+
+JS::Value
+StringValue(JSContext* cx, const char* chars, ErrorResult& rv)
+{
+    JSString* str = JS_NewStringCopyZ(cx, chars);
+    if (!str) {
+        rv.Throw(NS_ERROR_OUT_OF_MEMORY);
+        return JS::NullValue();
+    }
+
+    return JS::StringValue(str);
+}
+
+void
+WebGLContext::GenerateWarning(const char* fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+
+    GenerateWarning(fmt, ap);
+
+    va_end(ap);
+}
+
+void
+WebGLContext::GenerateWarning(const char* fmt, va_list ap)
+{
+    if (!ShouldGenerateWarnings())
+        return;
+
+    mAlreadyGeneratedWarnings++;
+
+    char buf[1024];
+    PR_vsnprintf(buf, 1024, fmt, ap);
+
+    // no need to print to stderr, as JS_ReportWarning takes care of this for us.
+
+    if (!mCanvasElement) {
+        return;
+    }
+
+    dom::AutoJSAPI api;
+    if (!api.Init(mCanvasElement->OwnerDoc()->GetScopeObject())) {
+        return;
+    }
+
+    JSContext* cx = api.cx();
+    JS_ReportWarningASCII(cx, "WebGL: %s", buf);
+    if (!ShouldGenerateWarnings()) {
+        JS_ReportWarningASCII(cx,
+                              "WebGL: No further warnings will be reported for"
+                              " this WebGL context."
+                              " (already reported %d warnings)",
+                              mAlreadyGeneratedWarnings);
+    }
+}
+
+bool
+WebGLContext::ShouldGenerateWarnings() const
+{
+    if (mMaxWarnings == -1)
+        return true;
+
+    return mAlreadyGeneratedWarnings < mMaxWarnings;
+}
+
+void
+WebGLContext::SynthesizeGLError(GLenum err)
+{
+    /* ES2 section 2.5 "GL Errors" states that implementations can have
+     * multiple 'flags', as errors might be caught in different parts of
+     * a distributed implementation.
+     * We're signing up as a distributed implementation here, with
+     * separate flags for WebGL and the underlying GLContext.
+     */
+    if (!mWebGLError)
+        mWebGLError = err;
+}
+
+void
+WebGLContext::SynthesizeGLError(GLenum err, const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(err);
+}
+
+void
+WebGLContext::ErrorInvalidEnum(const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(LOCAL_GL_INVALID_ENUM);
+}
+
+void
+WebGLContext::ErrorInvalidEnumInfo(const char* info, GLenum enumValue)
+{
+    nsCString name;
+    EnumName(enumValue, &name);
+
+    return ErrorInvalidEnum("%s: invalid enum value %s", info, name.BeginReading());
+}
+
+void
+WebGLContext::ErrorInvalidEnumInfo(const char* info, const char* funcName,
+                                   GLenum enumValue)
+{
+    nsCString name;
+    EnumName(enumValue, &name);
+
+    ErrorInvalidEnum("%s: %s: Invalid enum: 0x%04x (%s).", funcName, info,
+                     enumValue, name.BeginReading());
+}
+
+void
+WebGLContext::ErrorInvalidOperation(const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(LOCAL_GL_INVALID_OPERATION);
+}
+
+void
+WebGLContext::ErrorInvalidValue(const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(LOCAL_GL_INVALID_VALUE);
+}
+
+void
+WebGLContext::ErrorInvalidFramebufferOperation(const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION);
+}
+
+void
+WebGLContext::ErrorOutOfMemory(const char* fmt, ...)
+{
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(fmt, va);
+    va_end(va);
+
+    return SynthesizeGLError(LOCAL_GL_OUT_OF_MEMORY);
+}
+
+void
+WebGLContext::ErrorImplementationBug(const char* fmt, ...)
+{
+    const nsPrintfCString warning("Implementation bug, please file at %s! %s",
+                                  "https://bugzilla.mozilla.org/", fmt);
+
+    va_list va;
+    va_start(va, fmt);
+    GenerateWarning(warning.BeginReading(), va);
+    va_end(va);
+
+    MOZ_ASSERT(false, "WebGLContext::ErrorImplementationBug");
+    NS_ERROR("WebGLContext::ErrorImplementationBug");
+    return SynthesizeGLError(LOCAL_GL_OUT_OF_MEMORY);
+}
+
+const char*
+WebGLContext::ErrorName(GLenum error)
+{
+    switch(error) {
+    case LOCAL_GL_INVALID_ENUM:
+        return "INVALID_ENUM";
+    case LOCAL_GL_INVALID_OPERATION:
+        return "INVALID_OPERATION";
+    case LOCAL_GL_INVALID_VALUE:
+        return "INVALID_VALUE";
+    case LOCAL_GL_OUT_OF_MEMORY:
+        return "OUT_OF_MEMORY";
+    case LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION:
+        return "INVALID_FRAMEBUFFER_OPERATION";
+    case LOCAL_GL_NO_ERROR:
+        return "NO_ERROR";
+    default:
+        MOZ_ASSERT(false);
+        return "[unknown WebGL error]";
+    }
+}
+
+// This version is fallible and will return nullptr if unrecognized.
+static const char*
+GetEnumName(GLenum val)
+{
+    switch (val) {
+#define XX(x) case LOCAL_GL_##x: return #x
+        XX(NONE);
+        XX(ALPHA);
+        XX(ATC_RGB);
+        XX(ATC_RGBA_EXPLICIT_ALPHA);
+        XX(ATC_RGBA_INTERPOLATED_ALPHA);
+        XX(COMPRESSED_RGBA_PVRTC_2BPPV1);
+        XX(COMPRESSED_RGBA_PVRTC_4BPPV1);
+        XX(COMPRESSED_RGBA_S3TC_DXT1_EXT);
+        XX(COMPRESSED_RGBA_S3TC_DXT3_EXT);
+        XX(COMPRESSED_RGBA_S3TC_DXT5_EXT);
+        XX(COMPRESSED_RGB_PVRTC_2BPPV1);
+        XX(COMPRESSED_RGB_PVRTC_4BPPV1);
+        XX(COMPRESSED_RGB_S3TC_DXT1_EXT);
+        XX(DEPTH_ATTACHMENT);
+        XX(DEPTH_COMPONENT);
+        XX(DEPTH_COMPONENT16);
+        XX(DEPTH_COMPONENT32);
+        XX(DEPTH_STENCIL);
+        XX(DEPTH24_STENCIL8);
+        XX(DRAW_FRAMEBUFFER);
+        XX(ETC1_RGB8_OES);
+        XX(FLOAT);
+        XX(INT);
+        XX(FRAMEBUFFER);
+        XX(HALF_FLOAT);
+        XX(LUMINANCE);
+        XX(LUMINANCE_ALPHA);
+        XX(READ_FRAMEBUFFER);
+        XX(RGB);
+        XX(RGB16F);
+        XX(RGB32F);
+        XX(RGBA);
+        XX(RGBA16F);
+        XX(RGBA32F);
+        XX(SRGB);
+        XX(SRGB_ALPHA);
+        XX(TEXTURE_2D);
+        XX(TEXTURE_3D);
+        XX(TEXTURE_CUBE_MAP);
+        XX(TEXTURE_CUBE_MAP_NEGATIVE_X);
+        XX(TEXTURE_CUBE_MAP_NEGATIVE_Y);
+        XX(TEXTURE_CUBE_MAP_NEGATIVE_Z);
+        XX(TEXTURE_CUBE_MAP_POSITIVE_X);
+        XX(TEXTURE_CUBE_MAP_POSITIVE_Y);
+        XX(TEXTURE_CUBE_MAP_POSITIVE_Z);
+        XX(UNSIGNED_BYTE);
+        XX(UNSIGNED_INT);
+        XX(UNSIGNED_INT_24_8);
+        XX(UNSIGNED_SHORT);
+        XX(UNSIGNED_SHORT_4_4_4_4);
+        XX(UNSIGNED_SHORT_5_5_5_1);
+        XX(UNSIGNED_SHORT_5_6_5);
+        XX(READ_BUFFER);
+        XX(UNPACK_ROW_LENGTH);
+        XX(UNPACK_SKIP_ROWS);
+        XX(UNPACK_SKIP_PIXELS);
+        XX(PACK_ROW_LENGTH);
+        XX(PACK_SKIP_ROWS);
+        XX(PACK_SKIP_PIXELS);
+        XX(COLOR);
+        XX(DEPTH);
+        XX(STENCIL);
+        XX(RED);
+        XX(RGB8);
+        XX(RGBA8);
+        XX(RGB10_A2);
+        XX(TEXTURE_BINDING_3D);
+        XX(UNPACK_SKIP_IMAGES);
+        XX(UNPACK_IMAGE_HEIGHT);
+        XX(TEXTURE_WRAP_R);
+        XX(MAX_3D_TEXTURE_SIZE);
+        XX(UNSIGNED_INT_2_10_10_10_REV);
+        XX(MAX_ELEMENTS_VERTICES);
+        XX(MAX_ELEMENTS_INDICES);
+        XX(TEXTURE_MIN_LOD);
+        XX(TEXTURE_MAX_LOD);
+        XX(TEXTURE_BASE_LEVEL);
+        XX(TEXTURE_MAX_LEVEL);
+        XX(MIN);
+        XX(MAX);
+        XX(DEPTH_COMPONENT24);
+        XX(MAX_TEXTURE_LOD_BIAS);
+        XX(TEXTURE_COMPARE_MODE);
+        XX(TEXTURE_COMPARE_FUNC);
+        XX(CURRENT_QUERY);
+        XX(QUERY_RESULT);
+        XX(QUERY_RESULT_AVAILABLE);
+        XX(STREAM_READ);
+        XX(STREAM_COPY);
+        XX(STATIC_READ);
+        XX(STATIC_COPY);
+        XX(DYNAMIC_READ);
+        XX(DYNAMIC_COPY);
+        XX(MAX_DRAW_BUFFERS);
+        XX(DRAW_BUFFER0);
+        XX(DRAW_BUFFER1);
+        XX(DRAW_BUFFER2);
+        XX(DRAW_BUFFER3);
+        XX(DRAW_BUFFER4);
+        XX(DRAW_BUFFER5);
+        XX(DRAW_BUFFER6);
+        XX(DRAW_BUFFER7);
+        XX(DRAW_BUFFER8);
+        XX(DRAW_BUFFER9);
+        XX(DRAW_BUFFER10);
+        XX(DRAW_BUFFER11);
+        XX(DRAW_BUFFER12);
+        XX(DRAW_BUFFER13);
+        XX(DRAW_BUFFER14);
+        XX(DRAW_BUFFER15);
+        XX(MAX_FRAGMENT_UNIFORM_COMPONENTS);
+        XX(MAX_VERTEX_UNIFORM_COMPONENTS);
+        XX(SAMPLER_3D);
+        XX(SAMPLER_2D_SHADOW);
+        XX(FRAGMENT_SHADER_DERIVATIVE_HINT);
+        XX(PIXEL_PACK_BUFFER);
+        XX(PIXEL_UNPACK_BUFFER);
+        XX(PIXEL_PACK_BUFFER_BINDING);
+        XX(PIXEL_UNPACK_BUFFER_BINDING);
+        XX(FLOAT_MAT2x3);
+        XX(FLOAT_MAT2x4);
+        XX(FLOAT_MAT3x2);
+        XX(FLOAT_MAT3x4);
+        XX(FLOAT_MAT4x2);
+        XX(FLOAT_MAT4x3);
+        XX(SRGB8);
+        XX(SRGB8_ALPHA8);
+        XX(COMPARE_REF_TO_TEXTURE);
+        XX(VERTEX_ATTRIB_ARRAY_INTEGER);
+        XX(MAX_ARRAY_TEXTURE_LAYERS);
+        XX(MIN_PROGRAM_TEXEL_OFFSET);
+        XX(MAX_PROGRAM_TEXEL_OFFSET);
+        XX(MAX_VARYING_COMPONENTS);
+        XX(TEXTURE_2D_ARRAY);
+        XX(TEXTURE_BINDING_2D_ARRAY);
+        XX(R11F_G11F_B10F);
+        XX(UNSIGNED_INT_10F_11F_11F_REV);
+        XX(RGB9_E5);
+        XX(UNSIGNED_INT_5_9_9_9_REV);
+        XX(TRANSFORM_FEEDBACK_BUFFER_MODE);
+        XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS);
+        XX(TRANSFORM_FEEDBACK_VARYINGS);
+        XX(TRANSFORM_FEEDBACK_BUFFER_START);
+        XX(TRANSFORM_FEEDBACK_BUFFER_SIZE);
+        XX(TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+        XX(RASTERIZER_DISCARD);
+        XX(MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS);
+        XX(MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS);
+        XX(INTERLEAVED_ATTRIBS);
+        XX(SEPARATE_ATTRIBS);
+        XX(TRANSFORM_FEEDBACK_BUFFER);
+        XX(TRANSFORM_FEEDBACK_BUFFER_BINDING);
+        XX(RGBA32UI);
+        XX(RGB32UI);
+        XX(RGBA16UI);
+        XX(RGB16UI);
+        XX(RGBA8UI);
+        XX(RGB8UI);
+        XX(RGBA32I);
+        XX(RGB32I);
+        XX(RGBA16I);
+        XX(RGB16I);
+        XX(RGBA8I);
+        XX(RGB8I);
+        XX(RED_INTEGER);
+        XX(RGB_INTEGER);
+        XX(RGBA_INTEGER);
+        XX(SAMPLER_2D_ARRAY);
+        XX(SAMPLER_2D_ARRAY_SHADOW);
+        XX(SAMPLER_CUBE_SHADOW);
+        XX(UNSIGNED_INT_VEC2);
+        XX(UNSIGNED_INT_VEC3);
+        XX(UNSIGNED_INT_VEC4);
+        XX(INT_SAMPLER_2D);
+        XX(INT_SAMPLER_3D);
+        XX(INT_SAMPLER_CUBE);
+        XX(INT_SAMPLER_2D_ARRAY);
+        XX(UNSIGNED_INT_SAMPLER_2D);
+        XX(UNSIGNED_INT_SAMPLER_3D);
+        XX(UNSIGNED_INT_SAMPLER_CUBE);
+        XX(UNSIGNED_INT_SAMPLER_2D_ARRAY);
+        XX(DEPTH_COMPONENT32F);
+        XX(DEPTH32F_STENCIL8);
+        XX(FLOAT_32_UNSIGNED_INT_24_8_REV);
+        XX(FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING);
+        XX(FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE);
+        XX(FRAMEBUFFER_ATTACHMENT_RED_SIZE);
+        XX(FRAMEBUFFER_ATTACHMENT_GREEN_SIZE);
+        XX(FRAMEBUFFER_ATTACHMENT_BLUE_SIZE);
+        XX(FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE);
+        XX(FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
+        XX(FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
+        XX(FRAMEBUFFER_DEFAULT);
+        XX(DEPTH_STENCIL_ATTACHMENT);
+        XX(UNSIGNED_NORMALIZED);
+        XX(DRAW_FRAMEBUFFER_BINDING);
+        XX(READ_FRAMEBUFFER_BINDING);
+        XX(RENDERBUFFER_SAMPLES);
+        XX(FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER);
+        XX(MAX_COLOR_ATTACHMENTS);
+        XX(COLOR_ATTACHMENT0);
+        XX(COLOR_ATTACHMENT1);
+        XX(COLOR_ATTACHMENT2);
+        XX(COLOR_ATTACHMENT3);
+        XX(COLOR_ATTACHMENT4);
+        XX(COLOR_ATTACHMENT5);
+        XX(COLOR_ATTACHMENT6);
+        XX(COLOR_ATTACHMENT7);
+        XX(COLOR_ATTACHMENT8);
+        XX(COLOR_ATTACHMENT9);
+        XX(COLOR_ATTACHMENT10);
+        XX(COLOR_ATTACHMENT11);
+        XX(COLOR_ATTACHMENT12);
+        XX(COLOR_ATTACHMENT13);
+        XX(COLOR_ATTACHMENT14);
+        XX(COLOR_ATTACHMENT15);
+        XX(FRAMEBUFFER_INCOMPLETE_MULTISAMPLE);
+        XX(MAX_SAMPLES);
+        XX(RG);
+        XX(RG_INTEGER);
+        XX(R8);
+        XX(RG8);
+        XX(R16F);
+        XX(R32F);
+        XX(RG16F);
+        XX(RG32F);
+        XX(R8I);
+        XX(R8UI);
+        XX(R16I);
+        XX(R16UI);
+        XX(R32I);
+        XX(R32UI);
+        XX(RG8I);
+        XX(RG8UI);
+        XX(RG16I);
+        XX(RG16UI);
+        XX(RG32I);
+        XX(RG32UI);
+        XX(VERTEX_ARRAY_BINDING);
+        XX(R8_SNORM);
+        XX(RG8_SNORM);
+        XX(RGB8_SNORM);
+        XX(RGBA8_SNORM);
+        XX(SIGNED_NORMALIZED);
+        XX(PRIMITIVE_RESTART_FIXED_INDEX);
+        XX(COPY_READ_BUFFER);
+        XX(COPY_WRITE_BUFFER);
+        XX(UNIFORM_BUFFER);
+        XX(UNIFORM_BUFFER_BINDING);
+        XX(UNIFORM_BUFFER_START);
+        XX(UNIFORM_BUFFER_SIZE);
+        XX(MAX_VERTEX_UNIFORM_BLOCKS);
+        XX(MAX_FRAGMENT_UNIFORM_BLOCKS);
+        XX(MAX_COMBINED_UNIFORM_BLOCKS);
+        XX(MAX_UNIFORM_BUFFER_BINDINGS);
+        XX(MAX_UNIFORM_BLOCK_SIZE);
+        XX(MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS);
+        XX(MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS);
+        XX(UNIFORM_BUFFER_OFFSET_ALIGNMENT);
+        XX(ACTIVE_UNIFORM_BLOCKS);
+        XX(UNIFORM_TYPE);
+        XX(UNIFORM_SIZE);
+        XX(UNIFORM_BLOCK_INDEX);
+        XX(UNIFORM_OFFSET);
+        XX(UNIFORM_ARRAY_STRIDE);
+        XX(UNIFORM_MATRIX_STRIDE);
+        XX(UNIFORM_IS_ROW_MAJOR);
+        XX(UNIFORM_BLOCK_BINDING);
+        XX(UNIFORM_BLOCK_DATA_SIZE);
+        XX(UNIFORM_BLOCK_ACTIVE_UNIFORMS);
+        XX(UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES);
+        XX(UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER);
+        XX(UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER);
+        XX(MAX_VERTEX_OUTPUT_COMPONENTS);
+        XX(MAX_FRAGMENT_INPUT_COMPONENTS);
+        XX(MAX_SERVER_WAIT_TIMEOUT);
+        XX(OBJECT_TYPE);
+        XX(SYNC_CONDITION);
+        XX(SYNC_STATUS);
+        XX(SYNC_FLAGS);
+        XX(SYNC_FENCE);
+        XX(SYNC_GPU_COMMANDS_COMPLETE);
+        XX(UNSIGNALED);
+        XX(SIGNALED);
+        XX(ALREADY_SIGNALED);
+        XX(TIMEOUT_EXPIRED);
+        XX(CONDITION_SATISFIED);
+        XX(WAIT_FAILED);
+        XX(VERTEX_ATTRIB_ARRAY_DIVISOR);
+        XX(ANY_SAMPLES_PASSED);
+        XX(ANY_SAMPLES_PASSED_CONSERVATIVE);
+        XX(SAMPLER_BINDING);
+        XX(RGB10_A2UI);
+        XX(TEXTURE_SWIZZLE_R);
+        XX(TEXTURE_SWIZZLE_G);
+        XX(TEXTURE_SWIZZLE_B);
+        XX(TEXTURE_SWIZZLE_A);
+        XX(GREEN);
+        XX(BLUE);
+        XX(INT_2_10_10_10_REV);
+        XX(TRANSFORM_FEEDBACK);
+        XX(TRANSFORM_FEEDBACK_PAUSED);
+        XX(TRANSFORM_FEEDBACK_ACTIVE);
+        XX(TRANSFORM_FEEDBACK_BINDING);
+        XX(COMPRESSED_R11_EAC);
+        XX(COMPRESSED_SIGNED_R11_EAC);
+        XX(COMPRESSED_RG11_EAC);
+        XX(COMPRESSED_SIGNED_RG11_EAC);
+        XX(COMPRESSED_RGB8_ETC2);
+        XX(COMPRESSED_SRGB8_ETC2);
+        XX(COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2);
+        XX(COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2);
+        XX(COMPRESSED_RGBA8_ETC2_EAC);
+        XX(COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
+        XX(TEXTURE_IMMUTABLE_FORMAT);
+        XX(MAX_ELEMENT_INDEX);
+        XX(NUM_SAMPLE_COUNTS);
+        XX(TEXTURE_IMMUTABLE_LEVELS);
+#undef XX
+    }
+
+    return nullptr;
+}
+
+/*static*/ void
+WebGLContext::EnumName(GLenum val, nsCString* out_name)
+{
+    const char* name = GetEnumName(val);
+    if (name) {
+        *out_name = name;
+        return;
+    }
+
+    *out_name = nsPrintfCString("<enum 0x%04x>", val);
+}
+
+void
+WebGLContext::ErrorInvalidEnumArg(const char* funcName, const char* argName, GLenum val)
+{
+    nsCString enumName;
+    EnumName(val, &enumName);
+    ErrorInvalidEnum("%s: Bad `%s`: %s", funcName, argName, enumName.BeginReading());
+}
+
+bool
+IsCompressedTextureFormat(GLenum format)
+{
+    switch (format) {
+    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:
+    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:
+    case LOCAL_GL_COMPRESSED_R11_EAC:
+    case LOCAL_GL_COMPRESSED_SIGNED_R11_EAC:
+    case LOCAL_GL_COMPRESSED_RG11_EAC:
+    case LOCAL_GL_COMPRESSED_SIGNED_RG11_EAC:
+    case LOCAL_GL_COMPRESSED_RGB8_ETC2:
+    case LOCAL_GL_COMPRESSED_SRGB8_ETC2:
+    case LOCAL_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+    case LOCAL_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+    case LOCAL_GL_COMPRESSED_RGBA8_ETC2_EAC:
+    case LOCAL_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
+        return true;
+    default:
+        return false;
+    }
+}
+
+
+bool
+IsTextureFormatCompressed(TexInternalFormat format)
+{
+    return IsCompressedTextureFormat(format.get());
+}
+
+GLenum
+WebGLContext::GetAndFlushUnderlyingGLErrors()
+{
+    // Get and clear GL error in ALL cases.
+    GLenum error = gl->fGetError();
+
+    // Only store in mUnderlyingGLError if is hasn't already recorded an
+    // error.
+    if (!mUnderlyingGLError)
+        mUnderlyingGLError = error;
+
+    return error;
+}
+
+#ifdef DEBUG
+// For NaNs, etc.
+static bool
+IsCacheCorrect(float cached, float actual)
+{
+    if (IsNaN(cached)) {
+        // GL is allowed to do anything it wants for NaNs, so if we're shadowing
+        // a NaN, then whatever `actual` is might be correct.
+        return true;
+    }
+
+    return cached == actual;
+}
+
+void
+AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow)
+{
+    GLuint val = 0;
+    gl->GetUIntegerv(pname, &val);
+    if (val != shadow) {
+      printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
+                    pname, shadow, shadow, val, val);
+      MOZ_ASSERT(false, "Bad cached value.");
+    }
+}
+
+void
+AssertMaskedUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint mask,
+                             GLuint shadow)
+{
+    GLuint val = 0;
+    gl->GetUIntegerv(pname, &val);
+
+    const GLuint valMasked = val & mask;
+    const GLuint shadowMasked = shadow & mask;
+
+    if (valMasked != shadowMasked) {
+      printf_stderr("Failed 0x%04x shadow: Cached 0x%x/%u, should be 0x%x/%u.\n",
+                    pname, shadowMasked, shadowMasked, valMasked, valMasked);
+      MOZ_ASSERT(false, "Bad cached value.");
+    }
+}
+#else
+void
+AssertUintParamCorrect(gl::GLContext*, GLenum, GLuint)
+{
+}
+#endif
+
+void
+WebGLContext::AssertCachedBindings()
+{
+#ifdef DEBUG
+    MakeContextCurrent();
+
+    GetAndFlushUnderlyingGLErrors();
+
+    if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::OES_vertex_array_object)) {
+        GLuint bound = mBoundVertexArray ? mBoundVertexArray->GLName() : 0;
+        AssertUintParamCorrect(gl, LOCAL_GL_VERTEX_ARRAY_BINDING, bound);
+    }
+
+    // Framebuffers
+    if (IsWebGL2()) {
+        GLuint bound = mBoundDrawFramebuffer ? mBoundDrawFramebuffer->mGLName
+                                             : 0;
+        AssertUintParamCorrect(gl, LOCAL_GL_DRAW_FRAMEBUFFER_BINDING, bound);
+
+        bound = mBoundReadFramebuffer ? mBoundReadFramebuffer->mGLName : 0;
+        AssertUintParamCorrect(gl, LOCAL_GL_READ_FRAMEBUFFER_BINDING, bound);
+    } else {
+        MOZ_ASSERT(mBoundDrawFramebuffer == mBoundReadFramebuffer);
+        GLuint bound = mBoundDrawFramebuffer ? mBoundDrawFramebuffer->mGLName
+                                             : 0;
+        AssertUintParamCorrect(gl, LOCAL_GL_FRAMEBUFFER_BINDING, bound);
+    }
+
+    GLint stencilBits = 0;
+    if (GetStencilBits(&stencilBits)) { // Depends on current draw framebuffer.
+        const GLuint stencilRefMask = (1 << stencilBits) - 1;
+
+        AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_REF,      stencilRefMask, mStencilRefFront);
+        AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_REF, stencilRefMask, mStencilRefBack);
+    }
+
+    // Program
+    GLuint bound = mCurrentProgram ? mCurrentProgram->mGLName : 0;
+    AssertUintParamCorrect(gl, LOCAL_GL_CURRENT_PROGRAM, bound);
+
+    // Textures
+    GLenum activeTexture = mActiveTexture + LOCAL_GL_TEXTURE0;
+    AssertUintParamCorrect(gl, LOCAL_GL_ACTIVE_TEXTURE, activeTexture);
+
+    WebGLTexture* curTex = ActiveBoundTextureForTarget(LOCAL_GL_TEXTURE_2D);
+    bound = curTex ? curTex->mGLName : 0;
+    AssertUintParamCorrect(gl, LOCAL_GL_TEXTURE_BINDING_2D, bound);
+
+    curTex = ActiveBoundTextureForTarget(LOCAL_GL_TEXTURE_CUBE_MAP);
+    bound = curTex ? curTex->mGLName : 0;
+    AssertUintParamCorrect(gl, LOCAL_GL_TEXTURE_BINDING_CUBE_MAP, bound);
+
+    // Buffers
+    bound = mBoundArrayBuffer ? mBoundArrayBuffer->mGLName : 0;
+    AssertUintParamCorrect(gl, LOCAL_GL_ARRAY_BUFFER_BINDING, bound);
+
+    MOZ_ASSERT(mBoundVertexArray);
+    WebGLBuffer* curBuff = mBoundVertexArray->mElementArrayBuffer;
+    bound = curBuff ? curBuff->mGLName : 0;
+    AssertUintParamCorrect(gl, LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING, bound);
+
+    MOZ_ASSERT(!GetAndFlushUnderlyingGLErrors());
+#endif
+
+    // We do not check the renderbuffer binding, because we never rely on it matching.
+}
+
+void
+WebGLContext::AssertCachedGlobalState()
+{
+#ifdef DEBUG
+    MakeContextCurrent();
+
+    GetAndFlushUnderlyingGLErrors();
+
+    ////////////////
+
+    // Draw state
+    MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_DEPTH_TEST) == mDepthTestEnabled);
+    MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_DITHER) == mDitherEnabled);
+    MOZ_ASSERT_IF(IsWebGL2(),
+                  gl->fIsEnabled(LOCAL_GL_RASTERIZER_DISCARD) == mRasterizerDiscardEnabled);
+    MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_SCISSOR_TEST) == mScissorTestEnabled);
+    MOZ_ASSERT(gl->fIsEnabled(LOCAL_GL_STENCIL_TEST) == mStencilTestEnabled);
+
+    realGLboolean colorWriteMask[4] = {0, 0, 0, 0};
+    gl->fGetBooleanv(LOCAL_GL_COLOR_WRITEMASK, colorWriteMask);
+    MOZ_ASSERT(colorWriteMask[0] == mColorWriteMask[0] &&
+               colorWriteMask[1] == mColorWriteMask[1] &&
+               colorWriteMask[2] == mColorWriteMask[2] &&
+               colorWriteMask[3] == mColorWriteMask[3]);
+
+    GLfloat colorClearValue[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+    gl->fGetFloatv(LOCAL_GL_COLOR_CLEAR_VALUE, colorClearValue);
+    MOZ_ASSERT(IsCacheCorrect(mColorClearValue[0], colorClearValue[0]) &&
+               IsCacheCorrect(mColorClearValue[1], colorClearValue[1]) &&
+               IsCacheCorrect(mColorClearValue[2], colorClearValue[2]) &&
+               IsCacheCorrect(mColorClearValue[3], colorClearValue[3]));
+
+    realGLboolean depthWriteMask = 0;
+    gl->fGetBooleanv(LOCAL_GL_DEPTH_WRITEMASK, &depthWriteMask);
+    MOZ_ASSERT(depthWriteMask == mDepthWriteMask);
+
+    GLfloat depthClearValue = 0.0f;
+    gl->fGetFloatv(LOCAL_GL_DEPTH_CLEAR_VALUE, &depthClearValue);
+    MOZ_ASSERT(IsCacheCorrect(mDepthClearValue, depthClearValue));
+
+    AssertUintParamCorrect(gl, LOCAL_GL_STENCIL_CLEAR_VALUE, mStencilClearValue);
+
+    // GLES 3.0.4, $4.1.4, p177:
+    //   [...] the front and back stencil mask are both set to the value `2^s - 1`, where
+    //   `s` is greater than or equal to the number of bits in the deepest stencil buffer
+    //   supported by the GL implementation.
+    const int maxStencilBits = 8;
+    const GLuint maxStencilBitsMask = (1 << maxStencilBits) - 1;
+    AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_VALUE_MASK,      maxStencilBitsMask, mStencilValueMaskFront);
+    AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_VALUE_MASK, maxStencilBitsMask, mStencilValueMaskBack);
+
+    AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_WRITEMASK,       maxStencilBitsMask, mStencilWriteMaskFront);
+    AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_BACK_WRITEMASK,  maxStencilBitsMask, mStencilWriteMaskBack);
+
+    // Viewport
+    GLint int4[4] = {0, 0, 0, 0};
+    gl->fGetIntegerv(LOCAL_GL_VIEWPORT, int4);
+    MOZ_ASSERT(int4[0] == mViewportX &&
+               int4[1] == mViewportY &&
+               int4[2] == mViewportWidth &&
+               int4[3] == mViewportHeight);
+
+    AssertUintParamCorrect(gl, LOCAL_GL_PACK_ALIGNMENT, mPixelStore_PackAlignment);
+    AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_ALIGNMENT, mPixelStore_UnpackAlignment);
+
+    if (IsWebGL2()) {
+        AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_IMAGE_HEIGHT, mPixelStore_UnpackImageHeight);
+        AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_SKIP_IMAGES , mPixelStore_UnpackSkipImages);
+        AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_ROW_LENGTH  , mPixelStore_UnpackRowLength);
+        AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_SKIP_ROWS   , mPixelStore_UnpackSkipRows);
+        AssertUintParamCorrect(gl, LOCAL_GL_UNPACK_SKIP_PIXELS , mPixelStore_UnpackSkipPixels);
+        AssertUintParamCorrect(gl, LOCAL_GL_PACK_ROW_LENGTH    , mPixelStore_PackRowLength);
+        AssertUintParamCorrect(gl, LOCAL_GL_PACK_SKIP_ROWS     , mPixelStore_PackSkipRows);
+        AssertUintParamCorrect(gl, LOCAL_GL_PACK_SKIP_PIXELS   , mPixelStore_PackSkipPixels);
+    }
+
+    MOZ_ASSERT(!GetAndFlushUnderlyingGLErrors());
+#endif
+}
+
+const char*
+InfoFrom(WebGLTexImageFunc func, WebGLTexDimensions dims)
+{
+    switch (dims) {
+    case WebGLTexDimensions::Tex2D:
+        switch (func) {
+        case WebGLTexImageFunc::TexImage:        return "texImage2D";
+        case WebGLTexImageFunc::TexSubImage:     return "texSubImage2D";
+        case WebGLTexImageFunc::CopyTexImage:    return "copyTexImage2D";
+        case WebGLTexImageFunc::CopyTexSubImage: return "copyTexSubImage2D";
+        case WebGLTexImageFunc::CompTexImage:    return "compressedTexImage2D";
+        case WebGLTexImageFunc::CompTexSubImage: return "compressedTexSubImage2D";
+        default:
+            MOZ_CRASH("GFX: invalid 2D TexDimensions");
+        }
+    case WebGLTexDimensions::Tex3D:
+        switch (func) {
+        case WebGLTexImageFunc::TexImage:        return "texImage3D";
+        case WebGLTexImageFunc::TexSubImage:     return "texSubImage3D";
+        case WebGLTexImageFunc::CopyTexSubImage: return "copyTexSubImage3D";
+        case WebGLTexImageFunc::CompTexSubImage: return "compressedTexSubImage3D";
+        default:
+            MOZ_CRASH("GFX: invalid 3D TexDimensions");
+        }
+    default:
+        MOZ_CRASH("GFX: invalid TexDimensions");
+    }
+}
+
+} // namespace mozilla