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

#ifndef WEBGLCONTEXT_H_

#define WEBGLCONTEXT_H_

#include <stdarg.h>

#include "GLContextTypes.h"

#include "GLDefs.h"

#include "mozilla/Attributes.h"

#include "mozilla/CheckedInt.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "mozilla/dom/HTMLCanvasElement.h"

#include "mozilla/dom/Nullable.h"

#include "mozilla/dom/TypedArray.h"

#include "mozilla/EnumeratedArray.h"

#include "mozilla/ErrorResult.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/LinkedList.h"

#include "mozilla/UniquePtr.h"

#include "nsCycleCollectionNoteChild.h"

#include "nsICanvasRenderingContextInternal.h"

#include "nsLayoutUtils.h"

#include "nsTArray.h"

#include "nsWrapperCache.h"

#include "SurfaceTypes.h"

#include "ScopedGLHelpers.h"

#include "TexUnpackBlob.h"

// Local

#include "CacheMap.h"

#include "WebGLContextLossHandler.h"

#include "WebGLContextUnchecked.h"

#include "WebGLFormats.h"

#include "WebGLObjectModel.h"

#include "WebGLStrongTypes.h"

#include "WebGLTexture.h"

// Generated

#include "nsIDOMEventListener.h"

#include "nsICanvasRenderingContextInternal.h"

#include "nsIObserver.h"

#include "mozilla/dom/HTMLCanvasElement.h"

#include "nsWrapperCache.h"

#include "nsLayoutUtils.h"

#include "mozilla/dom/WebGLRenderingContextBinding.h"

#include "mozilla/dom/WebGL2RenderingContextBinding.h"

class nsIDocShell;

/*

 * WebGL-only GLenums

 */

#define LOCAL_GL_BROWSER_DEFAULT_WEBGL                       0x9244

#define LOCAL_GL_CONTEXT_LOST_WEBGL                          0x9242

#define LOCAL_GL_MAX_CLIENT_WAIT_TIMEOUT_WEBGL               0x9247

#define LOCAL_GL_UNPACK_COLORSPACE_CONVERSION_WEBGL          0x9243

#define LOCAL_GL_UNPACK_FLIP_Y_WEBGL                         0x9240

#define LOCAL_GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL              0x9241

namespace mozilla {

class ScopedCopyTexImageSource;

class ScopedDrawCallWrapper;

class ScopedResolveTexturesForDraw;

class ScopedUnpackReset;

class WebGLActiveInfo;

class WebGLBuffer;

class WebGLExtensionBase;

class WebGLFramebuffer;

class WebGLProgram;

class WebGLQuery;

class WebGLRenderbuffer;

class WebGLSampler;

class WebGLShader;

class WebGLShaderPrecisionFormat;

class WebGLSync;

class WebGLTexture;

class WebGLTransformFeedback;

class WebGLUniformLocation;

class WebGLVertexArray;

namespace dom {

class Element;

class ImageData;

class OwningHTMLCanvasElementOrOffscreenCanvas;

struct WebGLContextAttributes;

} // namespace dom

namespace gfx {

class SourceSurface;

class VRLayerChild;

} // namespace gfx

namespace gl {

class GLScreenBuffer;

class MozFramebuffer;

} // namespace gl

namespace webgl {

class AvailabilityRunnable;

struct CachedDrawFetchLimits;

struct LinkedProgramInfo;

class ShaderValidator;

class TexUnpackBlob;

struct UniformInfo;

struct UniformBlockInfo;

} // namespace webgl

WebGLTexelFormat GetWebGLTexelFormat(TexInternalFormat format);

void AssertUintParamCorrect(gl::GLContext* gl, GLenum pname, GLuint shadow);

struct WebGLContextOptions

{

    bool alpha = true;

    bool depth = true;

    bool stencil = false;

    bool premultipliedAlpha = true;

    bool antialias = true;

    bool preserveDrawingBuffer = false;

    bool failIfMajorPerformanceCaveat = false;

    dom::WebGLPowerPreference powerPreference = dom::WebGLPowerPreference::Default;

    WebGLContextOptions();

    bool operator==(const WebGLContextOptions&) const;

};

// From WebGLContextUtils

TexTarget TexImageTargetToTexTarget(TexImageTarget texImageTarget);

struct WebGLIntOrFloat {

    const enum {

        Int,

        Float,

        Uint

    } mType;

    union {

        GLint i;

        GLfloat f;

        GLuint u;

    } mValue;

    explicit WebGLIntOrFloat(GLint i) : mType(Int) { mValue.i = i; }

    explicit WebGLIntOrFloat(GLfloat f) : mType(Float) { mValue.f = f; }

    GLint AsInt() const { return (mType == Int) ? mValue.i : NS_lroundf(mValue.f); }

    GLfloat AsFloat() const { return (mType == Float) ? mValue.f : GLfloat(mValue.i); }

};

struct IndexedBufferBinding

{

    WebGLRefPtr<WebGLBuffer> mBufferBinding;

    uint64_t mRangeStart;

    uint64_t mRangeSize;

    IndexedBufferBinding();

    uint64_t ByteCount() const;

};

////

struct FloatOrInt final // For TexParameter[fi] and friends.

{

    const bool isFloat;

    const GLfloat f;

    const GLint i;

    explicit FloatOrInt(GLint x)

        : isFloat(false)

        , f(x)

        , i(x)

    { }

    explicit FloatOrInt(GLfloat x)

        : isFloat(true)

        , f(x)

        , i(roundf(x))

    { }

    FloatOrInt& operator =(const FloatOrInt& x) {

        memcpy(this, &x, sizeof(x));

        return *this;

    }

};

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

struct TexImageSource

{

