/* -*- 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/gfx/Logging.h"

#include "mozilla/Preferences.h"

#include "mozilla/Sprintf.h"

#include "nsIScriptSecurityManager.h"

#include "nsIVariant.h"

#include "nsPrintfCString.h"

#include "nsServiceManagerUtils.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, ...) const

{

    va_list ap;

    va_start(ap, fmt);

    GenerateWarning(fmt, ap);

    va_end(ap);

}

void

WebGLContext::GenerateWarning(const char* fmt, va_list ap) const

{

    if (!ShouldGenerateWarnings())

        return;

    mAlreadyGeneratedWarnings++;

    char buf[1024];

    VsprintfLiteral(buf, 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();

    const auto funcName = FuncName();

    JS_ReportWarningASCII(cx, "WebGL warning: %s: %s", funcName, 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::GeneratePerfWarning(const char* fmt, ...) const

{

    if (!ShouldGeneratePerfWarnings())

        return;

    if (!mCanvasElement)

        return;

    dom::AutoJSAPI api;

    if (!api.Init(mCanvasElement->OwnerDoc()->GetScopeObject()))

        return;

    JSContext* cx = api.cx();

    ////

    va_list ap;

    va_start(ap, fmt);

    char buf[1024];

    VsprintfLiteral(buf, fmt, ap);

    va_end(ap);

    ////

    const auto funcName = FuncName();

    JS_ReportWarningASCII(cx, "WebGL perf warning: %s: %s", funcName, buf);

    mNumPerfWarnings++;

    if (!ShouldGeneratePerfWarnings()) {

        JS_ReportWarningASCII(cx,

                              "WebGL: After reporting %u, no further perf warnings will"

                              " be reported for this WebGL context.",

                              uint32_t(mNumPerfWarnings));

    }

}

void

WebGLContext::SynthesizeGLError(GLenum err) const

{

    /* 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, ...) const

{

    va_list va;

    va_start(va, fmt);

    GenerateWarning(fmt, va);

    va_end(va);

    return SynthesizeGLError(err);

}

void

WebGLContext::ErrorInvalidEnum(const char* fmt, ...) const

{

    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) const

{

    nsCString name;

    EnumName(enumValue, &name);

    return ErrorInvalidEnum("%s: invalid enum value %s", info, name.BeginReading());

}

void

WebGLContext::ErrorInvalidOperation(const char* fmt, ...) const

{

    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, ...) const

{

    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, ...) const

{

    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, ...) const

{

    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

{

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

}

/*static*/ 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.

const char*

GetEnumName(const GLenum val, const char* const defaultRet)

{

    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 defaultRet;

}

/*static*/ void

WebGLContext::EnumName(GLenum val, nsCString* out_name)

{

    const char* name = GetEnumName(val, nullptr);

    if (name) {

        *out_name = name;

        return;

    }

    *out_name = nsPrintfCString("<enum 0x%04x>", val);

}

std::string

EnumString(const GLenum val)

{

    const char* name = GetEnumName(val, nullptr);

    if (name) {

        return name;

    }

    const nsPrintfCString hex("<enum 0x%04x>", val);

    return hex.BeginReading();

}

void

WebGLContext::ErrorInvalidEnumArg(const char* argName, GLenum val) const

{

    nsCString enumName;

    EnumName(val, &enumName);

    ErrorInvalidEnum("Bad `%s`: %s", 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_COMPRESSED_SRGB_S3TC_DXT1_EXT:

    case LOCAL_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:

    case LOCAL_GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:

    case LOCAL_GL_COMPRESSED_SRGB_ALPHA_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() const

{

    // 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() const

{

#ifdef DEBUG

    GetAndFlushUnderlyingGLErrors();

    if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::OES_vertex_array_object)) {

        GLuint bound = mBoundVertexArray ? mBoundVertexArray->GLName() : 0;

        AssertUintParamCorrect(gl, LOCAL_GL_VERTEX_ARRAY_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() const

{

#ifdef DEBUG

    GetAndFlushUnderlyingGLErrors();

    ////////////////

    // Draw state

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

    // Cannot trivially check COLOR_CLEAR_VALUE, since in old GL versions glGet may clamp

    // based on whether the current framebuffer is floating-point or not.

    // This also means COLOR_CLEAR_VALUE save+restore is dangerous!

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

    const int maxStencilBits = 8;

    const GLuint maxStencilBitsMask = (1 << maxStencilBits) - 1;

    AssertMaskedUintParamCorrect(gl, LOCAL_GL_STENCIL_CLEAR_VALUE, maxStencilBitsMask, 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.

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