Add m-esr52 at 52.6.0

1 files changed, 732 insertions, 0 deletions

diff --git a/dom/canvas/WebGLContextState.cpp b/dom/canvas/WebGLContextState.cpp
new file mode 100644
index 000000000..e0234f5c6
--- /dev/null
+++ b/dom/canvas/WebGLContextState.cpp
@@ -0,0 +1,732 @@
+/* -*- Mode: C++; tab-width: 4; 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 "WebGLContext.h"
+
+#include "GLContext.h"
+#include "GLScreenBuffer.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "mozilla/Preferences.h"
+#include "nsString.h"
+#include "WebGLBuffer.h"
+#include "WebGLContextUtils.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLProgram.h"
+#include "WebGLRenderbuffer.h"
+#include "WebGLShader.h"
+#include "WebGLTexture.h"
+#include "WebGLVertexArray.h"
+
+namespace mozilla {
+
+void
+WebGLContext::Disable(GLenum cap)
+{
+    if (IsContextLost())
+        return;
+
+    if (!ValidateCapabilityEnum(cap, "disable"))
+        return;
+
+    realGLboolean* trackingSlot = GetStateTrackingSlot(cap);
+
+    if (trackingSlot)
+    {
+        *trackingSlot = 0;
+    }
+
+    MakeContextCurrent();
+    gl->fDisable(cap);
+}
+
+void
+WebGLContext::Enable(GLenum cap)
+{
+    if (IsContextLost())
+        return;
+
+    if (!ValidateCapabilityEnum(cap, "enable"))
+        return;
+
+    realGLboolean* trackingSlot = GetStateTrackingSlot(cap);
+
+    if (trackingSlot)
+    {
+        *trackingSlot = 1;
+    }
+
+    MakeContextCurrent();
+    gl->fEnable(cap);
+}
+
+static JS::Value
+StringValue(JSContext* cx, const nsAString& str, ErrorResult& rv)
+{
+    JSString* jsStr = JS_NewUCStringCopyN(cx, str.BeginReading(), str.Length());
+    if (!jsStr) {
+        rv.Throw(NS_ERROR_OUT_OF_MEMORY);
+        return JS::NullValue();
+    }
+
+    return JS::StringValue(jsStr);
+}
+
+bool
+WebGLContext::GetStencilBits(GLint* const out_stencilBits)
+{
+    *out_stencilBits = 0;
+    if (mBoundDrawFramebuffer) {
+        if (mBoundDrawFramebuffer->StencilAttachment().IsDefined() &&
+            mBoundDrawFramebuffer->DepthStencilAttachment().IsDefined())
+        {
+            // Error, we don't know which stencil buffer's bits to use
+            ErrorInvalidFramebufferOperation("getParameter: framebuffer has two stencil buffers bound");
+            return false;
+        }
+
+        if (mBoundDrawFramebuffer->StencilAttachment().IsDefined() ||
+            mBoundDrawFramebuffer->DepthStencilAttachment().IsDefined())
+        {
+            *out_stencilBits = 8;
+        }
+    } else if (mOptions.stencil) {
+        *out_stencilBits = 8;
+    }
+
+    return true;
+}
+
+bool
+WebGLContext::GetChannelBits(const char* funcName, GLenum pname, GLint* const out_val)
+{
+    if (mBoundDrawFramebuffer) {
+        if (!mBoundDrawFramebuffer->ValidateAndInitAttachments(funcName))
+            return false;
+    }
+
+    if (!mBoundDrawFramebuffer) {
+        switch (pname) {
+        case LOCAL_GL_RED_BITS:
+        case LOCAL_GL_GREEN_BITS:
+        case LOCAL_GL_BLUE_BITS:
+            *out_val = 8;
+            break;
+
+        case LOCAL_GL_ALPHA_BITS:
+            *out_val = (mOptions.alpha ? 8 : 0);
+            break;
+
+        case LOCAL_GL_DEPTH_BITS:
+            if (mOptions.depth) {
+                *out_val = gl->Screen()->DepthBits();
+            } else {
+                *out_val = 0;
+            }
+            break;
+
+        case LOCAL_GL_STENCIL_BITS:
+            *out_val = (mOptions.stencil ? 8 : 0);
+            break;
+
+        default:
+            MOZ_CRASH("GFX: bad pname");
+        }
+        return true;
+    }
+
+    if (!gl->IsCoreProfile()) {
+        gl->fGetIntegerv(pname, out_val);
+        return true;
+    }
+
+    GLenum fbAttachment = 0;
+    GLenum fbPName = 0;
+    switch (pname) {
+    case LOCAL_GL_RED_BITS:
+        fbAttachment = LOCAL_GL_COLOR_ATTACHMENT0;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE;
+        break;
+
+    case LOCAL_GL_GREEN_BITS:
+        fbAttachment = LOCAL_GL_COLOR_ATTACHMENT0;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE;
+        break;
+
+    case LOCAL_GL_BLUE_BITS:
+        fbAttachment = LOCAL_GL_COLOR_ATTACHMENT0;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE;
+        break;
+
+    case LOCAL_GL_ALPHA_BITS:
+        fbAttachment = LOCAL_GL_COLOR_ATTACHMENT0;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE;
+        break;
+
+    case LOCAL_GL_DEPTH_BITS:
+        fbAttachment = LOCAL_GL_DEPTH_ATTACHMENT;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE;
+        break;
+
+    case LOCAL_GL_STENCIL_BITS:
+        fbAttachment = LOCAL_GL_STENCIL_ATTACHMENT;
+        fbPName = LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE;
+        break;
+
+    default:
+        MOZ_CRASH("GFX: bad pname");
+    }
+
+    gl->fGetFramebufferAttachmentParameteriv(LOCAL_GL_DRAW_FRAMEBUFFER, fbAttachment,
+                                             fbPName, out_val);
+    return true;
+}
+
+JS::Value
+WebGLContext::GetParameter(JSContext* cx, GLenum pname, ErrorResult& rv)
+{
+    const char funcName[] = "getParameter";
+
+    if (IsContextLost())
+        return JS::NullValue();
+
+    MakeContextCurrent();
+
+    if (MinCapabilityMode()) {
+        switch(pname) {
+            ////////////////////////////
+            // Single-value params
+
+            // int
+            case LOCAL_GL_MAX_VERTEX_ATTRIBS:
+                return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_ATTRIBS);
+
+            case LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
+                return JS::Int32Value(MINVALUE_GL_MAX_FRAGMENT_UNIFORM_VECTORS);
+
+            case LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS:
+                return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_UNIFORM_VECTORS);
+
+            case LOCAL_GL_MAX_VARYING_VECTORS:
+                return JS::Int32Value(MINVALUE_GL_MAX_VARYING_VECTORS);
+
+            case LOCAL_GL_MAX_TEXTURE_SIZE:
+                return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_SIZE);
+
+            case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+                return JS::Int32Value(MINVALUE_GL_MAX_CUBE_MAP_TEXTURE_SIZE);
+
+            case LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS:
+                return JS::Int32Value(MINVALUE_GL_MAX_TEXTURE_IMAGE_UNITS);
+
+            case LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+                return JS::Int32Value(MINVALUE_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+
+            case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
+                return JS::Int32Value(MINVALUE_GL_MAX_RENDERBUFFER_SIZE);
+
+            default:
+                // Return the real value; we're not overriding this one
+                break;
+        }
+    }
+
+    if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers)) {
+        if (pname == LOCAL_GL_MAX_COLOR_ATTACHMENTS) {
+            return JS::Int32Value(mImplMaxColorAttachments);
+
+        } else if (pname == LOCAL_GL_MAX_DRAW_BUFFERS) {
+            return JS::Int32Value(mImplMaxDrawBuffers);
+
+        } else if (pname >= LOCAL_GL_DRAW_BUFFER0 &&
+                   pname < GLenum(LOCAL_GL_DRAW_BUFFER0 + mImplMaxDrawBuffers))
+        {
+            GLint ret = LOCAL_GL_NONE;
+            if (!mBoundDrawFramebuffer) {
+                if (pname == LOCAL_GL_DRAW_BUFFER0) {
+                    ret = gl->Screen()->GetDrawBufferMode();
+                }
+            } else {
+                gl->fGetIntegerv(pname, &ret);
+            }
+            return JS::Int32Value(ret);
+        }
+    }
+
+    if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::OES_vertex_array_object)) {
+        if (pname == LOCAL_GL_VERTEX_ARRAY_BINDING) {
+            WebGLVertexArray* vao =
+                (mBoundVertexArray != mDefaultVertexArray) ? mBoundVertexArray.get() : nullptr;
+            return WebGLObjectAsJSValue(cx, vao, rv);
+        }
+    }
+
+    if (IsExtensionEnabled(WebGLExtensionID::EXT_disjoint_timer_query)) {
+        switch (pname) {
+        case LOCAL_GL_TIMESTAMP_EXT:
+            {
+                uint64_t val = 0;
+                if (Has64BitTimestamps()) {
+                    gl->fGetInteger64v(pname, (GLint64*)&val);
+                } else {
+                    gl->fGetIntegerv(pname, (GLint*)&val);
+                }
+                // TODO: JS doesn't support 64-bit integers. Be lossy and
+                // cast to double (53 bits)
+                return JS::NumberValue(val);
+            }
+
+        case LOCAL_GL_GPU_DISJOINT_EXT:
+            {
+                realGLboolean val = false; // Not disjoint by default.
+                if (gl->IsExtensionSupported(gl::GLContext::EXT_disjoint_timer_query)) {
+                    gl->fGetBooleanv(pname, &val);
+                }
+                return JS::BooleanValue(val);
+            }
+
+        default:
+            break;
+        }
+    }
+
+    // Privileged string params exposed by WEBGL_debug_renderer_info.
+    // The privilege check is done in WebGLContext::IsExtensionSupported.
+    // So here we just have to check that the extension is enabled.
+    if (IsExtensionEnabled(WebGLExtensionID::WEBGL_debug_renderer_info)) {
+        switch (pname) {
+        case UNMASKED_VENDOR_WEBGL:
+        case UNMASKED_RENDERER_WEBGL:
+            {
+                const char* overridePref = nullptr;
+                GLenum driverEnum = LOCAL_GL_NONE;
+
+                switch (pname) {
+                case UNMASKED_RENDERER_WEBGL:
+                    overridePref = "webgl.renderer-string-override";
+                    driverEnum = LOCAL_GL_RENDERER;
+                    break;
+                case UNMASKED_VENDOR_WEBGL:
+                    overridePref = "webgl.vendor-string-override";
+                    driverEnum = LOCAL_GL_VENDOR;
+                    break;
+                default:
+                    MOZ_CRASH("GFX: bad `pname`");
+                }
+
+                bool hasRetVal = false;
+
+                nsAutoString ret;
+                if (overridePref) {
+                    nsresult res = Preferences::GetString(overridePref, &ret);
+                    if (NS_SUCCEEDED(res) && ret.Length() > 0)
+                        hasRetVal = true;
+                }
+
+                if (!hasRetVal) {
+                    const char* chars = reinterpret_cast<const char*>(gl->fGetString(driverEnum));
+                    ret = NS_ConvertASCIItoUTF16(chars);
+                    hasRetVal = true;
+                }
+
+                return StringValue(cx, ret, rv);
+            }
+        }
+    }
+
+    if (IsWebGL2() || IsExtensionEnabled(WebGLExtensionID::OES_standard_derivatives)) {
+        if (pname == LOCAL_GL_FRAGMENT_SHADER_DERIVATIVE_HINT) {
+            GLint i = 0;
+            gl->fGetIntegerv(pname, &i);
+            return JS::Int32Value(i);
+        }
+    }
+
+    if (IsExtensionEnabled(WebGLExtensionID::EXT_texture_filter_anisotropic)) {
+        if (pname == LOCAL_GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT) {
+            GLfloat f = 0.f;
+            gl->fGetFloatv(pname, &f);
+            return JS::NumberValue(f);
+        }
+    }
+
+    switch (pname) {
+        //
+        // String params
+        //
+        case LOCAL_GL_VENDOR:
+        case LOCAL_GL_RENDERER:
+            return StringValue(cx, "Mozilla", rv);
+        case LOCAL_GL_VERSION:
+            return StringValue(cx, "WebGL 1.0", rv);
+        case LOCAL_GL_SHADING_LANGUAGE_VERSION:
+            return StringValue(cx, "WebGL GLSL ES 1.0", rv);
+
+        ////////////////////////////////
+        // Single-value params
+
+        // unsigned int
+        case LOCAL_GL_CULL_FACE_MODE:
+        case LOCAL_GL_FRONT_FACE:
+        case LOCAL_GL_ACTIVE_TEXTURE:
+        case LOCAL_GL_STENCIL_FUNC:
+        case LOCAL_GL_STENCIL_FAIL:
+        case LOCAL_GL_STENCIL_PASS_DEPTH_FAIL:
+        case LOCAL_GL_STENCIL_PASS_DEPTH_PASS:
+        case LOCAL_GL_STENCIL_BACK_FUNC:
+        case LOCAL_GL_STENCIL_BACK_FAIL:
+        case LOCAL_GL_STENCIL_BACK_PASS_DEPTH_FAIL:
+        case LOCAL_GL_STENCIL_BACK_PASS_DEPTH_PASS:
+        case LOCAL_GL_DEPTH_FUNC:
+        case LOCAL_GL_BLEND_SRC_RGB:
+        case LOCAL_GL_BLEND_SRC_ALPHA:
+        case LOCAL_GL_BLEND_DST_RGB:
+        case LOCAL_GL_BLEND_DST_ALPHA:
+        case LOCAL_GL_BLEND_EQUATION_RGB:
+        case LOCAL_GL_BLEND_EQUATION_ALPHA: {
+            GLint i = 0;
+            gl->fGetIntegerv(pname, &i);
+            return JS::NumberValue(uint32_t(i));
+        }
+
+        case LOCAL_GL_GENERATE_MIPMAP_HINT:
+            return JS::NumberValue(mGenerateMipmapHint);
+
+        case LOCAL_GL_IMPLEMENTATION_COLOR_READ_FORMAT:
+        case LOCAL_GL_IMPLEMENTATION_COLOR_READ_TYPE: {
+            const webgl::FormatUsageInfo* usage;
+            uint32_t width, height;
+            if (!ValidateCurFBForRead(funcName, &usage, &width, &height))
+                return JS::NullValue();
+
+            const auto implPI = ValidImplementationColorReadPI(usage);
+
+            GLenum ret;
+            if (pname == LOCAL_GL_IMPLEMENTATION_COLOR_READ_FORMAT) {
+                ret = implPI.format;
+            } else {
+                ret = implPI.type;
+            }
+            return JS::NumberValue(uint32_t(ret));
+        }
+
+        // int
+        case LOCAL_GL_STENCIL_REF:
+        case LOCAL_GL_STENCIL_BACK_REF: {
+            GLint stencilBits = 0;
+            if (!GetStencilBits(&stencilBits))
+                return JS::NullValue();
+
+            // Assuming stencils have 8 bits
+            const GLint stencilMask = (1 << stencilBits) - 1;
+
+            GLint refValue = 0;
+            gl->fGetIntegerv(pname, &refValue);
+
+            return JS::Int32Value(refValue & stencilMask);
+        }
+
+        case LOCAL_GL_STENCIL_CLEAR_VALUE:
+        case LOCAL_GL_UNPACK_ALIGNMENT:
+        case LOCAL_GL_PACK_ALIGNMENT:
+        case LOCAL_GL_SUBPIXEL_BITS:
+        case LOCAL_GL_SAMPLE_BUFFERS:
+        case LOCAL_GL_SAMPLES:
+        case LOCAL_GL_MAX_VERTEX_ATTRIBS:
+        case LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+        case LOCAL_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+        case LOCAL_GL_MAX_TEXTURE_IMAGE_UNITS: {
+            GLint i = 0;
+            gl->fGetIntegerv(pname, &i);
+            return JS::Int32Value(i);
+        }
+
+        case LOCAL_GL_RED_BITS:
+        case LOCAL_GL_GREEN_BITS:
+        case LOCAL_GL_BLUE_BITS:
+        case LOCAL_GL_ALPHA_BITS:
+        case LOCAL_GL_DEPTH_BITS:
+        case LOCAL_GL_STENCIL_BITS: {
+            // Deprecated and removed in GL Core profiles, so special handling required.
+            GLint val;
+            if (!GetChannelBits(funcName, pname, &val))
+                return JS::NullValue();
+
+            return JS::Int32Value(val);
+        }
+
+        case LOCAL_GL_MAX_TEXTURE_SIZE:
+            return JS::Int32Value(mImplMaxTextureSize);
+
+        case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+            return JS::Int32Value(mImplMaxCubeMapTextureSize);
+
+        case LOCAL_GL_MAX_RENDERBUFFER_SIZE:
+            return JS::Int32Value(mImplMaxRenderbufferSize);
+
+        case LOCAL_GL_MAX_VERTEX_UNIFORM_VECTORS:
+            return JS::Int32Value(mGLMaxVertexUniformVectors);
+
+        case LOCAL_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
+            return JS::Int32Value(mGLMaxFragmentUniformVectors);
+
+        case LOCAL_GL_MAX_VARYING_VECTORS:
+            return JS::Int32Value(mGLMaxVaryingVectors);
+
+        case LOCAL_GL_COMPRESSED_TEXTURE_FORMATS: {
+            uint32_t length = mCompressedTextureFormats.Length();
+            JSObject* obj = dom::Uint32Array::Create(cx, this, length,
+                                                     mCompressedTextureFormats.Elements());
+            if (!obj) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return JS::ObjectOrNullValue(obj);
+        }
+
+        // unsigned int. here we may have to return very large values like 2^32-1 that can't be represented as
+        // javascript integer values. We just return them as doubles and javascript doesn't care.
+        case LOCAL_GL_STENCIL_BACK_VALUE_MASK:
+            return JS::DoubleValue(mStencilValueMaskBack); // pass as FP value to allow large values such as 2^32-1.
+
+        case LOCAL_GL_STENCIL_BACK_WRITEMASK:
+            return JS::DoubleValue(mStencilWriteMaskBack);
+
+        case LOCAL_GL_STENCIL_VALUE_MASK:
+            return JS::DoubleValue(mStencilValueMaskFront);
+
+        case LOCAL_GL_STENCIL_WRITEMASK:
+            return JS::DoubleValue(mStencilWriteMaskFront);
+
+        // float
+        case LOCAL_GL_LINE_WIDTH:
+            return JS::DoubleValue(mLineWidth);
+
+        case LOCAL_GL_DEPTH_CLEAR_VALUE:
+        case LOCAL_GL_POLYGON_OFFSET_FACTOR:
+        case LOCAL_GL_POLYGON_OFFSET_UNITS:
+        case LOCAL_GL_SAMPLE_COVERAGE_VALUE: {
+            GLfloat f = 0.f;
+            gl->fGetFloatv(pname, &f);
+            return JS::DoubleValue(f);
+        }
+
+        // bool
+        case LOCAL_GL_BLEND:
+        case LOCAL_GL_DEPTH_TEST:
+        case LOCAL_GL_STENCIL_TEST:
+        case LOCAL_GL_CULL_FACE:
+        case LOCAL_GL_DITHER:
+        case LOCAL_GL_POLYGON_OFFSET_FILL:
+        case LOCAL_GL_SCISSOR_TEST:
+        case LOCAL_GL_SAMPLE_COVERAGE_INVERT:
+        case LOCAL_GL_DEPTH_WRITEMASK: {
+            realGLboolean b = 0;
+            gl->fGetBooleanv(pname, &b);
+            return JS::BooleanValue(bool(b));
+        }
+
+        // bool, WebGL-specific
+        case UNPACK_FLIP_Y_WEBGL:
+            return JS::BooleanValue(mPixelStore_FlipY);
+        case UNPACK_PREMULTIPLY_ALPHA_WEBGL:
+            return JS::BooleanValue(mPixelStore_PremultiplyAlpha);
+
+        // uint, WebGL-specific
+        case UNPACK_COLORSPACE_CONVERSION_WEBGL:
+            return JS::NumberValue(uint32_t(mPixelStore_ColorspaceConversion));
+
+        ////////////////////////////////
+        // Complex values
+
+        // 2 floats
+        case LOCAL_GL_DEPTH_RANGE:
+        case LOCAL_GL_ALIASED_POINT_SIZE_RANGE:
+        case LOCAL_GL_ALIASED_LINE_WIDTH_RANGE: {
+            GLenum driverPName = pname;
+            if (gl->IsCoreProfile() &&
+                driverPName == LOCAL_GL_ALIASED_POINT_SIZE_RANGE)
+            {
+                driverPName = LOCAL_GL_POINT_SIZE_RANGE;
+            }
+
+            GLfloat fv[2] = { 0 };
+            gl->fGetFloatv(driverPName, fv);
+            JSObject* obj = dom::Float32Array::Create(cx, this, 2, fv);
+            if (!obj) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return JS::ObjectOrNullValue(obj);
+        }
+
+        // 4 floats
+        case LOCAL_GL_COLOR_CLEAR_VALUE:
+        case LOCAL_GL_BLEND_COLOR: {
+            GLfloat fv[4] = { 0 };
+            gl->fGetFloatv(pname, fv);
+            JSObject* obj = dom::Float32Array::Create(cx, this, 4, fv);
+            if (!obj) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return JS::ObjectOrNullValue(obj);
+        }
+
+        // 2 ints
+        case LOCAL_GL_MAX_VIEWPORT_DIMS: {
+            GLint iv[2] = { 0 };
+            gl->fGetIntegerv(pname, iv);
+            JSObject* obj = dom::Int32Array::Create(cx, this, 2, iv);
+            if (!obj) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return JS::ObjectOrNullValue(obj);
+        }
+
+        // 4 ints
+        case LOCAL_GL_SCISSOR_BOX:
+        case LOCAL_GL_VIEWPORT: {
+            GLint iv[4] = { 0 };
+            gl->fGetIntegerv(pname, iv);
+            JSObject* obj = dom::Int32Array::Create(cx, this, 4, iv);
+            if (!obj) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return JS::ObjectOrNullValue(obj);
+        }
+
+        // 4 bools
+        case LOCAL_GL_COLOR_WRITEMASK: {
+            realGLboolean gl_bv[4] = { 0 };
+            gl->fGetBooleanv(pname, gl_bv);
+            bool vals[4] = { bool(gl_bv[0]), bool(gl_bv[1]),
+                             bool(gl_bv[2]), bool(gl_bv[3]) };
+            JS::Rooted<JS::Value> arr(cx);
+            if (!dom::ToJSValue(cx, vals, &arr)) {
+                rv = NS_ERROR_OUT_OF_MEMORY;
+            }
+            return arr;
+        }
+
+        case LOCAL_GL_ARRAY_BUFFER_BINDING: {
+            return WebGLObjectAsJSValue(cx, mBoundArrayBuffer.get(), rv);
+        }
+
+        case LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING: {
+            return WebGLObjectAsJSValue(cx, mBoundVertexArray->mElementArrayBuffer.get(), rv);
+        }
+
+        case LOCAL_GL_RENDERBUFFER_BINDING: {
+            return WebGLObjectAsJSValue(cx, mBoundRenderbuffer.get(), rv);
+        }
+
+        // DRAW_FRAMEBUFFER_BINDING is the same as FRAMEBUFFER_BINDING.
+        case LOCAL_GL_FRAMEBUFFER_BINDING: {
+            return WebGLObjectAsJSValue(cx, mBoundDrawFramebuffer.get(), rv);
+        }
+
+        case LOCAL_GL_CURRENT_PROGRAM: {
+            return WebGLObjectAsJSValue(cx, mCurrentProgram.get(), rv);
+        }
+
+        case LOCAL_GL_TEXTURE_BINDING_2D: {
+            return WebGLObjectAsJSValue(cx, mBound2DTextures[mActiveTexture].get(), rv);
+        }
+
+        case LOCAL_GL_TEXTURE_BINDING_CUBE_MAP: {
+            return WebGLObjectAsJSValue(cx, mBoundCubeMapTextures[mActiveTexture].get(), rv);
+        }
+
+        default:
+            break;
+    }
+
+    ErrorInvalidEnumInfo("getParameter: parameter", pname);
+    return JS::NullValue();
+}
+
+void
+WebGLContext::GetParameterIndexed(JSContext* cx, GLenum pname, GLuint index,
+                                  JS::MutableHandle<JS::Value> retval)
+{
+    if (IsContextLost()) {
+        retval.setNull();
+        return;
+    }
+
+    MakeContextCurrent();
+
+    switch (pname) {
+        case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
+        {
+            if (index >= mGLMaxTransformFeedbackSeparateAttribs) {
+                ErrorInvalidValue("getParameterIndexed: index should be less than MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", index);
+                retval.setNull();
+                return;
+            }
+            retval.setNull(); // See bug 903594
+            return;
+        }
+
+        default:
+            break;
+    }
+
+    ErrorInvalidEnumInfo("getParameterIndexed: parameter", pname);
+    retval.setNull();
+}
+
+bool
+WebGLContext::IsEnabled(GLenum cap)
+{
+    if (IsContextLost())
+        return false;
+
+    if (!ValidateCapabilityEnum(cap, "isEnabled"))
+        return false;
+
+    MakeContextCurrent();
+    return gl->fIsEnabled(cap);
+}
+
+bool
+WebGLContext::ValidateCapabilityEnum(GLenum cap, const char* info)
+{
+    switch (cap) {
+        case LOCAL_GL_BLEND:
+        case LOCAL_GL_CULL_FACE:
+        case LOCAL_GL_DEPTH_TEST:
+        case LOCAL_GL_DITHER:
+        case LOCAL_GL_POLYGON_OFFSET_FILL:
+        case LOCAL_GL_SAMPLE_ALPHA_TO_COVERAGE:
+        case LOCAL_GL_SAMPLE_COVERAGE:
+        case LOCAL_GL_SCISSOR_TEST:
+        case LOCAL_GL_STENCIL_TEST:
+            return true;
+        case LOCAL_GL_RASTERIZER_DISCARD:
+            return IsWebGL2();
+        default:
+            ErrorInvalidEnumInfo(info, cap);
+            return false;
+    }
+}
+
+realGLboolean*
+WebGLContext::GetStateTrackingSlot(GLenum cap)
+{
+    switch (cap) {
+        case LOCAL_GL_DEPTH_TEST:
+            return &mDepthTestEnabled;
+        case LOCAL_GL_DITHER:
+            return &mDitherEnabled;
+        case LOCAL_GL_RASTERIZER_DISCARD:
+            return &mRasterizerDiscardEnabled;
+        case LOCAL_GL_SCISSOR_TEST:
+            return &mScissorTestEnabled;
+        case LOCAL_GL_STENCIL_TEST:
+            return &mStencilTestEnabled;
+    }
+
+    return nullptr;
+}
+
+} // namespace mozilla