    const dom::ArrayBufferView* mView;

    GLuint mViewElemOffset;

    GLuint mViewElemLengthOverride;

    const WebGLsizeiptr* mPboOffset;

    const dom::ImageBitmap* mImageBitmap;

    const dom::ImageData* mImageData;

    const dom::Element* mDomElem;

    ErrorResult* mOut_error;

protected:

    TexImageSource() {

        memset(this, 0, sizeof(*this));

    }

};

////

struct TexImageSourceAdapter final : public TexImageSource

{

    TexImageSourceAdapter(const dom::Nullable<dom::ArrayBufferView>* maybeView,

                          ErrorResult*)

    {

        if (!maybeView->IsNull()) {

            mView = &(maybeView->Value());

        }

    }

    TexImageSourceAdapter(const dom::ArrayBufferView* view, ErrorResult*) {

        mView = view;

    }

    TexImageSourceAdapter(const dom::ArrayBufferView* view, GLuint viewElemOffset,

                          GLuint viewElemLengthOverride = 0)

    {

        mView = view;

        mViewElemOffset = viewElemOffset;

        mViewElemLengthOverride = viewElemLengthOverride;

    }

    TexImageSourceAdapter(const WebGLsizeiptr* pboOffset, GLuint ignored1, GLuint ignored2 = 0) {

        mPboOffset = pboOffset;

    }

    TexImageSourceAdapter(const WebGLsizeiptr* pboOffset, ErrorResult* ignored) {

        mPboOffset = pboOffset;

    }

    TexImageSourceAdapter(const dom::ImageBitmap* imageBitmap, ErrorResult*) {

        mImageBitmap = imageBitmap;

    }

    TexImageSourceAdapter(const dom::ImageData* imageData, ErrorResult*) {

        mImageData = imageData;

    }

    TexImageSourceAdapter(const dom::Element* domElem, ErrorResult* const out_error) {

        mDomElem = domElem;

        mOut_error = out_error;

    }

};

// --

namespace webgl {

class AvailabilityRunnable final : public Runnable

{

public:

    const RefPtr<WebGLContext> mWebGL; // Prevent CC

    std::vector<RefPtr<WebGLQuery>> mQueries;

    std::vector<RefPtr<WebGLSync>> mSyncs;

    explicit AvailabilityRunnable(WebGLContext* webgl);

    ~AvailabilityRunnable();

    NS_IMETHOD Run() override;

};

} // namespace webgl

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

class WebGLContext

    : public nsICanvasRenderingContextInternal

    , public nsSupportsWeakReference

    , public WebGLContextUnchecked

    , public nsWrapperCache

{

    friend class ScopedDrawCallWrapper;

    friend class ScopedDrawWithTransformFeedback;

    friend class ScopedFakeVertexAttrib0;

    friend class ScopedFBRebinder;

    friend class WebGL2Context;

    friend class WebGLContextUserData;

    friend class WebGLExtensionCompressedTextureASTC;

    friend class WebGLExtensionCompressedTextureATC;

    friend class WebGLExtensionCompressedTextureES3;

    friend class WebGLExtensionCompressedTextureETC1;

    friend class WebGLExtensionCompressedTexturePVRTC;

    friend class WebGLExtensionCompressedTextureS3TC;

    friend class WebGLExtensionCompressedTextureS3TC_SRGB;

    friend class WebGLExtensionDepthTexture;

    friend class WebGLExtensionDisjointTimerQuery;

    friend class WebGLExtensionDrawBuffers;

    friend class WebGLExtensionLoseContext;

    friend class WebGLExtensionMOZDebug;

    friend class WebGLExtensionVertexArray;

    friend class WebGLMemoryTracker;

    friend class webgl::AvailabilityRunnable;

    friend struct webgl::LinkedProgramInfo;

    friend struct webgl::UniformBlockInfo;

    friend const webgl::CachedDrawFetchLimits*

        ValidateDraw(WebGLContext*, GLenum, uint32_t);

    enum {

        UNPACK_FLIP_Y_WEBGL = 0x9240,

        UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241,

        // We throw InvalidOperation in TexImage if we fail to use GPU fast-path

        // for texture copy when it is set to true, only for debug purpose.

        UNPACK_REQUIRE_FASTPATH = 0x10001,

        CONTEXT_LOST_WEBGL = 0x9242,

        UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243,

        BROWSER_DEFAULT_WEBGL = 0x9244,

        UNMASKED_VENDOR_WEBGL = 0x9245,

        UNMASKED_RENDERER_WEBGL = 0x9246

    };

    const uint32_t mMaxPerfWarnings;

    mutable uint64_t mNumPerfWarnings;

    const uint32_t mMaxAcceptableFBStatusInvals;

    uint64_t mNextFenceId = 1;

    uint64_t mCompletedFenceId = 0;

public:

    class FuncScope;

private:

    mutable FuncScope* mFuncScope = nullptr;

public:

    WebGLContext();

protected:

    virtual ~WebGLContext();

public:

    NS_DECL_CYCLE_COLLECTING_ISUPPORTS

    NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(WebGLContext,

                                                           nsICanvasRenderingContextInternal)

    virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> givenProto) override = 0;

    virtual void OnVisibilityChange() override;

    virtual void OnMemoryPressure() override;

    // nsICanvasRenderingContextInternal

    virtual int32_t GetWidth() override { return DrawingBufferWidth(); }

    virtual int32_t GetHeight() override { return DrawingBufferHeight(); }

    NS_IMETHOD SetDimensions(int32_t width, int32_t height) override;

    NS_IMETHOD InitializeWithDrawTarget(nsIDocShell*,

                                        NotNull<gfx::DrawTarget*>) override

    {

        return NS_ERROR_NOT_IMPLEMENTED;

    }

    NS_IMETHOD Reset() override {

        /* (InitializeWithSurface) */

        return NS_ERROR_NOT_IMPLEMENTED;

    }

    virtual UniquePtr<uint8_t[]> GetImageBuffer(int32_t* out_format) override;

    NS_IMETHOD GetInputStream(const char* mimeType,

                              const char16_t* encoderOptions,

                              nsIInputStream** out_stream) override;

    virtual already_AddRefed<mozilla::gfx::SourceSurface>

    GetSurfaceSnapshot(gfxAlphaType* out_alphaType) override;

    virtual void SetOpaqueValueFromOpaqueAttr(bool) override {};

    bool GetIsOpaque() override { return !mOptions.alpha; }

    NS_IMETHOD SetContextOptions(JSContext* cx,

                                 JS::Handle<JS::Value> options,

                                 ErrorResult& aRvForDictionaryInit) override;

    NS_IMETHOD SetIsIPC(bool) override {

        return NS_ERROR_NOT_IMPLEMENTED;

    }

    /**

     * An abstract base class to be implemented by callers wanting to be notified

     * that a refresh has occurred. Callers must ensure an observer is removed

     * before it is destroyed.

     */

    virtual void DidRefresh() override;

    NS_IMETHOD Redraw(const gfxRect&) override {

        return NS_ERROR_NOT_IMPLEMENTED;

    }

    // -

    const auto& CurFuncScope() const { return *mFuncScope; }

    const char* FuncName() const;

    class FuncScope final {

    public:

        const WebGLContext& mWebGL;

        const char* const mFuncName;

    private:

#ifdef DEBUG

        mutable bool mStillNeedsToCheckContextLost = true;

#endif

    public:

        FuncScope(const WebGLContext& webgl, const char* funcName);

        ~FuncScope();

        void OnCheckContextLost() const {

#ifdef DEBUG

            mStillNeedsToCheckContextLost = false;

#endif

        }

    };

    void SynthesizeGLError(GLenum err) const;

    void SynthesizeGLError(GLenum err, const char* fmt, ...) const MOZ_FORMAT_PRINTF(3, 4);

    void ErrorInvalidEnum(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorInvalidOperation(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorInvalidValue(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorInvalidFramebufferOperation(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorInvalidEnumInfo(const char* info, GLenum enumValue) const;

    void ErrorOutOfMemory(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorImplementationBug(const char* fmt = 0, ...) const MOZ_FORMAT_PRINTF(2, 3);

    void ErrorInvalidEnumArg(const char* argName, GLenum val) const;

    static const char* ErrorName(GLenum error);

    /**

     * Return displayable name for GLenum.

     * This version is like gl::GLenumToStr but with out the GL_ prefix to

     * keep consistency with how errors are reported from WebGL.

     * Returns hex formatted version of glenum if glenum is unknown.

     */

    static void EnumName(GLenum val, nsCString* out_name);

    void DummyReadFramebufferOperation();

    WebGLTexture* ActiveBoundTextureForTarget(const TexTarget texTarget) const {

        switch (texTarget.get()) {

        case LOCAL_GL_TEXTURE_2D:

            return mBound2DTextures[mActiveTexture];

        case LOCAL_GL_TEXTURE_CUBE_MAP:

            return mBoundCubeMapTextures[mActiveTexture];

        case LOCAL_GL_TEXTURE_3D:

            return mBound3DTextures[mActiveTexture];

        case LOCAL_GL_TEXTURE_2D_ARRAY:

            return mBound2DArrayTextures[mActiveTexture];

        default:

            MOZ_CRASH("GFX: bad target");

        }

    }

    /* Use this function when you have the texture image target, for example:

     * GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_[POSITIVE|NEGATIVE]_[X|Y|Z], and

     * not the actual texture binding target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.

     */

    WebGLTexture*

    ActiveBoundTextureForTexImageTarget(const TexImageTarget texImgTarget) const

    {

        const TexTarget texTarget = TexImageTargetToTexTarget(texImgTarget);

        return ActiveBoundTextureForTarget(texTarget);

    }

    void InvalidateResolveCacheForTextureWithTexUnit(const GLuint);

    already_AddRefed<Layer>

    GetCanvasLayer(nsDisplayListBuilder* builder, Layer* oldLayer,

                   LayerManager* manager) override;

    bool

    UpdateWebRenderCanvasData(nsDisplayListBuilder* aBuilder,

                              WebRenderCanvasData* aCanvasData) override;

    bool

    InitializeCanvasRenderer(nsDisplayListBuilder* aBuilder,

                             CanvasRenderer* aRenderer) override;

    // Note that 'clean' here refers to its invalidation state, not the

    // contents of the buffer.

    void MarkContextClean() override { mInvalidated = false; }

    void MarkContextCleanForFrameCapture() override { mCapturedFrameInvalidated = false; }

    bool IsContextCleanForFrameCapture() override { return !mCapturedFrameInvalidated; }

    gl::GLContext* GL() const { return gl; }

    bool IsPremultAlpha() const { return mOptions.premultipliedAlpha; }

    bool IsPreservingDrawingBuffer() const { return mOptions.preserveDrawingBuffer; }

    bool PresentScreenBuffer(gl::GLScreenBuffer* const screen = nullptr);

    // Prepare the context for capture before compositing

    void BeginComposition(gl::GLScreenBuffer* const screen = nullptr);

    // Clean up the context after captured for compositing

    void EndComposition();

    // a number that increments every time we have an event that causes

    // all context resources to be lost.

    uint32_t Generation() const { return mGeneration.value(); }

    // This is similar to GLContext::ClearSafely, but tries to minimize the

    // amount of work it does.

    // It only clears the buffers we specify, and can reset its state without

    // first having to query anything, as WebGL knows its state at all times.

    void ForceClearFramebufferWithDefaultValues(GLbitfield bufferBits,

                                                bool fakeNoAlpha) const;

    void RunContextLossTimer();

    void UpdateContextLossStatus();

    void EnqueueUpdateContextLossStatus();

    bool TryToRestoreContext();

    void AssertCachedBindings() const;

    void AssertCachedGlobalState() const;

    dom::HTMLCanvasElement* GetCanvas() const { return mCanvasElement; }

    nsIDocument* GetOwnerDoc() const;

    // WebIDL WebGLRenderingContext API

    void Commit();

    void GetCanvas(dom::Nullable<dom::OwningHTMLCanvasElementOrOffscreenCanvas>& retval);

private:

    gfx::IntSize DrawingBufferSize();

public:

    GLsizei DrawingBufferWidth() {

        const FuncScope funcScope(*this, "drawingBufferWidth");

        return DrawingBufferSize().width;

    }

    GLsizei DrawingBufferHeight() {

        const FuncScope funcScope(*this, "drawingBufferHeight");

        return DrawingBufferSize().height;

    }

    layers::LayersBackend GetCompositorBackendType() const;

    void

    GetContextAttributes(dom::Nullable<dom::WebGLContextAttributes>& retval);

    // This is the entrypoint. Don't test against it directly.

    bool IsContextLost() const;

    void GetSupportedExtensions(dom::Nullable< nsTArray<nsString> >& retval,

                                dom::CallerType callerType);

    void GetExtension(JSContext* cx, const nsAString& name,

                      JS::MutableHandle<JSObject*> retval,

                      dom::CallerType callerType, ErrorResult& rv);

    void AttachShader(WebGLProgram& prog, WebGLShader& shader);

    void BindAttribLocation(WebGLProgram& prog, GLuint location,

                            const nsAString& name);

    void BindFramebuffer(GLenum target, WebGLFramebuffer* fb);

    void BindRenderbuffer(GLenum target, WebGLRenderbuffer* fb);

    void BindVertexArray(WebGLVertexArray* vao);

    void BlendColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a);

    void BlendEquation(GLenum mode);

    void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

    void BlendFunc(GLenum sfactor, GLenum dfactor);

    void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,

                           GLenum srcAlpha, GLenum dstAlpha);

    GLenum CheckFramebufferStatus(GLenum target);

    void Clear(GLbitfield mask);

    void ClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a);

    void ClearDepth(GLclampf v);

    void ClearStencil(GLint v);

    void ColorMask(WebGLboolean r, WebGLboolean g, WebGLboolean b, WebGLboolean a);

    void CompileShader(WebGLShader& shader);

    void CompileShaderANGLE(WebGLShader* shader);

    void CompileShaderBypass(WebGLShader* shader, const nsCString& shaderSource);

    already_AddRefed<WebGLFramebuffer> CreateFramebuffer();

    already_AddRefed<WebGLProgram> CreateProgram();

    already_AddRefed<WebGLRenderbuffer> CreateRenderbuffer();

    already_AddRefed<WebGLShader> CreateShader(GLenum type);

    already_AddRefed<WebGLVertexArray> CreateVertexArray();

    void CullFace(GLenum face);

    void DeleteFramebuffer(WebGLFramebuffer* fb);

    void DeleteProgram(WebGLProgram* prog);

    void DeleteRenderbuffer(WebGLRenderbuffer* rb);

    void DeleteShader(WebGLShader* shader);

    void DeleteVertexArray(WebGLVertexArray* vao);

    void DepthFunc(GLenum func);

    void DepthMask(WebGLboolean b);

    void DepthRange(GLclampf zNear, GLclampf zFar);

    void DetachShader(WebGLProgram& prog, const WebGLShader& shader);

    void DrawBuffers(const dom::Sequence<GLenum>& buffers);

    void Flush();

    void Finish();

    void FramebufferRenderbuffer(GLenum target, GLenum attachment,

                                 GLenum rbTarget, WebGLRenderbuffer* rb);

    void FramebufferTexture2D(GLenum target, GLenum attachment,

                              GLenum texImageTarget, WebGLTexture* tex,

                              GLint level);

    void FrontFace(GLenum mode);

    already_AddRefed<WebGLActiveInfo> GetActiveAttrib(const WebGLProgram& prog,

                                                      GLuint index);

    already_AddRefed<WebGLActiveInfo> GetActiveUniform(const WebGLProgram& prog,

                                                       GLuint index);

    void

    GetAttachedShaders(const WebGLProgram& prog,

                       dom::Nullable<nsTArray<RefPtr<WebGLShader>>>& retval);

    GLint GetAttribLocation(const WebGLProgram& prog, const nsAString& name);

    JS::Value GetBufferParameter(GLenum target, GLenum pname);

    void GetBufferParameter(JSContext*, GLenum target, GLenum pname,

                            JS::MutableHandle<JS::Value> retval)

    {

        retval.set(GetBufferParameter(target, pname));

    }

    GLenum GetError();

    virtual JS::Value GetFramebufferAttachmentParameter(JSContext* cx, GLenum target,

                                                        GLenum attachment, GLenum pname,

                                                        ErrorResult& rv);

    void GetFramebufferAttachmentParameter(JSContext* cx, GLenum target,

                                           GLenum attachment, GLenum pname,

                                           JS::MutableHandle<JS::Value> retval,

                                           ErrorResult& rv)

    {

        retval.set(GetFramebufferAttachmentParameter(cx, target, attachment,

                                                     pname, rv));

    }

    JS::Value GetProgramParameter(const WebGLProgram& prog, GLenum pname);

    void  GetProgramParameter(JSContext*, const WebGLProgram& prog, GLenum pname,

                              JS::MutableHandle<JS::Value> retval)

    {

        retval.set(GetProgramParameter(prog, pname));

    }

    void GetProgramInfoLog(const WebGLProgram& prog, nsACString& retval);

    void GetProgramInfoLog(const WebGLProgram& prog, nsAString& retval);

    JS::Value GetRenderbufferParameter(GLenum target, GLenum pname);

    void GetRenderbufferParameter(JSContext*, GLenum target, GLenum pname,

                                  JS::MutableHandle<JS::Value> retval)

    {

        retval.set(GetRenderbufferParameter(target, pname));

    }

    JS::Value GetShaderParameter(const WebGLShader& shader, GLenum pname);

    void GetShaderParameter(JSContext*, const WebGLShader& shader, GLenum pname,

                            JS::MutableHandle<JS::Value> retval)

    {

        retval.set(GetShaderParameter(shader, pname));

    }

    already_AddRefed<WebGLShaderPrecisionFormat>

    GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype);

    void GetShaderInfoLog(const WebGLShader& shader, nsACString& retval);

    void GetShaderInfoLog(const WebGLShader& shader, nsAString& retval);

    void GetShaderSource(const WebGLShader& shader, nsAString& retval);

    JS::Value GetUniform(JSContext* cx, const WebGLProgram& prog,

                         const WebGLUniformLocation& loc);

    void GetUniform(JSContext* cx, const WebGLProgram& prog,

                    const WebGLUniformLocation& loc,

                    JS::MutableHandle<JS::Value> retval)

    {

        retval.set(GetUniform(cx, prog, loc));

    }

    already_AddRefed<WebGLUniformLocation>

    GetUniformLocation(const WebGLProgram& prog, const nsAString& name);

    void Hint(GLenum target, GLenum mode);

    bool IsBuffer(const WebGLBuffer* obj);

    bool IsFramebuffer(const WebGLFramebuffer* obj);

    bool IsProgram(const WebGLProgram* obj);

    bool IsRenderbuffer(const WebGLRenderbuffer* obj);

    bool IsShader(const WebGLShader* obj);

    bool IsTexture(const WebGLTexture* obj);

    bool IsVertexArray(const WebGLVertexArray* obj);

    void LineWidth(GLfloat width);

    void LinkProgram(WebGLProgram& prog);

    void PixelStorei(GLenum pname, GLint param);

    void PolygonOffset(GLfloat factor, GLfloat units);

    already_AddRefed<layers::SharedSurfaceTextureClient> GetVRFrame();

    ////

    webgl::PackingInfo

    ValidImplementationColorReadPI(const webgl::FormatUsageInfo* usage) const;

protected:

    bool ReadPixels_SharedPrecheck(dom::CallerType aCallerType,

                                   ErrorResult& out_error);

    void ReadPixelsImpl(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,

                        GLenum type, void* data, uint32_t dataLen);

    bool DoReadPixelsAndConvert(const webgl::FormatInfo* srcFormat, GLint x, GLint y,

                                GLsizei width, GLsizei height, GLenum format,

                                GLenum destType, void* dest, uint32_t dataLen,

                                uint32_t rowStride);

public:

    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,

                    GLenum type, const dom::Nullable<dom::ArrayBufferView>& maybeView,

                    dom::CallerType aCallerType, ErrorResult& rv)

    {

        const FuncScope funcScope(*this, "readPixels");

        if (!ValidateNonNull("pixels", maybeView))

            return;

        ReadPixels(x, y, width, height, format, type, maybeView.Value(), 0,

                   aCallerType, rv);

    }

    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,

                    GLenum type, WebGLsizeiptr offset,

                    dom::CallerType, ErrorResult& out_error);

    void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,

                    GLenum type, const dom::ArrayBufferView& dstData, GLuint dstOffset,

                    dom::CallerType, ErrorResult& out_error);

    ////

    void RenderbufferStorage(GLenum target, GLenum internalFormat,

                             GLsizei width, GLsizei height)

    {

        const FuncScope funcScope(*this, "renderbufferStorage");

        RenderbufferStorage_base(target, 0, internalFormat, width, height);

    }

protected:

    void RenderbufferStorage_base(GLenum target, GLsizei samples, GLenum internalformat,

                                  GLsizei width, GLsizei height);

public:

    void SampleCoverage(GLclampf value, WebGLboolean invert);

    void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);

    void ShaderSource(WebGLShader& shader, const nsAString& 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 sfail, GLenum dpfail, GLenum dppass);

    void StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail,

                           GLenum dppass);

    //////

    void Uniform1f(WebGLUniformLocation* loc, GLfloat x);

    void Uniform2f(WebGLUniformLocation* loc, GLfloat x, GLfloat y);

    void Uniform3f(WebGLUniformLocation* loc, GLfloat x, GLfloat y, GLfloat z);

    void Uniform4f(WebGLUniformLocation* loc, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    void Uniform1i(WebGLUniformLocation* loc, GLint x);

    void Uniform2i(WebGLUniformLocation* loc, GLint x, GLint y);

    void Uniform3i(WebGLUniformLocation* loc, GLint x, GLint y, GLint z);

    void Uniform4i(WebGLUniformLocation* loc, GLint x, GLint y, GLint z, GLint w);

    void Uniform1ui(WebGLUniformLocation* loc, GLuint v0);

    void Uniform2ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1);

    void Uniform3ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1, GLuint v2);

    void Uniform4ui(WebGLUniformLocation* loc, GLuint v0, GLuint v1, GLuint v2,

                    GLuint v3);

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

    typedef dom::Float32ArrayOrUnrestrictedFloatSequence Float32ListU;

    typedef dom::Int32ArrayOrLongSequence Int32ListU;

    typedef dom::Uint32ArrayOrUnsignedLongSequence Uint32ListU;

protected:

    template<typename elemT, typename viewT>

    struct Arr {

        const size_t elemCount;

        const elemT* const elemBytes;

    private:

        static size_t ComputeAndReturnLength(const viewT& view) {

            view.ComputeLengthAndData();

            return view.LengthAllowShared();

        }

Unexecuted instantiation: mozilla::WebGLContext::Arr<float, mozilla::dom::TypedArray<float, &js::UnwrapFloat32Array, &(JS_GetFloat32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetFloat32ArrayLengthAndData, &(JS_NewFloat32Array(JSContext*, unsigned int))> >::ComputeAndReturnLength(mozilla::dom::TypedArray<float, &js::UnwrapFloat32Array, &(JS_GetFloat32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetFloat32ArrayLengthAndData, &(JS_NewFloat32Array(JSContext*, unsigned int))> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<int, mozilla::dom::TypedArray<int, &js::UnwrapInt32Array, &(JS_GetInt32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetInt32ArrayLengthAndData, &(JS_NewInt32Array(JSContext*, unsigned int))> >::ComputeAndReturnLength(mozilla::dom::TypedArray<int, &js::UnwrapInt32Array, &(JS_GetInt32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetInt32ArrayLengthAndData, &(JS_NewInt32Array(JSContext*, unsigned int))> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<unsigned int, mozilla::dom::TypedArray<unsigned int, &js::UnwrapUint32Array, &(JS_GetUint32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetUint32ArrayLengthAndData, &(JS_NewUint32Array(JSContext*, unsigned int))> >::ComputeAndReturnLength(mozilla::dom::TypedArray<unsigned int, &js::UnwrapUint32Array, &(JS_GetUint32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetUint32ArrayLengthAndData, &(JS_NewUint32Array(JSContext*, unsigned int))> const&)

    public:

        explicit Arr(const viewT& view)

            : elemCount(ComputeAndReturnLength(view))

            , elemBytes(view.DataAllowShared())

        { }

Unexecuted instantiation: mozilla::WebGLContext::Arr<float, mozilla::dom::TypedArray<float, &js::UnwrapFloat32Array, &(JS_GetFloat32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetFloat32ArrayLengthAndData, &(JS_NewFloat32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::TypedArray<float, &js::UnwrapFloat32Array, &(JS_GetFloat32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetFloat32ArrayLengthAndData, &(JS_NewFloat32Array(JSContext*, unsigned int))> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<int, mozilla::dom::TypedArray<int, &js::UnwrapInt32Array, &(JS_GetInt32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetInt32ArrayLengthAndData, &(JS_NewInt32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::TypedArray<int, &js::UnwrapInt32Array, &(JS_GetInt32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetInt32ArrayLengthAndData, &(JS_NewInt32Array(JSContext*, unsigned int))> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<unsigned int, mozilla::dom::TypedArray<unsigned int, &js::UnwrapUint32Array, &(JS_GetUint32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetUint32ArrayLengthAndData, &(JS_NewUint32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::TypedArray<unsigned int, &js::UnwrapUint32Array, &(JS_GetUint32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetUint32ArrayLengthAndData, &(JS_NewUint32Array(JSContext*, unsigned int))> const&)

        explicit Arr(const dom::Sequence<elemT>& seq)

            : elemCount(seq.Length())

            , elemBytes(seq.Elements())

        { }

Unexecuted instantiation: mozilla::WebGLContext::Arr<float, mozilla::dom::TypedArray<float, &js::UnwrapFloat32Array, &(JS_GetFloat32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetFloat32ArrayLengthAndData, &(JS_NewFloat32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::Sequence<float> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<int, mozilla::dom::TypedArray<int, &js::UnwrapInt32Array, &(JS_GetInt32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetInt32ArrayLengthAndData, &(JS_NewInt32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::Sequence<int> const&)

Unexecuted instantiation: mozilla::WebGLContext::Arr<unsigned int, mozilla::dom::TypedArray<unsigned int, &js::UnwrapUint32Array, &(JS_GetUint32ArrayData(JSObject*, bool*, JS::AutoRequireNoGC const&)), &js::GetUint32ArrayLengthAndData, &(JS_NewUint32Array(JSContext*, unsigned int))> >::Arr(mozilla::dom::Sequence<unsigned int> const&)

        Arr(size_t _elemCount, const elemT* _elemBytes)

            : elemCount(_elemCount)

            , elemBytes(_elemBytes)

        { }

        ////

        static Arr From(const Float32ListU& list) {

            if (list.IsFloat32Array())

                return Arr(list.GetAsFloat32Array());

            return Arr(list.GetAsUnrestrictedFloatSequence());

        }

        static Arr From(const Int32ListU& list) {

            if (list.IsInt32Array())

                return Arr(list.GetAsInt32Array());

            return Arr(list.GetAsLongSequence());

        }

        static Arr From(const Uint32ListU& list) {

            if (list.IsUint32Array())

                return Arr(list.GetAsUint32Array());

            return Arr(list.GetAsUnsignedLongSequence());

        }

    };

    typedef Arr<GLfloat, dom::Float32Array> Float32Arr;

    typedef Arr<GLint, dom::Int32Array> Int32Arr;

    typedef Arr<GLuint, dom::Uint32Array> Uint32Arr;

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

    void UniformNfv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,

                    const Float32Arr& arr, GLuint elemOffset, GLuint elemCountOverride);

    void UniformNiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,

                    const Int32Arr& arr, GLuint elemOffset, GLuint elemCountOverride);

    void UniformNuiv(const char* funcName, uint8_t N, WebGLUniformLocation* loc,

                     const Uint32Arr& arr, GLuint elemOffset, GLuint elemCountOverride);

    void UniformMatrixAxBfv(const char* funcName, uint8_t A, uint8_t B,

                            WebGLUniformLocation* loc, bool transpose,

                            const Float32Arr& arr, GLuint elemOffset,

                            GLuint elemCountOverride);

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

public:

    #define FOO(N) \

        void Uniform ## N ## fv(WebGLUniformLocation* loc, const Float32ListU& list,  \

                                GLuint elemOffset = 0, GLuint elemCountOverride = 0)  \

        {                                                                             \

            UniformNfv("uniform" #N "fv", N, loc, Float32Arr::From(list), elemOffset, \

                       elemCountOverride);                                            \

        }

Unexecuted instantiation: mozilla::WebGLContext::Uniform1fv(mozilla::WebGLUniformLocation*, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform2fv(mozilla::WebGLUniformLocation*, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform3fv(mozilla::WebGLUniformLocation*, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform4fv(mozilla::WebGLUniformLocation*, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

    FOO(1)

    FOO(2)

    FOO(3)

    FOO(4)

    #undef FOO

    //////

    #define FOO(N) \

        void Uniform ## N ## iv(WebGLUniformLocation* loc, const Int32ListU& list,   \

                                GLuint elemOffset = 0, GLuint elemCountOverride = 0) \

        {                                                                            \

            UniformNiv("uniform" #N "iv", N, loc, Int32Arr::From(list), elemOffset,  \

                       elemCountOverride);                                           \

        }

Unexecuted instantiation: mozilla::WebGLContext::Uniform1iv(mozilla::WebGLUniformLocation*, mozilla::dom::Int32ArrayOrLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform2iv(mozilla::WebGLUniformLocation*, mozilla::dom::Int32ArrayOrLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform3iv(mozilla::WebGLUniformLocation*, mozilla::dom::Int32ArrayOrLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform4iv(mozilla::WebGLUniformLocation*, mozilla::dom::Int32ArrayOrLongSequence const&, unsigned int, unsigned int)

    FOO(1)

    FOO(2)

    FOO(3)

    FOO(4)

    #undef FOO

    //////

    #define FOO(N) \

        void Uniform ## N ## uiv(WebGLUniformLocation* loc, const Uint32ListU& list,   \

                                 GLuint elemOffset = 0, GLuint elemCountOverride = 0)  \

        {                                                                              \

            UniformNuiv("uniform" #N "uiv", N, loc, Uint32Arr::From(list), elemOffset, \

                        elemCountOverride);                                            \

        }

Unexecuted instantiation: mozilla::WebGLContext::Uniform1uiv(mozilla::WebGLUniformLocation*, mozilla::dom::Uint32ArrayOrUnsignedLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform2uiv(mozilla::WebGLUniformLocation*, mozilla::dom::Uint32ArrayOrUnsignedLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform3uiv(mozilla::WebGLUniformLocation*, mozilla::dom::Uint32ArrayOrUnsignedLongSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::Uniform4uiv(mozilla::WebGLUniformLocation*, mozilla::dom::Uint32ArrayOrUnsignedLongSequence const&, unsigned int, unsigned int)

    FOO(1)

    FOO(2)

    FOO(3)

    FOO(4)

    #undef FOO

    //////

    #define FOO(X,A,B) \

        void UniformMatrix ## X ## fv(WebGLUniformLocation* loc, bool transpose,       \

                                      const Float32ListU& list, GLuint elemOffset = 0, \

                                      GLuint elemCountOverride = 0)                    \

        {                                                                              \

            UniformMatrixAxBfv("uniformMatrix" #X "fv", A, B, loc, transpose,          \

                               Float32Arr::From(list), elemOffset, elemCountOverride); \

        }

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix2fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix3x2fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix4x2fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix2x3fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix3fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix4x3fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix2x4fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix3x4fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

Unexecuted instantiation: mozilla::WebGLContext::UniformMatrix4fv(mozilla::WebGLUniformLocation*, bool, mozilla::dom::Float32ArrayOrUnrestrictedFloatSequence const&, unsigned int, unsigned int)

    FOO(2,2,2)

    FOO(2x3,2,3)

    FOO(2x4,2,4)

    FOO(3x2,3,2)

    FOO(3,3,3)

    FOO(3x4,3,4)

    FOO(4x2,4,2)

    FOO(4x3,4,3)

    FOO(4,4,4)

    #undef FOO

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

    void UseProgram(WebGLProgram* prog);

    bool ValidateAttribArraySetter(uint32_t count, uint32_t arrayLength);

    bool ValidateUniformLocation(WebGLUniformLocation* loc);

    bool ValidateUniformSetter(WebGLUniformLocation* loc, uint8_t setterSize,

                               GLenum setterType);

    bool ValidateUniformArraySetter(WebGLUniformLocation* loc,

                                    uint8_t setterElemSize, GLenum setterType,

                                    uint32_t setterArraySize,

                                    uint32_t* out_numElementsToUpload);

    bool ValidateUniformMatrixArraySetter(WebGLUniformLocation* loc,

                                          uint8_t setterCols,

                                          uint8_t setterRows,

                                          GLenum setterType,

                                          uint32_t setterArraySize,

                                          bool setterTranspose,

                                          uint32_t* out_numElementsToUpload);

    void ValidateProgram(const WebGLProgram& prog);

    bool ValidateUniformLocation(const char* info, WebGLUniformLocation* loc);

    bool ValidateSamplerUniformSetter(const char* info,

                                      WebGLUniformLocation* loc, GLint value);

    void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);

// -----------------------------------------------------------------------------

// WEBGL_lose_context

public:

    void LoseContext();

    void RestoreContext();

// -----------------------------------------------------------------------------

// Buffer Objects (WebGLContextBuffers.cpp)

    void BindBuffer(GLenum target, WebGLBuffer* buffer);

    void BindBufferBase(GLenum target, GLuint index, WebGLBuffer* buf);

    void BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buf,

                         WebGLintptr offset, WebGLsizeiptr size);

private:

    void BufferDataImpl(GLenum target, size_t dataLen, const uint8_t* data, GLenum usage);

public:

    void BufferData(GLenum target, WebGLsizeiptr size, GLenum usage);

    void BufferData(GLenum target, const dom::Nullable<dom::ArrayBuffer>& maybeSrc,

                    GLenum usage);

    void BufferData(GLenum target, const dom::ArrayBufferView& srcData, GLenum usage,

                    GLuint srcElemOffset = 0, GLuint srcElemCountOverride = 0);

private:

    void BufferSubDataImpl(GLenum target, WebGLsizeiptr dstByteOffset,

                           size_t srcDataLen, const uint8_t* srcData);

public:

    void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset,

                       const dom::ArrayBufferView& src, GLuint srcElemOffset = 0,

                       GLuint srcElemCountOverride = 0);

    void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset,

                       const dom::ArrayBuffer& src);

    void BufferSubData(GLenum target, WebGLsizeiptr dstByteOffset,

                       const dom::SharedArrayBuffer& src);

    already_AddRefed<WebGLBuffer> CreateBuffer();

    void DeleteBuffer(WebGLBuffer* buf);

protected:

    // bound buffer state

    WebGLRefPtr<WebGLBuffer> mBoundArrayBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundCopyReadBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundCopyWriteBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundPixelPackBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundPixelUnpackBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundTransformFeedbackBuffer;

    WebGLRefPtr<WebGLBuffer> mBoundUniformBuffer;

    std::vector<IndexedBufferBinding> mIndexedUniformBufferBindings;

    WebGLRefPtr<WebGLBuffer>& GetBufferSlotByTarget(GLenum target);

    WebGLRefPtr<WebGLBuffer>& GetBufferSlotByTargetIndexed(GLenum target,

                                                           GLuint index);

// -----------------------------------------------------------------------------

// Queries (WebGL2ContextQueries.cpp)

protected:

    WebGLRefPtr<WebGLQuery> mQuerySlot_SamplesPassed;

    WebGLRefPtr<WebGLQuery> mQuerySlot_TFPrimsWritten;

    WebGLRefPtr<WebGLQuery> mQuerySlot_TimeElapsed;

    WebGLRefPtr<WebGLQuery>*

    ValidateQuerySlotByTarget(GLenum target);

public:

    already_AddRefed<WebGLQuery> CreateQuery();

    void DeleteQuery(WebGLQuery* query);

    bool IsQuery(const WebGLQuery* query);

    void BeginQuery(GLenum target, WebGLQuery& query);

    void EndQuery(GLenum target);

    void GetQuery(JSContext* cx, GLenum target, GLenum pname,

                  JS::MutableHandleValue retval);

    void GetQueryParameter(JSContext* cx, const WebGLQuery& query, GLenum pname,

                           JS::MutableHandleValue retval);

// -----------------------------------------------------------------------------

// State and State Requests (WebGLContextState.cpp)

private:

    void SetEnabled(const char* funcName, GLenum cap, bool enabled);

public:

    void Disable(GLenum cap) { SetEnabled("disabled", cap, false); }

    void Enable(GLenum cap) { SetEnabled("enabled", cap, true); }

    bool GetStencilBits(GLint* const out_stencilBits) const;

    virtual JS::Value GetParameter(JSContext* cx, GLenum pname, ErrorResult& rv);

    void GetParameter(JSContext* cx, GLenum pname,

                      JS::MutableHandle<JS::Value> retval, ErrorResult& rv)

    {

        retval.set(GetParameter(cx, pname, rv));

    }

    void GetParameterIndexed(JSContext* cx, GLenum pname, GLuint index,

                             JS::MutableHandle<JS::Value> retval);

    bool IsEnabled(GLenum cap);

private:

    // State tracking slots

    realGLboolean mDitherEnabled;

    realGLboolean mRasterizerDiscardEnabled;

    realGLboolean mScissorTestEnabled;

    realGLboolean mDepthTestEnabled = 0;

    realGLboolean mStencilTestEnabled;

    GLenum mGenerateMipmapHint = 0;

    bool ValidateCapabilityEnum(GLenum cap);

    realGLboolean* GetStateTrackingSlot(GLenum cap);

    // Allocation debugging variables

    mutable uint64_t mDataAllocGLCallCount;

    void OnDataAllocCall() const {

       mDataAllocGLCallCount++;

    }

    uint64_t GetNumGLDataAllocCalls() const {

       return mDataAllocGLCallCount;

    }