WebGL1RenderingContext.cpp

/*

 * Copyright (C) 2009, 2013, 2014 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#if ENABLE(WEBGL)

#include "WebGLRenderingContext.h"

#include "ANGLEInstancedArrays.h"

#include "CachedImage.h"

#include "DOMWindow.h"

#include "Document.h"

#include "EXTBlendMinMax.h"

#include "EXTFragDepth.h"

#include "EXTShaderTextureLOD.h"

#include "EXTTextureFilterAnisotropic.h"

#include "EXTsRGB.h"

#include "ExceptionCode.h"

#include "Extensions3D.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "HTMLVideoElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "IntSize.h"

#include "Logging.h"

#include "MainFrame.h"

#include "NotImplemented.h"

#include "OESElementIndexUint.h"

#include "OESStandardDerivatives.h"

#include "OESTextureFloat.h"

#include "OESTextureFloatLinear.h"

#include "OESTextureHalfFloat.h"

#include "OESTextureHalfFloatLinear.h"

#include "OESVertexArrayObject.h"

#include "Page.h"

#include "RenderBox.h"

#include "Settings.h"

#include "WebGLActiveInfo.h"

#include "WebGLBuffer.h"

#include "WebGLCompressedTextureATC.h"

#include "WebGLCompressedTexturePVRTC.h"

#include "WebGLCompressedTextureS3TC.h"

#include "WebGLContextAttributes.h"

#include "WebGLContextEvent.h"

#include "WebGLContextGroup.h"

#include "WebGLDebugRendererInfo.h"

#include "WebGLDebugShaders.h"

#include "WebGLDepthTexture.h"

#include "WebGLDrawBuffers.h"

#include "WebGLFramebuffer.h"

#include "WebGLLoseContext.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLShader.h"

#include "WebGLShaderPrecisionFormat.h"

#include "WebGLTexture.h"

#include "WebGLUniformLocation.h"

#include <runtime/JSCInlines.h>

#include <runtime/TypedArrayInlines.h>

#include <runtime/Uint32Array.h>

#include <wtf/StdLibExtras.h>

#include <wtf/text/CString.h>

#include <wtf/text/StringBuilder.h>

namespace WebCore {

const double secondsBetweenRestoreAttempts = 1.0;

const int maxGLErrorsAllowedToConsole = 256;

namespace {

    class ScopedDrawingBufferBinder {

    public:

        ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)

            : m_drawingBuffer(drawingBuffer)

            , m_framebufferBinding(framebufferBinding)

        {

            // Commit DrawingBuffer if needed (e.g., for multisampling)

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->commit();

        }

        ~ScopedDrawingBufferBinder()

        {

            // Restore DrawingBuffer if needed

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->bind();

        }

    private:

        DrawingBuffer* m_drawingBuffer;

        WebGLFramebuffer* m_framebufferBinding;

    };

    Platform3DObject objectOrZero(WebGLObject* object)

    {

        return object ? object->object() : 0;

    }

    void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)

    {

        ASSERT(clippedStart && clippedRange);

        if (start < 0) {

            range += start;

            start = 0;

        }

        GC3Dint end = start + range;

        if (end > sourceRange)

            range -= end - sourceRange;

        *clippedStart = start;

        *clippedRange = range;

    }

    // Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.

    bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,

                GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,

                GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)

    {

        ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);

        clip1D(x, width, sourceWidth, clippedX, clippedWidth);

        clip1D(y, height, sourceHeight, clippedY, clippedHeight);

        return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);

    }

    GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)

    {

        if (value < min)

            value = min;

        if (value > max)

            value = max;

        return value;

    }

    // Return true if a character belongs to the ASCII subset as defined in

    // GLSL ES 1.0 spec section 3.1.

    bool validateCharacter(unsigned char c)

    {

        // Printing characters are valid except " $ ` @ \ ' DEL.

        if (c >= 32 && c <= 126

            && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')

            return true;

        // Horizontal tab, line feed, vertical tab, form feed, carriage return

        // are also valid.

        if (c >= 9 && c <= 13)

            return true;

        return false;

    }

    bool isPrefixReserved(const String& name)

    {

        if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))

            return true;

        return false;

    }

    // Strips comments from shader text. This allows non-ASCII characters

    // to be used in comments without potentially breaking OpenGL

    // implementations not expecting characters outside the GLSL ES set.

    class StripComments {

    public:

        StripComments(const String& str)

            : m_parseState(BeginningOfLine)

            , m_sourceString(str)

            , m_length(str.length())

            , m_position(0)

        {

            parse();

        }

        String result()

        {

            return m_builder.toString();

        }

    private:

        bool hasMoreCharacters() const

        {

            return (m_position < m_length);

        }

        void parse()

        {

            while (hasMoreCharacters()) {

                process(current());

                // process() might advance the position.

                if (hasMoreCharacters())

                    advance();

            }

        }

        void process(UChar);

        bool peek(UChar& character) const

        {

            if (m_position + 1 >= m_length)

                return false;

            character = m_sourceString[m_position + 1];

            return true;

        }

        UChar current() const

        {

            ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);

            return m_sourceString[m_position];

        }

        void advance()

        {

            ++m_position;

        }

        bool isNewline(UChar character) const

        {

            // Don't attempt to canonicalize newline related characters.

            return (character == '\n' || character == '\r');

        }

        void emit(UChar character)

        {

            m_builder.append(character);

        }

        enum ParseState {

            // Have not seen an ASCII non-whitespace character yet on

            // this line. Possible that we might see a preprocessor

            // directive.

            BeginningOfLine,

            // Have seen at least one ASCII non-whitespace character

            // on this line.

            MiddleOfLine,

            // Handling a preprocessor directive. Passes through all

            // characters up to the end of the line. Disables comment

            // processing.

            InPreprocessorDirective,

            // Handling a single-line comment. The comment text is

            // replaced with a single space.

            InSingleLineComment,

            // Handling a multi-line comment. Newlines are passed

            // through to preserve line numbers.

            InMultiLineComment

        };

        ParseState m_parseState;

        String m_sourceString;

        unsigned m_length;

        unsigned m_position;

        StringBuilder m_builder;

    };

    void StripComments::process(UChar c)

    {

        if (isNewline(c)) {

            // No matter what state we are in, pass through newlines

            // so we preserve line numbers.

            emit(c);

            if (m_parseState != InMultiLineComment)

                m_parseState = BeginningOfLine;

            return;

        }

        UChar temp = 0;

        switch (m_parseState) {

        case BeginningOfLine:

            if (WTF::isASCIISpace(c)) {

                emit(c);

                break;

            }

            if (c == '#') {

                m_parseState = InPreprocessorDirective;

                emit(c);

                break;

            }

            // Transition to normal state and re-handle character.

            m_parseState = MiddleOfLine;

            process(c);

            break;

        case MiddleOfLine:

            if (c == '/' && peek(temp)) {

                if (temp == '/') {

                    m_parseState = InSingleLineComment;

                    emit(' ');

                    advance();

                    break;

                }

                if (temp == '*') {

                    m_parseState = InMultiLineComment;

                    // Emit the comment start in case the user has

                    // an unclosed comment and we want to later

                    // signal an error.

                    emit('/');

                    emit('*');

                    advance();

                    break;

                }

            }

            emit(c);

            break;

        case InPreprocessorDirective:

            // No matter what the character is, just pass it

            // through. Do not parse comments in this state. This

            // might not be the right thing to do long term, but it

            // should handle the #error preprocessor directive.

            emit(c);

            break;

        case InSingleLineComment:

            // The newline code at the top of this function takes care

            // of resetting our state when we get out of the

            // single-line comment. Swallow all other characters.

            break;

        case InMultiLineComment:

            if (c == '*' && peek(temp) && temp == '/') {

                emit('*');

                emit('/');

                m_parseState = MiddleOfLine;

                advance();

                break;

            }

            // Swallow all other characters. Unclear whether we may

            // want or need to just emit a space per character to try

            // to preserve column numbers for debugging purposes.

            break;

        }

    }

} // namespace anonymous

class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextLostCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onContextLost() override { m_context->forceLostContext(WebGLRenderingContext::RealLostContext); }

    virtual ~WebGLRenderingContextLostCallback() {}

private:

    WebGLRenderingContext* m_context;

};

class WebGLRenderingContextErrorMessageCallback : public GraphicsContext3D::ErrorMessageCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onErrorMessage(const String& message, GC3Dint) override

    {

        if (m_context->m_synthesizedErrorsToConsole)

            m_context->printGLErrorToConsole(message);

    }

    virtual ~WebGLRenderingContextErrorMessageCallback() { }

private:

    WebGLRenderingContext* m_context;

};

std::unique_ptr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)

{

    Document& document = canvas->document();

    Frame* frame = document.frame();

    if (!frame)

        return nullptr;

    // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in

    // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));

        return nullptr;

    }

    bool isPendingPolicyResolution = false;

    Document& topDocument = document.topDocument();

    Page* page = topDocument.page();

    if (page && !topDocument.url().isLocalFile()) {

        WebGLLoadPolicy policy = page->mainFrame().loader().client().webGLPolicyForURL(topDocument.url());

        if (policy == WebGLBlockCreation) {

            LOG(WebGL, "The policy for this URL (%s) is to block WebGL.", topDocument.url().host().utf8().data());

            return nullptr;

        }

        if (policy == WebGLPendingCreation) {

            LOG(WebGL, "WebGL policy is pending. May need to be resolved later.");

            isPendingPolicyResolution = true;

        }

    }

    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();

    if (attributes.antialias) {

        if (!frame->settings().openGLMultisamplingEnabled())

            attributes.antialias = false;

    }

    attributes.noExtensions = true;

    attributes.shareResources = false;

    attributes.preferDiscreteGPU = true;

    if (frame->settings().forceSoftwareWebGLRendering())

        attributes.forceSoftwareRenderer = true;

    if (page)

        attributes.devicePixelRatio = page->deviceScaleFactor();

    if (isPendingPolicyResolution) {

        LOG(WebGL, "Create a WebGL context that looks real, but will require a policy resolution if used.");

        std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, attributes));

        renderingContext->suspendIfNeeded();

        return renderingContext;

    }

    HostWindow* hostWindow = document.view()->root()->hostWindow();

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));

    if (!context || !context->makeContextCurrent()) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));

        return nullptr;

    }

    Extensions3D* extensions = context->getExtensions();

    if (extensions->supports("GL_EXT_debug_marker"))

        extensions->pushGroupMarkerEXT("WebGLRenderingContext");

    std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, context, attributes));

    renderingContext->suspendIfNeeded();

    return renderingContext;

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(0)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(0)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(true)

    , m_hasRequestedPolicyResolution(false)

{

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,

    GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(context)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(4)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(false)

    , m_hasRequestedPolicyResolution(false)

{

    ASSERT(m_context);

    m_contextGroup = WebGLContextGroup::create();

    m_contextGroup->addContext(this);

    m_maxViewportDims[0] = m_maxViewportDims[1] = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);

    if (m_drawingBuffer)

        m_drawingBuffer->bind();

    setupFlags();

    initializeNewContext();

}

void WebGLRenderingContext::initializeNewContext()

{

    ASSERT(!m_contextLost);

    m_needsUpdate = true;

    m_markedCanvasDirty = false;

    m_activeTextureUnit = 0;

    m_packAlignment = 4;

    m_unpackAlignment = 4;

    m_unpackFlipY = false;

    m_unpackPremultiplyAlpha = false;

    m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;

    m_boundArrayBuffer = 0;

    m_currentProgram = 0;

    m_framebufferBinding = 0;

    m_renderbufferBinding = 0;

    m_depthMask = true;

    m_stencilEnabled = false;

    m_stencilMask = 0xFFFFFFFF;

    m_stencilMaskBack = 0xFFFFFFFF;

    m_stencilFuncRef = 0;

    m_stencilFuncRefBack = 0;

    m_stencilFuncMask = 0xFFFFFFFF;

    m_stencilFuncMaskBack = 0xFFFFFFFF;

    m_layerCleared = false;

    m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;

    m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;

    m_scissorEnabled = false;

    m_clearDepth = 1;

    m_clearStencil = 0;

    m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;

    GC3Dint numCombinedTextureImageUnits = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

    m_textureUnits.clear();

    m_textureUnits.resize(numCombinedTextureImageUnits);

    GC3Dint numVertexAttribs = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

    m_maxVertexAttribs = numVertexAttribs;

    m_maxTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

    m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

    m_maxCubeMapTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

    m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

    m_maxRenderbufferSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);

    // These two values from EXT_draw_buffers are lazily queried.

    m_maxDrawBuffers = 0;

    m_maxColorAttachments = 0;

    m_backDrawBuffer = GraphicsContext3D::BACK;

    m_drawBuffersWebGLRequirementsChecked = false;

    m_drawBuffersSupported = false;

    m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);

    addContextObject(m_defaultVertexArrayObject.get());

    m_boundVertexArrayObject = m_defaultVertexArrayObject;

    m_vertexAttribValue.resize(m_maxVertexAttribs);

    if (!isGLES2NPOTStrict())

        createFallbackBlackTextures1x1();

    if (!isGLES2Compliant())

        initVertexAttrib0();

    IntSize canvasSize = clampedCanvasSize();

    if (m_drawingBuffer)

        m_drawingBuffer->reset(canvasSize);

    m_context->reshape(canvasSize.width(), canvasSize.height());

    m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());

    m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());

    m_context->setContextLostCallback(std::make_unique<WebGLRenderingContextLostCallback>(this));

    m_context->setErrorMessageCallback(std::make_unique<WebGLRenderingContextErrorMessageCallback>(this));

}

void WebGLRenderingContext::setupFlags()

{

    ASSERT(m_context);

    if (Page* page = canvas()->document().page())

        m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();

    m_isGLES2Compliant = m_context->isGLES2Compliant();

    m_isErrorGeneratedOnOutOfBoundsAccesses = m_context->getExtensions()->isEnabled("GL_CHROMIUM_strict_attribs");

    m_isResourceSafe = m_context->getExtensions()->isEnabled("GL_CHROMIUM_resource_safe");

    if (m_isGLES2Compliant) {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");

    } else {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_ARB_texture_non_power_of_two");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_EXT_packed_depth_stencil");

    }

    m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");

}

bool WebGLRenderingContext::allowPrivilegedExtensions() const

{

    if (Page* page = canvas()->document().page())

        return page->settings().privilegedWebGLExtensionsEnabled();

    return false;

}

void WebGLRenderingContext::addCompressedTextureFormat(GC3Denum format)

{

    if (!m_compressedTextureFormats.contains(format))

        m_compressedTextureFormats.append(format);

}

WebGLRenderingContext::~WebGLRenderingContext()

{

    // Remove all references to WebGLObjects so if they are the last reference

    // they will be freed before the last context is removed from the context group.

    m_boundArrayBuffer = nullptr;

    m_defaultVertexArrayObject = nullptr;

    m_boundVertexArrayObject = nullptr;

    m_vertexAttrib0Buffer = nullptr;

    m_currentProgram = nullptr;

    m_framebufferBinding = nullptr;

    m_renderbufferBinding = nullptr;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        m_textureUnits[i].texture2DBinding = nullptr;

        m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    m_blackTexture2D = nullptr;

    m_blackTextureCubeMap = nullptr;

    if (!m_isPendingPolicyResolution) {

        detachAndRemoveAllObjects();

        destroyGraphicsContext3D();

        m_contextGroup->removeContext(this);

    }

}

void WebGLRenderingContext::destroyGraphicsContext3D()

{

    if (m_isPendingPolicyResolution)

        return;

    // The drawing buffer holds a context reference. It must also be destroyed

    // in order for the context to be released.

    if (m_drawingBuffer)

        m_drawingBuffer.clear();

    if (m_context) {

        m_context->setContextLostCallback(nullptr);

        m_context->setErrorMessageCallback(nullptr);

        m_context.clear();

    }

}

void WebGLRenderingContext::markContextChanged()

{

    if (m_framebufferBinding)

        return;

    m_context->markContextChanged();

    if (m_drawingBuffer)

        m_drawingBuffer->markContentsChanged();

    m_layerCleared = false;

    RenderBox* renderBox = canvas()->renderBox();

    if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {

        m_markedCanvasDirty = true;

        canvas()->clearCopiedImage();

        renderBox->contentChanged(CanvasChanged);

    } else {

        if (!m_markedCanvasDirty) {

            m_markedCanvasDirty = true;

            canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));

        }

    }

}

bool WebGLRenderingContext::clearIfComposited(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return false;

    if (!m_context->layerComposited() || m_layerCleared

        || m_attributes.preserveDrawingBuffer || (mask && m_framebufferBinding))

        return false;

    RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();

    // Determine if it's possible to combine the clear the user asked for and this clear.

    bool combinedClear = mask && !m_scissorEnabled;

    m_context->disable(GraphicsContext3D::SCISSOR_TEST);

    if (combinedClear && (mask & GraphicsContext3D::COLOR_BUFFER_BIT))

        m_context->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,

                              m_colorMask[1] ? m_clearColor[1] : 0,

                              m_colorMask[2] ? m_clearColor[2] : 0,

                              m_colorMask[3] ? m_clearColor[3] : 0);

    else

        m_context->clearColor(0, 0, 0, 0);

    m_context->colorMask(true, true, true, true);

    GC3Dbitfield clearMask = GraphicsContext3D::COLOR_BUFFER_BIT;

    if (contextAttributes->depth()) {

        if (!combinedClear || !m_depthMask || !(mask & GraphicsContext3D::DEPTH_BUFFER_BIT))

            m_context->clearDepth(1.0f);

        clearMask |= GraphicsContext3D::DEPTH_BUFFER_BIT;

        m_context->depthMask(true);

    }

    if (contextAttributes->stencil()) {

        if (combinedClear && (mask & GraphicsContext3D::STENCIL_BUFFER_BIT))

            m_context->clearStencil(m_clearStencil & m_stencilMask);

        else

            m_context->clearStencil(0);

        clearMask |= GraphicsContext3D::STENCIL_BUFFER_BIT;

        m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, 0xFFFFFFFF);

    }

    if (m_drawingBuffer)

        m_drawingBuffer->clearFramebuffers(clearMask);

    else {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

        m_context->clear(clearMask);

    }

    restoreStateAfterClear();

    if (m_framebufferBinding)

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

    m_layerCleared = true;

    return combinedClear;

}

void WebGLRenderingContext::restoreStateAfterClear()

{

    // Restore the state that the context set.

    if (m_scissorEnabled)

        m_context->enable(GraphicsContext3D::SCISSOR_TEST);

    m_context->clearColor(m_clearColor[0], m_clearColor[1],

                          m_clearColor[2], m_clearColor[3]);

    m_context->colorMask(m_colorMask[0], m_colorMask[1],

                         m_colorMask[2], m_colorMask[3]);

    m_context->clearDepth(m_clearDepth);

    m_context->clearStencil(m_clearStencil);

    m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, m_stencilMask);

    m_context->depthMask(m_depthMask);

}

void WebGLRenderingContext::markLayerComposited()

{

    if (isContextLostOrPending())

        return;

    m_context->markLayerComposited();

}

void WebGLRenderingContext::paintRenderingResultsToCanvas()

{

    if (isContextLostOrPending())

        return;

    if (canvas()->document().printing())

        canvas()->clearPresentationCopy();

    // Until the canvas is written to by the application, the clear that

    // happened after it was composited should be ignored by the compositor.

    if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {

        m_context->paintCompositedResultsToCanvas(canvas()->buffer());

        canvas()->makePresentationCopy();

    } else

        canvas()->clearPresentationCopy();

    clearIfComposited();

    if (!m_markedCanvasDirty && !m_layerCleared)

        return;

    canvas()->clearCopiedImage();

    m_markedCanvasDirty = false;

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    m_context->paintRenderingResultsToCanvas(canvas()->buffer(), m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

}

PassRefPtr<ImageData> WebGLRenderingContext::paintRenderingResultsToImageData()

{

    if (isContextLostOrPending())

        return nullptr;

    clearIfComposited();

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    RefPtr<ImageData> imageData = m_context->paintRenderingResultsToImageData(m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

    return imageData;

}

void WebGLRenderingContext::reshape(int width, int height)

{

    if (isContextLostOrPending())

        return;

    // This is an approximation because at WebGLRenderingContext level we don't

    // know if the underlying FBO uses textures or renderbuffers.

    GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);

    // Limit drawing buffer size to 4k to avoid memory exhaustion.

    const int sizeUpperLimit = 4096;

    maxSize = std::min(maxSize, sizeUpperLimit);

    GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);

    GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);

    width = clamp(width, 1, maxWidth);

    height = clamp(height, 1, maxHeight);

    if (m_needsUpdate) {

        RenderBox* renderBox = canvas()->renderBox();

        if (renderBox && renderBox->hasAcceleratedCompositing())

            renderBox->contentChanged(CanvasChanged);

        m_needsUpdate = false;

    }

    // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off

    // clear (and this matches what reshape will do).

    if (m_drawingBuffer) {

        m_drawingBuffer->reset(IntSize(width, height));

        restoreStateAfterClear();

    } else

        m_context->reshape(width, height);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].texture2DBinding.get()));

    m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));

    if (m_framebufferBinding)

      m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

}

int WebGLRenderingContext::drawingBufferWidth() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().width();

    return m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::drawingBufferHeight() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().height();

    return m_context->getInternalFramebufferSize().height();

}

unsigned int WebGLRenderingContext::sizeInBytes(GC3Denum type)

{

    switch (type) {

    case GraphicsContext3D::BYTE:

        return sizeof(GC3Dbyte);

    case GraphicsContext3D::UNSIGNED_BYTE:

        return sizeof(GC3Dubyte);

    case GraphicsContext3D::SHORT:

        return sizeof(GC3Dshort);

    case GraphicsContext3D::UNSIGNED_SHORT:

        return sizeof(GC3Dushort);

    case GraphicsContext3D::INT:

        return sizeof(GC3Dint);

    case GraphicsContext3D::UNSIGNED_INT:

        return sizeof(GC3Duint);

    case GraphicsContext3D::FLOAT:

        return sizeof(GC3Dfloat);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

void WebGLRenderingContext::activeTexture(GC3Denum texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "activeTexture", "texture unit out of range");

        return;

    }

    m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

    m_context->activeTexture(texture);

    if (m_drawingBuffer)

        m_drawingBuffer->setActiveTextureUnit(texture);

}

void WebGLRenderingContext::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))

        return;

    if (!program->attachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "attachShader", "shader attachment already has shader");

        return;

    }

    m_context->attachShader(objectOrZero(program), objectOrZero(shader));

    shader->onAttached();

}

void WebGLRenderingContext::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))

        return;

    if (!validateLocationLength("bindAttribLocation", name))

        return;

    if (!validateString("bindAttribLocation", name))

        return;

    if (isPrefixReserved(name)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindAttribLocation", "reserved prefix");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bindAttribLocation", "index out of range");

        return;

    }

    m_context->bindAttribLocation(objectOrZero(program), index, name);

}

bool WebGLRenderingContext::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)

{

    deleted = false;

    if (isContextLostOrPending())

        return false;

    if (object) {

        if (!object->validate(contextGroup(), this)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object not from this context");

            return false;

        }

        deleted = !object->object();

    }

    return true;

}

void WebGLRenderingContext::bindBuffer(GC3Denum target, WebGLBuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindBuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindBuffer", "buffers can not be used with multiple targets");

        return;

    }

    if (target == GraphicsContext3D::ARRAY_BUFFER)

        m_boundArrayBuffer = buffer;

    else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

        m_boundVertexArrayObject->setElementArrayBuffer(buffer);

    else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");

        return;

    }

    m_context->bindBuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setTarget(target);

}

void WebGLRenderingContext::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindFramebuffer", "invalid target");

        return;

    }

    m_framebufferBinding = buffer;

    if (m_drawingBuffer)

        m_drawingBuffer->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));

    if (!m_framebufferBinding && m_drawingBuffer) {

        // Instead of binding fb 0, bind the drawing buffer.

        m_drawingBuffer->bind();

    } else

        m_context->bindFramebuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setHasEverBeenBound();

    applyStencilTest();

}

void WebGLRenderingContext::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))

        return;

    if (deleted)

        renderBuffer = 0;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindRenderbuffer", "invalid target");

        return;

    }

    m_renderbufferBinding = renderBuffer;

    m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));

    if (renderBuffer)

        renderBuffer->setHasEverBeenBound();

}

void WebGLRenderingContext::bindTexture(GC3Denum target, WebGLTexture* texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindTexture", texture, deleted))

        return;

    if (deleted)

        texture = 0;

    if (texture && texture->getTarget() && texture->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");

        return;

    }

    GC3Dint maxLevel = 0;

    if (target == GraphicsContext3D::TEXTURE_2D) {

        m_textureUnits[m_activeTextureUnit].texture2DBinding = texture;

        maxLevel = m_maxTextureLevel;

        if (m_drawingBuffer && !m_activeTextureUnit)

            m_drawingBuffer->setTexture2DBinding(objectOrZero(texture));

    } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

        m_textureUnits[m_activeTextureUnit].textureCubeMapBinding = texture;

        maxLevel = m_maxCubeMapTextureLevel;

    } else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindTexture", "invalid target");

        return;

    }

    m_context->bindTexture(target, objectOrZero(texture));

    if (texture)

        texture->setTarget(target, maxLevel);

    // Note: previously we used to automatically set the TEXTURE_WRAP_R

    // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL

    // ES 2.0 doesn't expose this flag (a bug in the specification) and

    // otherwise the application has no control over the seams in this

    // dimension. However, it appears that supporting this properly on all

    // platforms is fairly involved (will require a HashMap from texture ID

    // in all ports), and we have not had any complaints, so the logic has

    // been removed.

}

void WebGLRenderingContext::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)

{

    if (isContextLostOrPending())

        return;

    m_context->blendColor(red, green, blue, alpha);

}

void WebGLRenderingContext::blendEquation(GC3Denum mode)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))

        return;

    m_context->blendEquation(mode);

}

void WebGLRenderingContext::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))

        return;

    m_context->blendEquationSeparate(modeRGB, modeAlpha);

}

void WebGLRenderingContext::blendFunc(GC3Denum sfactor, GC3Denum dfactor)

{

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))

        return;

    m_context->blendFunc(sfactor, dfactor);

}

void WebGLRenderingContext::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)

{

    // Note: Alpha does not have the same restrictions as RGB.

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))

        return;

    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

}

void WebGLRenderingContext::bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (size < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size < 0");

        return;

    }

    if (!size) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size == 0");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->data(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

GC3Denum WebGLRenderingContext::checkFramebufferStatus(GC3Denum target)

{

    if (isContextLostOrPending())

        return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "checkFramebufferStatus", "invalid target");

        return 0;

    }

    if (!m_framebufferBinding || !m_framebufferBinding->object())

        return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

    const char* reason = "framebuffer incomplete";

    GC3Denum result = m_framebufferBinding->checkStatus(&reason);

    if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {

        printGLWarningToConsole("checkFramebufferStatus", reason);

        return result;

    }

    result = m_context->checkFramebufferStatus(target);

    return result;

}

void WebGLRenderingContext::clear(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return;

    if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clear", "invalid mask");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);

        return;

    }

    if (!clearIfComposited(mask))

        m_context->clear(mask);

    markContextChanged();

}

void WebGLRenderingContext::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)

{

    if (isContextLostOrPending())

        return;

    if (std::isnan(r))

        r = 0;

    if (std::isnan(g))

        g = 0;

    if (std::isnan(b))

        b = 0;

    if (std::isnan(a))

        a = 1;

    m_clearColor[0] = r;

    m_clearColor[1] = g;

    m_clearColor[2] = b;

    m_clearColor[3] = a;

    m_context->clearColor(r, g, b, a);

}

void WebGLRenderingContext::clearDepth(GC3Dfloat depth)

{

    if (isContextLostOrPending())

        return;

    m_clearDepth = depth;

    m_context->clearDepth(depth);

}

void WebGLRenderingContext::clearStencil(GC3Dint s)

{

    if (isContextLostOrPending())

        return;

    m_clearStencil = s;

    m_context->clearStencil(s);

}

void WebGLRenderingContext::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)

{

    if (isContextLostOrPending())

        return;

    m_colorMask[0] = red;

    m_colorMask[1] = green;

    m_colorMask[2] = blue;

    m_colorMask[3] = alpha;

    m_context->colorMask(red, green, blue, alpha);

}

void WebGLRenderingContext::compileShader(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))

        return;

    m_context->compileShader(objectOrZero(shader));

    GC3Dint value;

    m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);

    shader->setValid(value);

}

void WebGLRenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                                                 GC3Dsizei height, GC3Dint border, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(internalformat)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");

        return;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "border not 0");

        return;

    }

    if (!validateCompressedTexDimensions("compressedTexImage2D", target, level, width, height, internalformat))

        return;

    if (!validateCompressedTexFuncData("compressedTexImage2D", width, height, internalformat, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);

    if (!tex)

        return;

    if (!isGLES2NPOTStrict()) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->compressedTexImage2D(target, level, internalformat, width, height,

        border, data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The compressedTexImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

        tex->markInvalid(target, level);

        return;

    }

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

    tex->setCompressed();

}

void WebGLRenderingContext::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                    GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(format)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexSubImage2D", "invalid format");

        return;

    }

    if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);

    if (!tex)

        return;

    if (format != tex->getInternalFormat(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");

        return;

    }

    if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))

        return;

    graphicsContext3D()->compressedTexSubImage2D(target, level, xoffset, yoffset,

                                                 width, height, format, data->byteLength(), data->baseAddress());

    tex->setCompressed();

}

bool WebGLRenderingContext::validateSettableTexFormat(const char* functionName, GC3Denum format)

{

    if (GraphicsContext3D::getClearBitsByFormat(format) & (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format can not be set, only rendered to");

        return false;

    }

    return true;

}

void WebGLRenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncParameters("copyTexImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

        return;

    if (!validateSettableTexFormat("copyTexImage2D", internalformat))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexImage2D", target, true);

    if (!tex)

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");

        return;

    }

    if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    } else {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            m_context->texImage2DResourceSafe(target, level, internalformat, width, height, border,

                                              internalformat, GraphicsContext3D::UNSIGNED_BYTE, m_unpackAlignment);

            if (clippedWidth > 0 && clippedHeight > 0) {

                m_context->copyTexSubImage2D(target, level, clippedX - x, clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else

            m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    }

    // FIXME: if the framebuffer is not complete, none of the below should be executed.

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

}

void WebGLRenderingContext::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("copyTexSubImage2D", target, level))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexSubImage2D", target, true);

    if (!tex)

        return;

    if (!validateSize("copyTexSubImage2D", xoffset, yoffset) || !validateSize("copyTexSubImage2D", width, height))

        return;

    // Before checking if it is in the range, check if overflow happens first.

    if (xoffset + width < 0 || yoffset + height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "bad dimensions");

        return;

    }

    if (xoffset + width > tex->getWidth(target, level) || yoffset + height > tex->getHeight(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");

        return;

    }

    GC3Denum internalformat = tex->getInternalFormat(target, level);

    if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

    } else {

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            GC3Denum format = tex->getInternalFormat(target, level);

            GC3Denum type = tex->getType(target, level);

            std::unique_ptr<unsigned char[]> zero;

            if (width && height) {

                unsigned int size;

                GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, 0);

                if (error != GraphicsContext3D::NO_ERROR) {

                    synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");

                    return;

                }

                zero = std::make_unique<unsigned char[]>(size);

                if (!zero) {

                    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "out of memory");

                    return;

                }

                memset(zero.get(), 0, size);

            }

            m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, zero.get());

            if (clippedWidth > 0 && clippedHeight > 0) {

                ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

                m_context->copyTexSubImage2D(target, level, xoffset + clippedX - x, yoffset + clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else {

            ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

            m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

        }

    }

}

PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);

    addContextObject(o.get());

    return o;

}

PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLTexture> o = WebGLTexture::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLProgram> o = WebGLProgram::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(GC3Denum type, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "createShader", "invalid shader type");

        return nullptr;

    }

    RefPtr<WebGLShader> o = WebGLShader::create(this, type);

    addSharedObject(o.get());

    return o;

}

void WebGLRenderingContext::cullFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->cullFace(mode);

}

bool WebGLRenderingContext::deleteObject(WebGLObject* object)

{

    if (isContextLostOrPending() || !object)

        return false;

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "delete", "object does not belong to this context");

        return false;

    }

    if (object->object())

        // We need to pass in context here because we want

        // things in this context unbound.

        object->deleteObject(graphicsContext3D());

    return true;

}

void WebGLRenderingContext::deleteBuffer(WebGLBuffer* buffer)

{

    if (!deleteObject(buffer))

        return;

    if (m_boundArrayBuffer == buffer)

        m_boundArrayBuffer = 0;

    m_boundVertexArrayObject->unbindBuffer(buffer);

}

void WebGLRenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!deleteObject(framebuffer))

        return;

    if (framebuffer == m_framebufferBinding) {

        m_framebufferBinding = 0;

        if (m_drawingBuffer) {

            m_drawingBuffer->setFramebufferBinding(0);

            // Have to call bindFramebuffer here to bind back to internal fbo.

            m_drawingBuffer->bind();

        } else

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

    }

}

void WebGLRenderingContext::deleteProgram(WebGLProgram* program)

{

    deleteObject(program);

    // We don't reset m_currentProgram to 0 here because the deletion of the

    // current program is delayed.

}

void WebGLRenderingContext::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!deleteObject(renderbuffer))

        return;

    if (renderbuffer == m_renderbufferBinding)

        m_renderbufferBinding = 0;

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);

}

void WebGLRenderingContext::deleteShader(WebGLShader* shader)

{

    deleteObject(shader);

}

void WebGLRenderingContext::deleteTexture(WebGLTexture* texture)

{

    if (!deleteObject(texture))

        return;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        if (texture == m_textureUnits[i].texture2DBinding)

            m_textureUnits[i].texture2DBinding = nullptr;

        if (texture == m_textureUnits[i].textureCubeMapBinding)

            m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);

}

void WebGLRenderingContext::depthFunc(GC3Denum func)

{

    if (isContextLostOrPending())

        return;

    m_context->depthFunc(func);

}

void WebGLRenderingContext::depthMask(GC3Dboolean flag)

{

    if (isContextLostOrPending())

        return;

    m_depthMask = flag;

    m_context->depthMask(flag);

}

void WebGLRenderingContext::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)

{

    if (isContextLostOrPending())

        return;

    if (zNear > zFar) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "depthRange", "zNear > zFar");

        return;

    }

    m_context->depthRange(zNear, zFar);

}

void WebGLRenderingContext::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))

        return;

    if (!program->detachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "detachShader", "shader not attached");

        return;

    }

    m_context->detachShader(objectOrZero(program), objectOrZero(shader));

    shader->onDetached(graphicsContext3D());

}

void WebGLRenderingContext::disable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("disable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = false;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = false;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->disable(cap);

}

void WebGLRenderingContext::disableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "disableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = false;

    if (index > 0 || isGLES2Compliant())

        m_context->disableVertexAttribArray(index);

}

bool WebGLRenderingContext::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)

{

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (offset < 0)

        return false;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // For an unsigned int array, offset must be divisible by 4 for alignment reasons.

        if (offset % 4)

            return false;

        // Make uoffset an element offset.

        offset /= 4;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // For an unsigned short array, offset must be divisible by 2 for alignment reasons.

        if (offset % 2)

            return false;

        // Make uoffset an element offset.

        offset /= 2;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        GC3Dsizeiptr n = elementArrayBuffer->byteLength();

        if (offset > n || count > n - offset)

            return false;

    }

    return true;

}

bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)

{

    // Performs conservative validation by caching a maximum index of

    // the given type per element array buffer. If all of the bound

    // array buffers have enough elements to satisfy that maximum

    // index, skips the expensive per-draw-call iteration in

    // validateIndexArrayPrecise.

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();

    // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.

    if (!numElements)

        return false;

    const ArrayBuffer* buffer = elementArrayBuffer->elementArrayBuffer();

    ASSERT(buffer);

    int maxIndex = elementArrayBuffer->getCachedMaxIndex(type);

    if (maxIndex < 0) {

        // Compute the maximum index in the entire buffer for the given type of index.

        switch (type) {

        case GraphicsContext3D::UNSIGNED_BYTE: {

            const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_SHORT: {

            numElements /= sizeof(GC3Dushort);

            const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_INT: {

            if (!m_oesElementIndexUint)

                return false;

            numElements /= sizeof(GC3Duint);

            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        default:

            return false;

        }

        elementArrayBuffer->setCachedMaxIndex(type, maxIndex);

    }

    if (maxIndex >= 0) {

        // The number of required elements is one more than the maximum

        // index that will be accessed.

        numElementsRequired = maxIndex + 1;

        return true;

    }

    return false;

}

bool WebGLRenderingContext::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)

{

    ASSERT(count >= 0 && offset >= 0);

    unsigned lastIndex = 0;

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (!count) {

        numElementsRequired = 0;

        return true;

    }

    if (!elementArrayBuffer->elementArrayBuffer())

        return false;

    unsigned long uoffset = offset;

    unsigned long n = count;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Duint);

        const GC3Duint* p = static_cast<const GC3Duint*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Dushort);

        const GC3Dushort* p = static_cast<const GC3Dushort*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        const GC3Dubyte* p = static_cast<const GC3Dubyte*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    }

    // Then set the last index in the index array and make sure it is valid.

    numElementsRequired = lastIndex + 1;

    return numElementsRequired > 0;

}

bool WebGLRenderingContext::validateVertexAttributes(unsigned elementCount, unsigned primitiveCount)

{

    if (!m_currentProgram)

        return false;

    // Look in each enabled vertex attrib and check if they've been bound to a buffer.

    for (unsigned i = 0; i < m_maxVertexAttribs; ++i) {

        if (!m_boundVertexArrayObject->getVertexAttribState(i).validateBinding())

            return false;

    }

    if (elementCount <= 0)

        return true;

    // Look in each consumed vertex attrib (by the current program).

    bool sawNonInstancedAttrib = false;

    bool sawEnabledAttrib = false;

    int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();

    for (int i = 0; i < numActiveAttribLocations; ++i) {

        int loc = m_currentProgram->getActiveAttribLocation(i);

        if (loc >= 0 && loc < static_cast<int>(m_maxVertexAttribs)) {

            const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(loc);

            if (state.enabled) {

                sawEnabledAttrib = true;

                // Avoid off-by-one errors in numElements computation.

                // For the last element, we will only touch the data for the

                // element and nothing beyond it.

                int bytesRemaining = static_cast<int>(state.bufferBinding->byteLength() - state.offset);

                unsigned numElements = 0;

                ASSERT(state.stride > 0);

                if (bytesRemaining >= state.bytesPerElement)

                    numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;

                unsigned instancesRequired = 0;

                if (state.divisor) {

                    instancesRequired = ceil(static_cast<float>(primitiveCount) / state.divisor);

                    if (instancesRequired > numElements)

                        return false;

                } else {

                    sawNonInstancedAttrib = true;

                    if (elementCount > numElements)

                        return false;

                }

            }

        }

    }

    if (!sawNonInstancedAttrib && sawEnabledAttrib)

        return false;

    return true;

}

bool WebGLRenderingContext::validateWebGLObject(const char* functionName, WebGLObject* object)

{

    if (!object || !object->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no object or object deleted");

        return false;

    }

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object does not belong to this context");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    if (first < 0 || count < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "first or count < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        Checked<GC3Dint, RecordOverflow> checkedFirst(first);

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount;

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedSum.hasOverflowed() || checkedPrimitiveCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimitiveCount.unsafeGet())) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateDrawArrays("drawArrays", mode, first, count, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", true);

    m_context->drawArrays(mode, first, count);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", false);

    markContextChanged();

}

bool WebGLRenderingContext::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT:

        break;

    case GraphicsContext3D::UNSIGNED_INT:

        if (m_oesElementIndexUint)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    }

    if (count < 0 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "count or offset < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!m_boundVertexArrayObject->getElementArrayBuffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");

            return false;

        }

        if (!count)

            return false;

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedCount.hasOverflowed() || checkedPrimitiveCount.hasOverflowed()) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

        if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

            if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

                return false;

            }

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    unsigned numElements = 0;

    if (!validateDrawElements("drawElements", mode, count, type, offset, numElements, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", true);

    m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", false);

    markContextChanged();

}

void WebGLRenderingContext::enable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("enable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = true;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = true;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->enable(cap);

}

void WebGLRenderingContext::enableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "enableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = true;

    m_context->enableVertexAttribArray(index);

}

void WebGLRenderingContext::finish()

{

    if (isContextLostOrPending())

        return;

    m_context->finish();

}

void WebGLRenderingContext::flush()

{

    if (isContextLostOrPending())

        return;

    m_context->flush();

}

void WebGLRenderingContext::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))

        return;

    if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "framebufferRenderbuffer", "invalid target");

        return;

    }

    if (buffer && !buffer->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");

        return;

    }

    Platform3DObject bufferObject = objectOrZero(buffer);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);

        break;

    default:

        m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);

    applyStencilTest();

}

void WebGLRenderingContext::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))

        return;

    if (level) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "framebufferTexture2D", "level not 0");

        return;

    }

    if (texture && !texture->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");

        return;

    }

    Platform3DObject textureObject = objectOrZero(texture);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, GraphicsContext3D::DEPTH_ATTACHMENT, textarget, textureObject, level);

        m_context->framebufferTexture2D(target, GraphicsContext3D::STENCIL_ATTACHMENT, textarget, textureObject, level);

        break;

    case GraphicsContext3D::DEPTH_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    case GraphicsContext3D::STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    default:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);

    applyStencilTest();

}

void WebGLRenderingContext::frontFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->frontFace(mode);

}

void WebGLRenderingContext::generateMipmap(GC3Denum target)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);

    if (!tex)

        return;

    if (!tex->canGenerateMipmaps()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");

        return;

    }

    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=123916. Compressed textures should be allowed in WebGL 2:

    if (tex->isCompressed()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "trying to generate mipmaps from compressed texture");

        return;

    }

    if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))

        return;

    // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR

    // on Mac.  Remove the hack once this driver bug is fixed.

#if OS(DARWIN)

    bool needToResetMinFilter = false;

    if (tex->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_LINEAR) {

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::NEAREST_MIPMAP_LINEAR);

        needToResetMinFilter = true;

    }

#endif

    m_context->generateMipmap(target);

#if OS(DARWIN)

    if (needToResetMinFilter)

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, tex->getMinFilter());

#endif

    tex->generateMipmapLevelInfo();

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveAttrib(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))

        return nullptr;

    ActiveInfo info;

    if (!m_context->getActiveAttrib(objectOrZero(program), index, info))

        return nullptr;

    LOG(WebGL, "Returning active attribute %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveUniform(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))

        return 0;

    ActiveInfo info;

    if (!m_context->getActiveUniform(objectOrZero(program), index, info))

        return nullptr;

    if (!isGLES2Compliant())

        if (info.size > 1 && !info.name.endsWith("[0]"))

            info.name.append("[0]");

    LOG(WebGL, "Returning active uniform %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

bool WebGLRenderingContext::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    shaderObjects.clear();

    if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))

        return false;

    const GC3Denum shaderType[] = {

        GraphicsContext3D::VERTEX_SHADER,

        GraphicsContext3D::FRAGMENT_SHADER

    };

    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {

        WebGLShader* shader = program->getAttachedShader(shaderType[i]);

        if (shader)

            shaderObjects.append(shader);

    }

    return true;

}

GC3Dint WebGLRenderingContext::getAttribLocation(WebGLProgram* program, const String& name)

{

    if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))

        return -1;

    if (!validateLocationLength("getAttribLocation", name))

        return -1;

    if (!validateString("getAttribLocation", name))

        return -1;

    if (isPrefixReserved(name))

        return -1;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getAttribLocation", "program not linked");

        return -1;

    }

    return m_context->getAttribLocation(objectOrZero(program), name);

}

WebGLGetInfo WebGLRenderingContext::getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (pname != GraphicsContext3D::BUFFER_SIZE && pname != GraphicsContext3D::BUFFER_USAGE) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    GC3Dint value = 0;

    m_context->getBufferParameteriv(target, pname, &value);

    if (pname == GraphicsContext3D::BUFFER_SIZE)

        return WebGLGetInfo(value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

PassRefPtr<WebGLContextAttributes> WebGLRenderingContext::getContextAttributes()

{

    if (isContextLostOrPending())

        return nullptr;

    // We always need to return a new WebGLContextAttributes object to

    // prevent the user from mutating any cached version.

    // Also, we need to enforce requested values of "false" for depth

    // and stencil, regardless of the properties of the underlying

    // GraphicsContext3D or DrawingBuffer.

    RefPtr<WebGLContextAttributes> attributes = WebGLContextAttributes::create(m_context->getContextAttributes());

    if (!m_attributes.depth)

        attributes->setDepth(false);

    if (!m_attributes.stencil)

        attributes->setStencil(false);

    if (m_drawingBuffer) {

        // The DrawingBuffer obtains its parameters from GraphicsContext3D::getContextAttributes(),

        // but it makes its own determination of whether multisampling is supported.

        attributes->setAntialias(m_drawingBuffer->multisample());

    }

    return attributes.release();

}

GC3Denum WebGLRenderingContext::getError()

{

    if (m_isPendingPolicyResolution)

        return GraphicsContext3D::NO_ERROR;

    return m_context->getError();

}

WebGLExtension* WebGLRenderingContext::getExtension(const String& name)

{

    if (isContextLostOrPending())

        return nullptr;

    if (equalIgnoringCase(name, "EXT_blend_minmax")

        && m_context->getExtensions()->supports("GL_EXT_blend_minmax")) {

        if (!m_extBlendMinMax) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_blend_minmax");

            m_extBlendMinMax = std::make_unique<EXTBlendMinMax>(this);

        }

        return m_extBlendMinMax.get();

    }

    if (equalIgnoringCase(name, "EXT_sRGB")

        && m_context->getExtensions()->supports("GL_EXT_sRGB")) {

        if (!m_extsRGB) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_sRGB");

            m_extsRGB = std::make_unique<EXTsRGB>(this);

        }

        return m_extsRGB.get();

    }

    if (equalIgnoringCase(name, "EXT_frag_depth")

        && m_context->getExtensions()->supports("GL_EXT_frag_depth")) {

        if (!m_extFragDepth) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_frag_depth");

            m_extFragDepth = std::make_unique<EXTFragDepth>(this);

        }

        return m_extFragDepth.get();

    }

    if (equalIgnoringCase(name, "EXT_shader_texture_lod")

        && (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))) {

        if (!m_extShaderTextureLOD) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_shader_texture_lod");

            m_extShaderTextureLOD = std::make_unique<EXTShaderTextureLOD>(this);

        }

        return m_extShaderTextureLOD.get();

    }

    if (equalIgnoringCase(name, "WEBKIT_EXT_texture_filter_anisotropic")

        && m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic")) {

        if (!m_extTextureFilterAnisotropic) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_texture_filter_anisotropic");

            m_extTextureFilterAnisotropic = std::make_unique<EXTTextureFilterAnisotropic>(this);

        }

        return m_extTextureFilterAnisotropic.get();

    }

    if (equalIgnoringCase(name, "OES_standard_derivatives")

        && m_context->getExtensions()->supports("GL_OES_standard_derivatives")) {

        if (!m_oesStandardDerivatives) {

            m_context->getExtensions()->ensureEnabled("GL_OES_standard_derivatives");

            m_oesStandardDerivatives = std::make_unique<OESStandardDerivatives>(this);

        }

        return m_oesStandardDerivatives.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float")

        && m_context->getExtensions()->supports("GL_OES_texture_float")) {

        if (!m_oesTextureFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float");

            m_oesTextureFloat = std::make_unique<OESTextureFloat>(this);

        }

        return m_oesTextureFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_float_linear")) {

        if (!m_oesTextureFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float_linear");

            m_oesTextureFloatLinear = std::make_unique<OESTextureFloatLinear>(this);

        }

        return m_oesTextureFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float")) {

        if (!m_oesTextureHalfFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float");

            m_oesTextureHalfFloat = std::make_unique<OESTextureHalfFloat>(this);

        }

        return m_oesTextureHalfFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float_linear")) {

        if (!m_oesTextureHalfFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float_linear");

            m_oesTextureHalfFloatLinear = std::make_unique<OESTextureHalfFloatLinear>(this);

        }

        return m_oesTextureHalfFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_vertex_array_object")

        && m_context->getExtensions()->supports("GL_OES_vertex_array_object")) {

        if (!m_oesVertexArrayObject) {

            m_context->getExtensions()->ensureEnabled("GL_OES_vertex_array_object");

            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(this);

        }

        return m_oesVertexArrayObject.get();

    }

    if (equalIgnoringCase(name, "OES_element_index_uint")

        && m_context->getExtensions()->supports("GL_OES_element_index_uint")) {

        if (!m_oesElementIndexUint) {

            m_context->getExtensions()->ensureEnabled("GL_OES_element_index_uint");

            m_oesElementIndexUint = std::make_unique<OESElementIndexUint>(this);

        }

        return m_oesElementIndexUint.get();

    }

    if (equalIgnoringCase(name, "WEBGL_lose_context")) {

        if (!m_webglLoseContext)

            m_webglLoseContext = std::make_unique<WebGLLoseContext>(this);

        return m_webglLoseContext.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_atc"))

        && WebGLCompressedTextureATC::supported(this)) {

        if (!m_webglCompressedTextureATC)

            m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(this);

        return m_webglCompressedTextureATC.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc"))

        && WebGLCompressedTexturePVRTC::supported(this)) {

        if (!m_webglCompressedTexturePVRTC)

            m_webglCompressedTexturePVRTC = std::make_unique<WebGLCompressedTexturePVRTC>(this);

        return m_webglCompressedTexturePVRTC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_compressed_texture_s3tc")

        && WebGLCompressedTextureS3TC::supported(this)) {

        if (!m_webglCompressedTextureS3TC)

            m_webglCompressedTextureS3TC = std::make_unique<WebGLCompressedTextureS3TC>(this);

        return m_webglCompressedTextureS3TC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_depth_texture")

        && WebGLDepthTexture::supported(graphicsContext3D())) {

        if (!m_webglDepthTexture) {

            m_context->getExtensions()->ensureEnabled("GL_CHROMIUM_depth_texture");

            m_webglDepthTexture = std::make_unique<WebGLDepthTexture>(this);

        }

        return m_webglDepthTexture.get();

    }

    if (equalIgnoringCase(name, "WEBGL_draw_buffers") && supportsDrawBuffers()) {

        if (!m_webglDrawBuffers) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_draw_buffers");

            m_webglDrawBuffers = std::make_unique<WebGLDrawBuffers>(this);

        }

        return m_webglDrawBuffers.get();

    }

    if (equalIgnoringCase(name, "ANGLE_instanced_arrays") && ANGLEInstancedArrays::supported(this)) {

        if (!m_angleInstancedArrays) {

            m_context->getExtensions()->ensureEnabled("GL_ANGLE_instanced_arrays");

            m_angleInstancedArrays = std::make_unique<ANGLEInstancedArrays>(this);

        }

        return m_angleInstancedArrays.get();

    }

    if (allowPrivilegedExtensions()) {

        if (equalIgnoringCase(name, "WEBGL_debug_renderer_info")) {

            if (!m_webglDebugRendererInfo)

                m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(this);

            return m_webglDebugRendererInfo.get();

        }

        if (equalIgnoringCase(name, "WEBGL_debug_shaders")

            && m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source")) {

            if (!m_webglDebugShaders)

                m_webglDebugShaders = std::make_unique<WebGLDebugShaders>(this);

            return m_webglDebugShaders.get();

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))

        return WebGLGetInfo();

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");

        return WebGLGetInfo();

    }

    WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(attachment);

    if (!object) {

        if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)

            return WebGLGetInfo(GraphicsContext3D::NONE);

        // OpenGL ES 2.0 specifies INVALID_ENUM in this case, while desktop GL

        // specifies INVALID_OPERATION.

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    ASSERT(object->isTexture() || object->isRenderbuffer());

    if (object->isTexture()) {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::TEXTURE);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLTexture>(reinterpret_cast<WebGLTexture*>(object)));

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            GC3Dint value = 0;

            m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);

            return WebGLGetInfo(value);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");

            return WebGLGetInfo();

        }

    } else {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::RENDERBUFFER);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(reinterpret_cast<WebGLRenderbuffer*>(object)));

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            WebGLRenderbuffer* renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object);

            GC3Denum renderBufferFormat = renderBuffer->getInternalFormat();

            ASSERT(renderBufferFormat != Extensions3D::SRGB_EXT && renderBufferFormat != Extensions3D::SRGB_ALPHA_EXT);

            if (renderBufferFormat == Extensions3D::SRGB8_ALPHA8_EXT)

                return WebGLGetInfo(Extensions3D::SRGB_EXT);

            return WebGLGetInfo(GraphicsContext3D::LINEAR);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");

            return WebGLGetInfo();

        }

    }

}

WebGLGetInfo WebGLRenderingContext::getParameter(GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    const int intZero = 0;

    switch (pname) {

    case GraphicsContext3D::ACTIVE_TEXTURE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALPHA_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));

    case GraphicsContext3D::BLEND:

        return getBooleanParameter(pname);

    case GraphicsContext3D::BLEND_COLOR:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::BLEND_DST_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_DST_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLUE_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::COLOR_WRITEMASK:

        return getBooleanArrayParameter(pname);

    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:

        return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));

    case GraphicsContext3D::CULL_FACE:

        return getBooleanParameter(pname);

    case GraphicsContext3D::CULL_FACE_MODE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::CURRENT_PROGRAM:

        return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));

    case GraphicsContext3D::DEPTH_BITS:

        if (!m_framebufferBinding && !m_attributes.depth)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::DEPTH_CLEAR_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::DEPTH_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::DEPTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::DEPTH_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DEPTH_WRITEMASK:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DITHER:

        return getBooleanParameter(pname);

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->getElementArrayBuffer()));

    case GraphicsContext3D::FRAMEBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));

    case GraphicsContext3D::FRONT_FACE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GREEN_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::LINE_WIDTH:

        return getFloatParameter(pname);

    case GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_RENDERBUFFER_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VARYING_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_ATTRIBS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::NUM_SHADER_BINARY_FORMATS:

        // FIXME: should we always return 0 for this?

        return getIntParameter(pname);

    case GraphicsContext3D::PACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FACTOR:

        return getFloatParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

        return getBooleanParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_UNITS:

        return getFloatParameter(pname);

    case GraphicsContext3D::RED_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::RENDERBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));

    case GraphicsContext3D::RENDERER:

        return WebGLGetInfo(String("WebKit WebGL"));

    case GraphicsContext3D::SAMPLE_BUFFERS:

        return getIntParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_INVERT:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::SAMPLES:

        return getIntParameter(pname);

    case GraphicsContext3D::SCISSOR_BOX:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::SCISSOR_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SHADING_LANGUAGE_VERSION:

        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + m_context->getString(GraphicsContext3D::SHADING_LANGUAGE_VERSION) + ")");

    case GraphicsContext3D::STENCIL_BACK_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BITS:

        if (!m_framebufferBinding && !m_attributes.stencil)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_CLEAR_VALUE:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::STENCIL_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::SUBPIXEL_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::TEXTURE_BINDING_2D:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].texture2DBinding));

    case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].textureCubeMapBinding));

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        return WebGLGetInfo(m_unpackFlipY);

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        return WebGLGetInfo(m_unpackPremultiplyAlpha);

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        return WebGLGetInfo(m_unpackColorspaceConversion);

    case GraphicsContext3D::VENDOR:

        return WebGLGetInfo(String("WebKit"));

    case GraphicsContext3D::VERSION:

        return WebGLGetInfo("WebGL 1.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")");

    case GraphicsContext3D::VIEWPORT:

        return getWebGLIntArrayParameter(pname);

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            return getUnsignedIntParameter(Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::RENDERER));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::VENDOR));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case Extensions3D::VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object

        if (m_oesVertexArrayObject) {

            if (!m_boundVertexArrayObject->isDefaultObject())

                return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject));

            return WebGLGetInfo();

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic)

            return getUnsignedIntParameter(Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxColorAttachments());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_DRAW_BUFFERS_EXT:

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxDrawBuffers());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    default:

        if (m_webglDrawBuffers

            && pname >= Extensions3D::DRAW_BUFFER0_EXT

            && pname < static_cast<GC3Denum>(Extensions3D::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {

            GC3Dint value = GraphicsContext3D::NONE;

            if (m_framebufferBinding)

                value = m_framebufferBinding->getDrawBuffer(pname);

            else // emulated backbuffer

                value = m_backDrawBuffer;

            return WebGLGetInfo(value);

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getProgramParameter(WebGLProgram* program, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(program->isDeleted());

    case GraphicsContext3D::VALIDATE_STATUS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::LINK_STATUS:

        return WebGLGetInfo(program->getLinkStatus());

    case GraphicsContext3D::ATTACHED_SHADERS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::ACTIVE_ATTRIBUTES:

    case GraphicsContext3D::ACTIVE_UNIFORMS:

        m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getProgramParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getProgramInfoLog(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getProgramInfoLog", program))

        return "";

    return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));

}

WebGLGetInfo WebGLRenderingContext::getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");

        return WebGLGetInfo();

    }

    if (m_renderbufferBinding->getInternalFormat() == GraphicsContext3D::DEPTH_STENCIL

        && !m_renderbufferBinding->isValid()) {

        ASSERT(!isDepthStencilSupported());

        int value = 0;

        switch (pname) {

        case GraphicsContext3D::RENDERBUFFER_WIDTH:

            value = m_renderbufferBinding->getWidth();

            break;

        case GraphicsContext3D::RENDERBUFFER_HEIGHT:

            value = m_renderbufferBinding->getHeight();

            break;

        case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

        case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

        case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

        case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

            value = 0;

            break;

        case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

            value = 24;

            break;

        case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

            value = 8;

            break;

        case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

            return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

            return WebGLGetInfo();

        }

        return WebGLGetInfo(value);

    }

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::RENDERBUFFER_WIDTH:

    case GraphicsContext3D::RENDERBUFFER_HEIGHT:

    case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

    case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

    case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

    case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

    case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

    case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

        m_context->getRenderbufferParameteriv(target, pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

        return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getShaderParameter(WebGLShader* shader, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(shader->isDeleted());

    case GraphicsContext3D::COMPILE_STATUS:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::SHADER_TYPE:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getShaderInfoLog(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderInfoLog", shader))

        return "";

    return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));

}

PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContext::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    switch (shaderType) {

    case GraphicsContext3D::VERTEX_SHADER:

    case GraphicsContext3D::FRAGMENT_SHADER:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");

        return nullptr;

    }

    switch (precisionType) {

    case GraphicsContext3D::LOW_FLOAT:

    case GraphicsContext3D::MEDIUM_FLOAT:

    case GraphicsContext3D::HIGH_FLOAT:

    case GraphicsContext3D::LOW_INT:

    case GraphicsContext3D::MEDIUM_INT:

    case GraphicsContext3D::HIGH_INT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");

        return nullptr;

    }

    GC3Dint range[2] = {0, 0};

    GC3Dint precision = 0;

    m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);

    return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);

}

String WebGLRenderingContext::getShaderSource(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderSource", shader))

        return "";

    return ensureNotNull(shader->getSource());

}

Vector<String> WebGLRenderingContext::getSupportedExtensions()

{

    Vector<String> result;

    if (m_isPendingPolicyResolution)

        return result;

    if (m_context->getExtensions()->supports("GL_EXT_blend_minmax"))

        result.append("EXT_blend_minmax");

    if (m_context->getExtensions()->supports("GL_EXT_sRGB"))

        result.append("EXT_sRGB");

    if (m_context->getExtensions()->supports("GL_EXT_frag_depth"))

        result.append("EXT_frag_depth");

    if (m_context->getExtensions()->supports("GL_OES_texture_float"))

        result.append("OES_texture_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_float_linear"))

        result.append("OES_texture_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float"))

        result.append("OES_texture_half_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float_linear"))

        result.append("OES_texture_half_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_standard_derivatives"))

        result.append("OES_standard_derivatives");

    if (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))

        result.append("EXT_shader_texture_lod");

    if (m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic"))

        result.append("WEBKIT_EXT_texture_filter_anisotropic");

    if (m_context->getExtensions()->supports("GL_OES_vertex_array_object"))

        result.append("OES_vertex_array_object");

    if (m_context->getExtensions()->supports("GL_OES_element_index_uint"))

        result.append("OES_element_index_uint");

    result.append("WEBGL_lose_context");

    if (WebGLCompressedTextureATC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_atc");

    if (WebGLCompressedTexturePVRTC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_pvrtc");

    if (WebGLCompressedTextureS3TC::supported(this))

        result.append("WEBGL_compressed_texture_s3tc");

    if (WebGLDepthTexture::supported(graphicsContext3D()))

        result.append("WEBGL_depth_texture");

    if (supportsDrawBuffers())

        result.append("WEBGL_draw_buffers");

    if (ANGLEInstancedArrays::supported(this))

        result.append("ANGLE_instanced_arrays");

    if (allowPrivilegedExtensions()) {

        if (m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source"))

            result.append("WEBGL_debug_shaders");

        result.append("WEBGL_debug_renderer_info");

    }

    return result;

}

WebGLGetInfo WebGLRenderingContext::getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);

    if (!tex)

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        m_context->getTexParameteriv(target, pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic) {

            m_context->getTexParameteriv(target, pname, &value);

            return WebGLGetInfo(static_cast<unsigned int>(value));

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniform", program))

        return WebGLGetInfo();

    if (!uniformLocation || uniformLocation->program() != program) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");

        return WebGLGetInfo();

    }

    GC3Dint location = uniformLocation->location();

    GC3Denum baseType;

    unsigned length;

    switch (uniformLocation->type()) {

    case GraphicsContext3D::BOOL:

        baseType = GraphicsContext3D::BOOL;

        length = 1;

        break;

    case GraphicsContext3D::BOOL_VEC2:

        baseType = GraphicsContext3D::BOOL;

        length = 2;

        break;

    case GraphicsContext3D::BOOL_VEC3:

        baseType = GraphicsContext3D::BOOL;

        length = 3;

        break;

    case GraphicsContext3D::BOOL_VEC4:

        baseType = GraphicsContext3D::BOOL;

        length = 4;

        break;

    case GraphicsContext3D::INT:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    case GraphicsContext3D::INT_VEC2:

        baseType = GraphicsContext3D::INT;

        length = 2;

        break;

    case GraphicsContext3D::INT_VEC3:

        baseType = GraphicsContext3D::INT;

        length = 3;

        break;

    case GraphicsContext3D::INT_VEC4:

        baseType = GraphicsContext3D::INT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT:

        baseType = GraphicsContext3D::FLOAT;

        length = 1;

        break;

    case GraphicsContext3D::FLOAT_VEC2:

        baseType = GraphicsContext3D::FLOAT;

        length = 2;

        break;

    case GraphicsContext3D::FLOAT_VEC3:

        baseType = GraphicsContext3D::FLOAT;

        length = 3;

        break;

    case GraphicsContext3D::FLOAT_VEC4:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT2:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT3:

        baseType = GraphicsContext3D::FLOAT;

        length = 9;

        break;

    case GraphicsContext3D::FLOAT_MAT4:

        baseType = GraphicsContext3D::FLOAT;

        length = 16;

        break;

    case GraphicsContext3D::SAMPLER_2D:

    case GraphicsContext3D::SAMPLER_CUBE:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    default:

        // Can't handle this type

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unhandled type");

        return WebGLGetInfo();

    }

    switch (baseType) {

    case GraphicsContext3D::FLOAT: {

        GC3Dfloat value[16] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);

        else

            m_context->getUniformfv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Float32Array::create(value, length));

    }

    case GraphicsContext3D::INT: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Int32Array::create(value, length));

    }

    case GraphicsContext3D::BOOL: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length > 1) {

            bool boolValue[16] = {0};

            for (unsigned j = 0; j < length; j++)

                boolValue[j] = static_cast<bool>(value[j]);

            return WebGLGetInfo(boolValue, length);

        }

        return WebGLGetInfo(static_cast<bool>(value[0]));

    }

    default:

        notImplemented();

    }

    // If we get here, something went wrong in our unfortunately complex logic above

    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unknown error");

    return WebGLGetInfo();

}

PassRefPtr<WebGLUniformLocation> WebGLRenderingContext::getUniformLocation(WebGLProgram* program, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniformLocation", program))

        return nullptr;

    if (!validateLocationLength("getUniformLocation", name))

        return nullptr;

    if (!validateString("getUniformLocation", name))

        return nullptr;

    if (isPrefixReserved(name))

        return nullptr;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniformLocation", "program not linked");

        return nullptr;

    }

    GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);

    if (uniformLocation == -1)

        return nullptr;

    GC3Dint activeUniforms = 0;

    m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContext3D::ACTIVE_UNIFORMS, &activeUniforms);

    for (GC3Dint i = 0; i < activeUniforms; i++) {

        ActiveInfo info;

        if (!m_context->getActiveUniform(objectOrZero(program), i, info))

            return nullptr;

        // Strip "[0]" from the name if it's an array.

        if (info.name.endsWith("[0]"))

            info.name = info.name.left(info.name.length() - 3);

        // If it's an array, we need to iterate through each element, appending "[index]" to the name.

        for (GC3Dint index = 0; index < info.size; ++index) {

            String uniformName = info.name + "[" + String::number(index) + "]";

            if (name == uniformName || name == info.name)

                return WebGLUniformLocation::create(program, uniformLocation, info.type);

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getVertexAttrib", "index out of range");

        return WebGLGetInfo();

    }

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    if (m_angleInstancedArrays && pname == GraphicsContext3D::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)

        return WebGLGetInfo(state.divisor);

    switch (pname) {

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:

        if ((!isGLES2Compliant() && !index && m_boundVertexArrayObject->getVertexAttribState(0).bufferBinding == m_vertexAttrib0Buffer)

            || !state.bufferBinding

            || !state.bufferBinding->object())

            return WebGLGetInfo();

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_ENABLED:

        return WebGLGetInfo(state.enabled);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_NORMALIZED:

        return WebGLGetInfo(state.normalized);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_SIZE:

        return WebGLGetInfo(state.size);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_STRIDE:

        return WebGLGetInfo(state.originalStride);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_TYPE:

        return WebGLGetInfo(state.type);

    case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:

        return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");

        return WebGLGetInfo();

    }

}

long long WebGLRenderingContext::getVertexAttribOffset(GC3Duint index, GC3Denum pname)

{

    if (isContextLostOrPending())

        return 0;

    GC3Dsizeiptr result = m_context->getVertexAttribOffset(index, pname);

    return static_cast<long long>(result);

}

void WebGLRenderingContext::hint(GC3Denum target, GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    bool isValid = false;

    switch (target) {

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        isValid = true;

        break;

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            isValid = true;

        break;

    }

    if (!isValid) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");

        return;

    }

    m_context->hint(target, mode);

}

GC3Dboolean WebGLRenderingContext::isBuffer(WebGLBuffer* buffer)

{

    if (!buffer || isContextLostOrPending())

        return 0;

    if (!buffer->hasEverBeenBound())

        return 0;

    return m_context->isBuffer(buffer->object());

}

bool WebGLRenderingContext::isContextLost() const

{

    return m_contextLost;

}

bool WebGLRenderingContext::isContextLostOrPending()

{

    if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {

        LOG(WebGL, "Context is being used. Attempt to resolve the policy.");

        Document& document = canvas()->document().topDocument();

        Page* page = document.page();

        if (page && !document.url().isLocalFile())

            page->mainFrame().loader().client().resolveWebGLPolicyForURL(document.url());

        // FIXME: We don't currently do anything with the result from resolution. A more

        // complete implementation might try to construct a real context, etc and proceed

        // with normal operation.

        // https://bugs.webkit.org/show_bug.cgi?id=129122

        m_hasRequestedPolicyResolution = true;

    }

    return m_contextLost || m_isPendingPolicyResolution;

}

GC3Dboolean WebGLRenderingContext::isEnabled(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("isEnabled", cap))

        return 0;

    if (cap == GraphicsContext3D::STENCIL_TEST)

        return m_stencilEnabled;

    return m_context->isEnabled(cap);

}

GC3Dboolean WebGLRenderingContext::isFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!framebuffer || isContextLostOrPending())

        return 0;

    if (!framebuffer->hasEverBeenBound())

        return 0;

    return m_context->isFramebuffer(framebuffer->object());

}

GC3Dboolean WebGLRenderingContext::isProgram(WebGLProgram* program)

{

    if (!program || isContextLostOrPending())

        return 0;

    return m_context->isProgram(program->object());

}

GC3Dboolean WebGLRenderingContext::isRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!renderbuffer || isContextLostOrPending())

        return 0;

    if (!renderbuffer->hasEverBeenBound())

        return 0;

    return m_context->isRenderbuffer(renderbuffer->object());

}

GC3Dboolean WebGLRenderingContext::isShader(WebGLShader* shader)

{

    if (!shader || isContextLostOrPending())

        return 0;

    return m_context->isShader(shader->object());

}

GC3Dboolean WebGLRenderingContext::isTexture(WebGLTexture* texture)

{

    if (!texture || isContextLostOrPending())

        return 0;

    if (!texture->hasEverBeenBound())

        return 0;

    return m_context->isTexture(texture->object());

}

void WebGLRenderingContext::lineWidth(GC3Dfloat width)

{

    if (isContextLostOrPending())

        return;

    m_context->lineWidth(width);

}

void WebGLRenderingContext::linkProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("linkProgram", program))

        return;

    if (!isGLES2Compliant()) {

        WebGLShader* vertexShader = program->getAttachedShader(GraphicsContext3D::VERTEX_SHADER);

        WebGLShader* fragmentShader = program->getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);

        if (!vertexShader || !vertexShader->isValid() || !fragmentShader || !fragmentShader->isValid() || !m_context->precisionsMatch(objectOrZero(vertexShader), objectOrZero(fragmentShader)) || !m_context->checkVaryingsPacking(objectOrZero(vertexShader), objectOrZero(fragmentShader))) {

            program->setLinkStatus(false);

            return;

        }

    }

    m_context->linkProgram(objectOrZero(program));

    program->increaseLinkCount();

}

void WebGLRenderingContext::pixelStorei(GC3Denum pname, GC3Dint param)

{

    if (isContextLostOrPending())

        return;

    switch (pname) {

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        m_unpackFlipY = param;

        break;

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        m_unpackPremultiplyAlpha = param;

        break;

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        if (param == GraphicsContext3D::BROWSER_DEFAULT_WEBGL || param == GraphicsContext3D::NONE)

            m_unpackColorspaceConversion = static_cast<GC3Denum>(param);

        else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");

            return;

        }

        break;

    case GraphicsContext3D::PACK_ALIGNMENT:

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        if (param == 1 || param == 2 || param == 4 || param == 8) {

            if (pname == GraphicsContext3D::PACK_ALIGNMENT)

                m_packAlignment = param;

            else // GraphicsContext3D::UNPACK_ALIGNMENT:

                m_unpackAlignment = param;

            m_context->pixelStorei(pname, param);

        } else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "pixelStorei", "invalid parameter name");

        return;

    }

}

void WebGLRenderingContext::polygonOffset(GC3Dfloat factor, GC3Dfloat units)

{

    if (isContextLostOrPending())

        return;

    m_context->polygonOffset(factor, units);

}

void WebGLRenderingContext::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&)

{

    if (isContextLostOrPending())

        return;

    // Due to WebGL's same-origin restrictions, it is not possible to

    // taint the origin using the WebGL API.

    ASSERT(canvas()->originClean());

    // Validate input parameters.

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "readPixels", "no destination ArrayBufferView");

        return;

    }

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format");

        return;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid type");

        return;

    }

    if (format != GraphicsContext3D::RGBA || type != GraphicsContext3D::UNSIGNED_BYTE) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");

        return;

    }

    // Validate array type against pixel type.

    if (pixels->getType() != JSC::TypeUint8) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);

        return;

    }

    // Calculate array size, taking into consideration of PACK_ALIGNMENT.

    unsigned int totalBytesRequired = 0;

    unsigned int padding = 0;

    if (!m_isRobustnessEXTSupported) {

        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

        if (error != GraphicsContext3D::NO_ERROR) {

            synthesizeGLError(error, "readPixels", "invalid dimensions");

            return;

        }

        if (pixels->byteLength() < totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");

            return;

        }

    }

    clearIfComposited();

    void* data = pixels->baseAddress();

    {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->readnPixelsEXT(x, y, width, height, format, type, pixels->byteLength(), data);

        else

            m_context->readPixels(x, y, width, height, format, type, data);

    }

#if OS(DARWIN)

    if (m_isRobustnessEXTSupported) // we haven't computed padding

        m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

    // FIXME: remove this section when GL driver bug on Mac AND the GLES driver bug

    // on QC is fixed, i.e., when alpha is off, readPixels should

    // set alpha to 255 instead of 0.

    if (!m_framebufferBinding && !m_context->getContextAttributes().alpha) {

        unsigned char* pixels = reinterpret_cast<unsigned char*>(data);

        for (GC3Dsizei iy = 0; iy < height; ++iy) {

            for (GC3Dsizei ix = 0; ix < width; ++ix) {

                pixels[3] = 255;

                pixels += 4;

            }

            pixels += padding;

        }

    }

#endif

}

void WebGLRenderingContext::releaseShaderCompiler()

{

    if (isContextLostOrPending())

        return;

    m_context->releaseShaderCompiler();

}

void WebGLRenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid target");

        return;

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "renderbufferStorage", "no bound renderbuffer");

        return;

    }

    if (!validateSize("renderbufferStorage", width, height))

        return;

    switch (internalformat) {

    case GraphicsContext3D::DEPTH_COMPONENT16:

    case GraphicsContext3D::RGBA4:

    case GraphicsContext3D::RGB5_A1:

    case GraphicsContext3D::RGB565:

    case GraphicsContext3D::STENCIL_INDEX8:

    case Extensions3D::SRGB8_ALPHA8_EXT:

        if (internalformat == Extensions3D::SRGB8_ALPHA8_EXT && !m_extsRGB) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

            return;

        }

        m_context->renderbufferStorage(target, internalformat, width, height);

        m_renderbufferBinding->setInternalFormat(internalformat);

        m_renderbufferBinding->setIsValid(true);

        m_renderbufferBinding->setSize(width, height);

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (isDepthStencilSupported()) {

            m_context->renderbufferStorage(target, Extensions3D::DEPTH24_STENCIL8, width, height);

        }

        m_renderbufferBinding->setSize(width, height);

        m_renderbufferBinding->setIsValid(isDepthStencilSupported());

        m_renderbufferBinding->setInternalFormat(internalformat);

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

        return;

    }

    applyStencilTest();

}

void WebGLRenderingContext::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)

{

    if (isContextLostOrPending())

        return;

    m_context->sampleCoverage(value, invert);

}

void WebGLRenderingContext::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("scissor", width, height))

        return;

    m_context->scissor(x, y, width, height);

}

void WebGLRenderingContext::shaderSource(WebGLShader* shader, const String& string, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("shaderSource", shader))

        return;

    String stringWithoutComments = StripComments(string).result();

    if (!validateString("shaderSource", stringWithoutComments))

        return;

    shader->setSource(string);

    m_context->shaderSource(objectOrZero(shader), stringWithoutComments);

}

void WebGLRenderingContext::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFunc", func))

        return;

    m_stencilFuncRef = ref;

    m_stencilFuncRefBack = ref;

    m_stencilFuncMask = mask;

    m_stencilFuncMaskBack = mask;

    m_context->stencilFunc(func, ref, mask);

}

void WebGLRenderingContext::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFuncSeparate", func))

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilFuncRef = ref;

        m_stencilFuncRefBack = ref;

        m_stencilFuncMask = mask;

        m_stencilFuncMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilFuncRef = ref;

        m_stencilFuncMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilFuncRefBack = ref;

        m_stencilFuncMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilFuncSeparate", "invalid face");

        return;

    }

    m_context->stencilFuncSeparate(face, func, ref, mask);

}

void WebGLRenderingContext::stencilMask(GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    m_stencilMask = mask;

    m_stencilMaskBack = mask;

    m_context->stencilMask(mask);

}

void WebGLRenderingContext::stencilMaskSeparate(GC3Denum face, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilMask = mask;

        m_stencilMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilMaskSeparate", "invalid face");

        return;

    }

    m_context->stencilMaskSeparate(face, mask);

}

void WebGLRenderingContext::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOp(fail, zfail, zpass);

}

void WebGLRenderingContext::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOpSeparate(face, fail, zfail, zpass);

}

void WebGLRenderingContext::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned.

    ec = 0;

    WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);

    ASSERT(validateTexFuncParameters("texImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, format, type));

    ASSERT(tex);

    ASSERT(!level || !WebGLTexture::isNPOT(width, height));

    if (!pixels) {

        // Note: Chromium's OpenGL implementation clears textures and isResourceSafe() is therefore true.

        // For other implementations, if they are using ANGLE_depth_texture, ANGLE depth textures

        // can not be cleared with texImage2D and must be cleared by binding to an fbo and calling

        // clear.

        if (isResourceSafe())

            m_context->texImage2D(target, level, internalformat, width, height, border, format, type, nullptr);

        else {

            bool succeed = m_context->texImage2DResourceSafe(target, level, internalformat, width, height,

                                                             border, format, type, m_unpackAlignment);

            if (!succeed)

                return;

        }

    } else {

        ASSERT(validateSettableTexFormat("texImage2D", internalformat));

        m_context->moveErrorsToSyntheticErrorList();

        m_context->texImage2D(target, level, internalformat, width, height,

                              border, format, type, pixels);

        if (m_context->moveErrorsToSyntheticErrorList()) {

            // The texImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

            tex->markInvalid(target, level);

            return;

        }

    }

    tex->setLevelInfo(target, level, internalformat, width, height, type);

}

void WebGLRenderingContext::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "packImage error");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

bool WebGLRenderingContext::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)

{

    if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))

        return false;

    WebGLTexture* texture = validateTextureBinding(functionName, target, true);

    if (!texture)

        return false;

    if (functionType == NotTexSubImage2D) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level > 0 not power of 2");

            return false;

        }

        // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat

        // by checking if the ArrayBufferView is null or not.

        if (sourceType != SourceArrayBufferView) {

            if (!validateSettableTexFormat(functionName, format))

                return false;

        }

    } else {

        if (!validateSettableTexFormat(functionName, format))

            return false;

        if (!validateSize(functionName, xoffset, yoffset))

            return false;

        // Before checking if it is in the range, check if overflow happens first.

        if (xoffset + width < 0 || yoffset + height < 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "bad dimensions");

            return false;

        }

        if (xoffset + width > texture->getWidth(target, level) || yoffset + height > texture->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "dimensions out of range");

            return false;

        }

        if (texture->getInternalFormat(target, level) != format || texture->getType(target, level) != type) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type and format do not match texture");

            return false;

        }

    }

    return true;

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                       GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, format, type, pixels, NullAllowed)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))

        return;

    void* data = pixels ? pixels->baseAddress() : 0;

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, width, height, border,

                   format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

PassRefPtr<Image> WebGLRenderingContext::drawImageIntoBuffer(Image* image, int width, int height, int deviceScaleFactor)

{

    IntSize size(width, height);

    size.scale(deviceScaleFactor);

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    FloatRect srcRect(FloatPoint(), image->size());

    FloatRect destRect(FloatPoint(), size);

    buf->context()->drawImage(image, ColorSpaceDeviceRGB, destRect, srcRect);

    return buf->copyImage(ImageBuffer::fastCopyImageMode());

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))

        return;

    texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas, ec) || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))

        return;

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    // If possible, copy from the canvas element directly to the texture

    // via the GPU, without a read-back to system memory.

    //

    // FIXME: restriction of (RGB || RGBA)/UNSIGNED_BYTE should be lifted when

    // ImageBuffer::copyToPlatformTexture implementations are fully functional.

    if (GraphicsContext3D::TEXTURE_2D == target && texture && type == texture->getType(target, level)

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) {

        ImageBuffer* buffer = canvas->buffer();

        if (buffer && buffer->copyToPlatformTexture(*m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);

            return;

        }

    }

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texImage2D(target, level, internalformat, format, type, imageData.get(), ec);

    else

        texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

PassRefPtr<Image> WebGLRenderingContext::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy, ExceptionCode&)

{

    IntSize size(video->videoWidth(), video->videoHeight());

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    IntRect destRect(0, 0, size.width(), size.height());

    // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.

    video->paintCurrentFrameInContext(buf->context(), destRect);

    return buf->copyImage(backingStoreCopy);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video, ec)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))

        return;

    // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.

    // Otherwise, it will fall back to the normal SW path.

    // FIXME: The current restrictions require that format shoud be RGB or RGBA,

    // type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    if (GraphicsContext3D::TEXTURE_2D == target && texture

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)

        && type == GraphicsContext3D::UNSIGNED_BYTE

        && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))

        && !level) {

        if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);

            return;

        }

    }

    // Normal pure SW path.

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("texParameter", target, false);

    if (!tex)

        return;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

        break;

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        if ((isFloat && paramf != GraphicsContext3D::CLAMP_TO_EDGE && paramf != GraphicsContext3D::MIRRORED_REPEAT && paramf != GraphicsContext3D::REPEAT)

            || (!isFloat && parami != GraphicsContext3D::CLAMP_TO_EDGE && parami != GraphicsContext3D::MIRRORED_REPEAT && parami != GraphicsContext3D::REPEAT)) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter");

            return;

        }

        break;

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (!m_extTextureFilterAnisotropic) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter name");

        return;

    }

    if (isFloat) {

        tex->setParameterf(pname, paramf);

        m_context->texParameterf(target, pname, paramf);

    } else {

        tex->setParameteri(pname, parami);

        m_context->texParameteri(target, pname, parami);

    }

}

void WebGLRenderingContext::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)

{

    texParameter(target, pname, param, 0, true);

}

void WebGLRenderingContext::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)

{

    texParameter(target, pname, 0, param, false);

}

void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned

    ec = 0;

    ASSERT(!isContextLost());

    ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage2D, target, level, format, width, height, 0, format, type));

    ASSERT(validateSize("texSubImage2D", xoffset, yoffset));

    ASSERT(validateSettableTexFormat("texSubImage2D", format));

    WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);

    if (!tex) {

        ASSERT_NOT_REACHED();

        return;

    }

    ASSERT((xoffset + width) >= 0);

    ASSERT((yoffset + height) >= 0);

    ASSERT(tex->getWidth(target, level) >= (xoffset + width));

    ASSERT(tex->getHeight(target, level) >= (yoffset + height));

    ASSERT(tex->getInternalFormat(target, level) == format);

    ASSERT(tex->getType(target, level) == type);

    m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);

}

void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);  

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, type,  needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Dsizei width, GC3Dsizei height,

                                          GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))

        return;

    void* data = pixels->baseAddress();

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLImageElement, target, level, format, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLCanvasElement, target, level, format, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);

    else

        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLVideoElement, target, level, format, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1f", "location not for current program");

        return;

    }

    m_context->uniform1f(location->location(), x);

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))

        return;

    m_context->uniform1fv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))

        return;

    m_context->uniform1fv(location->location(), size, v);

}

void WebGLRenderingContext::uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");

        return;

    }

    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");

        return;

    }

    m_context->uniform1i(location->location(), x);

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < v->length(); ++i) {

            if (v->data()[i] >= static_cast<int>(m_textureUnits.size())) {

                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v->data()[i], location->type());

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {

            if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), size, v);

}

void WebGLRenderingContext::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");

        return;

    }

    m_context->uniform2f(location->location(), x, y);

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))

        return;

    m_context->uniform2fv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))

        return;

    m_context->uniform2fv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2i", "location not for current program");

        return;

    }

    m_context->uniform2i(location->location(), x, y);

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))

        return;

    m_context->uniform2iv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))

        return;

    m_context->uniform2iv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");

        return;

    }

    m_context->uniform3f(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))

        return;

    m_context->uniform3fv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))

        return;

    m_context->uniform3fv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");

        return;

    }

    m_context->uniform3i(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))

        return;

    m_context->uniform3iv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))

        return;

    m_context->uniform3iv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");

        return;

    }

    m_context->uniform4f(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))

        return;

    m_context->uniform4fv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))

        return;

    m_context->uniform4fv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");

        return;

    }

    m_context->uniform4i(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))

        return;

    m_context->uniform4iv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))

        return;

    m_context->uniform4iv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);

}

void WebGLRenderingContext::useProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("useProgram", program, deleted))

        return;

    if (deleted)

        program = 0;

    if (program && !program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "useProgram", "program not valid");

        return;

    }

    if (m_currentProgram != program) {

        if (m_currentProgram)

            m_currentProgram->onDetached(graphicsContext3D());

        m_currentProgram = program;

        m_context->useProgram(objectOrZero(program));

        if (program)

            program->onAttached();

    }

}

void WebGLRenderingContext::validateProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("validateProgram", program))

        return;

    m_context->validateProgram(objectOrZero(program));

}

void WebGLRenderingContext::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)

{

    vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);

}

void WebGLRenderingContext::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)

{

    vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);

}

void WebGLRenderingContext::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)

{

    vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);

}

void WebGLRenderingContext::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);

}

void WebGLRenderingContext::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    switch (type) {

    case GraphicsContext3D::BYTE:

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::SHORT:

    case GraphicsContext3D::UNSIGNED_SHORT:

    case GraphicsContext3D::FLOAT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "index out of range");

        return;

    }

    if (size < 1 || size > 4 || stride < 0 || stride > 255 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "bad size, stride or offset");

        return;

    }

    if (!m_boundArrayBuffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");

        return;

    }

    // Determine the number of elements the bound buffer can hold, given the offset, size, type and stride

    unsigned int typeSize = sizeInBytes(type);

    if (!typeSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if ((stride % typeSize) || (static_cast<GC3Dintptr>(offset) % typeSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");

        return;

    }

    GC3Dsizei bytesPerElement = size * typeSize;

    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GC3Dintptr>(offset), m_boundArrayBuffer);

    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GC3Dintptr>(offset));

}

void WebGLRenderingContext::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("viewport", width, height))

        return;

    m_context->viewport(x, y, width, height);

}

void WebGLRenderingContext::forceLostContext(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "loseContext", "context already lost");

        return;

    }

    m_contextGroup->loseContextGroup(mode);

}

void WebGLRenderingContext::loseContextImpl(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLost())

        return;

    m_contextLost = true;

    m_contextLostMode = mode;

    if (mode == RealLostContext) {

        // Inform the embedder that a lost context was received. In response, the embedder might

        // decide to take action such as asking the user for permission to use WebGL again.

        if (Frame* frame = canvas()->document().frame())

            frame->loader().client().didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());

    }

    detachAndRemoveAllObjects();

    if (m_drawingBuffer) {

        // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.

        m_drawingBuffer->setTexture2DBinding(0);

        m_drawingBuffer->setFramebufferBinding(0);

    }

    // There is no direct way to clear errors from a GL implementation and

    // looping until getError() becomes NO_ERROR might cause an infinite loop if

    // the driver or context implementation had a bug. So, loop a reasonably

    // large number of times to clear any existing errors.

    for (int i = 0; i < 100; ++i) {

        if (m_context->getError() == GraphicsContext3D::NO_ERROR)

            break;

    }

    ConsoleDisplayPreference display = (mode == RealLostContext) ? DisplayInConsole: DontDisplayInConsole;

    synthesizeGLError(GraphicsContext3D::CONTEXT_LOST_WEBGL, "loseContext", "context lost", display);

    // Don't allow restoration unless the context lost event has both been

    // dispatched and its default behavior prevented.

    m_restoreAllowed = false;

    // Always defer the dispatch of the context lost event, to implement

    // the spec behavior of queueing a task.

    m_dispatchContextLostEventTimer.startOneShot(0);

}

void WebGLRenderingContext::forceRestoreContext()

{

    if (!isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context not lost");

        return;

    }

    if (!m_restoreAllowed) {

        if (m_contextLostMode == SyntheticLostContext)

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context restoration not allowed");

        return;

    }

    if (!m_restoreTimer.isActive())

        m_restoreTimer.startOneShot(0);

}

PlatformLayer* WebGLRenderingContext::platformLayer() const

{

    return (!isContextLost() && !m_isPendingPolicyResolution) ? m_context->platformLayer() : 0;

}

void WebGLRenderingContext::removeSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextGroup->removeObject(object);

}

void WebGLRenderingContext::addSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextGroup->addObject(object);

}

void WebGLRenderingContext::removeContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextObjects.remove(object);

}

void WebGLRenderingContext::addContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextObjects.add(object);

}

void WebGLRenderingContext::detachAndRemoveAllObjects()

{

    if (m_isPendingPolicyResolution)

        return;

    while (m_contextObjects.size() > 0) {

        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();

        (*it)->detachContext();

    }

}

bool WebGLRenderingContext::hasPendingActivity() const

{

    return false;

}

void WebGLRenderingContext::stop()

{

    if (!isContextLost() && !m_isPendingPolicyResolution) {

        forceLostContext(SyntheticLostContext);

        destroyGraphicsContext3D();

    }

}

WebGLGetInfo WebGLRenderingContext::getBooleanParameter(GC3Denum pname)

{

    GC3Dboolean value = 0;

    m_context->getBooleanv(pname, &value);

    return WebGLGetInfo(static_cast<bool>(value));

}

WebGLGetInfo WebGLRenderingContext::getBooleanArrayParameter(GC3Denum pname)

{

    if (pname != GraphicsContext3D::COLOR_WRITEMASK) {

        notImplemented();

        return WebGLGetInfo(0, 0);

    }

    GC3Dboolean value[4] = {0};

    m_context->getBooleanv(pname, value);

    bool boolValue[4];

    for (int ii = 0; ii < 4; ++ii)

        boolValue[ii] = static_cast<bool>(value[ii]);

    return WebGLGetInfo(boolValue, 4);

}

WebGLGetInfo WebGLRenderingContext::getFloatParameter(GC3Denum pname)

{

    GC3Dfloat value = 0;

    m_context->getFloatv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getUnsignedIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

WebGLGetInfo WebGLRenderingContext::getWebGLFloatArrayParameter(GC3Denum pname)

{

    GC3Dfloat value[4] = {0};

    m_context->getFloatv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

    case GraphicsContext3D::DEPTH_RANGE:

        length = 2;

        break;

    case GraphicsContext3D::BLEND_COLOR:

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Float32Array::create(value, length));

}

WebGLGetInfo WebGLRenderingContext::getWebGLIntArrayParameter(GC3Denum pname)

{

    GC3Dint value[4] = {0};

    m_context->getIntegerv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        length = 2;

        break;

    case GraphicsContext3D::SCISSOR_BOX:

    case GraphicsContext3D::VIEWPORT:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Int32Array::create(value, length));

}

void WebGLRenderingContext::checkTextureCompleteness(const char* functionName, bool prepareToDraw)

{

    bool resetActiveUnit = false;

    WebGLTexture::TextureExtensionFlag extensions = static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureExtensionFloatLinearEnabled : 0) | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureExtensionHalfFloatLinearEnabled : 0));

    for (unsigned ii = 0; ii < m_textureUnits.size(); ++ii) {

        if ((m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

            || (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))) {

            if (ii != m_activeTextureUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = true;

            } else if (resetActiveUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = false;

            }

            WebGLTexture* tex2D;

            WebGLTexture* texCubeMap;

            if (prepareToDraw) {

                String msg(String("texture bound to texture unit ") + String::number(ii)

                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete',"

                    + " or it is a float/half-float type with linear filtering and without the relevant float/half-float linear extension enabled.");

                printGLWarningToConsole(functionName, msg.utf8().data());

                tex2D = m_blackTexture2D.get();

                texCubeMap = m_blackTextureCubeMap.get();

            } else {

                tex2D = m_textureUnits[ii].texture2DBinding.get();

                texCubeMap = m_textureUnits[ii].textureCubeMapBinding.get();

            }

            if (m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));

            if (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));

        }

    }

    if (resetActiveUnit)

        m_context->activeTexture(m_activeTextureUnit);

}

void WebGLRenderingContext::createFallbackBlackTextures1x1()

{

    unsigned char black[] = {0, 0, 0, 255};

    m_blackTexture2D = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_blackTexture2D->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);

    m_blackTextureCubeMap = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, 0);

}

bool WebGLRenderingContext::isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                                           GC3Denum colorBufferFormat)

{

    unsigned need = GraphicsContext3D::getChannelBitsByFormat(texInternalFormat);

    unsigned have = GraphicsContext3D::getChannelBitsByFormat(colorBufferFormat);

    return (need & have) == need;

}

GC3Denum WebGLRenderingContext::getBoundFramebufferColorFormat()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferFormat();

    if (m_attributes.alpha)

        return GraphicsContext3D::RGBA;

    return GraphicsContext3D::RGB;

}

int WebGLRenderingContext::getBoundFramebufferWidth()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferWidth();

    return m_drawingBuffer ? m_drawingBuffer->size().width() : m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::getBoundFramebufferHeight()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferHeight();

    return m_drawingBuffer ? m_drawingBuffer->size().height() : m_context->getInternalFramebufferSize().height();

}

WebGLTexture* WebGLRenderingContext::validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap)

{

    WebGLTexture* texture = nullptr;

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        texture = m_textureUnits[m_activeTextureUnit].texture2DBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (!useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP:

        if (useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

        return nullptr;

    }

    if (!texture)

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no texture");

    return texture;

}

bool WebGLRenderingContext::validateLocationLength(const char* functionName, const String& string)

{

    const unsigned maxWebGLLocationLength = 256;

    if (string.length() > maxWebGLLocationLength) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "location length > 256");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateSize(const char* functionName, GC3Dint x, GC3Dint y)

{

    if (x < 0 || y < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "size < 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateString(const char* functionName, const String& string)

{

    for (size_t i = 0; i < string.length(); ++i) {

        if (!validateCharacter(string[i])) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "string not ASCII");

            return false;

        }

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level)

{

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");

        return false;

    case Extensions3D::SRGB_EXT:

    case Extensions3D::SRGB_ALPHA_EXT:

    default:

        if ((format == Extensions3D::SRGB_EXT || format == Extensions3D::SRGB_ALPHA_EXT)

            && m_extsRGB)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture format");

        return false;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    case GraphicsContext3D::FLOAT:

        if (m_oesTextureFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::HALF_FLOAT_OES:

        if (m_oesTextureHalfFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::UNSIGNED_INT:

    case GraphicsContext3D::UNSIGNED_INT_24_8:

    case GraphicsContext3D::UNSIGNED_SHORT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    }

    // Verify that the combination of format and type is supported.

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for format");

            return false;

        }

        break;

    case GraphicsContext3D::RGB:

    case Extensions3D::SRGB_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_6_5

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGB format");

            return false;

        }

        break;

    case GraphicsContext3D::RGBA:

    case Extensions3D::SRGB_ALPHA_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGBA format");

            return false;

        }

        break;

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_COMPONENT not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_SHORT

            && type != GraphicsContext3D::UNSIGNED_INT) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_COMPONENT format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_COMPONENT format");

          return false;

        }

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_STENCIL not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_INT_24_8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_STENCIL format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_STENCIL format");

          return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level)

{

    if (level < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level < 0");

        return false;

    }

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (level >= m_maxTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (level >= m_maxCubeMapTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    }

    // This function only checks if level is legal, so we return true and don't

    // generate INVALID_ENUM if target is illegal.

    return true;

}

bool WebGLRenderingContext::validateTexFuncParameters(const char* functionName,

                                                      TexFuncValidationFunctionType functionType,

                                                      GC3Denum target, GC3Dint level,

                                                      GC3Denum internalformat,

                                                      GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                                      GC3Denum format, GC3Denum type)

{

    // We absolutely have to validate the format and type combination.

    // The texImage2D entry points taking HTMLImage, etc. will produce

    // temporary data based on this combination, so it must be legal.

    if (!validateTexFuncFormatAndType(functionName, format, type, level) || !validateTexFuncLevel(functionName, target, level))

        return false;

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (functionType != TexSubImage2D && width != height) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");

            return false;

        }

        // No need to check height here. For texImage width == height.

        // For texSubImage that will be checked when checking yoffset + height is in range.

        if (width > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range for cube map");

            return false;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    if (format != internalformat) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format != internalformat");

        return false;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "border != 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncData(const char* functionName, GC3Dint level,

                                                GC3Dsizei width, GC3Dsizei height,

                                                GC3Denum format, GC3Denum type,

                                                ArrayBufferView* pixels,

                                                NullDisposition disposition)

{

    if (!pixels) {

        if (disposition == NullAllowed)

            return true;

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (!validateTexFuncFormatAndType(functionName, format, type, level))

        return false;

    if (!validateSettableTexFormat(functionName, format))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

        if (pixels->getType() != JSC::TypeUint8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_BYTE but ArrayBufferView not Uint8Array");

            return false;

        }

        break;

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        if (pixels->getType() != JSC::TypeUint16) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_SHORT but ArrayBufferView not Uint16Array");

            return false;

        }

        break;

    case GraphicsContext3D::FLOAT: // OES_texture_float

        if (pixels->getType() != JSC::TypeFloat32) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");

            return false;

        }

        break;

    case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float

        // As per the specification, ArrayBufferView should be null when

        // OES_texture_half_float is enabled.

        if (pixels) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL");

            return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    unsigned int totalBytesRequired;

    GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);

    if (error != GraphicsContext3D::NO_ERROR) {

        synthesizeGLError(error, functionName, "invalid texture dimensions");

        return false;

    }

    if (pixels->byteLength() < totalBytesRequired) {

        if (m_unpackAlignment != 1) {

          error = m_context->computeImageSizeInBytes(format, type, width, height, 1, &totalBytesRequired, 0);

          if (pixels->byteLength() == totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request with UNPACK_ALIGNMENT > 1");

            return false;

          }

        }

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexFormat(GC3Denum format)

{

    return m_compressedTextureFormats.contains(format);

}

bool WebGLRenderingContext::validateCompressedTexFuncData(const char* functionName,

                                                          GC3Dsizei width, GC3Dsizei height,

                                                          GC3Denum format, ArrayBufferView* pixels)

{

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    unsigned int bytesRequired = 0;

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_ATC_RGB_AMD:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT:

    case Extensions3D::COMPRESSED_ATC_RGBA_EXPLICIT_ALPHA_AMD:

    case Extensions3D::COMPRESSED_ATC_RGBA_INTERPOLATED_ALPHA_AMD:

        {

            const int kBlockSize = 16;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 8;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 4 + 7) / kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 16;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 2 + 7) / kBlockSize;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format");

        return false;

    }

    if (pixels->byteLength() != bytesRequired) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "length of ArrayBufferView is not correct for dimensions");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format)

{

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const GC3Dsizei kBlockWidth = 4;

        const GC3Dsizei kBlockHeight = 4;

        const GC3Dint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;

        const GC3Dsizei maxCompressedDimension = maxTextureSize >> level;

        bool widthValid = (level && width == 1) || (level && width == 2) || (!(width % kBlockWidth) && width <= maxCompressedDimension);

        bool heightValid = (level && height == 1) || (level && height == 2) || (!(height % kBlockHeight) && height <= maxCompressedDimension);

        if (!widthValid || !heightValid) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        // Height and width must be powers of 2.

        if ((width & (width - 1)) || (height & (height - 1))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                               GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture* tex)

{

    if (xoffset < 0 || yoffset < 0) {

      synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "xoffset or yoffset < 0");

      return false;

    }

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset or yoffset not multiple of 4");

            return false;

        }

        if (width - xoffset > tex->getWidth(target, level)

            || height - yoffset > tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions out of range");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: {

        if (xoffset || yoffset) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset and yoffset must be zero");

            return false;

        }

        if (width != tex->getWidth(target, level)

            || height != tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions must match existing level");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateDrawMode(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::POINTS:

    case GraphicsContext3D::LINE_STRIP:

    case GraphicsContext3D::LINE_LOOP:

    case GraphicsContext3D::LINES:

    case GraphicsContext3D::TRIANGLE_STRIP:

    case GraphicsContext3D::TRIANGLE_FAN:

    case GraphicsContext3D::TRIANGLES:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid draw mode");

        return false;

    }

}

bool WebGLRenderingContext::validateStencilSettings(const char* functionName)

{

    if (m_stencilMask != m_stencilMaskBack || m_stencilFuncRef != m_stencilFuncRefBack || m_stencilFuncMask != m_stencilFuncMaskBack) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "front and back stencils settings do not match");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateStencilFunc(const char* functionName, GC3Denum func)

{

    switch (func) {

    case GraphicsContext3D::NEVER:

    case GraphicsContext3D::LESS:

    case GraphicsContext3D::LEQUAL:

    case GraphicsContext3D::GREATER:

    case GraphicsContext3D::GEQUAL:

    case GraphicsContext3D::EQUAL:

    case GraphicsContext3D::NOTEQUAL:

    case GraphicsContext3D::ALWAYS:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid function");

        return false;

    }

}

void WebGLRenderingContext::printGLErrorToConsole(const String& message)

{

    if (!m_numGLErrorsToConsoleAllowed)

        return;

    --m_numGLErrorsToConsoleAllowed;

    printWarningToConsole(message);

    if (!m_numGLErrorsToConsoleAllowed)

        printWarningToConsole("WebGL: too many errors, no more errors will be reported to the console for this context.");

}

void WebGLRenderingContext::printWarningToConsole(const String& message)

{

    if (!canvas())

        return;

    canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);

}

bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)

{

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    switch (attachment) {

    case GraphicsContext3D::COLOR_ATTACHMENT0:

    case GraphicsContext3D::DEPTH_ATTACHMENT:

    case GraphicsContext3D::STENCIL_ATTACHMENT:

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        break;

    default:

        if (m_webglDrawBuffers

            && attachment > GraphicsContext3D::COLOR_ATTACHMENT0

            && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::FUNC_ADD:

    case GraphicsContext3D::FUNC_SUBTRACT:

    case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:

    case Extensions3D::MIN_EXT:

    case Extensions3D::MAX_EXT:

        if ((mode == Extensions3D::MIN_EXT || mode == Extensions3D::MAX_EXT) && !m_extBlendMinMax) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

            return false;

        }

        return true;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

        return false;

    }

}

bool WebGLRenderingContext::validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst)

{

    if (((src == GraphicsContext3D::CONSTANT_COLOR || src == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

         && (dst == GraphicsContext3D::CONSTANT_ALPHA || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))

        || ((dst == GraphicsContext3D::CONSTANT_COLOR || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

            && (src == GraphicsContext3D::CONSTANT_ALPHA || src == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "incompatible src and dst");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCapability(const char* functionName, GC3Denum cap)

{

    switch (cap) {

    case GraphicsContext3D::BLEND:

    case GraphicsContext3D::CULL_FACE:

    case GraphicsContext3D::DEPTH_TEST:

    case GraphicsContext3D::DITHER:

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

    case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:

    case GraphicsContext3D::SAMPLE_COVERAGE:

    case GraphicsContext3D::SCISSOR_TEST:

    case GraphicsContext3D::STENCIL_TEST:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");

        return false;

    }

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Int32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, transpose, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    if (!location)

        return false;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "location is not from current program");

        return false;

    }

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    if (transpose) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "transpose not FALSE");

        return false;

    }

    if (size < requiredMinSize || (size % requiredMinSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return false;

    }

    return true;

}

WebGLBuffer* WebGLRenderingContext::validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage)

{

    WebGLBuffer* buffer = 0;

    switch (target) {

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER:

        buffer = m_boundVertexArrayObject->getElementArrayBuffer().get();

        break;

    case GraphicsContext3D::ARRAY_BUFFER:

        buffer = m_boundArrayBuffer.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return nullptr;

    }

    if (!buffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no buffer");

        return nullptr;

    }

    switch (usage) {

    case GraphicsContext3D::STREAM_DRAW:

    case GraphicsContext3D::STATIC_DRAW:

    case GraphicsContext3D::DYNAMIC_DRAW:

        return buffer;

    }

    synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid usage");

    return nullptr;

}

bool WebGLRenderingContext::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionCode& ec)

{

    if (!image || !image->cachedImage()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");

        return false;

    }

    const URL& url = image->cachedImage()->response().url();

    if (url.isNull() || url.isEmpty() || !url.isValid()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");

        return false;

    }

    if (wouldTaintOrigin(image)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    if (!canvas || !canvas->buffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no canvas");

        return false;

    }

    if (wouldTaintOrigin(canvas)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#if ENABLE(VIDEO)

bool WebGLRenderingContext::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video, ExceptionCode& ec)

{

    if (!video || !video->videoWidth() || !video->videoHeight()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no video");

        return false;

    }

    if (wouldTaintOrigin(video)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#endif

void WebGLRenderingContext::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1f(index, v0);

            break;

        case 2:

            m_context->vertexAttrib2f(index, v0, v1);

            break;

        case 3:

            m_context->vertexAttrib3f(index, v0, v1, v2);

            break;

        case 4:

            m_context->vertexAttrib4f(index, v0, v1, v2, v3);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.value[0] = v0;

    attribValue.value[1] = v1;

    attribValue.value[2] = v2;

    attribValue.value[3] = v3;

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array* v, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    vertexAttribfvImpl(functionName, index, v->data(), v->length(), expectedSize);

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat* v, GC3Dsizei size, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    if (size < expectedSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1fv(index, v);

            break;

        case 2:

            m_context->vertexAttrib2fv(index, v);

            break;

        case 3:

            m_context->vertexAttrib3fv(index, v);

            break;

        case 4:

            m_context->vertexAttrib4fv(index, v);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.initValue();

    for (int ii = 0; ii < expectedSize; ++ii)

        attribValue.value[ii] = v[ii];

}

void WebGLRenderingContext::initVertexAttrib0()

{

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    m_vertexAttrib0Buffer = createBuffer();

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, 0, GraphicsContext3D::DYNAMIC_DRAW);

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, false, 0, 0);

    state.bufferBinding = m_vertexAttrib0Buffer;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, 0);

    m_context->enableVertexAttribArray(0);

    m_vertexAttrib0BufferSize = 0;

    m_vertexAttrib0BufferValue[0] = 0.0f;

    m_vertexAttrib0BufferValue[1] = 0.0f;

    m_vertexAttrib0BufferValue[2] = 0.0f;

    m_vertexAttrib0BufferValue[3] = 1.0f;

    m_forceAttrib0BufferRefill = false;

    m_vertexAttrib0UsedBefore = false;

}

bool WebGLRenderingContext::simulateVertexAttrib0(GC3Dsizei numVertex)

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    const VertexAttribValue& attribValue = m_vertexAttribValue[0];

    if (!m_currentProgram)

        return false;

    bool usingVertexAttrib0 = m_currentProgram->isUsingVertexAttrib0();

    if (usingVertexAttrib0)

        m_vertexAttrib0UsedBefore = true;

    if (state.enabled && usingVertexAttrib0)

        return false;

    if (!usingVertexAttrib0 && !m_vertexAttrib0UsedBefore)

        return false;

    m_vertexAttrib0UsedBefore = true;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    GC3Dsizeiptr bufferDataSize = (numVertex + 1) * 4 * sizeof(GC3Dfloat);

    if (bufferDataSize > m_vertexAttrib0BufferSize) {

        m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, bufferDataSize, 0, GraphicsContext3D::DYNAMIC_DRAW);

        m_vertexAttrib0BufferSize = bufferDataSize;

        m_forceAttrib0BufferRefill = true;

    }

    if (usingVertexAttrib0

        && (m_forceAttrib0BufferRefill

            || attribValue.value[0] != m_vertexAttrib0BufferValue[0]

            || attribValue.value[1] != m_vertexAttrib0BufferValue[1]

            || attribValue.value[2] != m_vertexAttrib0BufferValue[2]

            || attribValue.value[3] != m_vertexAttrib0BufferValue[3])) {

        auto bufferData = std::make_unique<GC3Dfloat[]>((numVertex + 1) * 4);

        for (GC3Dsizei ii = 0; ii < numVertex + 1; ++ii) {

            bufferData[ii * 4] = attribValue.value[0];

            bufferData[ii * 4 + 1] = attribValue.value[1];

            bufferData[ii * 4 + 2] = attribValue.value[2];

            bufferData[ii * 4 + 3] = attribValue.value[3];

        }

        m_vertexAttrib0BufferValue[0] = attribValue.value[0];

        m_vertexAttrib0BufferValue[1] = attribValue.value[1];

        m_vertexAttrib0BufferValue[2] = attribValue.value[2];

        m_vertexAttrib0BufferValue[3] = attribValue.value[3];

        m_forceAttrib0BufferRefill = false;

        m_context->bufferSubData(GraphicsContext3D::ARRAY_BUFFER, 0, bufferDataSize, bufferData.get());

    }

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, 0, 0, 0);

    return true;

}

void WebGLRenderingContext::restoreStatesAfterVertexAttrib0Simulation()

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    if (state.bufferBinding != m_vertexAttrib0Buffer) {

        m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(state.bufferBinding.get()));

        m_context->vertexAttribPointer(0, state.size, state.type, state.normalized, state.originalStride, state.offset);

    }

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));

}

void WebGLRenderingContext::dispatchContextLostEvent()

{

    RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");

    canvas()->dispatchEvent(event);

    m_restoreAllowed = event->defaultPrevented();

    if (m_contextLostMode == RealLostContext && m_restoreAllowed)

        m_restoreTimer.startOneShot(0);

}

void WebGLRenderingContext::maybeRestoreContext()

{

    ASSERT(m_contextLost);

    if (!m_contextLost)

        return;

    // The rendering context is not restored unless the default behavior of the

    // webglcontextlost event was prevented earlier.

    //

    // Because of the way m_restoreTimer is set up for real vs. synthetic lost

    // context events, we don't have to worry about this test short-circuiting

    // the retry loop for real context lost events.

    if (!m_restoreAllowed)

        return;

    int contextLostReason = m_context->getExtensions()->getGraphicsResetStatusARB();

    switch (contextLostReason) {

    case GraphicsContext3D::NO_ERROR:

        // The GraphicsContext3D implementation might not fully

        // support GL_ARB_robustness semantics yet. Alternatively, the

        // WEBGL_lose_context extension might have been used to force

        // a lost context.

        break;

    case Extensions3D::GUILTY_CONTEXT_RESET_ARB:

        // The rendering context is not restored if this context was

        // guilty of causing the graphics reset.

        printWarningToConsole("WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");

        return;

    case Extensions3D::INNOCENT_CONTEXT_RESET_ARB:

        // Always allow the context to be restored.

        break;

    case Extensions3D::UNKNOWN_CONTEXT_RESET_ARB:

        // Warn. Ideally, prompt the user telling them that WebGL

        // content on the page might have caused the graphics card to

        // reset and ask them whether they want to continue running

        // the content. Only if they say "yes" should we start

        // attempting to restore the context.

        printWarningToConsole("WARNING: WebGL content on the page might have caused the graphics card to reset");

        break;

    }

    Frame* frame = canvas()->document().frame();

    if (!frame)

        return;

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled()))

        return;

    FrameView* view = frame->view();

    if (!view)

        return;

    ScrollView* root = view->root();

    if (!root)

        return;

    HostWindow* hostWindow = root->hostWindow();

    if (!hostWindow)

        return;

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, hostWindow));

    if (!context) {

        if (m_contextLostMode == RealLostContext)

            m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);

        else

            // This likely shouldn't happen but is the best way to report it to the WebGL app.

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "", "error restoring context");

        return;

    }

    // Construct a new drawing buffer with the new GraphicsContext3D.

    if (m_drawingBuffer) {

        m_drawingBuffer->discardResources();

        DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;

        DrawingBuffer::AlphaRequirement alpha = m_attributes.alpha ? DrawingBuffer::Alpha : DrawingBuffer::Opaque;

        m_drawingBuffer = DrawingBuffer::create(context.get(), m_drawingBuffer->size(), preserve, alpha);

        m_drawingBuffer->bind();

    }

    m_context = context;

    m_contextLost = false;

    setupFlags();

    initializeNewContext();

    canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, ""));

}

String WebGLRenderingContext::ensureNotNull(const String& text) const

{

    if (text.isNull())

        return WTF::emptyString();

    return text;

}

WebGLRenderingContext::LRUImageBufferCache::LRUImageBufferCache(int capacity)

    : m_buffers(std::make_unique<std::unique_ptr<ImageBuffer>[]>(capacity))

    , m_capacity(capacity)

{

}

ImageBuffer* WebGLRenderingContext::LRUImageBufferCache::imageBuffer(const IntSize& size)

{

    int i;

    for (i = 0; i < m_capacity; ++i) {

        ImageBuffer* buf = m_buffers[i].get();

        if (!buf)

            break;

        if (buf->logicalSize() != size)

            continue;

        bubbleToFront(i);

        return buf;

    }

    std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, 1);

    if (!temp)

        return nullptr;

    i = std::min(m_capacity - 1, i);

    m_buffers[i] = WTF::move(temp);

    ImageBuffer* buf = m_buffers[i].get();

    bubbleToFront(i);

    return buf;

}

void WebGLRenderingContext::LRUImageBufferCache::bubbleToFront(int idx)

{

    for (int i = idx; i > 0; --i)

        m_buffers[i].swap(m_buffers[i-1]);

}

namespace {

    String GetErrorString(GC3Denum error)

    {

        switch (error) {

        case GraphicsContext3D::INVALID_ENUM:

            return "INVALID_ENUM";

        case GraphicsContext3D::INVALID_VALUE:

            return "INVALID_VALUE";

        case GraphicsContext3D::INVALID_OPERATION:

            return "INVALID_OPERATION";

        case GraphicsContext3D::OUT_OF_MEMORY:

            return "OUT_OF_MEMORY";

        case GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION:

            return "INVALID_FRAMEBUFFER_OPERATION";

        case GraphicsContext3D::CONTEXT_LOST_WEBGL:

            return "CONTEXT_LOST_WEBGL";

        default:

            return String::format("WebGL ERROR(%04x)", error);

        }

    }

} // namespace anonymous

void WebGLRenderingContext::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)

{

    if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {

      String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);

      printGLErrorToConsole(str);

    }

    m_context->synthesizeGLError(error);

}

void WebGLRenderingContext::printGLWarningToConsole(const char* functionName, const char* description)

{

    if (m_synthesizedErrorsToConsole) {

        String str = String("WebGL: ") + String(functionName) + ": " + String(description);

        printGLErrorToConsole(str);

    }

}

void WebGLRenderingContext::applyStencilTest()

{

    bool haveStencilBuffer = false;

    if (m_framebufferBinding)

        haveStencilBuffer = m_framebufferBinding->hasStencilBuffer();

    else {

        RefPtr<WebGLContextAttributes> attributes = getContextAttributes();

        haveStencilBuffer = attributes->stencil();

    }

    enableOrDisable(GraphicsContext3D::STENCIL_TEST,

                    m_stencilEnabled && haveStencilBuffer);

}

void WebGLRenderingContext::enableOrDisable(GC3Denum capability, bool enable)

{

    if (enable)

        m_context->enable(capability);

    else

        m_context->disable(capability);

}

IntSize WebGLRenderingContext::clampedCanvasSize()

{

    return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),

                   clamp(canvas()->height(), 1, m_maxViewportDims[1]));

}

GC3Dint WebGLRenderingContext::getMaxDrawBuffers()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxDrawBuffers)

        m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.

    return std::min(m_maxDrawBuffers, m_maxColorAttachments);

}

GC3Dint WebGLRenderingContext::getMaxColorAttachments()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    return m_maxColorAttachments;

}

void WebGLRenderingContext::setBackDrawBuffer(GC3Denum buf)

{

    m_backDrawBuffer = buf;

}

void WebGLRenderingContext::restoreCurrentFramebuffer()

{

    ExceptionCode ec;

    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);

}

void WebGLRenderingContext::restoreCurrentTexture2D()

{

    ExceptionCode ec;

    bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].texture2DBinding.get(), ec);

}

bool WebGLRenderingContext::supportsDrawBuffers()

{

    if (!m_drawBuffersWebGLRequirementsChecked) {

        m_drawBuffersWebGLRequirementsChecked = true;

        m_drawBuffersSupported = WebGLDrawBuffers::supported(this);

    }

    return m_drawBuffersSupported;

}

void WebGLRenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    if (!validateDrawArrays("drawArraysInstanced", mode, first, count, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", true);

    m_context->drawArraysInstanced(mode, first, count, primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    unsigned numElements = 0;

    if (!validateDrawElements("drawElementsInstanced", mode, count, type, offset, numElements, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", true);

    m_context->drawElementsInstanced(mode, count, type, static_cast<GC3Dintptr>(offset), primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribDivisor", "index out of range");

        return;

    }

    m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);

    m_context->vertexAttribDivisor(index, divisor);

}

} // namespace WebCore

#endif // ENABLE(WEBGL)

176994

Source/WebCore/html/canvas/WebGL1RenderingContext.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

#include "config.h"

#if ENABLE(WEBGL)

#include "WebGLRenderingContext.h"

#include "ANGLEInstancedArrays.h"

#include "CachedImage.h"

#include "DOMWindow.h"

#include "Document.h"

#include "EXTShaderTextureLOD.h"

#include "EXTTextureFilterAnisotropic.h"

#include "ExceptionCode.h"

#include "Extensions3D.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "HTMLVideoElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "IntSize.h"

#include "Logging.h"

#include "MainFrame.h"

#include "NotImplemented.h"

#include "OESElementIndexUint.h"

#include "OESStandardDerivatives.h"

#include "OESTextureFloat.h"

#include "OESTextureFloatLinear.h"

#include "OESTextureHalfFloat.h"

#include "OESTextureHalfFloatLinear.h"

#include "OESVertexArrayObject.h"

#include "Page.h"

#include "RenderBox.h"

#include "Settings.h"

#include "WebGLActiveInfo.h"

#include "WebGLBuffer.h"

#include "WebGLCompressedTextureATC.h"

#include "WebGLCompressedTexturePVRTC.h"

#include "WebGLCompressedTextureS3TC.h"

#include "WebGLContextAttributes.h"

#include "WebGLContextEvent.h"

#include "WebGLContextGroup.h"

#include "WebGLDebugRendererInfo.h"

#include "WebGLDebugShaders.h"

#include "WebGLDepthTexture.h"

#include "WebGLDrawBuffers.h"

#include "WebGLFramebuffer.h"

#include "WebGLLoseContext.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLShader.h"

#include "WebGLShaderPrecisionFormat.h"

#include "WebGLTexture.h"

#include "WebGLUniformLocation.h"

#include <runtime/JSCInlines.h>

#include <runtime/TypedArrayInlines.h>

#include <runtime/Uint32Array.h>

#include <wtf/StdLibExtras.h>

#include <wtf/text/CString.h>

#include <wtf/text/StringBuilder.h>

29#include "WebGL1RenderingContext.h"

namespace WebCore {

const double secondsBetweenRestoreAttempts = 1.0;

const int maxGLErrorsAllowedToConsole = 256;

namespace {

    class ScopedDrawingBufferBinder {

    public:

        ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)

            : m_drawingBuffer(drawingBuffer)

            , m_framebufferBinding(framebufferBinding)

        {

            // Commit DrawingBuffer if needed (e.g., for multisampling)

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->commit();

        }

        ~ScopedDrawingBufferBinder()

        {

            // Restore DrawingBuffer if needed

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->bind();

        }

    private:

        DrawingBuffer* m_drawingBuffer;

        WebGLFramebuffer* m_framebufferBinding;

    };

    Platform3DObject objectOrZero(WebGLObject* object)

    {

        return object ? object->object() : 0;

    }

    void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)

    {

        ASSERT(clippedStart && clippedRange);

        if (start < 0) {

            range += start;

            start = 0;

        }

        GC3Dint end = start + range;

        if (end > sourceRange)

            range -= end - sourceRange;

        *clippedStart = start;

        *clippedRange = range;

    }

    // Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.

    bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,

                GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,

                GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)

    {

        ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);

        clip1D(x, width, sourceWidth, clippedX, clippedWidth);

        clip1D(y, height, sourceHeight, clippedY, clippedHeight);

        return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);

    }

    GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)

    {

        if (value < min)

            value = min;

        if (value > max)

            value = max;

        return value;

    }

    // Return true if a character belongs to the ASCII subset as defined in

    // GLSL ES 1.0 spec section 3.1.

    bool validateCharacter(unsigned char c)

    {

        // Printing characters are valid except " $ ` @ \ ' DEL.

        if (c >= 32 && c <= 126

            && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')

            return true;

        // Horizontal tab, line feed, vertical tab, form feed, carriage return

        // are also valid.

        if (c >= 9 && c <= 13)

            return true;

        return false;

    }

    bool isPrefixReserved(const String& name)

    {

        if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))

            return true;

        return false;

    }

    // Strips comments from shader text. This allows non-ASCII characters

    // to be used in comments without potentially breaking OpenGL

    // implementations not expecting characters outside the GLSL ES set.

    class StripComments {

    public:

        StripComments(const String& str)

            : m_parseState(BeginningOfLine)

            , m_sourceString(str)

            , m_length(str.length())

            , m_position(0)

        {

            parse();

        }

        String result()

        {

            return m_builder.toString();

        }

    private:

        bool hasMoreCharacters() const

        {

            return (m_position < m_length);

        }

        void parse()

        {

            while (hasMoreCharacters()) {

                process(current());

                // process() might advance the position.

                if (hasMoreCharacters())

                    advance();

            }

        }

        void process(UChar);

        bool peek(UChar& character) const

        {

            if (m_position + 1 >= m_length)

                return false;

            character = m_sourceString[m_position + 1];

            return true;

        }

        UChar current() const

        {

            ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);

            return m_sourceString[m_position];

        }

        void advance()

        {

            ++m_position;

        }

        bool isNewline(UChar character) const

        {

            // Don't attempt to canonicalize newline related characters.

            return (character == '\n' || character == '\r');

        }

        void emit(UChar character)

        {

            m_builder.append(character);

        }

        enum ParseState {

            // Have not seen an ASCII non-whitespace character yet on

            // this line. Possible that we might see a preprocessor

            // directive.

            BeginningOfLine,

            // Have seen at least one ASCII non-whitespace character

            // on this line.

            MiddleOfLine,

            // Handling a preprocessor directive. Passes through all

            // characters up to the end of the line. Disables comment

            // processing.

            InPreprocessorDirective,

            // Handling a single-line comment. The comment text is

            // replaced with a single space.

            InSingleLineComment,

            // Handling a multi-line comment. Newlines are passed

            // through to preserve line numbers.

            InMultiLineComment

        };

        ParseState m_parseState;

        String m_sourceString;

        unsigned m_length;

        unsigned m_position;

        StringBuilder m_builder;

    };

    void StripComments::process(UChar c)

    {

        if (isNewline(c)) {

            // No matter what state we are in, pass through newlines

            // so we preserve line numbers.

            emit(c);

            if (m_parseState != InMultiLineComment)

                m_parseState = BeginningOfLine;

            return;

        }

        UChar temp = 0;

        switch (m_parseState) {

        case BeginningOfLine:

            if (WTF::isASCIISpace(c)) {

                emit(c);

                break;

            }

            if (c == '#') {

                m_parseState = InPreprocessorDirective;

                emit(c);

                break;

            }

            // Transition to normal state and re-handle character.

            m_parseState = MiddleOfLine;

            process(c);

            break;

        case MiddleOfLine:

            if (c == '/' && peek(temp)) {

                if (temp == '/') {

                    m_parseState = InSingleLineComment;

                    emit(' ');

                    advance();

                    break;

                }

                if (temp == '*') {

                    m_parseState = InMultiLineComment;

                    // Emit the comment start in case the user has

                    // an unclosed comment and we want to later

                    // signal an error.

                    emit('/');

                    emit('*');

                    advance();

                    break;

                }

            }

            emit(c);

            break;

        case InPreprocessorDirective:

            // No matter what the character is, just pass it

            // through. Do not parse comments in this state. This

            // might not be the right thing to do long term, but it

            // should handle the #error preprocessor directive.

            emit(c);

            break;

        case InSingleLineComment:

            // The newline code at the top of this function takes care

            // of resetting our state when we get out of the

            // single-line comment. Swallow all other characters.

            break;

        case InMultiLineComment:

            if (c == '*' && peek(temp) && temp == '/') {

                emit('*');

                emit('/');

                m_parseState = MiddleOfLine;

                advance();

                break;

            }

            // Swallow all other characters. Unclear whether we may

            // want or need to just emit a space per character to try

            // to preserve column numbers for debugging purposes.

            break;

        }

    }

} // namespace anonymous

class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextLostCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onContextLost() override { m_context->forceLostContext(WebGLRenderingContext::RealLostContext); }

    virtual ~WebGLRenderingContextLostCallback() {}

private:

    WebGLRenderingContext* m_context;

};

class WebGLRenderingContextErrorMessageCallback : public GraphicsContext3D::ErrorMessageCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onErrorMessage(const String& message, GC3Dint) override

    {

        if (m_context->m_synthesizedErrorsToConsole)

            m_context->printGLErrorToConsole(message);

    }

    virtual ~WebGLRenderingContextErrorMessageCallback() { }

private:

    WebGLRenderingContext* m_context;

};

std::unique_ptr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)

{

    Document& document = canvas->document();

    Frame* frame = document.frame();

    if (!frame)

        return nullptr;

    // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in

    // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));

        return nullptr;

    }

    bool isPendingPolicyResolution = false;

    Document& topDocument = document.topDocument();

    Page* page = topDocument.page();

    if (page && !topDocument.url().isLocalFile()) {

        WebGLLoadPolicy policy = page->mainFrame().loader().client().webGLPolicyForURL(topDocument.url());

        if (policy == WebGLBlockCreation) {

            LOG(WebGL, "The policy for this URL (%s) is to block WebGL.", topDocument.url().host().utf8().data());

            return nullptr;

        }

        if (policy == WebGLPendingCreation) {

            LOG(WebGL, "WebGL policy is pending. May need to be resolved later.");

            isPendingPolicyResolution = true;

        }

    }

    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();

    if (attributes.antialias) {

        if (!frame->settings().openGLMultisamplingEnabled())

            attributes.antialias = false;

    }

    attributes.noExtensions = true;

    attributes.shareResources = false;

    attributes.preferDiscreteGPU = true;

    if (frame->settings().forceSoftwareWebGLRendering())

        attributes.forceSoftwareRenderer = true;

    if (page)

        attributes.devicePixelRatio = page->deviceScaleFactor();

    if (isPendingPolicyResolution) {

        LOG(WebGL, "Create a WebGL context that looks real, but will require a policy resolution if used.");

        std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, attributes));

        renderingContext->suspendIfNeeded();

        return renderingContext;

    }

    HostWindow* hostWindow = document.view()->root()->hostWindow();

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));

    if (!context || !context->makeContextCurrent()) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));

        return nullptr;

    }

    Extensions3D* extensions = context->getExtensions();

    if (extensions->supports("GL_EXT_debug_marker"))

        extensions->pushGroupMarkerEXT("WebGLRenderingContext");

    std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, context, attributes));

    renderingContext->suspendIfNeeded();

    return renderingContext;

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(0)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(0)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(true)

    , m_hasRequestedPolicyResolution(false)

{

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,

    GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(context)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(4)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(false)

    , m_hasRequestedPolicyResolution(false)

{

    ASSERT(m_context);

    m_contextGroup = WebGLContextGroup::create();

    m_contextGroup->addContext(this);

    m_maxViewportDims[0] = m_maxViewportDims[1] = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);

    if (m_drawingBuffer)

        m_drawingBuffer->bind();

    setupFlags();

    initializeNewContext();

}

void WebGLRenderingContext::initializeNewContext()

{

    ASSERT(!m_contextLost);

    m_needsUpdate = true;

    m_markedCanvasDirty = false;

    m_activeTextureUnit = 0;

    m_packAlignment = 4;

    m_unpackAlignment = 4;

    m_unpackFlipY = false;

    m_unpackPremultiplyAlpha = false;

    m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;

    m_boundArrayBuffer = 0;

    m_currentProgram = 0;

    m_framebufferBinding = 0;

    m_renderbufferBinding = 0;

    m_depthMask = true;

    m_stencilEnabled = false;

    m_stencilMask = 0xFFFFFFFF;

    m_stencilMaskBack = 0xFFFFFFFF;

    m_stencilFuncRef = 0;

    m_stencilFuncRefBack = 0;

    m_stencilFuncMask = 0xFFFFFFFF;

    m_stencilFuncMaskBack = 0xFFFFFFFF;

    m_layerCleared = false;

    m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;

    m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;

    m_scissorEnabled = false;

    m_clearDepth = 1;

    m_clearStencil = 0;

    m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;

    GC3Dint numCombinedTextureImageUnits = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

    m_textureUnits.clear();

    m_textureUnits.resize(numCombinedTextureImageUnits);

    GC3Dint numVertexAttribs = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

    m_maxVertexAttribs = numVertexAttribs;

    m_maxTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

    m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

    m_maxCubeMapTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

    m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

    m_maxRenderbufferSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);

    // These two values from EXT_draw_buffers are lazily queried.

    m_maxDrawBuffers = 0;

    m_maxColorAttachments = 0;

    m_backDrawBuffer = GraphicsContext3D::BACK;

    m_drawBuffersWebGLRequirementsChecked = false;

    m_drawBuffersSupported = false;

    m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);

    addContextObject(m_defaultVertexArrayObject.get());

    m_boundVertexArrayObject = m_defaultVertexArrayObject;

    m_vertexAttribValue.resize(m_maxVertexAttribs);

    if (!isGLES2NPOTStrict())

        createFallbackBlackTextures1x1();

    if (!isGLES2Compliant())

        initVertexAttrib0();

    IntSize canvasSize = clampedCanvasSize();

    if (m_drawingBuffer)

        m_drawingBuffer->reset(canvasSize);

    m_context->reshape(canvasSize.width(), canvasSize.height());

    m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());

    m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());

    m_context->setContextLostCallback(std::make_unique<WebGLRenderingContextLostCallback>(this));

    m_context->setErrorMessageCallback(std::make_unique<WebGLRenderingContextErrorMessageCallback>(this));

}

void WebGLRenderingContext::setupFlags()

{

    ASSERT(m_context);

    if (Page* page = canvas()->document().page())

        m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();

    m_isGLES2Compliant = m_context->isGLES2Compliant();

    m_isErrorGeneratedOnOutOfBoundsAccesses = m_context->getExtensions()->isEnabled("GL_CHROMIUM_strict_attribs");

    m_isResourceSafe = m_context->getExtensions()->isEnabled("GL_CHROMIUM_resource_safe");

    if (m_isGLES2Compliant) {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");

    } else {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_ARB_texture_non_power_of_two");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_EXT_packed_depth_stencil");

    }

    m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");

}

bool WebGLRenderingContext::allowPrivilegedExtensions() const

{

    if (Page* page = canvas()->document().page())

        return page->settings().privilegedWebGLExtensionsEnabled();

    return false;

}

void WebGLRenderingContext::addCompressedTextureFormat(GC3Denum format)

{

    if (!m_compressedTextureFormats.contains(format))

        m_compressedTextureFormats.append(format);

}

WebGLRenderingContext::~WebGLRenderingContext()

{

    // Remove all references to WebGLObjects so if they are the last reference

    // they will be freed before the last context is removed from the context group.

    m_boundArrayBuffer = nullptr;

    m_defaultVertexArrayObject = nullptr;

    m_boundVertexArrayObject = nullptr;

    m_vertexAttrib0Buffer = nullptr;

    m_currentProgram = nullptr;

    m_framebufferBinding = nullptr;

    m_renderbufferBinding = nullptr;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        m_textureUnits[i].texture2DBinding = nullptr;

        m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    m_blackTexture2D = nullptr;

    m_blackTextureCubeMap = nullptr;

    if (!m_isPendingPolicyResolution) {

        detachAndRemoveAllObjects();

        destroyGraphicsContext3D();

        m_contextGroup->removeContext(this);

    }

}

void WebGLRenderingContext::destroyGraphicsContext3D()

{

    if (m_isPendingPolicyResolution)

        return;

    // The drawing buffer holds a context reference. It must also be destroyed

    // in order for the context to be released.

    if (m_drawingBuffer)

        m_drawingBuffer.clear();

    if (m_context) {

        m_context->setContextLostCallback(nullptr);

        m_context->setErrorMessageCallback(nullptr);

        m_context.clear();

    }

}

void WebGLRenderingContext::markContextChanged()

{

    if (m_framebufferBinding)

        return;

    m_context->markContextChanged();

    if (m_drawingBuffer)

        m_drawingBuffer->markContentsChanged();

    m_layerCleared = false;

    RenderBox* renderBox = canvas()->renderBox();

    if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {

        m_markedCanvasDirty = true;

        canvas()->clearCopiedImage();

        renderBox->contentChanged(CanvasChanged);

    } else {

        if (!m_markedCanvasDirty) {

            m_markedCanvasDirty = true;

            canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));

        }

    }

}

bool WebGLRenderingContext::clearIfComposited(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return false;

    if (!m_context->layerComposited() || m_layerCleared

        || m_attributes.preserveDrawingBuffer || (mask && m_framebufferBinding))

        return false;

    RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();

    // Determine if it's possible to combine the clear the user asked for and this clear.

    bool combinedClear = mask && !m_scissorEnabled;

    m_context->disable(GraphicsContext3D::SCISSOR_TEST);

    if (combinedClear && (mask & GraphicsContext3D::COLOR_BUFFER_BIT))

        m_context->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,

                              m_colorMask[1] ? m_clearColor[1] : 0,

                              m_colorMask[2] ? m_clearColor[2] : 0,

                              m_colorMask[3] ? m_clearColor[3] : 0);

    else

        m_context->clearColor(0, 0, 0, 0);

    m_context->colorMask(true, true, true, true);

    GC3Dbitfield clearMask = GraphicsContext3D::COLOR_BUFFER_BIT;

    if (contextAttributes->depth()) {

        if (!combinedClear || !m_depthMask || !(mask & GraphicsContext3D::DEPTH_BUFFER_BIT))

            m_context->clearDepth(1.0f);

        clearMask |= GraphicsContext3D::DEPTH_BUFFER_BIT;

        m_context->depthMask(true);

    }

    if (contextAttributes->stencil()) {

        if (combinedClear && (mask & GraphicsContext3D::STENCIL_BUFFER_BIT))

            m_context->clearStencil(m_clearStencil & m_stencilMask);

        else

            m_context->clearStencil(0);

        clearMask |= GraphicsContext3D::STENCIL_BUFFER_BIT;

        m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, 0xFFFFFFFF);

    }

    if (m_drawingBuffer)

        m_drawingBuffer->clearFramebuffers(clearMask);

    else {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

        m_context->clear(clearMask);

    }

    restoreStateAfterClear();

    if (m_framebufferBinding)

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

    m_layerCleared = true;

    return combinedClear;

}

void WebGLRenderingContext::restoreStateAfterClear()

{

    // Restore the state that the context set.

    if (m_scissorEnabled)

        m_context->enable(GraphicsContext3D::SCISSOR_TEST);

    m_context->clearColor(m_clearColor[0], m_clearColor[1],

                          m_clearColor[2], m_clearColor[3]);

    m_context->colorMask(m_colorMask[0], m_colorMask[1],

                         m_colorMask[2], m_colorMask[3]);

    m_context->clearDepth(m_clearDepth);

    m_context->clearStencil(m_clearStencil);

    m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, m_stencilMask);

    m_context->depthMask(m_depthMask);

}

void WebGLRenderingContext::markLayerComposited()

{

    if (isContextLostOrPending())

        return;

    m_context->markLayerComposited();

}

void WebGLRenderingContext::paintRenderingResultsToCanvas()

{

    if (isContextLostOrPending())

        return;

    if (canvas()->document().printing())

        canvas()->clearPresentationCopy();

    // Until the canvas is written to by the application, the clear that

    // happened after it was composited should be ignored by the compositor.

    if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {

        m_context->paintCompositedResultsToCanvas(canvas()->buffer());

        canvas()->makePresentationCopy();

    } else

        canvas()->clearPresentationCopy();

    clearIfComposited();

    if (!m_markedCanvasDirty && !m_layerCleared)

        return;

    canvas()->clearCopiedImage();

    m_markedCanvasDirty = false;

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    m_context->paintRenderingResultsToCanvas(canvas()->buffer(), m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

}

PassRefPtr<ImageData> WebGLRenderingContext::paintRenderingResultsToImageData()

{

    if (isContextLostOrPending())

        return nullptr;

    clearIfComposited();

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    RefPtr<ImageData> imageData = m_context->paintRenderingResultsToImageData(m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

    return imageData;

}

void WebGLRenderingContext::reshape(int width, int height)

{

    if (isContextLostOrPending())

        return;

    // This is an approximation because at WebGLRenderingContext level we don't

    // know if the underlying FBO uses textures or renderbuffers.

    GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);

    // Limit drawing buffer size to 4k to avoid memory exhaustion.

    const int sizeUpperLimit = 4096;

    maxSize = std::min(maxSize, sizeUpperLimit);

    GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);

    GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);

    width = clamp(width, 1, maxWidth);

    height = clamp(height, 1, maxHeight);

    if (m_needsUpdate) {

        RenderBox* renderBox = canvas()->renderBox();

        if (renderBox && renderBox->hasAcceleratedCompositing())

            renderBox->contentChanged(CanvasChanged);

        m_needsUpdate = false;

    }

    // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off

    // clear (and this matches what reshape will do).

    if (m_drawingBuffer) {

        m_drawingBuffer->reset(IntSize(width, height));

        restoreStateAfterClear();

    } else

        m_context->reshape(width, height);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].texture2DBinding.get()));

    m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));

    if (m_framebufferBinding)

      m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

}

int WebGLRenderingContext::drawingBufferWidth() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().width();

    return m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::drawingBufferHeight() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().height();

    return m_context->getInternalFramebufferSize().height();

}

unsigned int WebGLRenderingContext::sizeInBytes(GC3Denum type)

{

    switch (type) {

    case GraphicsContext3D::BYTE:

        return sizeof(GC3Dbyte);

    case GraphicsContext3D::UNSIGNED_BYTE:

        return sizeof(GC3Dubyte);

    case GraphicsContext3D::SHORT:

        return sizeof(GC3Dshort);

    case GraphicsContext3D::UNSIGNED_SHORT:

        return sizeof(GC3Dushort);

    case GraphicsContext3D::INT:

        return sizeof(GC3Dint);

    case GraphicsContext3D::UNSIGNED_INT:

        return sizeof(GC3Duint);

    case GraphicsContext3D::FLOAT:

        return sizeof(GC3Dfloat);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

void WebGLRenderingContext::activeTexture(GC3Denum texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "activeTexture", "texture unit out of range");

        return;

    }

    m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

    m_context->activeTexture(texture);

    if (m_drawingBuffer)

        m_drawingBuffer->setActiveTextureUnit(texture);

}

void WebGLRenderingContext::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))

        return;

    if (!program->attachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "attachShader", "shader attachment already has shader");

        return;

    }

    m_context->attachShader(objectOrZero(program), objectOrZero(shader));

    shader->onAttached();

}

void WebGLRenderingContext::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))

        return;

    if (!validateLocationLength("bindAttribLocation", name))

        return;

    if (!validateString("bindAttribLocation", name))

        return;

    if (isPrefixReserved(name)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindAttribLocation", "reserved prefix");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bindAttribLocation", "index out of range");

        return;

    }

    m_context->bindAttribLocation(objectOrZero(program), index, name);

}

bool WebGLRenderingContext::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)

{

    deleted = false;

    if (isContextLostOrPending())

        return false;

    if (object) {

        if (!object->validate(contextGroup(), this)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object not from this context");

            return false;

        }

        deleted = !object->object();

    }

    return true;

}

void WebGLRenderingContext::bindBuffer(GC3Denum target, WebGLBuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindBuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindBuffer", "buffers can not be used with multiple targets");

        return;

    }

    if (target == GraphicsContext3D::ARRAY_BUFFER)

        m_boundArrayBuffer = buffer;

    else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

        m_boundVertexArrayObject->setElementArrayBuffer(buffer);

    else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");

        return;

    }

    m_context->bindBuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setTarget(target);

}

void WebGLRenderingContext::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindFramebuffer", "invalid target");

        return;

    }

    m_framebufferBinding = buffer;

    if (m_drawingBuffer)

        m_drawingBuffer->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));

    if (!m_framebufferBinding && m_drawingBuffer) {

        // Instead of binding fb 0, bind the drawing buffer.

        m_drawingBuffer->bind();

    } else

        m_context->bindFramebuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setHasEverBeenBound();

    applyStencilTest();

}

void WebGLRenderingContext::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))

        return;

    if (deleted)

        renderBuffer = 0;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindRenderbuffer", "invalid target");

        return;

    }

    m_renderbufferBinding = renderBuffer;

    m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));

    if (renderBuffer)

        renderBuffer->setHasEverBeenBound();

}

void WebGLRenderingContext::bindTexture(GC3Denum target, WebGLTexture* texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindTexture", texture, deleted))

        return;

    if (deleted)

        texture = 0;

    if (texture && texture->getTarget() && texture->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");

        return;

    }

    GC3Dint maxLevel = 0;

    if (target == GraphicsContext3D::TEXTURE_2D) {

        m_textureUnits[m_activeTextureUnit].texture2DBinding = texture;

        maxLevel = m_maxTextureLevel;

        if (m_drawingBuffer && !m_activeTextureUnit)

            m_drawingBuffer->setTexture2DBinding(objectOrZero(texture));

    } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

        m_textureUnits[m_activeTextureUnit].textureCubeMapBinding = texture;

        maxLevel = m_maxCubeMapTextureLevel;

    } else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindTexture", "invalid target");

        return;

    }

    m_context->bindTexture(target, objectOrZero(texture));

    if (texture)

        texture->setTarget(target, maxLevel);

    // Note: previously we used to automatically set the TEXTURE_WRAP_R

    // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL

    // ES 2.0 doesn't expose this flag (a bug in the specification) and

    // otherwise the application has no control over the seams in this

    // dimension. However, it appears that supporting this properly on all

    // platforms is fairly involved (will require a HashMap from texture ID

    // in all ports), and we have not had any complaints, so the logic has

    // been removed.

}

void WebGLRenderingContext::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)

{

    if (isContextLostOrPending())

        return;

    m_context->blendColor(red, green, blue, alpha);

}

void WebGLRenderingContext::blendEquation(GC3Denum mode)

33WebGL1RenderingContext::WebGL1RenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

34 : WebGLRenderingContextBase(passedCanvas, attributes)

108635{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))

        return;

    m_context->blendEquation(mode);

}

void WebGLRenderingContext::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))

        return;

    m_context->blendEquationSeparate(modeRGB, modeAlpha);

}

void WebGLRenderingContext::blendFunc(GC3Denum sfactor, GC3Denum dfactor)

{

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))

        return;

    m_context->blendFunc(sfactor, dfactor);

}

void WebGLRenderingContext::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)

{

    // Note: Alpha does not have the same restrictions as RGB.

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))

        return;

    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

}

void WebGLRenderingContext::bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (size < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size < 0");

        return;

    }

    if (!size) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size == 0");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->data(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

GC3Denum WebGLRenderingContext::checkFramebufferStatus(GC3Denum target)

{

    if (isContextLostOrPending())

        return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "checkFramebufferStatus", "invalid target");

        return 0;

    }

    if (!m_framebufferBinding || !m_framebufferBinding->object())

        return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

    const char* reason = "framebuffer incomplete";

    GC3Denum result = m_framebufferBinding->checkStatus(&reason);

    if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {

        printGLWarningToConsole("checkFramebufferStatus", reason);

        return result;

    }

    result = m_context->checkFramebufferStatus(target);

    return result;

}

void WebGLRenderingContext::clear(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return;

    if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clear", "invalid mask");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);

        return;

    }

    if (!clearIfComposited(mask))

        m_context->clear(mask);

    markContextChanged();

}

void WebGLRenderingContext::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)

{

    if (isContextLostOrPending())

        return;

    if (std::isnan(r))

        r = 0;

    if (std::isnan(g))

        g = 0;

    if (std::isnan(b))

        b = 0;

    if (std::isnan(a))

        a = 1;

    m_clearColor[0] = r;

    m_clearColor[1] = g;

    m_clearColor[2] = b;

    m_clearColor[3] = a;

    m_context->clearColor(r, g, b, a);

}

void WebGLRenderingContext::clearDepth(GC3Dfloat depth)

{

    if (isContextLostOrPending())

        return;

    m_clearDepth = depth;

    m_context->clearDepth(depth);

}

void WebGLRenderingContext::clearStencil(GC3Dint s)

{

    if (isContextLostOrPending())

        return;

    m_clearStencil = s;

    m_context->clearStencil(s);

}

void WebGLRenderingContext::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)

{

    if (isContextLostOrPending())

        return;

    m_colorMask[0] = red;

    m_colorMask[1] = green;

    m_colorMask[2] = blue;

    m_colorMask[3] = alpha;

    m_context->colorMask(red, green, blue, alpha);

}

void WebGLRenderingContext::compileShader(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))

        return;

    m_context->compileShader(objectOrZero(shader));

    GC3Dint value;

    m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);

    shader->setValid(value);

}

void WebGLRenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                                                 GC3Dsizei height, GC3Dint border, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(internalformat)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");

        return;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "border not 0");

        return;

    }

    if (!validateCompressedTexDimensions("compressedTexImage2D", target, level, width, height, internalformat))

        return;

    if (!validateCompressedTexFuncData("compressedTexImage2D", width, height, internalformat, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);

    if (!tex)

        return;

    if (!isGLES2NPOTStrict()) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->compressedTexImage2D(target, level, internalformat, width, height,

        border, data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The compressedTexImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

        tex->markInvalid(target, level);

        return;

    }

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

    tex->setCompressed();

}

void WebGLRenderingContext::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                    GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(format)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexSubImage2D", "invalid format");

        return;

    }

    if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);

    if (!tex)

        return;

    if (format != tex->getInternalFormat(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");

        return;

    }

    if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))

        return;

    graphicsContext3D()->compressedTexSubImage2D(target, level, xoffset, yoffset,

                                                 width, height, format, data->byteLength(), data->baseAddress());

    tex->setCompressed();

36 m_type = "webgl1";

142537}

142638

1427 bool WebGLRenderingContext::validateSettableTexFormat(const char* functionName, GC3Denum format)

39WebGL1RenderingContext::WebGL1RenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,

40 GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, context, attributes)

142841{

    if (GraphicsContext3D::getClearBitsByFormat(format) & (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format can not be set, only rendered to");

        return false;

    }

    return true;

42 m_type = "webgl1";

143443}

143544

void WebGLRenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncParameters("copyTexImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

        return;

    if (!validateSettableTexFormat("copyTexImage2D", internalformat))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexImage2D", target, true);

    if (!tex)

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");

        return;

    }

    if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    } else {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            m_context->texImage2DResourceSafe(target, level, internalformat, width, height, border,

                                              internalformat, GraphicsContext3D::UNSIGNED_BYTE, m_unpackAlignment);

            if (clippedWidth > 0 && clippedHeight > 0) {

                m_context->copyTexSubImage2D(target, level, clippedX - x, clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else

            m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    }

    // FIXME: if the framebuffer is not complete, none of the below should be executed.

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

}

void WebGLRenderingContext::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("copyTexSubImage2D", target, level))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexSubImage2D", target, true);

    if (!tex)

        return;

    if (!validateSize("copyTexSubImage2D", xoffset, yoffset) || !validateSize("copyTexSubImage2D", width, height))

        return;

    // Before checking if it is in the range, check if overflow happens first.

    if (xoffset + width < 0 || yoffset + height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "bad dimensions");

        return;

    }

    if (xoffset + width > tex->getWidth(target, level) || yoffset + height > tex->getHeight(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");

        return;

    }

    GC3Denum internalformat = tex->getInternalFormat(target, level);

    if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

    } else {

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            GC3Denum format = tex->getInternalFormat(target, level);

            GC3Denum type = tex->getType(target, level);

            std::unique_ptr<unsigned char[]> zero;

            if (width && height) {

                unsigned int size;

                GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, 0);

                if (error != GraphicsContext3D::NO_ERROR) {

                    synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");

                    return;

                }

                zero = std::make_unique<unsigned char[]>(size);

                if (!zero) {

                    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "out of memory");

                    return;

                }

                memset(zero.get(), 0, size);

            }

            m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, zero.get());

            if (clippedWidth > 0 && clippedHeight > 0) {

                ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

                m_context->copyTexSubImage2D(target, level, xoffset + clippedX - x, yoffset + clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else {

            ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

            m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

        }

    }

}

PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);

    addContextObject(o.get());

    return o;

}

PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLTexture> o = WebGLTexture::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLProgram> o = WebGLProgram::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(GC3Denum type, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "createShader", "invalid shader type");

        return nullptr;

    }

    RefPtr<WebGLShader> o = WebGLShader::create(this, type);

    addSharedObject(o.get());

    return o;

}

void WebGLRenderingContext::cullFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->cullFace(mode);

}

bool WebGLRenderingContext::deleteObject(WebGLObject* object)

{

    if (isContextLostOrPending() || !object)

        return false;

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "delete", "object does not belong to this context");

        return false;

    }

    if (object->object())

        // We need to pass in context here because we want

        // things in this context unbound.

        object->deleteObject(graphicsContext3D());

    return true;

}

void WebGLRenderingContext::deleteBuffer(WebGLBuffer* buffer)

{

    if (!deleteObject(buffer))

        return;

    if (m_boundArrayBuffer == buffer)

        m_boundArrayBuffer = 0;

    m_boundVertexArrayObject->unbindBuffer(buffer);

}

void WebGLRenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!deleteObject(framebuffer))

        return;

    if (framebuffer == m_framebufferBinding) {

        m_framebufferBinding = 0;

        if (m_drawingBuffer) {

            m_drawingBuffer->setFramebufferBinding(0);

            // Have to call bindFramebuffer here to bind back to internal fbo.

            m_drawingBuffer->bind();

        } else

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

    }

}

void WebGLRenderingContext::deleteProgram(WebGLProgram* program)

{

    deleteObject(program);

    // We don't reset m_currentProgram to 0 here because the deletion of the

    // current program is delayed.

}

void WebGLRenderingContext::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!deleteObject(renderbuffer))

        return;

    if (renderbuffer == m_renderbufferBinding)

        m_renderbufferBinding = 0;

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);

}

void WebGLRenderingContext::deleteShader(WebGLShader* shader)

{

    deleteObject(shader);

}

void WebGLRenderingContext::deleteTexture(WebGLTexture* texture)

{

    if (!deleteObject(texture))

        return;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        if (texture == m_textureUnits[i].texture2DBinding)

            m_textureUnits[i].texture2DBinding = nullptr;

        if (texture == m_textureUnits[i].textureCubeMapBinding)

            m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);

}

void WebGLRenderingContext::depthFunc(GC3Denum func)

{

    if (isContextLostOrPending())

        return;

    m_context->depthFunc(func);

}

void WebGLRenderingContext::depthMask(GC3Dboolean flag)

{

    if (isContextLostOrPending())

        return;

    m_depthMask = flag;

    m_context->depthMask(flag);

}

void WebGLRenderingContext::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)

{

    if (isContextLostOrPending())

        return;

    if (zNear > zFar) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "depthRange", "zNear > zFar");

        return;

    }

    m_context->depthRange(zNear, zFar);

}

void WebGLRenderingContext::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))

        return;

    if (!program->detachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "detachShader", "shader not attached");

        return;

    }

    m_context->detachShader(objectOrZero(program), objectOrZero(shader));

    shader->onDetached(graphicsContext3D());

}

void WebGLRenderingContext::disable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("disable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = false;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = false;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->disable(cap);

}

void WebGLRenderingContext::disableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "disableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = false;

    if (index > 0 || isGLES2Compliant())

        m_context->disableVertexAttribArray(index);

}

bool WebGLRenderingContext::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)

{

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (offset < 0)

        return false;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // For an unsigned int array, offset must be divisible by 4 for alignment reasons.

        if (offset % 4)

            return false;

        // Make uoffset an element offset.

        offset /= 4;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // For an unsigned short array, offset must be divisible by 2 for alignment reasons.

        if (offset % 2)

            return false;

        // Make uoffset an element offset.

        offset /= 2;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        GC3Dsizeiptr n = elementArrayBuffer->byteLength();

        if (offset > n || count > n - offset)

            return false;

    }

    return true;

}

bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)

{

    // Performs conservative validation by caching a maximum index of

    // the given type per element array buffer. If all of the bound

    // array buffers have enough elements to satisfy that maximum

    // index, skips the expensive per-draw-call iteration in

    // validateIndexArrayPrecise.

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();

    // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.

    if (!numElements)

        return false;

    const ArrayBuffer* buffer = elementArrayBuffer->elementArrayBuffer();

    ASSERT(buffer);

    int maxIndex = elementArrayBuffer->getCachedMaxIndex(type);

    if (maxIndex < 0) {

        // Compute the maximum index in the entire buffer for the given type of index.

        switch (type) {

        case GraphicsContext3D::UNSIGNED_BYTE: {

            const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_SHORT: {

            numElements /= sizeof(GC3Dushort);

            const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_INT: {

            if (!m_oesElementIndexUint)

                return false;

            numElements /= sizeof(GC3Duint);

            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        default:

            return false;

        }

        elementArrayBuffer->setCachedMaxIndex(type, maxIndex);

    }

    if (maxIndex >= 0) {

        // The number of required elements is one more than the maximum

        // index that will be accessed.

        numElementsRequired = maxIndex + 1;

        return true;

    }

    return false;

}

bool WebGLRenderingContext::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)

{

    ASSERT(count >= 0 && offset >= 0);

    unsigned lastIndex = 0;

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (!count) {

        numElementsRequired = 0;

        return true;

    }

    if (!elementArrayBuffer->elementArrayBuffer())

        return false;

    unsigned long uoffset = offset;

    unsigned long n = count;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Duint);

        const GC3Duint* p = static_cast<const GC3Duint*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Dushort);

        const GC3Dushort* p = static_cast<const GC3Dushort*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        const GC3Dubyte* p = static_cast<const GC3Dubyte*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    }

    // Then set the last index in the index array and make sure it is valid.

    numElementsRequired = lastIndex + 1;

    return numElementsRequired > 0;

}

bool WebGLRenderingContext::validateVertexAttributes(unsigned elementCount, unsigned primitiveCount)

{

    if (!m_currentProgram)

        return false;

    // Look in each enabled vertex attrib and check if they've been bound to a buffer.

    for (unsigned i = 0; i < m_maxVertexAttribs; ++i) {

        if (!m_boundVertexArrayObject->getVertexAttribState(i).validateBinding())

            return false;

    }

    if (elementCount <= 0)

        return true;

    // Look in each consumed vertex attrib (by the current program).

    bool sawNonInstancedAttrib = false;

    bool sawEnabledAttrib = false;

    int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();

    for (int i = 0; i < numActiveAttribLocations; ++i) {

        int loc = m_currentProgram->getActiveAttribLocation(i);

        if (loc >= 0 && loc < static_cast<int>(m_maxVertexAttribs)) {

            const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(loc);

            if (state.enabled) {

                sawEnabledAttrib = true;

                // Avoid off-by-one errors in numElements computation.

                // For the last element, we will only touch the data for the

                // element and nothing beyond it.

                int bytesRemaining = static_cast<int>(state.bufferBinding->byteLength() - state.offset);

                unsigned numElements = 0;

                ASSERT(state.stride > 0);

                if (bytesRemaining >= state.bytesPerElement)

                    numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;

                if (!state.divisor)

                    sawNonInstancedAttrib = true;

                if ((!state.divisor && elementCount > numElements) || (state.divisor && primitiveCount > numElements))

                    return false;

            }

        }

    }

    if (!sawNonInstancedAttrib && sawEnabledAttrib)

        return false;

    return true;

}

bool WebGLRenderingContext::validateWebGLObject(const char* functionName, WebGLObject* object)

{

    if (!object || !object->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no object or object deleted");

        return false;

    }

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object does not belong to this context");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    if (first < 0 || count < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "first or count < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primcount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        Checked<GC3Dint, RecordOverflow> checkedFirst(first);

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount;

        Checked<GC3Dint, RecordOverflow> checkedPrimCount(primcount);

        if (checkedSum.hasOverflowed() || checkedPrimCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimCount.unsafeGet())) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateDrawArrays("drawArrays", mode, first, count, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", true);

    m_context->drawArrays(mode, first, count);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", false);

    markContextChanged();

}

bool WebGLRenderingContext::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT:

        break;

    case GraphicsContext3D::UNSIGNED_INT:

        if (m_oesElementIndexUint)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    }

    if (count < 0 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "count or offset < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (!m_boundVertexArrayObject->getElementArrayBuffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");

            return false;

        }

        if (!count)

            return false;

        if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements)) {

            if (!validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements)) {

                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

                return false;

            }

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    unsigned numElements = 0;

    if (!validateDrawElements("drawElements", mode, count, type, offset, numElements))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", true);

    m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", false);

    markContextChanged();

}

void WebGLRenderingContext::enable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("enable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = true;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = true;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->enable(cap);

}

void WebGLRenderingContext::enableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "enableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = true;

    m_context->enableVertexAttribArray(index);

}

void WebGLRenderingContext::finish()

{

    if (isContextLostOrPending())

        return;

    m_context->finish();

}

void WebGLRenderingContext::flush()

{

    if (isContextLostOrPending())

        return;

    m_context->flush();

}

void WebGLRenderingContext::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))

        return;

    if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "framebufferRenderbuffer", "invalid target");

        return;

    }

    if (buffer && !buffer->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");

        return;

    }

    Platform3DObject bufferObject = objectOrZero(buffer);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);

        break;

    default:

        m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);

    applyStencilTest();

}

void WebGLRenderingContext::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))

        return;

    if (level) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "framebufferTexture2D", "level not 0");

        return;

    }

    if (texture && !texture->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");

        return;

    }

    Platform3DObject textureObject = objectOrZero(texture);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, GraphicsContext3D::DEPTH_ATTACHMENT, textarget, textureObject, level);

        m_context->framebufferTexture2D(target, GraphicsContext3D::STENCIL_ATTACHMENT, textarget, textureObject, level);

        break;

    case GraphicsContext3D::DEPTH_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    case GraphicsContext3D::STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    default:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);

    applyStencilTest();

}

void WebGLRenderingContext::frontFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->frontFace(mode);

}

void WebGLRenderingContext::generateMipmap(GC3Denum target)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);

    if (!tex)

        return;

    if (!tex->canGenerateMipmaps()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");

        return;

    }

    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=123916. Compressed textures should be allowed in WebGL 2:

    if (tex->isCompressed()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "trying to generate mipmaps from compressed texture");

        return;

    }

    if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))

        return;

    // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR

    // on Mac.  Remove the hack once this driver bug is fixed.

#if OS(DARWIN)

    bool needToResetMinFilter = false;

    if (tex->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_LINEAR) {

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::NEAREST_MIPMAP_LINEAR);

        needToResetMinFilter = true;

    }

#endif

    m_context->generateMipmap(target);

#if OS(DARWIN)

    if (needToResetMinFilter)

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, tex->getMinFilter());

#endif

    tex->generateMipmapLevelInfo();

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveAttrib(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))

        return nullptr;

    ActiveInfo info;

    if (!m_context->getActiveAttrib(objectOrZero(program), index, info))

        return nullptr;

    LOG(WebGL, "Returning active attribute %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveUniform(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))

        return 0;

    ActiveInfo info;

    if (!m_context->getActiveUniform(objectOrZero(program), index, info))

        return nullptr;

    if (!isGLES2Compliant())

        if (info.size > 1 && !info.name.endsWith("[0]"))

            info.name.append("[0]");

    LOG(WebGL, "Returning active uniform %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

bool WebGLRenderingContext::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    shaderObjects.clear();

    if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))

        return false;

    const GC3Denum shaderType[] = {

        GraphicsContext3D::VERTEX_SHADER,

        GraphicsContext3D::FRAGMENT_SHADER

    };

    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {

        WebGLShader* shader = program->getAttachedShader(shaderType[i]);

        if (shader)

            shaderObjects.append(shader);

    }

    return true;

}

GC3Dint WebGLRenderingContext::getAttribLocation(WebGLProgram* program, const String& name)

{

    if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))

        return -1;

    if (!validateLocationLength("getAttribLocation", name))

        return -1;

    if (!validateString("getAttribLocation", name))

        return -1;

    if (isPrefixReserved(name))

        return -1;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getAttribLocation", "program not linked");

        return -1;

    }

    return m_context->getAttribLocation(objectOrZero(program), name);

}

WebGLGetInfo WebGLRenderingContext::getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (pname != GraphicsContext3D::BUFFER_SIZE && pname != GraphicsContext3D::BUFFER_USAGE) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    GC3Dint value = 0;

    m_context->getBufferParameteriv(target, pname, &value);

    if (pname == GraphicsContext3D::BUFFER_SIZE)

        return WebGLGetInfo(value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

PassRefPtr<WebGLContextAttributes> WebGLRenderingContext::getContextAttributes()

{

    if (isContextLostOrPending())

        return nullptr;

    // We always need to return a new WebGLContextAttributes object to

    // prevent the user from mutating any cached version.

    // Also, we need to enforce requested values of "false" for depth

    // and stencil, regardless of the properties of the underlying

    // GraphicsContext3D or DrawingBuffer.

    RefPtr<WebGLContextAttributes> attributes = WebGLContextAttributes::create(m_context->getContextAttributes());

    if (!m_attributes.depth)

        attributes->setDepth(false);

    if (!m_attributes.stencil)

        attributes->setStencil(false);

    if (m_drawingBuffer) {

        // The DrawingBuffer obtains its parameters from GraphicsContext3D::getContextAttributes(),

        // but it makes its own determination of whether multisampling is supported.

        attributes->setAntialias(m_drawingBuffer->multisample());

    }

    return attributes.release();

}

GC3Denum WebGLRenderingContext::getError()

{

    if (m_isPendingPolicyResolution)

        return GraphicsContext3D::NO_ERROR;

    return m_context->getError();

}

WebGLExtension* WebGLRenderingContext::getExtension(const String& name)

{

    if (isContextLostOrPending())

        return nullptr;

    if (equalIgnoringCase(name, "EXT_shader_texture_lod")

        && (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))) {

        if (!m_extShaderTextureLOD) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_shader_texture_lod");

            m_extShaderTextureLOD = std::make_unique<EXTShaderTextureLOD>(this);

        }

        return m_extShaderTextureLOD.get();

    }

    if (equalIgnoringCase(name, "WEBKIT_EXT_texture_filter_anisotropic")

        && m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic")) {

        if (!m_extTextureFilterAnisotropic) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_texture_filter_anisotropic");

            m_extTextureFilterAnisotropic = std::make_unique<EXTTextureFilterAnisotropic>(this);

        }

        return m_extTextureFilterAnisotropic.get();

    }

    if (equalIgnoringCase(name, "OES_standard_derivatives")

        && m_context->getExtensions()->supports("GL_OES_standard_derivatives")) {

        if (!m_oesStandardDerivatives) {

            m_context->getExtensions()->ensureEnabled("GL_OES_standard_derivatives");

            m_oesStandardDerivatives = std::make_unique<OESStandardDerivatives>(this);

        }

        return m_oesStandardDerivatives.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float")

        && m_context->getExtensions()->supports("GL_OES_texture_float")) {

        if (!m_oesTextureFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float");

            m_oesTextureFloat = std::make_unique<OESTextureFloat>(this);

        }

        return m_oesTextureFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_float_linear")) {

        if (!m_oesTextureFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float_linear");

            m_oesTextureFloatLinear = std::make_unique<OESTextureFloatLinear>(this);

        }

        return m_oesTextureFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float")) {

        if (!m_oesTextureHalfFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float");

            m_oesTextureHalfFloat = std::make_unique<OESTextureHalfFloat>(this);

        }

        return m_oesTextureHalfFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float_linear")) {

        if (!m_oesTextureHalfFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float_linear");

            m_oesTextureHalfFloatLinear = std::make_unique<OESTextureHalfFloatLinear>(this);

        }

        return m_oesTextureHalfFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_vertex_array_object")

        && m_context->getExtensions()->supports("GL_OES_vertex_array_object")) {

        if (!m_oesVertexArrayObject) {

            m_context->getExtensions()->ensureEnabled("GL_OES_vertex_array_object");

            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(this);

        }

        return m_oesVertexArrayObject.get();

    }

    if (equalIgnoringCase(name, "OES_element_index_uint")

        && m_context->getExtensions()->supports("GL_OES_element_index_uint")) {

        if (!m_oesElementIndexUint) {

            m_context->getExtensions()->ensureEnabled("GL_OES_element_index_uint");

            m_oesElementIndexUint = std::make_unique<OESElementIndexUint>(this);

        }

        return m_oesElementIndexUint.get();

    }

    if (equalIgnoringCase(name, "WEBGL_lose_context")) {

        if (!m_webglLoseContext)

            m_webglLoseContext = std::make_unique<WebGLLoseContext>(this);

        return m_webglLoseContext.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_atc"))

        && WebGLCompressedTextureATC::supported(this)) {

        if (!m_webglCompressedTextureATC)

            m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(this);

        return m_webglCompressedTextureATC.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc"))

        && WebGLCompressedTexturePVRTC::supported(this)) {

        if (!m_webglCompressedTexturePVRTC)

            m_webglCompressedTexturePVRTC = std::make_unique<WebGLCompressedTexturePVRTC>(this);

        return m_webglCompressedTexturePVRTC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_compressed_texture_s3tc")

        && WebGLCompressedTextureS3TC::supported(this)) {

        if (!m_webglCompressedTextureS3TC)

            m_webglCompressedTextureS3TC = std::make_unique<WebGLCompressedTextureS3TC>(this);

        return m_webglCompressedTextureS3TC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_depth_texture")

        && WebGLDepthTexture::supported(graphicsContext3D())) {

        if (!m_webglDepthTexture) {

            m_context->getExtensions()->ensureEnabled("GL_CHROMIUM_depth_texture");

            m_webglDepthTexture = std::make_unique<WebGLDepthTexture>(this);

        }

        return m_webglDepthTexture.get();

    }

    if (equalIgnoringCase(name, "WEBGL_draw_buffers") && supportsDrawBuffers()) {

        if (!m_webglDrawBuffers) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_draw_buffers");

            m_webglDrawBuffers = std::make_unique<WebGLDrawBuffers>(this);

        }

        return m_webglDrawBuffers.get();

    }

    if (equalIgnoringCase(name, "ANGLE_instanced_arrays") && ANGLEInstancedArrays::supported(this)) {

        if (!m_angleInstancedArrays) {

            m_context->getExtensions()->ensureEnabled("GL_ANGLE_instanced_arrays");

            m_angleInstancedArrays = std::make_unique<ANGLEInstancedArrays>(this);

        }

        return m_angleInstancedArrays.get();

    }

    if (allowPrivilegedExtensions()) {

        if (equalIgnoringCase(name, "WEBGL_debug_renderer_info")) {

            if (!m_webglDebugRendererInfo)

                m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(this);

            return m_webglDebugRendererInfo.get();

        }

        if (equalIgnoringCase(name, "WEBGL_debug_shaders")

            && m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source")) {

            if (!m_webglDebugShaders)

                m_webglDebugShaders = std::make_unique<WebGLDebugShaders>(this);

            return m_webglDebugShaders.get();

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))

        return WebGLGetInfo();

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");

        return WebGLGetInfo();

    }

    WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(attachment);

    if (!object) {

        if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)

            return WebGLGetInfo(GraphicsContext3D::NONE);

        // OpenGL ES 2.0 specifies INVALID_ENUM in this case, while desktop GL

        // specifies INVALID_OPERATION.

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    ASSERT(object->isTexture() || object->isRenderbuffer());

    if (object->isTexture()) {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::TEXTURE);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLTexture>(reinterpret_cast<WebGLTexture*>(object)));

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:

            {

                GC3Dint value = 0;

                m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);

                return WebGLGetInfo(value);

            }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");

            return WebGLGetInfo();

        }

    } else {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::RENDERBUFFER);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(reinterpret_cast<WebGLRenderbuffer*>(object)));

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");

            return WebGLGetInfo();

        }

    }

}

WebGLGetInfo WebGLRenderingContext::getParameter(GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    const int intZero = 0;

    switch (pname) {

    case GraphicsContext3D::ACTIVE_TEXTURE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALPHA_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));

    case GraphicsContext3D::BLEND:

        return getBooleanParameter(pname);

    case GraphicsContext3D::BLEND_COLOR:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::BLEND_DST_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_DST_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLUE_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::COLOR_WRITEMASK:

        return getBooleanArrayParameter(pname);

    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:

        return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));

    case GraphicsContext3D::CULL_FACE:

        return getBooleanParameter(pname);

    case GraphicsContext3D::CULL_FACE_MODE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::CURRENT_PROGRAM:

        return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));

    case GraphicsContext3D::DEPTH_BITS:

        if (!m_framebufferBinding && !m_attributes.depth)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::DEPTH_CLEAR_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::DEPTH_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::DEPTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::DEPTH_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DEPTH_WRITEMASK:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DITHER:

        return getBooleanParameter(pname);

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->getElementArrayBuffer()));

    case GraphicsContext3D::FRAMEBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));

    case GraphicsContext3D::FRONT_FACE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GREEN_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::LINE_WIDTH:

        return getFloatParameter(pname);

    case GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_RENDERBUFFER_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VARYING_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_ATTRIBS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::NUM_SHADER_BINARY_FORMATS:

        // FIXME: should we always return 0 for this?

        return getIntParameter(pname);

    case GraphicsContext3D::PACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FACTOR:

        return getFloatParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

        return getBooleanParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_UNITS:

        return getFloatParameter(pname);

    case GraphicsContext3D::RED_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::RENDERBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));

    case GraphicsContext3D::RENDERER:

        return WebGLGetInfo(String("WebKit WebGL"));

    case GraphicsContext3D::SAMPLE_BUFFERS:

        return getIntParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_INVERT:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::SAMPLES:

        return getIntParameter(pname);

    case GraphicsContext3D::SCISSOR_BOX:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::SCISSOR_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SHADING_LANGUAGE_VERSION:

        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + m_context->getString(GraphicsContext3D::SHADING_LANGUAGE_VERSION) + ")");

    case GraphicsContext3D::STENCIL_BACK_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BITS:

        if (!m_framebufferBinding && !m_attributes.stencil)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_CLEAR_VALUE:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::STENCIL_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::SUBPIXEL_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::TEXTURE_BINDING_2D:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].texture2DBinding));

    case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].textureCubeMapBinding));

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        return WebGLGetInfo(m_unpackFlipY);

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        return WebGLGetInfo(m_unpackPremultiplyAlpha);

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        return WebGLGetInfo(m_unpackColorspaceConversion);

    case GraphicsContext3D::VENDOR:

        return WebGLGetInfo(String("WebKit"));

    case GraphicsContext3D::VERSION:

        return WebGLGetInfo("WebGL 1.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")");

    case GraphicsContext3D::VIEWPORT:

        return getWebGLIntArrayParameter(pname);

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            return getUnsignedIntParameter(Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::RENDERER));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::VENDOR));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case Extensions3D::VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object

        if (m_oesVertexArrayObject) {

            if (!m_boundVertexArrayObject->isDefaultObject())

                return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject));

            return WebGLGetInfo();

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic)

            return getUnsignedIntParameter(Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxColorAttachments());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_DRAW_BUFFERS_EXT:

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxDrawBuffers());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    default:

        if (m_webglDrawBuffers

            && pname >= Extensions3D::DRAW_BUFFER0_EXT

            && pname < static_cast<GC3Denum>(Extensions3D::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {

            GC3Dint value = GraphicsContext3D::NONE;

            if (m_framebufferBinding)

                value = m_framebufferBinding->getDrawBuffer(pname);

            else // emulated backbuffer

                value = m_backDrawBuffer;

            return WebGLGetInfo(value);

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getProgramParameter(WebGLProgram* program, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(program->isDeleted());

    case GraphicsContext3D::VALIDATE_STATUS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::LINK_STATUS:

        return WebGLGetInfo(program->getLinkStatus());

    case GraphicsContext3D::ATTACHED_SHADERS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::ACTIVE_ATTRIBUTES:

    case GraphicsContext3D::ACTIVE_UNIFORMS:

        m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getProgramParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getProgramInfoLog(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getProgramInfoLog", program))

        return "";

    return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));

}

WebGLGetInfo WebGLRenderingContext::getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");

        return WebGLGetInfo();

    }

    if (m_renderbufferBinding->getInternalFormat() == GraphicsContext3D::DEPTH_STENCIL

        && !m_renderbufferBinding->isValid()) {

        ASSERT(!isDepthStencilSupported());

        int value = 0;

        switch (pname) {

        case GraphicsContext3D::RENDERBUFFER_WIDTH:

            value = m_renderbufferBinding->getWidth();

            break;

        case GraphicsContext3D::RENDERBUFFER_HEIGHT:

            value = m_renderbufferBinding->getHeight();

            break;

        case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

        case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

        case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

        case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

            value = 0;

            break;

        case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

            value = 24;

            break;

        case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

            value = 8;

            break;

        case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

            return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

            return WebGLGetInfo();

        }

        return WebGLGetInfo(value);

    }

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::RENDERBUFFER_WIDTH:

    case GraphicsContext3D::RENDERBUFFER_HEIGHT:

    case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

    case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

    case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

    case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

    case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

    case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

        m_context->getRenderbufferParameteriv(target, pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

        return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getShaderParameter(WebGLShader* shader, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(shader->isDeleted());

    case GraphicsContext3D::COMPILE_STATUS:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::SHADER_TYPE:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getShaderInfoLog(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderInfoLog", shader))

        return "";

    return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));

}

PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContext::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    switch (shaderType) {

    case GraphicsContext3D::VERTEX_SHADER:

    case GraphicsContext3D::FRAGMENT_SHADER:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");

        return nullptr;

    }

    switch (precisionType) {

    case GraphicsContext3D::LOW_FLOAT:

    case GraphicsContext3D::MEDIUM_FLOAT:

    case GraphicsContext3D::HIGH_FLOAT:

    case GraphicsContext3D::LOW_INT:

    case GraphicsContext3D::MEDIUM_INT:

    case GraphicsContext3D::HIGH_INT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");

        return nullptr;

    }

    GC3Dint range[2] = {0, 0};

    GC3Dint precision = 0;

    m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);

    return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);

}

String WebGLRenderingContext::getShaderSource(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderSource", shader))

        return "";

    return ensureNotNull(shader->getSource());

}

Vector<String> WebGLRenderingContext::getSupportedExtensions()

{

    Vector<String> result;

    if (m_isPendingPolicyResolution)

        return result;

    if (m_context->getExtensions()->supports("GL_OES_texture_float"))

        result.append("OES_texture_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_float_linear"))

        result.append("OES_texture_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float"))

        result.append("OES_texture_half_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float_linear"))

        result.append("OES_texture_half_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_standard_derivatives"))

        result.append("OES_standard_derivatives");

    if (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))

        result.append("EXT_shader_texture_lod");

    if (m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic"))

        result.append("WEBKIT_EXT_texture_filter_anisotropic");

    if (m_context->getExtensions()->supports("GL_OES_vertex_array_object"))

        result.append("OES_vertex_array_object");

    if (m_context->getExtensions()->supports("GL_OES_element_index_uint"))

        result.append("OES_element_index_uint");

    result.append("WEBGL_lose_context");

    if (WebGLCompressedTextureATC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_atc");

    if (WebGLCompressedTexturePVRTC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_pvrtc");

    if (WebGLCompressedTextureS3TC::supported(this))

        result.append("WEBGL_compressed_texture_s3tc");

    if (WebGLDepthTexture::supported(graphicsContext3D()))

        result.append("WEBGL_depth_texture");

    if (supportsDrawBuffers())

        result.append("WEBGL_draw_buffers");

    if (ANGLEInstancedArrays::supported(this))

        result.append("ANGLE_instanced_arrays");

    if (allowPrivilegedExtensions()) {

        if (m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source"))

            result.append("WEBGL_debug_shaders");

        result.append("WEBGL_debug_renderer_info");

    }

    return result;

}

WebGLGetInfo WebGLRenderingContext::getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);

    if (!tex)

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        m_context->getTexParameteriv(target, pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic) {

            m_context->getTexParameteriv(target, pname, &value);

            return WebGLGetInfo(static_cast<unsigned int>(value));

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniform", program))

        return WebGLGetInfo();

    if (!uniformLocation || uniformLocation->program() != program) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");

        return WebGLGetInfo();

    }

    GC3Dint location = uniformLocation->location();

    GC3Denum baseType;

    unsigned length;

    switch (uniformLocation->type()) {

    case GraphicsContext3D::BOOL:

        baseType = GraphicsContext3D::BOOL;

        length = 1;

        break;

    case GraphicsContext3D::BOOL_VEC2:

        baseType = GraphicsContext3D::BOOL;

        length = 2;

        break;

    case GraphicsContext3D::BOOL_VEC3:

        baseType = GraphicsContext3D::BOOL;

        length = 3;

        break;

    case GraphicsContext3D::BOOL_VEC4:

        baseType = GraphicsContext3D::BOOL;

        length = 4;

        break;

    case GraphicsContext3D::INT:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    case GraphicsContext3D::INT_VEC2:

        baseType = GraphicsContext3D::INT;

        length = 2;

        break;

    case GraphicsContext3D::INT_VEC3:

        baseType = GraphicsContext3D::INT;

        length = 3;

        break;

    case GraphicsContext3D::INT_VEC4:

        baseType = GraphicsContext3D::INT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT:

        baseType = GraphicsContext3D::FLOAT;

        length = 1;

        break;

    case GraphicsContext3D::FLOAT_VEC2:

        baseType = GraphicsContext3D::FLOAT;

        length = 2;

        break;

    case GraphicsContext3D::FLOAT_VEC3:

        baseType = GraphicsContext3D::FLOAT;

        length = 3;

        break;

    case GraphicsContext3D::FLOAT_VEC4:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT2:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT3:

        baseType = GraphicsContext3D::FLOAT;

        length = 9;

        break;

    case GraphicsContext3D::FLOAT_MAT4:

        baseType = GraphicsContext3D::FLOAT;

        length = 16;

        break;

    case GraphicsContext3D::SAMPLER_2D:

    case GraphicsContext3D::SAMPLER_CUBE:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    default:

        // Can't handle this type

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unhandled type");

        return WebGLGetInfo();

    }

    switch (baseType) {

    case GraphicsContext3D::FLOAT: {

        GC3Dfloat value[16] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);

        else

            m_context->getUniformfv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Float32Array::create(value, length));

    }

    case GraphicsContext3D::INT: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Int32Array::create(value, length));

    }

    case GraphicsContext3D::BOOL: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length > 1) {

            bool boolValue[16] = {0};

            for (unsigned j = 0; j < length; j++)

                boolValue[j] = static_cast<bool>(value[j]);

            return WebGLGetInfo(boolValue, length);

        }

        return WebGLGetInfo(static_cast<bool>(value[0]));

    }

    default:

        notImplemented();

    }

    // If we get here, something went wrong in our unfortunately complex logic above

    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unknown error");

    return WebGLGetInfo();

}

PassRefPtr<WebGLUniformLocation> WebGLRenderingContext::getUniformLocation(WebGLProgram* program, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniformLocation", program))

        return nullptr;

    if (!validateLocationLength("getUniformLocation", name))

        return nullptr;

    if (!validateString("getUniformLocation", name))

        return nullptr;

    if (isPrefixReserved(name))

        return nullptr;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniformLocation", "program not linked");

        return nullptr;

    }

    GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);

    if (uniformLocation == -1)

        return nullptr;

    GC3Dint activeUniforms = 0;

    m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContext3D::ACTIVE_UNIFORMS, &activeUniforms);

    for (GC3Dint i = 0; i < activeUniforms; i++) {

        ActiveInfo info;

        if (!m_context->getActiveUniform(objectOrZero(program), i, info))

            return nullptr;

        // Strip "[0]" from the name if it's an array.

        if (info.name.endsWith("[0]"))

            info.name = info.name.left(info.name.length() - 3);

        // If it's an array, we need to iterate through each element, appending "[index]" to the name.

        for (GC3Dint index = 0; index < info.size; ++index) {

            String uniformName = info.name + "[" + String::number(index) + "]";

            if (name == uniformName || name == info.name)

                return WebGLUniformLocation::create(program, uniformLocation, info.type);

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getVertexAttrib", "index out of range");

        return WebGLGetInfo();

    }

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    if (m_angleInstancedArrays && pname == GraphicsContext3D::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)

        return WebGLGetInfo(state.divisor);

    switch (pname) {

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:

        if ((!isGLES2Compliant() && !index && m_boundVertexArrayObject->getVertexAttribState(0).bufferBinding == m_vertexAttrib0Buffer)

            || !state.bufferBinding

            || !state.bufferBinding->object())

            return WebGLGetInfo();

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_ENABLED:

        return WebGLGetInfo(state.enabled);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_NORMALIZED:

        return WebGLGetInfo(state.normalized);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_SIZE:

        return WebGLGetInfo(state.size);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_STRIDE:

        return WebGLGetInfo(state.originalStride);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_TYPE:

        return WebGLGetInfo(state.type);

    case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:

        return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");

        return WebGLGetInfo();

    }

}

long long WebGLRenderingContext::getVertexAttribOffset(GC3Duint index, GC3Denum pname)

{

    if (isContextLostOrPending())

        return 0;

    GC3Dsizeiptr result = m_context->getVertexAttribOffset(index, pname);

    return static_cast<long long>(result);

}

void WebGLRenderingContext::hint(GC3Denum target, GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    bool isValid = false;

    switch (target) {

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        isValid = true;

        break;

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            isValid = true;

        break;

    }

    if (!isValid) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");

        return;

    }

    m_context->hint(target, mode);

}

GC3Dboolean WebGLRenderingContext::isBuffer(WebGLBuffer* buffer)

{

    if (!buffer || isContextLostOrPending())

        return 0;

    if (!buffer->hasEverBeenBound())

        return 0;

    return m_context->isBuffer(buffer->object());

}

bool WebGLRenderingContext::isContextLost() const

{

    return m_contextLost;

}

bool WebGLRenderingContext::isContextLostOrPending()

{

    if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {

        LOG(WebGL, "Context is being used. Attempt to resolve the policy.");

        Document& document = canvas()->document().topDocument();

        Page* page = document.page();

        if (page && !document.url().isLocalFile())

            page->mainFrame().loader().client().resolveWebGLPolicyForURL(document.url());

        // FIXME: We don't currently do anything with the result from resolution. A more

        // complete implementation might try to construct a real context, etc and proceed

        // with normal operation.

        // https://bugs.webkit.org/show_bug.cgi?id=129122

        m_hasRequestedPolicyResolution = true;

    }

    return m_contextLost || m_isPendingPolicyResolution;

}

GC3Dboolean WebGLRenderingContext::isEnabled(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("isEnabled", cap))

        return 0;

    if (cap == GraphicsContext3D::STENCIL_TEST)

        return m_stencilEnabled;

    return m_context->isEnabled(cap);

}

GC3Dboolean WebGLRenderingContext::isFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!framebuffer || isContextLostOrPending())

        return 0;

    if (!framebuffer->hasEverBeenBound())

        return 0;

    return m_context->isFramebuffer(framebuffer->object());

}

GC3Dboolean WebGLRenderingContext::isProgram(WebGLProgram* program)

{

    if (!program || isContextLostOrPending())

        return 0;

    return m_context->isProgram(program->object());

}

GC3Dboolean WebGLRenderingContext::isRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!renderbuffer || isContextLostOrPending())

        return 0;

    if (!renderbuffer->hasEverBeenBound())

        return 0;

    return m_context->isRenderbuffer(renderbuffer->object());

}

GC3Dboolean WebGLRenderingContext::isShader(WebGLShader* shader)

{

    if (!shader || isContextLostOrPending())

        return 0;

    return m_context->isShader(shader->object());

}

GC3Dboolean WebGLRenderingContext::isTexture(WebGLTexture* texture)

{

    if (!texture || isContextLostOrPending())

        return 0;

    if (!texture->hasEverBeenBound())

        return 0;

    return m_context->isTexture(texture->object());

}

void WebGLRenderingContext::lineWidth(GC3Dfloat width)

{

    if (isContextLostOrPending())

        return;

    m_context->lineWidth(width);

}

void WebGLRenderingContext::linkProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("linkProgram", program))

        return;

    if (!isGLES2Compliant()) {

        WebGLShader* vertexShader = program->getAttachedShader(GraphicsContext3D::VERTEX_SHADER);

        WebGLShader* fragmentShader = program->getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);

        if (!vertexShader || !vertexShader->isValid() || !fragmentShader || !fragmentShader->isValid() || !m_context->precisionsMatch(objectOrZero(vertexShader), objectOrZero(fragmentShader)) || !m_context->checkVaryingsPacking(objectOrZero(vertexShader), objectOrZero(fragmentShader))) {

            program->setLinkStatus(false);

            return;

        }

    }

    m_context->linkProgram(objectOrZero(program));

    program->increaseLinkCount();

}

void WebGLRenderingContext::pixelStorei(GC3Denum pname, GC3Dint param)

{

    if (isContextLostOrPending())

        return;

    switch (pname) {

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        m_unpackFlipY = param;

        break;

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        m_unpackPremultiplyAlpha = param;

        break;

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        if (param == GraphicsContext3D::BROWSER_DEFAULT_WEBGL || param == GraphicsContext3D::NONE)

            m_unpackColorspaceConversion = static_cast<GC3Denum>(param);

        else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");

            return;

        }

        break;

    case GraphicsContext3D::PACK_ALIGNMENT:

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        if (param == 1 || param == 2 || param == 4 || param == 8) {

            if (pname == GraphicsContext3D::PACK_ALIGNMENT)

                m_packAlignment = param;

            else // GraphicsContext3D::UNPACK_ALIGNMENT:

                m_unpackAlignment = param;

            m_context->pixelStorei(pname, param);

        } else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "pixelStorei", "invalid parameter name");

        return;

    }

}

void WebGLRenderingContext::polygonOffset(GC3Dfloat factor, GC3Dfloat units)

{

    if (isContextLostOrPending())

        return;

    m_context->polygonOffset(factor, units);

}

void WebGLRenderingContext::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&)

{

    if (isContextLostOrPending())

        return;

    // Due to WebGL's same-origin restrictions, it is not possible to

    // taint the origin using the WebGL API.

    ASSERT(canvas()->originClean());

    // Validate input parameters.

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "readPixels", "no destination ArrayBufferView");

        return;

    }

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format");

        return;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid type");

        return;

    }

    if (format != GraphicsContext3D::RGBA || type != GraphicsContext3D::UNSIGNED_BYTE) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");

        return;

    }

    // Validate array type against pixel type.

    if (pixels->getType() != JSC::TypeUint8) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);

        return;

    }

    // Calculate array size, taking into consideration of PACK_ALIGNMENT.

    unsigned int totalBytesRequired = 0;

    unsigned int padding = 0;

    if (!m_isRobustnessEXTSupported) {

        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

        if (error != GraphicsContext3D::NO_ERROR) {

            synthesizeGLError(error, "readPixels", "invalid dimensions");

            return;

        }

        if (pixels->byteLength() < totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");

            return;

        }

    }

    clearIfComposited();

    void* data = pixels->baseAddress();

    {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->readnPixelsEXT(x, y, width, height, format, type, pixels->byteLength(), data);

        else

            m_context->readPixels(x, y, width, height, format, type, data);

    }

#if OS(DARWIN)

    if (m_isRobustnessEXTSupported) // we haven't computed padding

        m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

    // FIXME: remove this section when GL driver bug on Mac AND the GLES driver bug

    // on QC is fixed, i.e., when alpha is off, readPixels should

    // set alpha to 255 instead of 0.

    if (!m_framebufferBinding && !m_context->getContextAttributes().alpha) {

        unsigned char* pixels = reinterpret_cast<unsigned char*>(data);

        for (GC3Dsizei iy = 0; iy < height; ++iy) {

            for (GC3Dsizei ix = 0; ix < width; ++ix) {

                pixels[3] = 255;

                pixels += 4;

            }

            pixels += padding;

        }

    }

#endif

}

void WebGLRenderingContext::releaseShaderCompiler()

{

    if (isContextLostOrPending())

        return;

    m_context->releaseShaderCompiler();

}

void WebGLRenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid target");

        return;

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "renderbufferStorage", "no bound renderbuffer");

        return;

    }

    if (!validateSize("renderbufferStorage", width, height))

        return;

    switch (internalformat) {

    case GraphicsContext3D::DEPTH_COMPONENT16:

    case GraphicsContext3D::RGBA4:

    case GraphicsContext3D::RGB5_A1:

    case GraphicsContext3D::RGB565:

    case GraphicsContext3D::STENCIL_INDEX8:

        m_context->renderbufferStorage(target, internalformat, width, height);

        m_renderbufferBinding->setInternalFormat(internalformat);

        m_renderbufferBinding->setIsValid(true);

        m_renderbufferBinding->setSize(width, height);

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (isDepthStencilSupported()) {

            m_context->renderbufferStorage(target, Extensions3D::DEPTH24_STENCIL8, width, height);

        }

        m_renderbufferBinding->setSize(width, height);

        m_renderbufferBinding->setIsValid(isDepthStencilSupported());

        m_renderbufferBinding->setInternalFormat(internalformat);

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

        return;

    }

    applyStencilTest();

}

void WebGLRenderingContext::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)

{

    if (isContextLostOrPending())

        return;

    m_context->sampleCoverage(value, invert);

}

void WebGLRenderingContext::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("scissor", width, height))

        return;

    m_context->scissor(x, y, width, height);

}

void WebGLRenderingContext::shaderSource(WebGLShader* shader, const String& string, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("shaderSource", shader))

        return;

    String stringWithoutComments = StripComments(string).result();

    if (!validateString("shaderSource", stringWithoutComments))

        return;

    shader->setSource(string);

    m_context->shaderSource(objectOrZero(shader), stringWithoutComments);

}

void WebGLRenderingContext::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFunc", func))

        return;

    m_stencilFuncRef = ref;

    m_stencilFuncRefBack = ref;

    m_stencilFuncMask = mask;

    m_stencilFuncMaskBack = mask;

    m_context->stencilFunc(func, ref, mask);

}

void WebGLRenderingContext::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFuncSeparate", func))

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilFuncRef = ref;

        m_stencilFuncRefBack = ref;

        m_stencilFuncMask = mask;

        m_stencilFuncMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilFuncRef = ref;

        m_stencilFuncMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilFuncRefBack = ref;

        m_stencilFuncMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilFuncSeparate", "invalid face");

        return;

    }

    m_context->stencilFuncSeparate(face, func, ref, mask);

}

void WebGLRenderingContext::stencilMask(GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    m_stencilMask = mask;

    m_stencilMaskBack = mask;

    m_context->stencilMask(mask);

}

void WebGLRenderingContext::stencilMaskSeparate(GC3Denum face, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilMask = mask;

        m_stencilMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilMaskSeparate", "invalid face");

        return;

    }

    m_context->stencilMaskSeparate(face, mask);

}

void WebGLRenderingContext::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOp(fail, zfail, zpass);

}

void WebGLRenderingContext::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOpSeparate(face, fail, zfail, zpass);

}

void WebGLRenderingContext::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned.

    ec = 0;

    WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);

    ASSERT(validateTexFuncParameters("texImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, format, type));

    ASSERT(tex);

    ASSERT(!level || !WebGLTexture::isNPOT(width, height));

    if (!pixels) {

        // Note: Chromium's OpenGL implementation clears textures and isResourceSafe() is therefore true.

        // For other implementations, if they are using ANGLE_depth_texture, ANGLE depth textures

        // can not be cleared with texImage2D and must be cleared by binding to an fbo and calling

        // clear.

        if (isResourceSafe())

            m_context->texImage2D(target, level, internalformat, width, height, border, format, type, nullptr);

        else {

            bool succeed = m_context->texImage2DResourceSafe(target, level, internalformat, width, height,

                                                             border, format, type, m_unpackAlignment);

            if (!succeed)

                return;

        }

    } else {

        ASSERT(validateSettableTexFormat("texImage2D", internalformat));

        m_context->moveErrorsToSyntheticErrorList();

        m_context->texImage2D(target, level, internalformat, width, height,

                              border, format, type, pixels);

        if (m_context->moveErrorsToSyntheticErrorList()) {

            // The texImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

            tex->markInvalid(target, level);

            return;

        }

    }

    tex->setLevelInfo(target, level, internalformat, width, height, type);

}

void WebGLRenderingContext::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "packImage error");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

bool WebGLRenderingContext::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)

{

    if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))

        return false;

    WebGLTexture* texture = validateTextureBinding(functionName, target, true);

    if (!texture)

        return false;

    if (functionType == NotTexSubImage2D) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level > 0 not power of 2");

            return false;

        }

        // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat

        // by checking if the ArrayBufferView is null or not.

        if (sourceType != SourceArrayBufferView) {

            if (!validateSettableTexFormat(functionName, format))

                return false;

        }

    } else {

        if (!validateSettableTexFormat(functionName, format))

            return false;

        if (!validateSize(functionName, xoffset, yoffset))

            return false;

        // Before checking if it is in the range, check if overflow happens first.

        if (xoffset + width < 0 || yoffset + height < 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "bad dimensions");

            return false;

        }

        if (xoffset + width > texture->getWidth(target, level) || yoffset + height > texture->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "dimensions out of range");

            return false;

        }

        if (texture->getInternalFormat(target, level) != format || texture->getType(target, level) != type) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type and format do not match texture");

            return false;

        }

    }

    return true;

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                       GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, format, type, pixels, NullAllowed)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))

        return;

    void* data = pixels ? pixels->baseAddress() : 0;

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, width, height, border,

                   format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

PassRefPtr<Image> WebGLRenderingContext::drawImageIntoBuffer(Image* image, int width, int height, int deviceScaleFactor)

{

    IntSize size(width, height);

    size.scale(deviceScaleFactor);

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    FloatRect srcRect(FloatPoint(), image->size());

    FloatRect destRect(FloatPoint(), size);

    buf->context()->drawImage(image, ColorSpaceDeviceRGB, destRect, srcRect);

    return buf->copyImage(ImageBuffer::fastCopyImageMode());

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))

        return;

    texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas, ec) || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))

        return;

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    // If possible, copy from the canvas element directly to the texture

    // via the GPU, without a read-back to system memory.

    //

    // FIXME: restriction of (RGB || RGBA)/UNSIGNED_BYTE should be lifted when

    // ImageBuffer::copyToPlatformTexture implementations are fully functional.

    if (GraphicsContext3D::TEXTURE_2D == target && texture && type == texture->getType(target, level)

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) {

        ImageBuffer* buffer = canvas->buffer();

        if (buffer && buffer->copyToPlatformTexture(*m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);

            return;

        }

    }

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texImage2D(target, level, internalformat, format, type, imageData.get(), ec);

    else

        texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

PassRefPtr<Image> WebGLRenderingContext::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy, ExceptionCode&)

{

    IntSize size(video->videoWidth(), video->videoHeight());

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    IntRect destRect(0, 0, size.width(), size.height());

    // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.

    video->paintCurrentFrameInContext(buf->context(), destRect);

    return buf->copyImage(backingStoreCopy);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video, ec)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))

        return;

    // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.

    // Otherwise, it will fall back to the normal SW path.

    // FIXME: The current restrictions require that format shoud be RGB or RGBA,

    // type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    if (GraphicsContext3D::TEXTURE_2D == target && texture

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)

        && type == GraphicsContext3D::UNSIGNED_BYTE

        && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))

        && !level) {

        if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);

            return;

        }

    }

    // Normal pure SW path.

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("texParameter", target, false);

    if (!tex)

        return;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

        break;

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        if ((isFloat && paramf != GraphicsContext3D::CLAMP_TO_EDGE && paramf != GraphicsContext3D::MIRRORED_REPEAT && paramf != GraphicsContext3D::REPEAT)

            || (!isFloat && parami != GraphicsContext3D::CLAMP_TO_EDGE && parami != GraphicsContext3D::MIRRORED_REPEAT && parami != GraphicsContext3D::REPEAT)) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter");

            return;

        }

        break;

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (!m_extTextureFilterAnisotropic) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter name");

        return;

    }

    if (isFloat) {

        tex->setParameterf(pname, paramf);

        m_context->texParameterf(target, pname, paramf);

    } else {

        tex->setParameteri(pname, parami);

        m_context->texParameteri(target, pname, parami);

    }

}

void WebGLRenderingContext::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)

{

    texParameter(target, pname, param, 0, true);

}

void WebGLRenderingContext::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)

{

    texParameter(target, pname, 0, param, false);

}

void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned

    ec = 0;

    ASSERT(!isContextLost());

    ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage2D, target, level, format, width, height, 0, format, type));

    ASSERT(validateSize("texSubImage2D", xoffset, yoffset));

    ASSERT(validateSettableTexFormat("texSubImage2D", format));

    WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);

    if (!tex) {

        ASSERT_NOT_REACHED();

        return;

    }

    ASSERT((xoffset + width) >= 0);

    ASSERT((yoffset + height) >= 0);

    ASSERT(tex->getWidth(target, level) >= (xoffset + width));

    ASSERT(tex->getHeight(target, level) >= (yoffset + height));

    ASSERT(tex->getInternalFormat(target, level) == format);

    ASSERT(tex->getType(target, level) == type);

    m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);

}

void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);  

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, type,  needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Dsizei width, GC3Dsizei height,

                                          GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))

        return;

    void* data = pixels->baseAddress();

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLImageElement, target, level, format, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLCanvasElement, target, level, format, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);

    else

        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLVideoElement, target, level, format, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1f", "location not for current program");

        return;

    }

    m_context->uniform1f(location->location(), x);

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))

        return;

    m_context->uniform1fv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))

        return;

    m_context->uniform1fv(location->location(), size, v);

}

void WebGLRenderingContext::uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");

        return;

    }

    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");

        return;

    }

    m_context->uniform1i(location->location(), x);

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < v->length(); ++i) {

            if (v->data()[i] >= static_cast<int>(m_textureUnits.size())) {

                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v->data()[i], location->type());

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {

            if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), size, v);

}

void WebGLRenderingContext::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");

        return;

    }

    m_context->uniform2f(location->location(), x, y);

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))

        return;

    m_context->uniform2fv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))

        return;

    m_context->uniform2fv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2i", "location not for current program");

        return;

    }

    m_context->uniform2i(location->location(), x, y);

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))

        return;

    m_context->uniform2iv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))

        return;

    m_context->uniform2iv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");

        return;

    }

    m_context->uniform3f(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))

        return;

    m_context->uniform3fv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))

        return;

    m_context->uniform3fv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");

        return;

    }

    m_context->uniform3i(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))

        return;

    m_context->uniform3iv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))

        return;

    m_context->uniform3iv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");

        return;

    }

    m_context->uniform4f(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))

        return;

    m_context->uniform4fv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))

        return;

    m_context->uniform4fv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");

        return;

    }

    m_context->uniform4i(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))

        return;

    m_context->uniform4iv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))

        return;

    m_context->uniform4iv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);

}

void WebGLRenderingContext::useProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("useProgram", program, deleted))

        return;

    if (deleted)

        program = 0;

    if (program && !program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "useProgram", "program not valid");

        return;

    }

    if (m_currentProgram != program) {

        if (m_currentProgram)

            m_currentProgram->onDetached(graphicsContext3D());

        m_currentProgram = program;

        m_context->useProgram(objectOrZero(program));

        if (program)

            program->onAttached();

    }

}

void WebGLRenderingContext::validateProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("validateProgram", program))

        return;

    m_context->validateProgram(objectOrZero(program));

}

void WebGLRenderingContext::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)

{

    vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);

}

void WebGLRenderingContext::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)

{

    vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);

}

void WebGLRenderingContext::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)

{

    vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);

}

void WebGLRenderingContext::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);

}

void WebGLRenderingContext::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    switch (type) {

    case GraphicsContext3D::BYTE:

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::SHORT:

    case GraphicsContext3D::UNSIGNED_SHORT:

    case GraphicsContext3D::FLOAT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "index out of range");

        return;

    }

    if (size < 1 || size > 4 || stride < 0 || stride > 255 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "bad size, stride or offset");

        return;

    }

    if (!m_boundArrayBuffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");

        return;

    }

    // Determine the number of elements the bound buffer can hold, given the offset, size, type and stride

    unsigned int typeSize = sizeInBytes(type);

    if (!typeSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if ((stride % typeSize) || (static_cast<GC3Dintptr>(offset) % typeSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");

        return;

    }

    GC3Dsizei bytesPerElement = size * typeSize;

    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GC3Dintptr>(offset), m_boundArrayBuffer);

    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GC3Dintptr>(offset));

}

void WebGLRenderingContext::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("viewport", width, height))

        return;

    m_context->viewport(x, y, width, height);

}

void WebGLRenderingContext::forceLostContext(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "loseContext", "context already lost");

        return;

    }

    m_contextGroup->loseContextGroup(mode);

}

void WebGLRenderingContext::loseContextImpl(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLost())

        return;

    m_contextLost = true;

    m_contextLostMode = mode;

    if (mode == RealLostContext) {

        // Inform the embedder that a lost context was received. In response, the embedder might

        // decide to take action such as asking the user for permission to use WebGL again.

        if (Frame* frame = canvas()->document().frame())

            frame->loader().client().didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());

    }

    detachAndRemoveAllObjects();

    if (m_drawingBuffer) {

        // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.

        m_drawingBuffer->setTexture2DBinding(0);

        m_drawingBuffer->setFramebufferBinding(0);

    }

    // There is no direct way to clear errors from a GL implementation and

    // looping until getError() becomes NO_ERROR might cause an infinite loop if

    // the driver or context implementation had a bug. So, loop a reasonably

    // large number of times to clear any existing errors.

    for (int i = 0; i < 100; ++i) {

        if (m_context->getError() == GraphicsContext3D::NO_ERROR)

            break;

    }

    ConsoleDisplayPreference display = (mode == RealLostContext) ? DisplayInConsole: DontDisplayInConsole;

    synthesizeGLError(GraphicsContext3D::CONTEXT_LOST_WEBGL, "loseContext", "context lost", display);

    // Don't allow restoration unless the context lost event has both been

    // dispatched and its default behavior prevented.

    m_restoreAllowed = false;

    // Always defer the dispatch of the context lost event, to implement

    // the spec behavior of queueing a task.

    m_dispatchContextLostEventTimer.startOneShot(0);

}

void WebGLRenderingContext::forceRestoreContext()

{

    if (!isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context not lost");

        return;

    }

    if (!m_restoreAllowed) {

        if (m_contextLostMode == SyntheticLostContext)

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context restoration not allowed");

        return;

    }

    if (!m_restoreTimer.isActive())

        m_restoreTimer.startOneShot(0);

}

PlatformLayer* WebGLRenderingContext::platformLayer() const

{

    return (!isContextLost() && !m_isPendingPolicyResolution) ? m_context->platformLayer() : 0;

}

void WebGLRenderingContext::removeSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextGroup->removeObject(object);

}

void WebGLRenderingContext::addSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextGroup->addObject(object);

}

void WebGLRenderingContext::removeContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextObjects.remove(object);

}

void WebGLRenderingContext::addContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextObjects.add(object);

}

void WebGLRenderingContext::detachAndRemoveAllObjects()

{

    if (m_isPendingPolicyResolution)

        return;

    while (m_contextObjects.size() > 0) {

        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();

        (*it)->detachContext();

    }

}

bool WebGLRenderingContext::hasPendingActivity() const

{

    return false;

}

void WebGLRenderingContext::stop()

{

    if (!isContextLost() && !m_isPendingPolicyResolution) {

        forceLostContext(SyntheticLostContext);

        destroyGraphicsContext3D();

    }

}

WebGLGetInfo WebGLRenderingContext::getBooleanParameter(GC3Denum pname)

{

    GC3Dboolean value = 0;

    m_context->getBooleanv(pname, &value);

    return WebGLGetInfo(static_cast<bool>(value));

}

WebGLGetInfo WebGLRenderingContext::getBooleanArrayParameter(GC3Denum pname)

{

    if (pname != GraphicsContext3D::COLOR_WRITEMASK) {

        notImplemented();

        return WebGLGetInfo(0, 0);

    }

    GC3Dboolean value[4] = {0};

    m_context->getBooleanv(pname, value);

    bool boolValue[4];

    for (int ii = 0; ii < 4; ++ii)

        boolValue[ii] = static_cast<bool>(value[ii]);

    return WebGLGetInfo(boolValue, 4);

}

WebGLGetInfo WebGLRenderingContext::getFloatParameter(GC3Denum pname)

{

    GC3Dfloat value = 0;

    m_context->getFloatv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getUnsignedIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

WebGLGetInfo WebGLRenderingContext::getWebGLFloatArrayParameter(GC3Denum pname)

{

    GC3Dfloat value[4] = {0};

    m_context->getFloatv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

    case GraphicsContext3D::DEPTH_RANGE:

        length = 2;

        break;

    case GraphicsContext3D::BLEND_COLOR:

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Float32Array::create(value, length));

}

WebGLGetInfo WebGLRenderingContext::getWebGLIntArrayParameter(GC3Denum pname)

{

    GC3Dint value[4] = {0};

    m_context->getIntegerv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        length = 2;

        break;

    case GraphicsContext3D::SCISSOR_BOX:

    case GraphicsContext3D::VIEWPORT:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Int32Array::create(value, length));

}

void WebGLRenderingContext::checkTextureCompleteness(const char* functionName, bool prepareToDraw)

{

    bool resetActiveUnit = false;

    WebGLTexture::TextureExtensionFlag extensions = static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureExtensionFloatLinearEnabled : 0) | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureExtensionHalfFloatLinearEnabled : 0));

    for (unsigned ii = 0; ii < m_textureUnits.size(); ++ii) {

        if ((m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

            || (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))) {

            if (ii != m_activeTextureUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = true;

            } else if (resetActiveUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = false;

            }

            WebGLTexture* tex2D;

            WebGLTexture* texCubeMap;

            if (prepareToDraw) {

                String msg(String("texture bound to texture unit ") + String::number(ii)

                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete',"

                    + " or it is a float/half-float type with linear filtering and without the relevant float/half-float linear extension enabled.");

                printGLWarningToConsole(functionName, msg.utf8().data());

                tex2D = m_blackTexture2D.get();

                texCubeMap = m_blackTextureCubeMap.get();

            } else {

                tex2D = m_textureUnits[ii].texture2DBinding.get();

                texCubeMap = m_textureUnits[ii].textureCubeMapBinding.get();

            }

            if (m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));

            if (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));

        }

    }

    if (resetActiveUnit)

        m_context->activeTexture(m_activeTextureUnit);

}

void WebGLRenderingContext::createFallbackBlackTextures1x1()

{

    unsigned char black[] = {0, 0, 0, 255};

    m_blackTexture2D = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_blackTexture2D->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);

    m_blackTextureCubeMap = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, 0);

}

bool WebGLRenderingContext::isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                                           GC3Denum colorBufferFormat)

{

    unsigned need = GraphicsContext3D::getChannelBitsByFormat(texInternalFormat);

    unsigned have = GraphicsContext3D::getChannelBitsByFormat(colorBufferFormat);

    return (need & have) == need;

}

GC3Denum WebGLRenderingContext::getBoundFramebufferColorFormat()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferFormat();

    if (m_attributes.alpha)

        return GraphicsContext3D::RGBA;

    return GraphicsContext3D::RGB;

}

int WebGLRenderingContext::getBoundFramebufferWidth()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferWidth();

    return m_drawingBuffer ? m_drawingBuffer->size().width() : m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::getBoundFramebufferHeight()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferHeight();

    return m_drawingBuffer ? m_drawingBuffer->size().height() : m_context->getInternalFramebufferSize().height();

}

WebGLTexture* WebGLRenderingContext::validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap)

{

    WebGLTexture* texture = nullptr;

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        texture = m_textureUnits[m_activeTextureUnit].texture2DBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (!useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP:

        if (useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

        return nullptr;

    }

    if (!texture)

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no texture");

    return texture;

}

bool WebGLRenderingContext::validateLocationLength(const char* functionName, const String& string)

{

    const unsigned maxWebGLLocationLength = 256;

    if (string.length() > maxWebGLLocationLength) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "location length > 256");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateSize(const char* functionName, GC3Dint x, GC3Dint y)

{

    if (x < 0 || y < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "size < 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateString(const char* functionName, const String& string)

{

    for (size_t i = 0; i < string.length(); ++i) {

        if (!validateCharacter(string[i])) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "string not ASCII");

            return false;

        }

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level)

{

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture format");

        return false;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    case GraphicsContext3D::FLOAT:

        if (m_oesTextureFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::HALF_FLOAT_OES:

        if (m_oesTextureHalfFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::UNSIGNED_INT:

    case GraphicsContext3D::UNSIGNED_INT_24_8:

    case GraphicsContext3D::UNSIGNED_SHORT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    }

    // Verify that the combination of format and type is supported.

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for format");

            return false;

        }

        break;

    case GraphicsContext3D::RGB:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_6_5

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGB format");

            return false;

        }

        break;

    case GraphicsContext3D::RGBA:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGBA format");

            return false;

        }

        break;

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_COMPONENT not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_SHORT

            && type != GraphicsContext3D::UNSIGNED_INT) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_COMPONENT format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_COMPONENT format");

          return false;

        }

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_STENCIL not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_INT_24_8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_STENCIL format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_STENCIL format");

          return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level)

{

    if (level < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level < 0");

        return false;

    }

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (level >= m_maxTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (level >= m_maxCubeMapTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    }

    // This function only checks if level is legal, so we return true and don't

    // generate INVALID_ENUM if target is illegal.

    return true;

}

bool WebGLRenderingContext::validateTexFuncParameters(const char* functionName,

                                                      TexFuncValidationFunctionType functionType,

                                                      GC3Denum target, GC3Dint level,

                                                      GC3Denum internalformat,

                                                      GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                                      GC3Denum format, GC3Denum type)

{

    // We absolutely have to validate the format and type combination.

    // The texImage2D entry points taking HTMLImage, etc. will produce

    // temporary data based on this combination, so it must be legal.

    if (!validateTexFuncFormatAndType(functionName, format, type, level) || !validateTexFuncLevel(functionName, target, level))

        return false;

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (functionType != TexSubImage2D && width != height) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");

            return false;

        }

        // No need to check height here. For texImage width == height.

        // For texSubImage that will be checked when checking yoffset + height is in range.

        if (width > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range for cube map");

            return false;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    if (format != internalformat) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format != internalformat");

        return false;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "border != 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncData(const char* functionName, GC3Dint level,

                                                GC3Dsizei width, GC3Dsizei height,

                                                GC3Denum format, GC3Denum type,

                                                ArrayBufferView* pixels,

                                                NullDisposition disposition)

{

    if (!pixels) {

        if (disposition == NullAllowed)

            return true;

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (!validateTexFuncFormatAndType(functionName, format, type, level))

        return false;

    if (!validateSettableTexFormat(functionName, format))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

        if (pixels->getType() != JSC::TypeUint8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_BYTE but ArrayBufferView not Uint8Array");

            return false;

        }

        break;

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        if (pixels->getType() != JSC::TypeUint16) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_SHORT but ArrayBufferView not Uint16Array");

            return false;

        }

        break;

    case GraphicsContext3D::FLOAT: // OES_texture_float

        if (pixels->getType() != JSC::TypeFloat32) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");

            return false;

        }

        break;

    case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float

        // As per the specification, ArrayBufferView should be null when

        // OES_texture_half_float is enabled.

        if (pixels) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL");

            return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    unsigned int totalBytesRequired;

    GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);

    if (error != GraphicsContext3D::NO_ERROR) {

        synthesizeGLError(error, functionName, "invalid texture dimensions");

        return false;

    }

    if (pixels->byteLength() < totalBytesRequired) {

        if (m_unpackAlignment != 1) {

          error = m_context->computeImageSizeInBytes(format, type, width, height, 1, &totalBytesRequired, 0);

          if (pixels->byteLength() == totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request with UNPACK_ALIGNMENT > 1");

            return false;

          }

        }

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexFormat(GC3Denum format)

{

    return m_compressedTextureFormats.contains(format);

}

bool WebGLRenderingContext::validateCompressedTexFuncData(const char* functionName,

                                                          GC3Dsizei width, GC3Dsizei height,

                                                          GC3Denum format, ArrayBufferView* pixels)

{

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    unsigned int bytesRequired = 0;

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_ATC_RGB_AMD:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT:

    case Extensions3D::COMPRESSED_ATC_RGBA_EXPLICIT_ALPHA_AMD:

    case Extensions3D::COMPRESSED_ATC_RGBA_INTERPOLATED_ALPHA_AMD:

        {

            const int kBlockSize = 16;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 8;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 4 + 7) / kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 16;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 2 + 7) / kBlockSize;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format");

        return false;

    }

    if (pixels->byteLength() != bytesRequired) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "length of ArrayBufferView is not correct for dimensions");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format)

{

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const GC3Dsizei kBlockWidth = 4;

        const GC3Dsizei kBlockHeight = 4;

        const GC3Dint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;

        const GC3Dsizei maxCompressedDimension = maxTextureSize >> level;

        bool widthValid = (level && width == 1) || (level && width == 2) || (!(width % kBlockWidth) && width <= maxCompressedDimension);

        bool heightValid = (level && height == 1) || (level && height == 2) || (!(height % kBlockHeight) && height <= maxCompressedDimension);

        if (!widthValid || !heightValid) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        // Height and width must be powers of 2.

        if ((width & (width - 1)) || (height & (height - 1))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                               GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture* tex)

{

    if (xoffset < 0 || yoffset < 0) {

      synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "xoffset or yoffset < 0");

      return false;

    }

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset or yoffset not multiple of 4");

            return false;

        }

        if (width - xoffset > tex->getWidth(target, level)

            || height - yoffset > tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions out of range");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: {

        if (xoffset || yoffset) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset and yoffset must be zero");

            return false;

        }

        if (width != tex->getWidth(target, level)

            || height != tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions must match existing level");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateDrawMode(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::POINTS:

    case GraphicsContext3D::LINE_STRIP:

    case GraphicsContext3D::LINE_LOOP:

    case GraphicsContext3D::LINES:

    case GraphicsContext3D::TRIANGLE_STRIP:

    case GraphicsContext3D::TRIANGLE_FAN:

    case GraphicsContext3D::TRIANGLES:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid draw mode");

        return false;

    }

}

bool WebGLRenderingContext::validateStencilSettings(const char* functionName)

{

    if (m_stencilMask != m_stencilMaskBack || m_stencilFuncRef != m_stencilFuncRefBack || m_stencilFuncMask != m_stencilFuncMaskBack) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "front and back stencils settings do not match");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateStencilFunc(const char* functionName, GC3Denum func)

{

    switch (func) {

    case GraphicsContext3D::NEVER:

    case GraphicsContext3D::LESS:

    case GraphicsContext3D::LEQUAL:

    case GraphicsContext3D::GREATER:

    case GraphicsContext3D::GEQUAL:

    case GraphicsContext3D::EQUAL:

    case GraphicsContext3D::NOTEQUAL:

    case GraphicsContext3D::ALWAYS:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid function");

        return false;

    }

}

void WebGLRenderingContext::printGLErrorToConsole(const String& message)

{

    if (!m_numGLErrorsToConsoleAllowed)

        return;

    --m_numGLErrorsToConsoleAllowed;

    printWarningToConsole(message);

    if (!m_numGLErrorsToConsoleAllowed)

        printWarningToConsole("WebGL: too many errors, no more errors will be reported to the console for this context.");

}

void WebGLRenderingContext::printWarningToConsole(const String& message)

{

    if (!canvas())

        return;

    canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);

}

bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)

{

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    switch (attachment) {

    case GraphicsContext3D::COLOR_ATTACHMENT0:

    case GraphicsContext3D::DEPTH_ATTACHMENT:

    case GraphicsContext3D::STENCIL_ATTACHMENT:

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        break;

    default:

        if (m_webglDrawBuffers

            && attachment > GraphicsContext3D::COLOR_ATTACHMENT0

            && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::FUNC_ADD:

    case GraphicsContext3D::FUNC_SUBTRACT:

    case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

        return false;

    }

}

bool WebGLRenderingContext::validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst)

{

    if (((src == GraphicsContext3D::CONSTANT_COLOR || src == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

         && (dst == GraphicsContext3D::CONSTANT_ALPHA || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))

        || ((dst == GraphicsContext3D::CONSTANT_COLOR || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

            && (src == GraphicsContext3D::CONSTANT_ALPHA || src == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "incompatible src and dst");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCapability(const char* functionName, GC3Denum cap)

{

    switch (cap) {

    case GraphicsContext3D::BLEND:

    case GraphicsContext3D::CULL_FACE:

    case GraphicsContext3D::DEPTH_TEST:

    case GraphicsContext3D::DITHER:

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

    case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:

    case GraphicsContext3D::SAMPLE_COVERAGE:

    case GraphicsContext3D::SCISSOR_TEST:

    case GraphicsContext3D::STENCIL_TEST:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");

        return false;

    }

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Int32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, transpose, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    if (!location)

        return false;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "location is not from current program");

        return false;

    }

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    if (transpose) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "transpose not FALSE");

        return false;

    }

    if (size < requiredMinSize || (size % requiredMinSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return false;

    }

    return true;

}

WebGLBuffer* WebGLRenderingContext::validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage)

{

    WebGLBuffer* buffer = 0;

    switch (target) {

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER:

        buffer = m_boundVertexArrayObject->getElementArrayBuffer().get();

        break;

    case GraphicsContext3D::ARRAY_BUFFER:

        buffer = m_boundArrayBuffer.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return nullptr;

    }

    if (!buffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no buffer");

        return nullptr;

    }

    switch (usage) {

    case GraphicsContext3D::STREAM_DRAW:

    case GraphicsContext3D::STATIC_DRAW:

    case GraphicsContext3D::DYNAMIC_DRAW:

        return buffer;

    }

    synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid usage");

    return nullptr;

}

bool WebGLRenderingContext::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionCode& ec)

{

    if (!image || !image->cachedImage()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");

        return false;

    }

    const URL& url = image->cachedImage()->response().url();

    if (url.isNull() || url.isEmpty() || !url.isValid()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");

        return false;

    }

    if (wouldTaintOrigin(image)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    if (!canvas || !canvas->buffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no canvas");

        return false;

    }

    if (wouldTaintOrigin(canvas)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#if ENABLE(VIDEO)

bool WebGLRenderingContext::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video, ExceptionCode& ec)

{

    if (!video || !video->videoWidth() || !video->videoHeight()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no video");

        return false;

    }

    if (wouldTaintOrigin(video)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#endif

void WebGLRenderingContext::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1f(index, v0);

            break;

        case 2:

            m_context->vertexAttrib2f(index, v0, v1);

            break;

        case 3:

            m_context->vertexAttrib3f(index, v0, v1, v2);

            break;

        case 4:

            m_context->vertexAttrib4f(index, v0, v1, v2, v3);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.value[0] = v0;

    attribValue.value[1] = v1;

    attribValue.value[2] = v2;

    attribValue.value[3] = v3;

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array* v, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    vertexAttribfvImpl(functionName, index, v->data(), v->length(), expectedSize);

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat* v, GC3Dsizei size, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    if (size < expectedSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1fv(index, v);

            break;

        case 2:

            m_context->vertexAttrib2fv(index, v);

            break;

        case 3:

            m_context->vertexAttrib3fv(index, v);

            break;

        case 4:

            m_context->vertexAttrib4fv(index, v);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.initValue();

    for (int ii = 0; ii < expectedSize; ++ii)

        attribValue.value[ii] = v[ii];

}

void WebGLRenderingContext::initVertexAttrib0()

{

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    m_vertexAttrib0Buffer = createBuffer();

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, 0, GraphicsContext3D::DYNAMIC_DRAW);

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, false, 0, 0);

    state.bufferBinding = m_vertexAttrib0Buffer;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, 0);

    m_context->enableVertexAttribArray(0);

    m_vertexAttrib0BufferSize = 0;

    m_vertexAttrib0BufferValue[0] = 0.0f;

    m_vertexAttrib0BufferValue[1] = 0.0f;

    m_vertexAttrib0BufferValue[2] = 0.0f;

    m_vertexAttrib0BufferValue[3] = 1.0f;

    m_forceAttrib0BufferRefill = false;

    m_vertexAttrib0UsedBefore = false;

}

bool WebGLRenderingContext::simulateVertexAttrib0(GC3Dsizei numVertex)

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    const VertexAttribValue& attribValue = m_vertexAttribValue[0];

    if (!m_currentProgram)

        return false;

    bool usingVertexAttrib0 = m_currentProgram->isUsingVertexAttrib0();

    if (usingVertexAttrib0)

        m_vertexAttrib0UsedBefore = true;

    if (state.enabled && usingVertexAttrib0)

        return false;

    if (!usingVertexAttrib0 && !m_vertexAttrib0UsedBefore)

        return false;

    m_vertexAttrib0UsedBefore = true;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    GC3Dsizeiptr bufferDataSize = (numVertex + 1) * 4 * sizeof(GC3Dfloat);

    if (bufferDataSize > m_vertexAttrib0BufferSize) {

        m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, bufferDataSize, 0, GraphicsContext3D::DYNAMIC_DRAW);

        m_vertexAttrib0BufferSize = bufferDataSize;

        m_forceAttrib0BufferRefill = true;

    }

    if (usingVertexAttrib0

        && (m_forceAttrib0BufferRefill

            || attribValue.value[0] != m_vertexAttrib0BufferValue[0]

            || attribValue.value[1] != m_vertexAttrib0BufferValue[1]

            || attribValue.value[2] != m_vertexAttrib0BufferValue[2]

            || attribValue.value[3] != m_vertexAttrib0BufferValue[3])) {

        auto bufferData = std::make_unique<GC3Dfloat[]>((numVertex + 1) * 4);

        for (GC3Dsizei ii = 0; ii < numVertex + 1; ++ii) {

            bufferData[ii * 4] = attribValue.value[0];

            bufferData[ii * 4 + 1] = attribValue.value[1];

            bufferData[ii * 4 + 2] = attribValue.value[2];

            bufferData[ii * 4 + 3] = attribValue.value[3];

        }

        m_vertexAttrib0BufferValue[0] = attribValue.value[0];

        m_vertexAttrib0BufferValue[1] = attribValue.value[1];

        m_vertexAttrib0BufferValue[2] = attribValue.value[2];

        m_vertexAttrib0BufferValue[3] = attribValue.value[3];

        m_forceAttrib0BufferRefill = false;

        m_context->bufferSubData(GraphicsContext3D::ARRAY_BUFFER, 0, bufferDataSize, bufferData.get());

    }

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, 0, 0, 0);

    return true;

}

void WebGLRenderingContext::restoreStatesAfterVertexAttrib0Simulation()

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    if (state.bufferBinding != m_vertexAttrib0Buffer) {

        m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(state.bufferBinding.get()));

        m_context->vertexAttribPointer(0, state.size, state.type, state.normalized, state.originalStride, state.offset);

    }

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));

}

void WebGLRenderingContext::dispatchContextLostEvent()

{

    RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");

    canvas()->dispatchEvent(event);

    m_restoreAllowed = event->defaultPrevented();

    if (m_contextLostMode == RealLostContext && m_restoreAllowed)

        m_restoreTimer.startOneShot(0);

}

void WebGLRenderingContext::maybeRestoreContext()

{

    ASSERT(m_contextLost);

    if (!m_contextLost)

        return;

    // The rendering context is not restored unless the default behavior of the

    // webglcontextlost event was prevented earlier.

    //

    // Because of the way m_restoreTimer is set up for real vs. synthetic lost

    // context events, we don't have to worry about this test short-circuiting

    // the retry loop for real context lost events.

    if (!m_restoreAllowed)

        return;

    int contextLostReason = m_context->getExtensions()->getGraphicsResetStatusARB();

    switch (contextLostReason) {

    case GraphicsContext3D::NO_ERROR:

        // The GraphicsContext3D implementation might not fully

        // support GL_ARB_robustness semantics yet. Alternatively, the

        // WEBGL_lose_context extension might have been used to force

        // a lost context.

        break;

    case Extensions3D::GUILTY_CONTEXT_RESET_ARB:

        // The rendering context is not restored if this context was

        // guilty of causing the graphics reset.

        printWarningToConsole("WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");

        return;

    case Extensions3D::INNOCENT_CONTEXT_RESET_ARB:

        // Always allow the context to be restored.

        break;

    case Extensions3D::UNKNOWN_CONTEXT_RESET_ARB:

        // Warn. Ideally, prompt the user telling them that WebGL

        // content on the page might have caused the graphics card to

        // reset and ask them whether they want to continue running

        // the content. Only if they say "yes" should we start

        // attempting to restore the context.

        printWarningToConsole("WARNING: WebGL content on the page might have caused the graphics card to reset");

        break;

    }

    Frame* frame = canvas()->document().frame();

    if (!frame)

        return;

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled()))

        return;

    FrameView* view = frame->view();

    if (!view)

        return;

    ScrollView* root = view->root();

    if (!root)

        return;

    HostWindow* hostWindow = root->hostWindow();

    if (!hostWindow)

        return;

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, hostWindow));

    if (!context) {

        if (m_contextLostMode == RealLostContext)

            m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);

        else

            // This likely shouldn't happen but is the best way to report it to the WebGL app.

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "", "error restoring context");

        return;

    }

    // Construct a new drawing buffer with the new GraphicsContext3D.

    if (m_drawingBuffer) {

        m_drawingBuffer->discardResources();

        DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;

        DrawingBuffer::AlphaRequirement alpha = m_attributes.alpha ? DrawingBuffer::Alpha : DrawingBuffer::Opaque;

        m_drawingBuffer = DrawingBuffer::create(context.get(), m_drawingBuffer->size(), preserve, alpha);

        m_drawingBuffer->bind();

    }

    m_context = context;

    m_contextLost = false;

    setupFlags();

    initializeNewContext();

    canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, ""));

}

String WebGLRenderingContext::ensureNotNull(const String& text) const

{

    if (text.isNull())

        return WTF::emptyString();

    return text;

}

WebGLRenderingContext::LRUImageBufferCache::LRUImageBufferCache(int capacity)

    : m_buffers(std::make_unique<std::unique_ptr<ImageBuffer>[]>(capacity))

    , m_capacity(capacity)

{

}

ImageBuffer* WebGLRenderingContext::LRUImageBufferCache::imageBuffer(const IntSize& size)

{

    int i;

    for (i = 0; i < m_capacity; ++i) {

        ImageBuffer* buf = m_buffers[i].get();

        if (!buf)

            break;

        if (buf->logicalSize() != size)

            continue;

        bubbleToFront(i);

        return buf;

    }

    std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, 1);

    if (!temp)

        return nullptr;

    i = std::min(m_capacity - 1, i);

    m_buffers[i] = WTF::move(temp);

    ImageBuffer* buf = m_buffers[i].get();

    bubbleToFront(i);

    return buf;

}

void WebGLRenderingContext::LRUImageBufferCache::bubbleToFront(int idx)

{

    for (int i = idx; i > 0; --i)

        m_buffers[i].swap(m_buffers[i-1]);

}

namespace {

    String GetErrorString(GC3Denum error)

    {

        switch (error) {

        case GraphicsContext3D::INVALID_ENUM:

            return "INVALID_ENUM";

        case GraphicsContext3D::INVALID_VALUE:

            return "INVALID_VALUE";

        case GraphicsContext3D::INVALID_OPERATION:

            return "INVALID_OPERATION";

        case GraphicsContext3D::OUT_OF_MEMORY:

            return "OUT_OF_MEMORY";

        case GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION:

            return "INVALID_FRAMEBUFFER_OPERATION";

        case GraphicsContext3D::CONTEXT_LOST_WEBGL:

            return "CONTEXT_LOST_WEBGL";

        default:

            return String::format("WebGL ERROR(%04x)", error);

        }

    }

} // namespace anonymous

void WebGLRenderingContext::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)

{

    if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {

      String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);

      printGLErrorToConsole(str);

    }

    m_context->synthesizeGLError(error);

}

void WebGLRenderingContext::printGLWarningToConsole(const char* functionName, const char* description)

{

    if (m_synthesizedErrorsToConsole) {

        String str = String("WebGL: ") + String(functionName) + ": " + String(description);

        printGLErrorToConsole(str);

    }

}

void WebGLRenderingContext::applyStencilTest()

{

    bool haveStencilBuffer = false;

    if (m_framebufferBinding)

        haveStencilBuffer = m_framebufferBinding->hasStencilBuffer();

    else {

        RefPtr<WebGLContextAttributes> attributes = getContextAttributes();

        haveStencilBuffer = attributes->stencil();

    }

    enableOrDisable(GraphicsContext3D::STENCIL_TEST,

                    m_stencilEnabled && haveStencilBuffer);

}

void WebGLRenderingContext::enableOrDisable(GC3Denum capability, bool enable)

{

    if (enable)

        m_context->enable(capability);

    else

        m_context->disable(capability);

}

IntSize WebGLRenderingContext::clampedCanvasSize()

{

    return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),

                   clamp(canvas()->height(), 1, m_maxViewportDims[1]));

}

GC3Dint WebGLRenderingContext::getMaxDrawBuffers()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxDrawBuffers)

        m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.

    return std::min(m_maxDrawBuffers, m_maxColorAttachments);

}

GC3Dint WebGLRenderingContext::getMaxColorAttachments()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    return m_maxColorAttachments;

}

void WebGLRenderingContext::setBackDrawBuffer(GC3Denum buf)

{

    m_backDrawBuffer = buf;

}

void WebGLRenderingContext::restoreCurrentFramebuffer()

{

    ExceptionCode ec;

    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);

}

void WebGLRenderingContext::restoreCurrentTexture2D()

{

    ExceptionCode ec;

    bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].texture2DBinding.get(), ec);

}

bool WebGLRenderingContext::supportsDrawBuffers()

{

    if (!m_drawBuffersWebGLRequirementsChecked) {

        m_drawBuffersWebGLRequirementsChecked = true;

        m_drawBuffersSupported = WebGLDrawBuffers::supported(this);

    }

    return m_drawBuffersSupported;

}

void WebGLRenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)

{

    if (!validateDrawArrays("drawArraysInstanced", mode, first, count, primcount))

        return;

    if (primcount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawArraysInstanced", "primcount < 0");

        return;

    }

    if (!primcount) {

        markContextChanged();

        return;

    }

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", true);

    UNUSED_PARAM(primcount);

    m_context->drawArraysInstanced(mode, first, count, primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)

{

    unsigned numElements = 0;

    if (!validateDrawElements("drawElementsInstanced", mode, count, type, offset, numElements))

        return;

    if (primcount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawElementsInstanced", "primcount < 0");

        return;

    }

    if (!primcount) {

        markContextChanged();

        return;

    }

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", true);

    m_context->drawElementsInstanced(mode, count, type, static_cast<GC3Dintptr>(offset), primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribDivisor", "index out of range");

        return;

    }

    m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);

    m_context->vertexAttribDivisor(index, divisor);

}

} // namespace WebCore

#endif // ENABLE(WEBGL)

working copy

Source/WebCore/html/canvas/WebGL1RenderingContext.h

/*

 * Copyright (C) 2009, 2014 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef WebGLRenderingContext_h

#define WebGLRenderingContext_h

#include "ActiveDOMObject.h"

#include "CanvasRenderingContext.h"

#include "DrawingBuffer.h"

#include "GraphicsContext3D.h"

#include "ImageBuffer.h"

#include "Timer.h"

#include "WebGLGetInfo.h"

#include <memory>

#include <runtime/Float32Array.h>

#include <runtime/Int32Array.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

class ANGLEInstancedArrays;

class EXTBlendMinMax;

class EXTTextureFilterAnisotropic;

class EXTShaderTextureLOD;

class EXTsRGB;

class EXTFragDepth;

class HTMLImageElement;

class HTMLVideoElement;

class ImageBuffer;

class ImageData;

class IntSize;

class OESStandardDerivatives;

class OESTextureFloat;

class OESTextureFloatLinear;

class OESTextureHalfFloat;

class OESTextureHalfFloatLinear;

class OESVertexArrayObject;

class OESElementIndexUint;

class WebGLActiveInfo;

class WebGLBuffer;

class WebGLContextGroup;

class WebGLContextObject;

class WebGLCompressedTextureATC;

class WebGLCompressedTexturePVRTC;

class WebGLCompressedTextureS3TC;

class WebGLContextAttributes;

class WebGLDebugRendererInfo;

class WebGLDebugShaders;

class WebGLDepthTexture;

class WebGLDrawBuffers;

class WebGLExtension;

class WebGLFramebuffer;

class WebGLLoseContext;

class WebGLObject;

class WebGLProgram;

class WebGLRenderbuffer;

class WebGLShader;

class WebGLSharedObject;

class WebGLShaderPrecisionFormat;

class WebGLTexture;

class WebGLUniformLocation;

class WebGLVertexArrayObjectOES;

typedef int ExceptionCode;

class WebGLRenderingContext final : public CanvasRenderingContext, public ActiveDOMObject {

public:

    static std::unique_ptr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);

    virtual ~WebGLRenderingContext();

    virtual bool is3d() const override { return true; }

#if PLATFORM(WIN)

    // FIXME: Implement accelerated 3d canvas on Windows.

    virtual bool isAccelerated() const override { return false; }

#else

    virtual bool isAccelerated() const override { return true; }

#endif

    int drawingBufferWidth() const;

    int drawingBufferHeight() const;

    void activeTexture(GC3Denum texture, ExceptionCode&);

    void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);

    void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);

    void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);

    void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);

    void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);

    void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void blendEquation(GC3Denum mode);

    void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);

    void blendFunc(GC3Denum sfactor, GC3Denum dfactor);

    void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);

    void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);

    GC3Denum checkFramebufferStatus(GC3Denum target);

    void clear(GC3Dbitfield mask);

    void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void clearDepth(GC3Dfloat);

    void clearStencil(GC3Dint);

    void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);

    void compileShader(WebGLShader*, ExceptionCode&);

    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                              GC3Dsizei height, GC3Dint border, ArrayBufferView* data);

    void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                 GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);

    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);

    void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    PassRefPtr<WebGLBuffer> createBuffer();

    PassRefPtr<WebGLFramebuffer> createFramebuffer();

    PassRefPtr<WebGLProgram> createProgram();

    PassRefPtr<WebGLRenderbuffer> createRenderbuffer();

    PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);

    PassRefPtr<WebGLTexture> createTexture();

    void cullFace(GC3Denum mode);

    void deleteBuffer(WebGLBuffer*);

    void deleteFramebuffer(WebGLFramebuffer*);

    void deleteProgram(WebGLProgram*);

    void deleteRenderbuffer(WebGLRenderbuffer*);

    void deleteShader(WebGLShader*);

    void deleteTexture(WebGLTexture*);

    void depthFunc(GC3Denum);

    void depthMask(GC3Dboolean);

    void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);

    void detachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void disable(GC3Denum cap);

    void disableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);

    void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);

    void enable(GC3Denum cap);

    void enableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void finish();

    void flush();

    void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);

    void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);

    void frontFace(GC3Denum mode);

    void generateMipmap(GC3Denum target);

    PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);

    PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);

    bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&, ExceptionCode&);

    GC3Dint getAttribLocation(WebGLProgram*, const String& name);

    WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    PassRefPtr<WebGLContextAttributes> getContextAttributes();

    GC3Denum getError();

    WebGLExtension* getExtension(const String& name);

    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);

    String getProgramInfoLog(WebGLProgram*, ExceptionCode&);

    WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);

    String getShaderInfoLog(WebGLShader*, ExceptionCode&);

    PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);

    String getShaderSource(WebGLShader*, ExceptionCode&);

    Vector<String> getSupportedExtensions();

    WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);

    PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);

    WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);

    long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);

    void hint(GC3Denum target, GC3Denum mode);

    GC3Dboolean isBuffer(WebGLBuffer*);

    bool isContextLost() const;

    GC3Dboolean isEnabled(GC3Denum cap);

    GC3Dboolean isFramebuffer(WebGLFramebuffer*);

    GC3Dboolean isProgram(WebGLProgram*);

    GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);

    GC3Dboolean isShader(WebGLShader*);

    GC3Dboolean isTexture(WebGLTexture*);

    void lineWidth(GC3Dfloat);

    void linkProgram(WebGLProgram*, ExceptionCode&);

    void pixelStorei(GC3Denum pname, GC3Dint param);

    void polygonOffset(GC3Dfloat factor, GC3Dfloat units);

    void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&);

    void releaseShaderCompiler();

    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);

    void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);

    void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    void shaderSource(WebGLShader*, const String&, ExceptionCode&);

    void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilMask(GC3Duint);

    void stencilMaskSeparate(GC3Denum face, GC3Duint mask);

    void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                    GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);

    void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Dsizei width, GC3Dsizei height,

                       GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void useProgram(WebGLProgram*, ExceptionCode&);

    void validateProgram(WebGLProgram*, ExceptionCode&);

    void vertexAttrib1f(GC3Duint index, GC3Dfloat x);

    void vertexAttrib1fv(GC3Duint index, Float32Array* values);

    void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);

    void vertexAttrib2fv(GC3Duint index, Float32Array* values);

    void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);

    void vertexAttrib3fv(GC3Duint index, Float32Array* values);

    void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);

    void vertexAttrib4fv(GC3Duint index, Float32Array* values);

    void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,

                             GC3Dsizei stride, long long offset, ExceptionCode&);

    void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    // WEBKIT_lose_context support

    enum LostContextMode {

        // Lost context occurred at the graphics system level.

        RealLostContext,

        // Lost context provoked by WEBKIT_lose_context.

        SyntheticLostContext

    };

    void forceLostContext(LostContextMode);

    void forceRestoreContext();

    void loseContextImpl(LostContextMode);

    GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }

    WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }

    virtual PlatformLayer* platformLayer() const override;

    void reshape(int width, int height);

    void markLayerComposited();

    virtual void paintRenderingResultsToCanvas() override;

    PassRefPtr<ImageData> paintRenderingResultsToImageData();

    void removeSharedObject(WebGLSharedObject*);

    void removeContextObject(WebGLContextObject*);

    unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }

    // ANGLE_instanced_arrays extension functions.

    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);

    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);

private:

    friend class WebGLDrawBuffers;

    friend class WebGLFramebuffer;

    friend class WebGLObject;

    friend class OESVertexArrayObject;

    friend class WebGLDebugShaders;

    friend class WebGLCompressedTextureATC;

    friend class WebGLCompressedTexturePVRTC;

    friend class WebGLCompressedTextureS3TC;

    friend class WebGLRenderingContextErrorMessageCallback;

    friend class WebGLVertexArrayObjectOES;

    WebGLRenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);

    WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);

    void initializeNewContext();

    void setupFlags();

    // ActiveDOMObject

    virtual bool hasPendingActivity() const override;

    virtual void stop() override;

    virtual const char* activeDOMObjectName() const override { return "WebGLRenderingContext"; }

    void addSharedObject(WebGLSharedObject*);

    void addContextObject(WebGLContextObject*);

    void detachAndRemoveAllObjects();

    void destroyGraphicsContext3D();

    void markContextChanged();

    // Query whether it is built on top of compliant GLES2 implementation.

    bool isGLES2Compliant() { return m_isGLES2Compliant; }

    // Query if the GL implementation is NPOT strict.

    bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }

    // Query if the GL implementation generates errors on out-of-bounds buffer accesses.

    bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }

    // Query if the GL implementation initializes textures/renderbuffers to 0.

    bool isResourceSafe() { return m_isResourceSafe; }

    // Query if depth_stencil buffer is supported.

    bool isDepthStencilSupported() { return m_isDepthStencilSupported; }

    // Helper to return the size in bytes of OpenGL data types

    // like GL_FLOAT, GL_INT, etc.

    unsigned int sizeInBytes(GC3Denum type);

    // Basic validation of count and offset against number of elements in element array buffer

    bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);

    // Conservative but quick index validation

    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired);

    // Precise but slow index validation -- only done if conservative checks fail

    bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);

    bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);

    bool validateWebGLObject(const char*, WebGLObject*);

    bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primcount);

    // Adds a compressed texture format.

    void addCompressedTextureFormat(GC3Denum);

    PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, int deviceScaleFactor);

#if ENABLE(VIDEO)

    PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);

#endif

    RefPtr<GraphicsContext3D> m_context;

    RefPtr<WebGLContextGroup> m_contextGroup;

    // Optional structure for rendering to a DrawingBuffer, instead of directly

    // to the back-buffer of m_context.

    RefPtr<DrawingBuffer> m_drawingBuffer;

    // Dispatches a context lost event once it is determined that one is needed.

    // This is used both for synthetic and real context losses. For real ones, it's

    // likely that there's no JavaScript on the stack, but that might be dependent

    // on how exactly the platform discovers that the context was lost. For better

    // portability we always defer the dispatch of the event.

    Timer m_dispatchContextLostEventTimer;

    bool m_restoreAllowed;

    Timer m_restoreTimer;

    bool m_needsUpdate;

    bool m_markedCanvasDirty;

    HashSet<WebGLContextObject*> m_contextObjects;

    // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER

    RefPtr<WebGLBuffer> m_boundArrayBuffer;

    RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;

    RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;

    void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> arrayObject)

    {

        if (arrayObject)

            m_boundVertexArrayObject = arrayObject;

        else

            m_boundVertexArrayObject = m_defaultVertexArrayObject;

    }

    class VertexAttribValue {

    public:

        VertexAttribValue()

        {

            initValue();

        }

        void initValue()

        {

            value[0] = 0.0f;

            value[1] = 0.0f;

            value[2] = 0.0f;

            value[3] = 1.0f;

        }

        GC3Dfloat value[4];

    };

    Vector<VertexAttribValue> m_vertexAttribValue;

    unsigned m_maxVertexAttribs;

    RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;

    long m_vertexAttrib0BufferSize;

    GC3Dfloat m_vertexAttrib0BufferValue[4];

    bool m_forceAttrib0BufferRefill;

    bool m_vertexAttrib0UsedBefore;

    RefPtr<WebGLProgram> m_currentProgram;

    RefPtr<WebGLFramebuffer> m_framebufferBinding;

    RefPtr<WebGLRenderbuffer> m_renderbufferBinding;

    struct TextureUnitState {

        RefPtr<WebGLTexture> texture2DBinding;

        RefPtr<WebGLTexture> textureCubeMapBinding;

    };

    Vector<TextureUnitState> m_textureUnits;

    unsigned long m_activeTextureUnit;

    RefPtr<WebGLTexture> m_blackTexture2D;

    RefPtr<WebGLTexture> m_blackTextureCubeMap;

    Vector<GC3Denum> m_compressedTextureFormats;

    // Fixed-size cache of reusable image buffers for video texImage2D calls.

    class LRUImageBufferCache {

    public:

        LRUImageBufferCache(int capacity);

        // The pointer returned is owned by the image buffer map.

        ImageBuffer* imageBuffer(const IntSize& size);

    private:

        void bubbleToFront(int idx);

        std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;

        int m_capacity;

    };

    LRUImageBufferCache m_generatedImageCache;

    GC3Dint m_maxTextureSize;

    GC3Dint m_maxCubeMapTextureSize;

    GC3Dint m_maxRenderbufferSize;

    GC3Dint m_maxViewportDims[2];

    GC3Dint m_maxTextureLevel;

    GC3Dint m_maxCubeMapTextureLevel;

    GC3Dint m_maxDrawBuffers;

    GC3Dint m_maxColorAttachments;

    GC3Denum m_backDrawBuffer;

    bool m_drawBuffersWebGLRequirementsChecked;

    bool m_drawBuffersSupported;

    GC3Dint m_packAlignment;

    GC3Dint m_unpackAlignment;

    bool m_unpackFlipY;

    bool m_unpackPremultiplyAlpha;

    GC3Denum m_unpackColorspaceConversion;

    bool m_contextLost;

    LostContextMode m_contextLostMode;

    GraphicsContext3D::Attributes m_attributes;

    bool m_layerCleared;

    GC3Dfloat m_clearColor[4];

    bool m_scissorEnabled;

    GC3Dfloat m_clearDepth;

    GC3Dint m_clearStencil;

    GC3Dboolean m_colorMask[4];

    GC3Dboolean m_depthMask;

    bool m_stencilEnabled;

    GC3Duint m_stencilMask, m_stencilMaskBack;

    GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.

    GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;

    bool m_isGLES2Compliant;

    bool m_isGLES2NPOTStrict;

    bool m_isErrorGeneratedOnOutOfBoundsAccesses;

    bool m_isResourceSafe;

    bool m_isDepthStencilSupported;

    bool m_isRobustnessEXTSupported;

    bool m_synthesizedErrorsToConsole;

    int m_numGLErrorsToConsoleAllowed;

    // A WebGLRenderingContext can be created in a state where it appears as

    // a valid and active context, but will not execute any important operations

    // until its load policy is completely resolved.

    bool m_isPendingPolicyResolution;

    bool m_hasRequestedPolicyResolution;

    bool isContextLostOrPending();

    // Enabled extension objects.

    std::unique_ptr<EXTFragDepth> m_extFragDepth;

    std::unique_ptr<EXTBlendMinMax> m_extBlendMinMax;

    std::unique_ptr<EXTsRGB> m_extsRGB;

    std::unique_ptr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;

    std::unique_ptr<EXTShaderTextureLOD> m_extShaderTextureLOD;

    std::unique_ptr<OESTextureFloat> m_oesTextureFloat;

    std::unique_ptr<OESTextureFloatLinear> m_oesTextureFloatLinear;

    std::unique_ptr<OESTextureHalfFloat> m_oesTextureHalfFloat;

    std::unique_ptr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;

    std::unique_ptr<OESStandardDerivatives> m_oesStandardDerivatives;

    std::unique_ptr<OESVertexArrayObject> m_oesVertexArrayObject;

    std::unique_ptr<OESElementIndexUint> m_oesElementIndexUint;

    std::unique_ptr<WebGLLoseContext> m_webglLoseContext;

    std::unique_ptr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;

    std::unique_ptr<WebGLDebugShaders> m_webglDebugShaders;

    std::unique_ptr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;

    std::unique_ptr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;

    std::unique_ptr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;

    std::unique_ptr<WebGLDepthTexture> m_webglDepthTexture;

    std::unique_ptr<WebGLDrawBuffers> m_webglDrawBuffers;

    std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;

    // Helpers for getParameter and others

    WebGLGetInfo getBooleanParameter(GC3Denum);

    WebGLGetInfo getBooleanArrayParameter(GC3Denum);

    WebGLGetInfo getFloatParameter(GC3Denum);

    WebGLGetInfo getIntParameter(GC3Denum);

    WebGLGetInfo getUnsignedIntParameter(GC3Denum);

    WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);

    WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);

    // Clear the backbuffer if it was composited since the last operation.

    // clearMask is set to the bitfield of any clear that would happen anyway at this time

    // and the function returns true if that clear is now unnecessary.

    bool clearIfComposited(GC3Dbitfield clearMask = 0);

    // Helper to restore state that clearing the framebuffer may destroy.

    void restoreStateAfterClear();

    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void checkTextureCompleteness(const char*, bool);

    void createFallbackBlackTextures1x1();

    // Helper function for copyTex{Sub}Image, check whether the internalformat

    // and the color buffer format of the current bound framebuffer combination

    // is valid.

    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                        GC3Denum colorBufferFormat);

    // Helper function to get the bound framebuffer's color buffer format.

    GC3Denum getBoundFramebufferColorFormat();

    // Helper function to get the bound framebuffer's width.

    int getBoundFramebufferWidth();

    // Helper function to get the bound framebuffer's height.

    int getBoundFramebufferHeight();

    // Helper function to verify limits on the length of uniform and attribute locations.

    bool validateLocationLength(const char* functionName, const String&);

    // Helper function to check if size is non-negative.

    // Generate GL error and return false for negative inputs; otherwise, return true.

    bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);

    // Helper function to check if all characters in the string belong to the

    // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.

    bool validateString(const char* functionName, const String&);

    // Helper function to check target and texture bound to the target.

    // Generate GL errors and return 0 if target is invalid or texture bound is

    // null.  Otherwise, return the texture bound to the target.

    WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);

    // Helper function to check input format/type for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level);

    // Helper function to check input level for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if level is invalid.

    bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);

    enum TexFuncValidationFunctionType {

        NotTexSubImage2D,

        TexSubImage2D,

    };

    enum TexFuncValidationSourceType {

        SourceArrayBufferView,

        SourceImageData,

        SourceHTMLImageElement,

        SourceHTMLCanvasElement,

        SourceHTMLVideoElement,

    };

    // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.

    // Otherwise, it would return quickly without doing other work.

    bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

        GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);

    // Helper function to check input parameters for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncParameters(const char* functionName,

                                   TexFuncValidationFunctionType,

                                   GC3Denum target, GC3Dint level,

                                   GC3Denum internalformat,

                                   GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                   GC3Denum format, GC3Denum type);

    enum NullDisposition {

        NullAllowed,

        NullNotAllowed

    };

    // Helper function to validate that the given ArrayBufferView

    // is of the correct type and contains enough data for the texImage call.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncData(const char* functionName, GC3Dint level,

                             GC3Dsizei width, GC3Dsizei height,

                             GC3Denum format, GC3Denum type,

                             ArrayBufferView* pixels,

                             NullDisposition);

    // Helper function to validate a given texture format is settable as in

    // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and

    // copyTexSubImage2D.

    // Generates GL error and returns false if the format is not settable.

    bool validateSettableTexFormat(const char* functionName, GC3Denum format);

    // Helper function to validate compressed texture data is correct size

    // for the given format and dimensions.

    bool validateCompressedTexFuncData(const char* functionName,

                                       GC3Dsizei width, GC3Dsizei height,

                                       GC3Denum format, ArrayBufferView* pixels);

    // Helper function for validating compressed texture formats.

    bool validateCompressedTexFormat(GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                            GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);

    // Helper function to validate mode for draw{Arrays/Elements}.

    bool validateDrawMode(const char* functionName, GC3Denum);

    // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.

    bool validateStencilSettings(const char* functionName);

    // Helper function to validate stencil func.

    bool validateStencilFunc(const char* functionName, GC3Denum);

    // Helper function for texParameterf and texParameteri.

    void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);

    // Helper function to print GL errors to console.

    void printGLErrorToConsole(const String&);

    void printGLWarningToConsole(const char* function, const char* reason);

    // Helper function to print warnings to console. Currently

    // used only to warn about use of obsolete functions.

    void printWarningToConsole(const String&);

    // Helper function to validate input parameters for framebuffer functions.

    // Generate GL error if parameters are illegal.

    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment);

    // Helper function to validate blend equation mode.

    bool validateBlendEquation(const char* functionName, GC3Denum);

    // Helper function to validate blend func factors.

    bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);

    // Helper function to validate a GL capability.

    bool validateCapability(const char* functionName, GC3Denum);

    // Helper function to validate input parameters for uniform functions.

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);

    // Helper function to validate parameters for bufferData.

    // Return the current bound buffer to target, or 0 if parameters are invalid.

    WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);

    // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.

    bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);

    // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.

    bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.

    bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);

#endif

    // Helper functions for vertexAttribNf{v}.

    void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);

    // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.

    // Return false if caller should return without further processing.

    bool deleteObject(WebGLObject*);

    // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.

    // If the object has already been deleted, set deleted to true upon return.

    // Return false if caller should return without further processing.

    bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);

    // Helpers for simulating vertexAttrib0

    void initVertexAttrib0();

    bool simulateVertexAttrib0(GC3Dsizei numVertex);

    void restoreStatesAfterVertexAttrib0Simulation();

    void dispatchContextLostEvent();

    // Helper for restoration after context lost.

    void maybeRestoreContext();

    // Determine if we are running privileged code in the browser, for example,

    // a Safari or Chrome extension.

    bool allowPrivilegedExtensions() const;

    enum ConsoleDisplayPreference {

        DisplayInConsole,

        DontDisplayInConsole

    };

    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message

    // to the JavaScript console.

    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);

    String ensureNotNull(const String&) const;

    // Enable or disable stencil test based on user setting and

    // whether the current FBO has a stencil buffer.

    void applyStencilTest();

    // Helper for enabling or disabling a capability.

    void enableOrDisable(GC3Denum capability, bool enable);

    // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.

    IntSize clampedCanvasSize();

    // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.

    // Later, return the cached value.

    GC3Dint getMaxDrawBuffers();

    GC3Dint getMaxColorAttachments();

    void setBackDrawBuffer(GC3Denum);

    void restoreCurrentFramebuffer();

    void restoreCurrentTexture2D();

    // Check if EXT_draw_buffers extension is supported and if it satisfies the WebGL requirements.

    bool supportsDrawBuffers();

};

} // namespace WebCore

#endif

176994

Source/WebCore/html/canvas/WebGL1RenderingContext.h

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

#ifndef WebGLRenderingContext_h

#define WebGLRenderingContext_h

#include "ActiveDOMObject.h"

#include "CanvasRenderingContext.h"

#include "DrawingBuffer.h"

#include "GraphicsContext3D.h"

#include "ImageBuffer.h"

#include "Timer.h"

#include "WebGLGetInfo.h"

#include <memory>

#include <runtime/Float32Array.h>

#include <runtime/Int32Array.h>

#include <wtf/text/WTFString.h>

29#include "WebGLRenderingContextBase.h"

namespace WebCore {

class ANGLEInstancedArrays;

class EXTTextureFilterAnisotropic;

class EXTShaderTextureLOD;

class HTMLImageElement;

class HTMLVideoElement;

class ImageBuffer;

class ImageData;

class IntSize;

class OESStandardDerivatives;

class OESTextureFloat;

class OESTextureFloatLinear;

class OESTextureHalfFloat;

class OESTextureHalfFloatLinear;

class OESVertexArrayObject;

class OESElementIndexUint;

class WebGLActiveInfo;

class WebGLBuffer;

class WebGLContextGroup;

class WebGLContextObject;

class WebGLCompressedTextureATC;

class WebGLCompressedTexturePVRTC;

class WebGLCompressedTextureS3TC;

class WebGLContextAttributes;

class WebGLDebugRendererInfo;

class WebGLDebugShaders;

class WebGLDepthTexture;

class WebGLDrawBuffers;

class WebGLExtension;

class WebGLFramebuffer;

class WebGLLoseContext;

class WebGLObject;

class WebGLProgram;

class WebGLRenderbuffer;

class WebGLShader;

class WebGLSharedObject;

class WebGLShaderPrecisionFormat;

class WebGLTexture;

class WebGLUniformLocation;

class WebGLVertexArrayObjectOES;

typedef int ExceptionCode;

class WebGLRenderingContext final : public CanvasRenderingContext, public ActiveDOMObject {

33class WebGL1RenderingContext final : public WebGLRenderingContextBase {

8634public:

    static std::unique_ptr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);

    virtual ~WebGLRenderingContext();

    virtual bool is3d() const override { return true; }

#if PLATFORM(WIN)

    // FIXME: Implement accelerated 3d canvas on Windows.

    virtual bool isAccelerated() const override { return false; }

#else

    virtual bool isAccelerated() const override { return true; }

#endif

    int drawingBufferWidth() const;

    int drawingBufferHeight() const;

    void activeTexture(GC3Denum texture, ExceptionCode&);

    void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);

    void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);

    void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);

    void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);

    void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);

    void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void blendEquation(GC3Denum mode);

    void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);

    void blendFunc(GC3Denum sfactor, GC3Denum dfactor);

    void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);

    void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);

    GC3Denum checkFramebufferStatus(GC3Denum target);

    void clear(GC3Dbitfield mask);

    void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void clearDepth(GC3Dfloat);

    void clearStencil(GC3Dint);

    void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);

    void compileShader(WebGLShader*, ExceptionCode&);

    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                              GC3Dsizei height, GC3Dint border, ArrayBufferView* data);

    void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                 GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);

    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);

    void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    PassRefPtr<WebGLBuffer> createBuffer();

    PassRefPtr<WebGLFramebuffer> createFramebuffer();

    PassRefPtr<WebGLProgram> createProgram();

    PassRefPtr<WebGLRenderbuffer> createRenderbuffer();

    PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);

    PassRefPtr<WebGLTexture> createTexture();

    void cullFace(GC3Denum mode);

    void deleteBuffer(WebGLBuffer*);

    void deleteFramebuffer(WebGLFramebuffer*);

    void deleteProgram(WebGLProgram*);

    void deleteRenderbuffer(WebGLRenderbuffer*);

    void deleteShader(WebGLShader*);

    void deleteTexture(WebGLTexture*);

    void depthFunc(GC3Denum);

    void depthMask(GC3Dboolean);

    void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);

    void detachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void disable(GC3Denum cap);

    void disableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);

    void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);

    void enable(GC3Denum cap);

    void enableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void finish();

    void flush();

    void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);

    void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);

    void frontFace(GC3Denum mode);

    void generateMipmap(GC3Denum target);

    PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);

    PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);

    bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&, ExceptionCode&);

    GC3Dint getAttribLocation(WebGLProgram*, const String& name);

    WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    PassRefPtr<WebGLContextAttributes> getContextAttributes();

    GC3Denum getError();

    WebGLExtension* getExtension(const String& name);

    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);

    String getProgramInfoLog(WebGLProgram*, ExceptionCode&);

    WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);

    String getShaderInfoLog(WebGLShader*, ExceptionCode&);

    PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);

    String getShaderSource(WebGLShader*, ExceptionCode&);

    Vector<String> getSupportedExtensions();

    WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);

    PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);

    WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);

    long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);

    void hint(GC3Denum target, GC3Denum mode);

    GC3Dboolean isBuffer(WebGLBuffer*);

    bool isContextLost() const;

    GC3Dboolean isEnabled(GC3Denum cap);

    GC3Dboolean isFramebuffer(WebGLFramebuffer*);

    GC3Dboolean isProgram(WebGLProgram*);

    GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);

    GC3Dboolean isShader(WebGLShader*);

    GC3Dboolean isTexture(WebGLTexture*);

    void lineWidth(GC3Dfloat);

    void linkProgram(WebGLProgram*, ExceptionCode&);

    void pixelStorei(GC3Denum pname, GC3Dint param);

    void polygonOffset(GC3Dfloat factor, GC3Dfloat units);

    void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&);

    void releaseShaderCompiler();

    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);

    void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);

    void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    void shaderSource(WebGLShader*, const String&, ExceptionCode&);

    void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilMask(GC3Duint);

    void stencilMaskSeparate(GC3Denum face, GC3Duint mask);

    void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                    GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);

    void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Dsizei width, GC3Dsizei height,

                       GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void useProgram(WebGLProgram*, ExceptionCode&);

    void validateProgram(WebGLProgram*, ExceptionCode&);

    void vertexAttrib1f(GC3Duint index, GC3Dfloat x);

    void vertexAttrib1fv(GC3Duint index, Float32Array* values);

    void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);

    void vertexAttrib2fv(GC3Duint index, Float32Array* values);

    void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);

    void vertexAttrib3fv(GC3Duint index, Float32Array* values);

    void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);

    void vertexAttrib4fv(GC3Duint index, Float32Array* values);

    void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,

                             GC3Dsizei stride, long long offset, ExceptionCode&);

    void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    // WEBKIT_lose_context support

    enum LostContextMode {

        // Lost context occurred at the graphics system level.

        RealLostContext,

        // Lost context provoked by WEBKIT_lose_context.

        SyntheticLostContext

    };

    void forceLostContext(LostContextMode);

    void forceRestoreContext();

    void loseContextImpl(LostContextMode);

    GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }

    WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }

    virtual PlatformLayer* platformLayer() const override;

    void reshape(int width, int height);

    void markLayerComposited();

    virtual void paintRenderingResultsToCanvas() override;

    PassRefPtr<ImageData> paintRenderingResultsToImageData();

    void removeSharedObject(WebGLSharedObject*);

    void removeContextObject(WebGLContextObject*);

    unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }

    // ANGLE_instanced_arrays extension functions.

    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);

    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);

private:

    friend class WebGLDrawBuffers;

    friend class WebGLFramebuffer;

    friend class WebGLObject;

    friend class OESVertexArrayObject;

    friend class WebGLDebugShaders;

    friend class WebGLCompressedTextureATC;

    friend class WebGLCompressedTexturePVRTC;

    friend class WebGLCompressedTextureS3TC;

    friend class WebGLRenderingContextErrorMessageCallback;

    friend class WebGLVertexArrayObjectOES;

    WebGLRenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);

    WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);

    void initializeNewContext();

    void setupFlags();

    // ActiveDOMObject

    virtual bool hasPendingActivity() const override;

    virtual void stop() override;

    void addSharedObject(WebGLSharedObject*);

    void addContextObject(WebGLContextObject*);

    void detachAndRemoveAllObjects();

    void destroyGraphicsContext3D();

    void markContextChanged();

    // Query whether it is built on top of compliant GLES2 implementation.

    bool isGLES2Compliant() { return m_isGLES2Compliant; }

    // Query if the GL implementation is NPOT strict.

    bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }

    // Query if the GL implementation generates errors on out-of-bounds buffer accesses.

    bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }

    // Query if the GL implementation initializes textures/renderbuffers to 0.

    bool isResourceSafe() { return m_isResourceSafe; }

    // Query if depth_stencil buffer is supported.

    bool isDepthStencilSupported() { return m_isDepthStencilSupported; }

    // Helper to return the size in bytes of OpenGL data types

    // like GL_FLOAT, GL_INT, etc.

    unsigned int sizeInBytes(GC3Denum type);

    // Basic validation of count and offset against number of elements in element array buffer

    bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);

    // Conservative but quick index validation

    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired);

    // Precise but slow index validation -- only done if conservative checks fail

    bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);

    bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);

    bool validateWebGLObject(const char*, WebGLObject*);

    bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements);

    // Adds a compressed texture format.

    void addCompressedTextureFormat(GC3Denum);

    PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, int deviceScaleFactor);

#if ENABLE(VIDEO)

    PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);

#endif

    RefPtr<GraphicsContext3D> m_context;

    RefPtr<WebGLContextGroup> m_contextGroup;

    // Optional structure for rendering to a DrawingBuffer, instead of directly

    // to the back-buffer of m_context.

    RefPtr<DrawingBuffer> m_drawingBuffer;

    // Dispatches a context lost event once it is determined that one is needed.

    // This is used both for synthetic and real context losses. For real ones, it's

    // likely that there's no JavaScript on the stack, but that might be dependent

    // on how exactly the platform discovers that the context was lost. For better

    // portability we always defer the dispatch of the event.

    Timer m_dispatchContextLostEventTimer;

    bool m_restoreAllowed;

    Timer m_restoreTimer;

    bool m_needsUpdate;

    bool m_markedCanvasDirty;

    HashSet<WebGLContextObject*> m_contextObjects;

    // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER

    RefPtr<WebGLBuffer> m_boundArrayBuffer;

    RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;

    RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;

    void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> arrayObject)

    {

        if (arrayObject)

            m_boundVertexArrayObject = arrayObject;

        else

            m_boundVertexArrayObject = m_defaultVertexArrayObject;

    }

    class VertexAttribValue {

    public:

        VertexAttribValue()

        {

            initValue();

        }

        void initValue()

        {

            value[0] = 0.0f;

            value[1] = 0.0f;

            value[2] = 0.0f;

            value[3] = 1.0f;

        }

        GC3Dfloat value[4];

    };

    Vector<VertexAttribValue> m_vertexAttribValue;

    unsigned m_maxVertexAttribs;

    RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;

    long m_vertexAttrib0BufferSize;

    GC3Dfloat m_vertexAttrib0BufferValue[4];

    bool m_forceAttrib0BufferRefill;

    bool m_vertexAttrib0UsedBefore;

    RefPtr<WebGLProgram> m_currentProgram;

    RefPtr<WebGLFramebuffer> m_framebufferBinding;

    RefPtr<WebGLRenderbuffer> m_renderbufferBinding;

    struct TextureUnitState {

        RefPtr<WebGLTexture> texture2DBinding;

        RefPtr<WebGLTexture> textureCubeMapBinding;

    };

    Vector<TextureUnitState> m_textureUnits;

    unsigned long m_activeTextureUnit;

    RefPtr<WebGLTexture> m_blackTexture2D;

    RefPtr<WebGLTexture> m_blackTextureCubeMap;

    Vector<GC3Denum> m_compressedTextureFormats;

    // Fixed-size cache of reusable image buffers for video texImage2D calls.

    class LRUImageBufferCache {

    public:

        LRUImageBufferCache(int capacity);

        // The pointer returned is owned by the image buffer map.

        ImageBuffer* imageBuffer(const IntSize& size);

    private:

        void bubbleToFront(int idx);

        std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;

        int m_capacity;

    };

    LRUImageBufferCache m_generatedImageCache;

    GC3Dint m_maxTextureSize;

    GC3Dint m_maxCubeMapTextureSize;

    GC3Dint m_maxRenderbufferSize;

    GC3Dint m_maxViewportDims[2];

    GC3Dint m_maxTextureLevel;

    GC3Dint m_maxCubeMapTextureLevel;

    GC3Dint m_maxDrawBuffers;

    GC3Dint m_maxColorAttachments;

    GC3Denum m_backDrawBuffer;

    bool m_drawBuffersWebGLRequirementsChecked;

    bool m_drawBuffersSupported;

    GC3Dint m_packAlignment;

    GC3Dint m_unpackAlignment;

    bool m_unpackFlipY;

    bool m_unpackPremultiplyAlpha;

    GC3Denum m_unpackColorspaceConversion;

    bool m_contextLost;

    LostContextMode m_contextLostMode;

    GraphicsContext3D::Attributes m_attributes;

    bool m_layerCleared;

    GC3Dfloat m_clearColor[4];

    bool m_scissorEnabled;

    GC3Dfloat m_clearDepth;

    GC3Dint m_clearStencil;

    GC3Dboolean m_colorMask[4];

    GC3Dboolean m_depthMask;

    bool m_stencilEnabled;

    GC3Duint m_stencilMask, m_stencilMaskBack;

    GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.

    GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;

    bool m_isGLES2Compliant;

    bool m_isGLES2NPOTStrict;

    bool m_isErrorGeneratedOnOutOfBoundsAccesses;

    bool m_isResourceSafe;

    bool m_isDepthStencilSupported;

    bool m_isRobustnessEXTSupported;

    bool m_synthesizedErrorsToConsole;

    int m_numGLErrorsToConsoleAllowed;

    // A WebGLRenderingContext can be created in a state where it appears as

    // a valid and active context, but will not execute any important operations

    // until its load policy is completely resolved.

    bool m_isPendingPolicyResolution;

    bool m_hasRequestedPolicyResolution;

    bool isContextLostOrPending();

    // Enabled extension objects.

    std::unique_ptr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;

    std::unique_ptr<EXTShaderTextureLOD> m_extShaderTextureLOD;

    std::unique_ptr<OESTextureFloat> m_oesTextureFloat;

    std::unique_ptr<OESTextureFloatLinear> m_oesTextureFloatLinear;

    std::unique_ptr<OESTextureHalfFloat> m_oesTextureHalfFloat;

    std::unique_ptr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;

    std::unique_ptr<OESStandardDerivatives> m_oesStandardDerivatives;

    std::unique_ptr<OESVertexArrayObject> m_oesVertexArrayObject;

    std::unique_ptr<OESElementIndexUint> m_oesElementIndexUint;

    std::unique_ptr<WebGLLoseContext> m_webglLoseContext;

    std::unique_ptr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;

    std::unique_ptr<WebGLDebugShaders> m_webglDebugShaders;

    std::unique_ptr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;

    std::unique_ptr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;

    std::unique_ptr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;

    std::unique_ptr<WebGLDepthTexture> m_webglDepthTexture;

    std::unique_ptr<WebGLDrawBuffers> m_webglDrawBuffers;

    std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;

    // Helpers for getParameter and others

    WebGLGetInfo getBooleanParameter(GC3Denum);

    WebGLGetInfo getBooleanArrayParameter(GC3Denum);

    WebGLGetInfo getFloatParameter(GC3Denum);

    WebGLGetInfo getIntParameter(GC3Denum);

    WebGLGetInfo getUnsignedIntParameter(GC3Denum);

    WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);

    WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);

    // Clear the backbuffer if it was composited since the last operation.

    // clearMask is set to the bitfield of any clear that would happen anyway at this time

    // and the function returns true if that clear is now unnecessary.

    bool clearIfComposited(GC3Dbitfield clearMask = 0);

    // Helper to restore state that clearing the framebuffer may destroy.

    void restoreStateAfterClear();

    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void checkTextureCompleteness(const char*, bool);

    void createFallbackBlackTextures1x1();

    // Helper function for copyTex{Sub}Image, check whether the internalformat

    // and the color buffer format of the current bound framebuffer combination

    // is valid.

    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                        GC3Denum colorBufferFormat);

    // Helper function to get the bound framebuffer's color buffer format.

    GC3Denum getBoundFramebufferColorFormat();

    // Helper function to get the bound framebuffer's width.

    int getBoundFramebufferWidth();

    // Helper function to get the bound framebuffer's height.

    int getBoundFramebufferHeight();

    // Helper function to verify limits on the length of uniform and attribute locations.

    bool validateLocationLength(const char* functionName, const String&);

    // Helper function to check if size is non-negative.

    // Generate GL error and return false for negative inputs; otherwise, return true.

    bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);

    // Helper function to check if all characters in the string belong to the

    // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.

    bool validateString(const char* functionName, const String&);

    // Helper function to check target and texture bound to the target.

    // Generate GL errors and return 0 if target is invalid or texture bound is

    // null.  Otherwise, return the texture bound to the target.

    WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);

    // Helper function to check input format/type for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level);

    // Helper function to check input level for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if level is invalid.

    bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);

    enum TexFuncValidationFunctionType {

        NotTexSubImage2D,

        TexSubImage2D,

    };

    enum TexFuncValidationSourceType {

        SourceArrayBufferView,

        SourceImageData,

        SourceHTMLImageElement,

        SourceHTMLCanvasElement,

        SourceHTMLVideoElement,

    };

    // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.

    // Otherwise, it would return quickly without doing other work.

    bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

        GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);

    // Helper function to check input parameters for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncParameters(const char* functionName,

                                   TexFuncValidationFunctionType,

                                   GC3Denum target, GC3Dint level,

                                   GC3Denum internalformat,

                                   GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                   GC3Denum format, GC3Denum type);

    enum NullDisposition {

        NullAllowed,

        NullNotAllowed

    };

    // Helper function to validate that the given ArrayBufferView

    // is of the correct type and contains enough data for the texImage call.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncData(const char* functionName, GC3Dint level,

                             GC3Dsizei width, GC3Dsizei height,

                             GC3Denum format, GC3Denum type,

                             ArrayBufferView* pixels,

                             NullDisposition);

    // Helper function to validate a given texture format is settable as in

    // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and

    // copyTexSubImage2D.

    // Generates GL error and returns false if the format is not settable.

    bool validateSettableTexFormat(const char* functionName, GC3Denum format);

    // Helper function to validate compressed texture data is correct size

    // for the given format and dimensions.

    bool validateCompressedTexFuncData(const char* functionName,

                                       GC3Dsizei width, GC3Dsizei height,

                                       GC3Denum format, ArrayBufferView* pixels);

    // Helper function for validating compressed texture formats.

    bool validateCompressedTexFormat(GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                            GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);

    // Helper function to validate mode for draw{Arrays/Elements}.

    bool validateDrawMode(const char* functionName, GC3Denum);

    // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.

    bool validateStencilSettings(const char* functionName);

    // Helper function to validate stencil func.

    bool validateStencilFunc(const char* functionName, GC3Denum);

    // Helper function for texParameterf and texParameteri.

    void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);

    // Helper function to print GL errors to console.

    void printGLErrorToConsole(const String&);

    void printGLWarningToConsole(const char* function, const char* reason);

    // Helper function to print warnings to console. Currently

    // used only to warn about use of obsolete functions.

    void printWarningToConsole(const String&);

    // Helper function to validate input parameters for framebuffer functions.

    // Generate GL error if parameters are illegal.

    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment);

    // Helper function to validate blend equation mode.

    bool validateBlendEquation(const char* functionName, GC3Denum);

    // Helper function to validate blend func factors.

    bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);

    // Helper function to validate a GL capability.

    bool validateCapability(const char* functionName, GC3Denum);

    // Helper function to validate input parameters for uniform functions.

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);

    // Helper function to validate parameters for bufferData.

    // Return the current bound buffer to target, or 0 if parameters are invalid.

    WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);

    // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.

    bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);

    // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.

    bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.

    bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);

#endif

    // Helper functions for vertexAttribNf{v}.

    void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);

    // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.

    // Return false if caller should return without further processing.

    bool deleteObject(WebGLObject*);

    // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.

    // If the object has already been deleted, set deleted to true upon return.

    // Return false if caller should return without further processing.

    bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);

    // Helpers for simulating vertexAttrib0

    void initVertexAttrib0();

    bool simulateVertexAttrib0(GC3Dsizei numVertex);

    void restoreStatesAfterVertexAttrib0Simulation();

    void dispatchContextLostEvent();

    // Helper for restoration after context lost.

    void maybeRestoreContext();

    // Determine if we are running privileged code in the browser, for example,

    // a Safari or Chrome extension.

    bool allowPrivilegedExtensions() const;

    enum ConsoleDisplayPreference {

        DisplayInConsole,

        DontDisplayInConsole

    };

    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message

    // to the JavaScript console.

    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);

    String ensureNotNull(const String&) const;

    // Enable or disable stencil test based on user setting and

    // whether the current FBO has a stencil buffer.

    void applyStencilTest();

    // Helper for enabling or disabling a capability.

    void enableOrDisable(GC3Denum capability, bool enable);

    // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.

    IntSize clampedCanvasSize();

    // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.

    // Later, return the cached value.

    GC3Dint getMaxDrawBuffers();

    GC3Dint getMaxColorAttachments();

    void setBackDrawBuffer(GC3Denum);

    void restoreCurrentFramebuffer();

    void restoreCurrentTexture2D();

    // Check if EXT_draw_buffers extension is supported and if it satisfies the WebGL requirements.

    bool supportsDrawBuffers();

35 WebGL1RenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);

36 WebGL1RenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);

80537};

806

} // namespace WebCore

#endif

working copy

Source/WebCore/html/canvas/WebGL1RenderingContext.idl

/*

 * Copyright (C) 2009 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

typedef unsigned long  GLenum;

typedef boolean        GLboolean;

typedef unsigned long  GLbitfield;

typedef byte           GLbyte;         /* 'byte' should be a signed 8 bit type. */

typedef short          GLshort;

typedef long           GLint;

typedef long           GLsizei;

typedef long long      GLintptr;

typedef long long      GLsizeiptr;

typedef octet          GLubyte;        /* 'octet' should be an unsigned 8 bit type. */

typedef unsigned short GLushort;

typedef unsigned long  GLuint;

typedef unrestricted float GLfloat;

typedef unrestricted float GLclampf;

[

    Conditional=WEBGL,

    JSCustomMarkFunction,

    DoNotCheckConstants,

] interface WebGLRenderingContext : CanvasRenderingContext {

    /* ClearBufferMask */

    const GLenum DEPTH_BUFFER_BIT               = 0x00000100;

    const GLenum STENCIL_BUFFER_BIT             = 0x00000400;

    const GLenum COLOR_BUFFER_BIT               = 0x00004000;

    /* BeginMode */

    const GLenum POINTS                         = 0x0000;

    const GLenum LINES                          = 0x0001;

    const GLenum LINE_LOOP                      = 0x0002;

    const GLenum LINE_STRIP                     = 0x0003;

    const GLenum TRIANGLES                      = 0x0004;

    const GLenum TRIANGLE_STRIP                 = 0x0005;

    const GLenum TRIANGLE_FAN                   = 0x0006;

    /* AlphaFunction (not supported in ES20) */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* BlendingFactorDest */

    const GLenum ZERO                           = 0;

    const GLenum ONE                            = 1;

    const GLenum SRC_COLOR                      = 0x0300;

    const GLenum ONE_MINUS_SRC_COLOR            = 0x0301;

    const GLenum SRC_ALPHA                      = 0x0302;

    const GLenum ONE_MINUS_SRC_ALPHA            = 0x0303;

    const GLenum DST_ALPHA                      = 0x0304;

    const GLenum ONE_MINUS_DST_ALPHA            = 0x0305;

    /* BlendingFactorSrc */

    /*      ZERO */

    /*      ONE */

    const GLenum DST_COLOR                      = 0x0306;

    const GLenum ONE_MINUS_DST_COLOR            = 0x0307;

    const GLenum SRC_ALPHA_SATURATE             = 0x0308;

    /*      SRC_ALPHA */

    /*      ONE_MINUS_SRC_ALPHA */

    /*      DST_ALPHA */

    /*      ONE_MINUS_DST_ALPHA */

    /* BlendEquationSeparate */

    const GLenum FUNC_ADD                       = 0x8006;

    const GLenum BLEND_EQUATION                 = 0x8009;

    const GLenum BLEND_EQUATION_RGB             = 0x8009;   /* same as BLEND_EQUATION */

    const GLenum BLEND_EQUATION_ALPHA           = 0x883D;

    /* BlendSubtract */

    const GLenum FUNC_SUBTRACT                  = 0x800A;

    const GLenum FUNC_REVERSE_SUBTRACT          = 0x800B;

    /* Separate Blend Functions */

    const GLenum BLEND_DST_RGB                  = 0x80C8;

    const GLenum BLEND_SRC_RGB                  = 0x80C9;

    const GLenum BLEND_DST_ALPHA                = 0x80CA;

    const GLenum BLEND_SRC_ALPHA                = 0x80CB;

    const GLenum CONSTANT_COLOR                 = 0x8001;

    const GLenum ONE_MINUS_CONSTANT_COLOR       = 0x8002;

    const GLenum CONSTANT_ALPHA                 = 0x8003;

    const GLenum ONE_MINUS_CONSTANT_ALPHA       = 0x8004;

    const GLenum BLEND_COLOR                    = 0x8005;

    /* Buffer Objects */

    const GLenum ARRAY_BUFFER                   = 0x8892;

    const GLenum ELEMENT_ARRAY_BUFFER           = 0x8893;

    const GLenum ARRAY_BUFFER_BINDING           = 0x8894;

    const GLenum ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;

    const GLenum STREAM_DRAW                    = 0x88E0;

    const GLenum STATIC_DRAW                    = 0x88E4;

    const GLenum DYNAMIC_DRAW                   = 0x88E8;

    const GLenum BUFFER_SIZE                    = 0x8764;

    const GLenum BUFFER_USAGE                   = 0x8765;

    const GLenum CURRENT_VERTEX_ATTRIB          = 0x8626;

    /* CullFaceMode */

    const GLenum FRONT                          = 0x0404;

    const GLenum BACK                           = 0x0405;

    const GLenum FRONT_AND_BACK                 = 0x0408;

    /* DepthFunction */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* EnableCap */

    const GLenum TEXTURE_2D                     = 0x0DE1;

    const GLenum CULL_FACE                      = 0x0B44;

    const GLenum BLEND                          = 0x0BE2;

    const GLenum DITHER                         = 0x0BD0;

    const GLenum STENCIL_TEST                   = 0x0B90;

    const GLenum DEPTH_TEST                     = 0x0B71;

    const GLenum SCISSOR_TEST                   = 0x0C11;

    const GLenum POLYGON_OFFSET_FILL            = 0x8037;

    const GLenum SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;

    const GLenum SAMPLE_COVERAGE                = 0x80A0;

    /* ErrorCode */

    const GLenum NO_ERROR                       = 0;

    const GLenum INVALID_ENUM                   = 0x0500;

    const GLenum INVALID_VALUE                  = 0x0501;

    const GLenum INVALID_OPERATION              = 0x0502;

    const GLenum OUT_OF_MEMORY                  = 0x0505;

    /* FrontFaceDirection */

    const GLenum CW                             = 0x0900;

    const GLenum CCW                            = 0x0901;

    /* GetPName */

    const GLenum LINE_WIDTH                     = 0x0B21;

    const GLenum ALIASED_POINT_SIZE_RANGE       = 0x846D;

    const GLenum ALIASED_LINE_WIDTH_RANGE       = 0x846E;

    const GLenum CULL_FACE_MODE                 = 0x0B45;

    const GLenum FRONT_FACE                     = 0x0B46;

    const GLenum DEPTH_RANGE                    = 0x0B70;

    const GLenum DEPTH_WRITEMASK                = 0x0B72;

    const GLenum DEPTH_CLEAR_VALUE              = 0x0B73;

    const GLenum DEPTH_FUNC                     = 0x0B74;

    const GLenum STENCIL_CLEAR_VALUE            = 0x0B91;

    const GLenum STENCIL_FUNC                   = 0x0B92;

    const GLenum STENCIL_FAIL                   = 0x0B94;

    const GLenum STENCIL_PASS_DEPTH_FAIL        = 0x0B95;

    const GLenum STENCIL_PASS_DEPTH_PASS        = 0x0B96;

    const GLenum STENCIL_REF                    = 0x0B97;

    const GLenum STENCIL_VALUE_MASK             = 0x0B93;

    const GLenum STENCIL_WRITEMASK              = 0x0B98;

    const GLenum STENCIL_BACK_FUNC              = 0x8800;

    const GLenum STENCIL_BACK_FAIL              = 0x8801;

    const GLenum STENCIL_BACK_PASS_DEPTH_FAIL   = 0x8802;

    const GLenum STENCIL_BACK_PASS_DEPTH_PASS   = 0x8803;

    const GLenum STENCIL_BACK_REF               = 0x8CA3;

    const GLenum STENCIL_BACK_VALUE_MASK        = 0x8CA4;

    const GLenum STENCIL_BACK_WRITEMASK         = 0x8CA5;

    const GLenum VIEWPORT                       = 0x0BA2;

    const GLenum SCISSOR_BOX                    = 0x0C10;

    /*      SCISSOR_TEST */

    const GLenum COLOR_CLEAR_VALUE              = 0x0C22;

    const GLenum COLOR_WRITEMASK                = 0x0C23;

    const GLenum UNPACK_ALIGNMENT               = 0x0CF5;

    const GLenum PACK_ALIGNMENT                 = 0x0D05;

    const GLenum MAX_TEXTURE_SIZE               = 0x0D33;

    const GLenum MAX_VIEWPORT_DIMS              = 0x0D3A;

    const GLenum SUBPIXEL_BITS                  = 0x0D50;

    const GLenum RED_BITS                       = 0x0D52;

    const GLenum GREEN_BITS                     = 0x0D53;

    const GLenum BLUE_BITS                      = 0x0D54;

    const GLenum ALPHA_BITS                     = 0x0D55;

    const GLenum DEPTH_BITS                     = 0x0D56;

    const GLenum STENCIL_BITS                   = 0x0D57;

    const GLenum POLYGON_OFFSET_UNITS           = 0x2A00;

    /*      POLYGON_OFFSET_FILL */

    const GLenum POLYGON_OFFSET_FACTOR          = 0x8038;

    const GLenum TEXTURE_BINDING_2D             = 0x8069;

    const GLenum SAMPLE_BUFFERS                 = 0x80A8;

    const GLenum SAMPLES                        = 0x80A9;

    const GLenum SAMPLE_COVERAGE_VALUE          = 0x80AA;

    const GLenum SAMPLE_COVERAGE_INVERT         = 0x80AB;

    /* GetTextureParameter */

    /*      TEXTURE_MAG_FILTER */

    /*      TEXTURE_MIN_FILTER */

    /*      TEXTURE_WRAP_S */

    /*      TEXTURE_WRAP_T */

    const GLenum COMPRESSED_TEXTURE_FORMATS     = 0x86A3;

    /* HintMode */

    const GLenum DONT_CARE                      = 0x1100;

    const GLenum FASTEST                        = 0x1101;

    const GLenum NICEST                         = 0x1102;

    /* HintTarget */

    const GLenum GENERATE_MIPMAP_HINT            = 0x8192;

    /* DataType */

    const GLenum BYTE                           = 0x1400;

    const GLenum UNSIGNED_BYTE                  = 0x1401;

    const GLenum SHORT                          = 0x1402;

    const GLenum UNSIGNED_SHORT                 = 0x1403;

    const GLenum INT                            = 0x1404;

    const GLenum UNSIGNED_INT                   = 0x1405;

    const GLenum FLOAT                          = 0x1406;

    /* PixelFormat */

    const GLenum DEPTH_COMPONENT                = 0x1902;

    const GLenum ALPHA                          = 0x1906;

    const GLenum RGB                            = 0x1907;

    const GLenum RGBA                           = 0x1908;

    const GLenum LUMINANCE                      = 0x1909;

    const GLenum LUMINANCE_ALPHA                = 0x190A;

    /* PixelType */

    /*      UNSIGNED_BYTE */

    const GLenum UNSIGNED_SHORT_4_4_4_4         = 0x8033;

    const GLenum UNSIGNED_SHORT_5_5_5_1         = 0x8034;

    const GLenum UNSIGNED_SHORT_5_6_5           = 0x8363;

    /* Shaders */

    const GLenum FRAGMENT_SHADER                  = 0x8B30;

    const GLenum VERTEX_SHADER                    = 0x8B31;

    const GLenum MAX_VERTEX_ATTRIBS               = 0x8869;

    const GLenum MAX_VERTEX_UNIFORM_VECTORS       = 0x8DFB;

    const GLenum MAX_VARYING_VECTORS              = 0x8DFC;

    const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;

    const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C;

    const GLenum MAX_TEXTURE_IMAGE_UNITS          = 0x8872;

    const GLenum MAX_FRAGMENT_UNIFORM_VECTORS     = 0x8DFD;

    const GLenum SHADER_TYPE                      = 0x8B4F;

    const GLenum DELETE_STATUS                    = 0x8B80;

    const GLenum LINK_STATUS                      = 0x8B82;

    const GLenum VALIDATE_STATUS                  = 0x8B83;

    const GLenum ATTACHED_SHADERS                 = 0x8B85;

    const GLenum ACTIVE_UNIFORMS                  = 0x8B86;

    const GLenum ACTIVE_ATTRIBUTES                = 0x8B89;

    const GLenum SHADING_LANGUAGE_VERSION         = 0x8B8C;

    const GLenum CURRENT_PROGRAM                  = 0x8B8D;

    /* StencilFunction */

    const GLenum NEVER                          = 0x0200;

    const GLenum LESS                           = 0x0201;

    const GLenum EQUAL                          = 0x0202;

    const GLenum LEQUAL                         = 0x0203;

    const GLenum GREATER                        = 0x0204;

    const GLenum NOTEQUAL                       = 0x0205;

    const GLenum GEQUAL                         = 0x0206;

    const GLenum ALWAYS                         = 0x0207;

    /* StencilOp */

    /*      ZERO */

    const GLenum KEEP                           = 0x1E00;

    const GLenum REPLACE                        = 0x1E01;

    const GLenum INCR                           = 0x1E02;

    const GLenum DECR                           = 0x1E03;

    const GLenum INVERT                         = 0x150A;

    const GLenum INCR_WRAP                      = 0x8507;

    const GLenum DECR_WRAP                      = 0x8508;

    /* StringName */

    const GLenum VENDOR                         = 0x1F00;

    const GLenum RENDERER                       = 0x1F01;

    const GLenum VERSION                        = 0x1F02;

    /* TextureMagFilter */

    const GLenum NEAREST                        = 0x2600;

    const GLenum LINEAR                         = 0x2601;

    /* TextureMinFilter */

    /*      NEAREST */

    /*      LINEAR */

    const GLenum NEAREST_MIPMAP_NEAREST         = 0x2700;

    const GLenum LINEAR_MIPMAP_NEAREST          = 0x2701;

    const GLenum NEAREST_MIPMAP_LINEAR          = 0x2702;

    const GLenum LINEAR_MIPMAP_LINEAR           = 0x2703;

    /* TextureParameterName */

    const GLenum TEXTURE_MAG_FILTER             = 0x2800;

    const GLenum TEXTURE_MIN_FILTER             = 0x2801;

    const GLenum TEXTURE_WRAP_S                 = 0x2802;

    const GLenum TEXTURE_WRAP_T                 = 0x2803;

    /* TextureTarget */

    /*      TEXTURE_2D */

    const GLenum TEXTURE                        = 0x1702;

    const GLenum TEXTURE_CUBE_MAP               = 0x8513;

    const GLenum TEXTURE_BINDING_CUBE_MAP       = 0x8514;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;

    const GLenum MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;

    /* TextureUnit */

    const GLenum TEXTURE0                       = 0x84C0;

    const GLenum TEXTURE1                       = 0x84C1;

    const GLenum TEXTURE2                       = 0x84C2;

    const GLenum TEXTURE3                       = 0x84C3;

    const GLenum TEXTURE4                       = 0x84C4;

    const GLenum TEXTURE5                       = 0x84C5;

    const GLenum TEXTURE6                       = 0x84C6;

    const GLenum TEXTURE7                       = 0x84C7;

    const GLenum TEXTURE8                       = 0x84C8;

    const GLenum TEXTURE9                       = 0x84C9;

    const GLenum TEXTURE10                      = 0x84CA;

    const GLenum TEXTURE11                      = 0x84CB;

    const GLenum TEXTURE12                      = 0x84CC;

    const GLenum TEXTURE13                      = 0x84CD;

    const GLenum TEXTURE14                      = 0x84CE;

    const GLenum TEXTURE15                      = 0x84CF;

    const GLenum TEXTURE16                      = 0x84D0;

    const GLenum TEXTURE17                      = 0x84D1;

    const GLenum TEXTURE18                      = 0x84D2;

    const GLenum TEXTURE19                      = 0x84D3;

    const GLenum TEXTURE20                      = 0x84D4;

    const GLenum TEXTURE21                      = 0x84D5;

    const GLenum TEXTURE22                      = 0x84D6;

    const GLenum TEXTURE23                      = 0x84D7;

    const GLenum TEXTURE24                      = 0x84D8;

    const GLenum TEXTURE25                      = 0x84D9;

    const GLenum TEXTURE26                      = 0x84DA;

    const GLenum TEXTURE27                      = 0x84DB;

    const GLenum TEXTURE28                      = 0x84DC;

    const GLenum TEXTURE29                      = 0x84DD;

    const GLenum TEXTURE30                      = 0x84DE;

    const GLenum TEXTURE31                      = 0x84DF;

    const GLenum ACTIVE_TEXTURE                 = 0x84E0;

    /* TextureWrapMode */

    const GLenum REPEAT                         = 0x2901;

    const GLenum CLAMP_TO_EDGE                  = 0x812F;

    const GLenum MIRRORED_REPEAT                = 0x8370;

    /* Uniform Types */

    const GLenum FLOAT_VEC2                     = 0x8B50;

    const GLenum FLOAT_VEC3                     = 0x8B51;

    const GLenum FLOAT_VEC4                     = 0x8B52;

    const GLenum INT_VEC2                       = 0x8B53;

    const GLenum INT_VEC3                       = 0x8B54;

    const GLenum INT_VEC4                       = 0x8B55;

    const GLenum BOOL                           = 0x8B56;

    const GLenum BOOL_VEC2                      = 0x8B57;

    const GLenum BOOL_VEC3                      = 0x8B58;

    const GLenum BOOL_VEC4                      = 0x8B59;

    const GLenum FLOAT_MAT2                     = 0x8B5A;

    const GLenum FLOAT_MAT3                     = 0x8B5B;

    const GLenum FLOAT_MAT4                     = 0x8B5C;

    const GLenum SAMPLER_2D                     = 0x8B5E;

    const GLenum SAMPLER_CUBE                   = 0x8B60;

    /* Vertex Arrays */

    const GLenum VERTEX_ATTRIB_ARRAY_ENABLED        = 0x8622;

    const GLenum VERTEX_ATTRIB_ARRAY_SIZE           = 0x8623;

    const GLenum VERTEX_ATTRIB_ARRAY_STRIDE         = 0x8624;

    const GLenum VERTEX_ATTRIB_ARRAY_TYPE           = 0x8625;

    const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED     = 0x886A;

    const GLenum VERTEX_ATTRIB_ARRAY_POINTER        = 0x8645;

    const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;

    /* Shader Source */

    const GLenum COMPILE_STATUS                 = 0x8B81;

    /* Shader Precision-Specified Types */

    const GLenum LOW_FLOAT                      = 0x8DF0;

    const GLenum MEDIUM_FLOAT                   = 0x8DF1;

    const GLenum HIGH_FLOAT                     = 0x8DF2;

    const GLenum LOW_INT                        = 0x8DF3;

    const GLenum MEDIUM_INT                     = 0x8DF4;

    const GLenum HIGH_INT                       = 0x8DF5;

    /* Framebuffer Object. */

    const GLenum FRAMEBUFFER                    = 0x8D40;

    const GLenum RENDERBUFFER                   = 0x8D41;

    const GLenum RGBA4                          = 0x8056;

    const GLenum RGB5_A1                        = 0x8057;

    const GLenum RGB565                         = 0x8D62;

    const GLenum DEPTH_COMPONENT16              = 0x81A5;

    const GLenum STENCIL_INDEX                  = 0x1901;

    const GLenum STENCIL_INDEX8                 = 0x8D48;

    const GLenum DEPTH_STENCIL                  = 0x84F9;

    const GLenum SRGB_EXT                                     = 0x8C40;

    const GLenum SRGB_ALPHA_EXT                               = 0x8C42;

    const GLenum SRGB8_ALPHA8_EXT                             = 0x8C43;

    const GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT    = 0x8210;

    const GLenum MIN_EXT                        = 0x8007;

    const GLenum MAX_EXT                        = 0x8008;

    const GLenum RENDERBUFFER_WIDTH             = 0x8D42;

    const GLenum RENDERBUFFER_HEIGHT            = 0x8D43;

    const GLenum RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;

    const GLenum RENDERBUFFER_RED_SIZE          = 0x8D50;

    const GLenum RENDERBUFFER_GREEN_SIZE        = 0x8D51;

    const GLenum RENDERBUFFER_BLUE_SIZE         = 0x8D52;

    const GLenum RENDERBUFFER_ALPHA_SIZE        = 0x8D53;

    const GLenum RENDERBUFFER_DEPTH_SIZE        = 0x8D54;

    const GLenum RENDERBUFFER_STENCIL_SIZE      = 0x8D55;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           = 0x8CD0;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           = 0x8CD1;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         = 0x8CD2;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;

    const GLenum COLOR_ATTACHMENT0              = 0x8CE0;

    const GLenum DEPTH_ATTACHMENT               = 0x8D00;

    const GLenum STENCIL_ATTACHMENT             = 0x8D20;

    const GLenum DEPTH_STENCIL_ATTACHMENT       = 0x821A;

    const GLenum NONE                           = 0;

    const GLenum FRAMEBUFFER_COMPLETE                      = 0x8CD5;

    const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT         = 0x8CD6;

    const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;

    const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS         = 0x8CD9;

    const GLenum FRAMEBUFFER_UNSUPPORTED                   = 0x8CDD;

    const GLenum FRAMEBUFFER_BINDING            = 0x8CA6;

    const GLenum RENDERBUFFER_BINDING           = 0x8CA7;

    const GLenum MAX_RENDERBUFFER_SIZE          = 0x84E8;

    const GLenum INVALID_FRAMEBUFFER_OPERATION  = 0x0506;

    /* WebGL-specific enums */

    const GLenum UNPACK_FLIP_Y_WEBGL                = 0x9240;

    const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL     = 0x9241;

    const GLenum CONTEXT_LOST_WEBGL                 = 0x9242;

    const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;

    const GLenum BROWSER_DEFAULT_WEBGL              = 0x9244;

    readonly attribute GLsizei drawingBufferWidth;

    readonly attribute GLsizei drawingBufferHeight;

    [StrictTypeChecking, RaisesException] void         activeTexture(GLenum texture);

    [StrictTypeChecking, RaisesException] void         attachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking, RaisesException] void         bindAttribLocation(WebGLProgram program, GLuint index, DOMString name);

    [StrictTypeChecking, RaisesException] void         bindBuffer(GLenum target, WebGLBuffer buffer);

    [StrictTypeChecking, RaisesException] void         bindFramebuffer(GLenum target, WebGLFramebuffer framebuffer);

    [StrictTypeChecking, RaisesException] void         bindRenderbuffer(GLenum target, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         bindTexture(GLenum target, WebGLTexture texture);

    [StrictTypeChecking] void         blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         blendEquation(GLenum mode);

    [StrictTypeChecking] void         blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

    [StrictTypeChecking] void         blendFunc(GLenum sfactor, GLenum dfactor);

    [StrictTypeChecking] void         blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBuffer? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBufferView? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, GLsizeiptr size, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBuffer? data);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBufferView? data);

    [StrictTypeChecking] GLenum       checkFramebufferStatus(GLenum target);

    [StrictTypeChecking] void         clear(GLbitfield mask);

    [StrictTypeChecking] void         clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         clearDepth(GLclampf depth);

    [StrictTypeChecking] void         clearStencil(GLint s);

    [StrictTypeChecking] void         colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

    [StrictTypeChecking, RaisesException] void         compileShader(WebGLShader shader);

    [StrictTypeChecking] void         compressedTexImage2D(GLenum target, GLint level, GLenum internalformat,

                                                           GLsizei width, GLsizei height, GLint border, ArrayBufferView data);

    [StrictTypeChecking] void         compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                              GLsizei width, GLsizei height, GLenum format, ArrayBufferView data);

    [StrictTypeChecking] void         copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

    [StrictTypeChecking] void         copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking] WebGLBuffer createBuffer();

    [StrictTypeChecking] WebGLFramebuffer createFramebuffer();

    [StrictTypeChecking] WebGLProgram createProgram();

    [StrictTypeChecking] WebGLRenderbuffer createRenderbuffer();

    [StrictTypeChecking, RaisesException] WebGLShader createShader(GLenum type);

    [StrictTypeChecking] WebGLTexture createTexture();

    [StrictTypeChecking] void         cullFace(GLenum mode);

    [StrictTypeChecking] void         deleteBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] void         deleteFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] void         deleteProgram(WebGLProgram program);

    [StrictTypeChecking] void         deleteRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] void         deleteShader(WebGLShader shader);

    [StrictTypeChecking] void         deleteTexture(WebGLTexture texture);

    [StrictTypeChecking] void         depthFunc(GLenum func);

    [StrictTypeChecking] void         depthMask(GLboolean flag);

    [StrictTypeChecking] void         depthRange(GLclampf zNear, GLclampf zFar);

    [StrictTypeChecking, RaisesException] void         detachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking] void         disable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         disableVertexAttribArray(GLuint index);

    [StrictTypeChecking, RaisesException] void         drawArrays(GLenum mode, GLint first, GLsizei count);

    [StrictTypeChecking, RaisesException] void         drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);

    [StrictTypeChecking] void         enable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         enableVertexAttribArray(GLuint index);

    [StrictTypeChecking] void         finish();

    [StrictTypeChecking] void         flush();

    [StrictTypeChecking, RaisesException] void         framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture texture, GLint level);

    [StrictTypeChecking] void         frontFace(GLenum mode);

    [StrictTypeChecking] void         generateMipmap(GLenum target);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveAttrib(WebGLProgram program, GLuint index);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveUniform(WebGLProgram program, GLuint index);

    [StrictTypeChecking, Custom, RaisesException] void getAttachedShaders(WebGLProgram program);

    [StrictTypeChecking] GLint        getAttribLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom] any getBufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking] WebGLContextAttributes getContextAttributes();

    [StrictTypeChecking] GLenum getError();

    // object getExtension(DOMString name);

    [StrictTypeChecking, Custom] any getExtension(DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getParameter(GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getProgramParameter(WebGLProgram program, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString getProgramInfoLog(WebGLProgram program);

    [StrictTypeChecking, Custom, RaisesException] any getRenderbufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getShaderParameter(WebGLShader shader, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderInfoLog(WebGLShader shader);

    [StrictTypeChecking, RaisesException] WebGLShaderPrecisionFormat getShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderSource(WebGLShader shader);

    [StrictTypeChecking, Custom] sequence<DOMString> getSupportedExtensions();

    [StrictTypeChecking, Custom, RaisesException] any getTexParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getUniform(WebGLProgram program, WebGLUniformLocation location);

    [StrictTypeChecking, RaisesException] WebGLUniformLocation getUniformLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getVertexAttrib(GLuint index, GLenum pname);

    [StrictTypeChecking] GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);

    [StrictTypeChecking] void         hint(GLenum target, GLenum mode);

    [StrictTypeChecking] GLboolean    isBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] GLboolean    isContextLost();

    [StrictTypeChecking] GLboolean    isEnabled(GLenum cap);

    [StrictTypeChecking] GLboolean    isFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] GLboolean    isProgram(WebGLProgram program);

    [StrictTypeChecking] GLboolean    isRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] GLboolean    isShader(WebGLShader shader);

    [StrictTypeChecking] GLboolean    isTexture(WebGLTexture texture);

    [StrictTypeChecking] void         lineWidth(GLfloat width);

    [StrictTypeChecking, RaisesException] void         linkProgram(WebGLProgram program);

    [StrictTypeChecking] void         pixelStorei(GLenum pname, GLint param);

    [StrictTypeChecking] void         polygonOffset(GLfloat factor, GLfloat units);

    [StrictTypeChecking, RaisesException] void         readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView pixels);

    [StrictTypeChecking] void         releaseShaderCompiler();

    [StrictTypeChecking] void         renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

    [StrictTypeChecking] void         sampleCoverage(GLclampf value, GLboolean invert);

    [StrictTypeChecking] void         scissor(GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking, RaisesException] void         shaderSource(WebGLShader shader, DOMString string);

    [StrictTypeChecking] void         stencilFunc(GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilMask(GLuint mask);

    [StrictTypeChecking] void         stencilMaskSeparate(GLenum face, GLuint mask);

    [StrictTypeChecking] void         stencilOp(GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         texParameterf(GLenum target, GLenum pname, GLfloat param);

    [StrictTypeChecking] void         texParameteri(GLenum target, GLenum pname, GLint param);

    // Supported forms:

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, 

                                                 GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 

                                                    GLsizei width, GLsizei height, 

                                                    GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void uniform1f(WebGLUniformLocation location, GLfloat x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform1i(WebGLUniformLocation location, GLint x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform2f(WebGLUniformLocation location, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform2i(WebGLUniformLocation location, GLint x, GLint y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform3f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform3i(WebGLUniformLocation location, GLint x, GLint y, GLint z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform4f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform4i(WebGLUniformLocation location, GLint x, GLint y, GLint z, GLint w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix2fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix3fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix4fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, RaisesException] void         useProgram(WebGLProgram program);

    [StrictTypeChecking, RaisesException] void         validateProgram(WebGLProgram program);

    [StrictTypeChecking] void         vertexAttrib1f(GLuint indx, GLfloat x);

    [StrictTypeChecking, Custom] void vertexAttrib1fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom] void vertexAttrib2fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom] void vertexAttrib3fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom] void vertexAttrib4fv(GLuint indx, Float32Array values);

    [StrictTypeChecking, RaisesException] void         vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, 

                                                          GLsizei stride, GLintptr offset);

    [StrictTypeChecking] void         viewport(GLint x, GLint y, GLsizei width, GLsizei height);

};

176994

Source/WebCore/html/canvas/WebGL1RenderingContext.idl

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

typedef unsigned long  GLenum;

typedef boolean        GLboolean;

typedef unsigned long  GLbitfield;

typedef byte           GLbyte;         /* 'byte' should be a signed 8 bit type. */

typedef short          GLshort;

typedef long           GLint;

typedef long           GLsizei;

typedef long long      GLintptr;

typedef long long      GLsizeiptr;

typedef octet          GLubyte;        /* 'octet' should be an unsigned 8 bit type. */

typedef unsigned short GLushort;

typedef unsigned long  GLuint;

typedef unrestricted float GLfloat;

typedef unrestricted float GLclampf;

[

    Conditional=WEBGL,

    JSCustomMarkFunction,

    DoNotCheckConstants,

] interface WebGLRenderingContext : CanvasRenderingContext {

    /* ClearBufferMask */

    const GLenum DEPTH_BUFFER_BIT               = 0x00000100;

    const GLenum STENCIL_BUFFER_BIT             = 0x00000400;

    const GLenum COLOR_BUFFER_BIT               = 0x00004000;

    /* BeginMode */

    const GLenum POINTS                         = 0x0000;

    const GLenum LINES                          = 0x0001;

    const GLenum LINE_LOOP                      = 0x0002;

    const GLenum LINE_STRIP                     = 0x0003;

    const GLenum TRIANGLES                      = 0x0004;

    const GLenum TRIANGLE_STRIP                 = 0x0005;

    const GLenum TRIANGLE_FAN                   = 0x0006;

    /* AlphaFunction (not supported in ES20) */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* BlendingFactorDest */

    const GLenum ZERO                           = 0;

    const GLenum ONE                            = 1;

    const GLenum SRC_COLOR                      = 0x0300;

    const GLenum ONE_MINUS_SRC_COLOR            = 0x0301;

    const GLenum SRC_ALPHA                      = 0x0302;

    const GLenum ONE_MINUS_SRC_ALPHA            = 0x0303;

    const GLenum DST_ALPHA                      = 0x0304;

    const GLenum ONE_MINUS_DST_ALPHA            = 0x0305;

    /* BlendingFactorSrc */

    /*      ZERO */

    /*      ONE */

    const GLenum DST_COLOR                      = 0x0306;

    const GLenum ONE_MINUS_DST_COLOR            = 0x0307;

    const GLenum SRC_ALPHA_SATURATE             = 0x0308;

    /*      SRC_ALPHA */

    /*      ONE_MINUS_SRC_ALPHA */

    /*      DST_ALPHA */

    /*      ONE_MINUS_DST_ALPHA */

    /* BlendEquationSeparate */

    const GLenum FUNC_ADD                       = 0x8006;

    const GLenum BLEND_EQUATION                 = 0x8009;

    const GLenum BLEND_EQUATION_RGB             = 0x8009;   /* same as BLEND_EQUATION */

    const GLenum BLEND_EQUATION_ALPHA           = 0x883D;

    /* BlendSubtract */

    const GLenum FUNC_SUBTRACT                  = 0x800A;

    const GLenum FUNC_REVERSE_SUBTRACT          = 0x800B;

    /* Separate Blend Functions */

    const GLenum BLEND_DST_RGB                  = 0x80C8;

    const GLenum BLEND_SRC_RGB                  = 0x80C9;

    const GLenum BLEND_DST_ALPHA                = 0x80CA;

    const GLenum BLEND_SRC_ALPHA                = 0x80CB;

    const GLenum CONSTANT_COLOR                 = 0x8001;

    const GLenum ONE_MINUS_CONSTANT_COLOR       = 0x8002;

    const GLenum CONSTANT_ALPHA                 = 0x8003;

    const GLenum ONE_MINUS_CONSTANT_ALPHA       = 0x8004;

    const GLenum BLEND_COLOR                    = 0x8005;

    /* Buffer Objects */

    const GLenum ARRAY_BUFFER                   = 0x8892;

    const GLenum ELEMENT_ARRAY_BUFFER           = 0x8893;

    const GLenum ARRAY_BUFFER_BINDING           = 0x8894;

    const GLenum ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;

    const GLenum STREAM_DRAW                    = 0x88E0;

    const GLenum STATIC_DRAW                    = 0x88E4;

    const GLenum DYNAMIC_DRAW                   = 0x88E8;

    const GLenum BUFFER_SIZE                    = 0x8764;

    const GLenum BUFFER_USAGE                   = 0x8765;

    const GLenum CURRENT_VERTEX_ATTRIB          = 0x8626;

    /* CullFaceMode */

    const GLenum FRONT                          = 0x0404;

    const GLenum BACK                           = 0x0405;

    const GLenum FRONT_AND_BACK                 = 0x0408;

    /* DepthFunction */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* EnableCap */

    const GLenum TEXTURE_2D                     = 0x0DE1;

    const GLenum CULL_FACE                      = 0x0B44;

    const GLenum BLEND                          = 0x0BE2;

    const GLenum DITHER                         = 0x0BD0;

    const GLenum STENCIL_TEST                   = 0x0B90;

    const GLenum DEPTH_TEST                     = 0x0B71;

    const GLenum SCISSOR_TEST                   = 0x0C11;

    const GLenum POLYGON_OFFSET_FILL            = 0x8037;

    const GLenum SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;

    const GLenum SAMPLE_COVERAGE                = 0x80A0;

    /* ErrorCode */

    const GLenum NO_ERROR                       = 0;

    const GLenum INVALID_ENUM                   = 0x0500;

    const GLenum INVALID_VALUE                  = 0x0501;

    const GLenum INVALID_OPERATION              = 0x0502;

    const GLenum OUT_OF_MEMORY                  = 0x0505;

    /* FrontFaceDirection */

    const GLenum CW                             = 0x0900;

    const GLenum CCW                            = 0x0901;

    /* GetPName */

    const GLenum LINE_WIDTH                     = 0x0B21;

    const GLenum ALIASED_POINT_SIZE_RANGE       = 0x846D;

    const GLenum ALIASED_LINE_WIDTH_RANGE       = 0x846E;

    const GLenum CULL_FACE_MODE                 = 0x0B45;

    const GLenum FRONT_FACE                     = 0x0B46;

    const GLenum DEPTH_RANGE                    = 0x0B70;

    const GLenum DEPTH_WRITEMASK                = 0x0B72;

    const GLenum DEPTH_CLEAR_VALUE              = 0x0B73;

    const GLenum DEPTH_FUNC                     = 0x0B74;

    const GLenum STENCIL_CLEAR_VALUE            = 0x0B91;

    const GLenum STENCIL_FUNC                   = 0x0B92;

    const GLenum STENCIL_FAIL                   = 0x0B94;

    const GLenum STENCIL_PASS_DEPTH_FAIL        = 0x0B95;

    const GLenum STENCIL_PASS_DEPTH_PASS        = 0x0B96;

    const GLenum STENCIL_REF                    = 0x0B97;

    const GLenum STENCIL_VALUE_MASK             = 0x0B93;

    const GLenum STENCIL_WRITEMASK              = 0x0B98;

    const GLenum STENCIL_BACK_FUNC              = 0x8800;

    const GLenum STENCIL_BACK_FAIL              = 0x8801;

    const GLenum STENCIL_BACK_PASS_DEPTH_FAIL   = 0x8802;

    const GLenum STENCIL_BACK_PASS_DEPTH_PASS   = 0x8803;

    const GLenum STENCIL_BACK_REF               = 0x8CA3;

    const GLenum STENCIL_BACK_VALUE_MASK        = 0x8CA4;

    const GLenum STENCIL_BACK_WRITEMASK         = 0x8CA5;

    const GLenum VIEWPORT                       = 0x0BA2;

    const GLenum SCISSOR_BOX                    = 0x0C10;

    /*      SCISSOR_TEST */

    const GLenum COLOR_CLEAR_VALUE              = 0x0C22;

    const GLenum COLOR_WRITEMASK                = 0x0C23;

    const GLenum UNPACK_ALIGNMENT               = 0x0CF5;

    const GLenum PACK_ALIGNMENT                 = 0x0D05;

    const GLenum MAX_TEXTURE_SIZE               = 0x0D33;

    const GLenum MAX_VIEWPORT_DIMS              = 0x0D3A;

    const GLenum SUBPIXEL_BITS                  = 0x0D50;

    const GLenum RED_BITS                       = 0x0D52;

    const GLenum GREEN_BITS                     = 0x0D53;

    const GLenum BLUE_BITS                      = 0x0D54;

    const GLenum ALPHA_BITS                     = 0x0D55;

    const GLenum DEPTH_BITS                     = 0x0D56;

    const GLenum STENCIL_BITS                   = 0x0D57;

    const GLenum POLYGON_OFFSET_UNITS           = 0x2A00;

    /*      POLYGON_OFFSET_FILL */

    const GLenum POLYGON_OFFSET_FACTOR          = 0x8038;

    const GLenum TEXTURE_BINDING_2D             = 0x8069;

    const GLenum SAMPLE_BUFFERS                 = 0x80A8;

    const GLenum SAMPLES                        = 0x80A9;

    const GLenum SAMPLE_COVERAGE_VALUE          = 0x80AA;

    const GLenum SAMPLE_COVERAGE_INVERT         = 0x80AB;

    /* GetTextureParameter */

    /*      TEXTURE_MAG_FILTER */

    /*      TEXTURE_MIN_FILTER */

    /*      TEXTURE_WRAP_S */

    /*      TEXTURE_WRAP_T */

    const GLenum COMPRESSED_TEXTURE_FORMATS     = 0x86A3;

    /* HintMode */

    const GLenum DONT_CARE                      = 0x1100;

    const GLenum FASTEST                        = 0x1101;

    const GLenum NICEST                         = 0x1102;

    /* HintTarget */

    const GLenum GENERATE_MIPMAP_HINT            = 0x8192;

    /* DataType */

    const GLenum BYTE                           = 0x1400;

    const GLenum UNSIGNED_BYTE                  = 0x1401;

    const GLenum SHORT                          = 0x1402;

    const GLenum UNSIGNED_SHORT                 = 0x1403;

    const GLenum INT                            = 0x1404;

    const GLenum UNSIGNED_INT                   = 0x1405;

    const GLenum FLOAT                          = 0x1406;

    /* PixelFormat */

    const GLenum DEPTH_COMPONENT                = 0x1902;

    const GLenum ALPHA                          = 0x1906;

    const GLenum RGB                            = 0x1907;

    const GLenum RGBA                           = 0x1908;

    const GLenum LUMINANCE                      = 0x1909;

    const GLenum LUMINANCE_ALPHA                = 0x190A;

    /* PixelType */

    /*      UNSIGNED_BYTE */

    const GLenum UNSIGNED_SHORT_4_4_4_4         = 0x8033;

    const GLenum UNSIGNED_SHORT_5_5_5_1         = 0x8034;

    const GLenum UNSIGNED_SHORT_5_6_5           = 0x8363;

    /* Shaders */

    const GLenum FRAGMENT_SHADER                  = 0x8B30;

    const GLenum VERTEX_SHADER                    = 0x8B31;

    const GLenum MAX_VERTEX_ATTRIBS               = 0x8869;

    const GLenum MAX_VERTEX_UNIFORM_VECTORS       = 0x8DFB;

    const GLenum MAX_VARYING_VECTORS              = 0x8DFC;

    const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;

    const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C;

    const GLenum MAX_TEXTURE_IMAGE_UNITS          = 0x8872;

    const GLenum MAX_FRAGMENT_UNIFORM_VECTORS     = 0x8DFD;

    const GLenum SHADER_TYPE                      = 0x8B4F;

    const GLenum DELETE_STATUS                    = 0x8B80;

    const GLenum LINK_STATUS                      = 0x8B82;

    const GLenum VALIDATE_STATUS                  = 0x8B83;

    const GLenum ATTACHED_SHADERS                 = 0x8B85;

    const GLenum ACTIVE_UNIFORMS                  = 0x8B86;

    const GLenum ACTIVE_ATTRIBUTES                = 0x8B89;

    const GLenum SHADING_LANGUAGE_VERSION         = 0x8B8C;

    const GLenum CURRENT_PROGRAM                  = 0x8B8D;

    /* StencilFunction */

    const GLenum NEVER                          = 0x0200;

    const GLenum LESS                           = 0x0201;

    const GLenum EQUAL                          = 0x0202;

    const GLenum LEQUAL                         = 0x0203;

    const GLenum GREATER                        = 0x0204;

    const GLenum NOTEQUAL                       = 0x0205;

    const GLenum GEQUAL                         = 0x0206;

    const GLenum ALWAYS                         = 0x0207;

    /* StencilOp */

    /*      ZERO */

    const GLenum KEEP                           = 0x1E00;

    const GLenum REPLACE                        = 0x1E01;

    const GLenum INCR                           = 0x1E02;

    const GLenum DECR                           = 0x1E03;

    const GLenum INVERT                         = 0x150A;

    const GLenum INCR_WRAP                      = 0x8507;

    const GLenum DECR_WRAP                      = 0x8508;

    /* StringName */

    const GLenum VENDOR                         = 0x1F00;

    const GLenum RENDERER                       = 0x1F01;

    const GLenum VERSION                        = 0x1F02;

    /* TextureMagFilter */

    const GLenum NEAREST                        = 0x2600;

    const GLenum LINEAR                         = 0x2601;

    /* TextureMinFilter */

    /*      NEAREST */

    /*      LINEAR */

    const GLenum NEAREST_MIPMAP_NEAREST         = 0x2700;

    const GLenum LINEAR_MIPMAP_NEAREST          = 0x2701;

    const GLenum NEAREST_MIPMAP_LINEAR          = 0x2702;

    const GLenum LINEAR_MIPMAP_LINEAR           = 0x2703;

    /* TextureParameterName */

    const GLenum TEXTURE_MAG_FILTER             = 0x2800;

    const GLenum TEXTURE_MIN_FILTER             = 0x2801;

    const GLenum TEXTURE_WRAP_S                 = 0x2802;

    const GLenum TEXTURE_WRAP_T                 = 0x2803;

    /* TextureTarget */

    /*      TEXTURE_2D */

    const GLenum TEXTURE                        = 0x1702;

    const GLenum TEXTURE_CUBE_MAP               = 0x8513;

    const GLenum TEXTURE_BINDING_CUBE_MAP       = 0x8514;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;

    const GLenum MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;

    /* TextureUnit */

    const GLenum TEXTURE0                       = 0x84C0;

    const GLenum TEXTURE1                       = 0x84C1;

    const GLenum TEXTURE2                       = 0x84C2;

    const GLenum TEXTURE3                       = 0x84C3;

    const GLenum TEXTURE4                       = 0x84C4;

    const GLenum TEXTURE5                       = 0x84C5;

    const GLenum TEXTURE6                       = 0x84C6;

    const GLenum TEXTURE7                       = 0x84C7;

    const GLenum TEXTURE8                       = 0x84C8;

    const GLenum TEXTURE9                       = 0x84C9;

    const GLenum TEXTURE10                      = 0x84CA;

    const GLenum TEXTURE11                      = 0x84CB;

    const GLenum TEXTURE12                      = 0x84CC;

    const GLenum TEXTURE13                      = 0x84CD;

    const GLenum TEXTURE14                      = 0x84CE;

    const GLenum TEXTURE15                      = 0x84CF;

    const GLenum TEXTURE16                      = 0x84D0;

    const GLenum TEXTURE17                      = 0x84D1;

    const GLenum TEXTURE18                      = 0x84D2;

    const GLenum TEXTURE19                      = 0x84D3;

    const GLenum TEXTURE20                      = 0x84D4;

    const GLenum TEXTURE21                      = 0x84D5;

    const GLenum TEXTURE22                      = 0x84D6;

    const GLenum TEXTURE23                      = 0x84D7;

    const GLenum TEXTURE24                      = 0x84D8;

    const GLenum TEXTURE25                      = 0x84D9;

    const GLenum TEXTURE26                      = 0x84DA;

    const GLenum TEXTURE27                      = 0x84DB;

    const GLenum TEXTURE28                      = 0x84DC;

    const GLenum TEXTURE29                      = 0x84DD;

    const GLenum TEXTURE30                      = 0x84DE;

    const GLenum TEXTURE31                      = 0x84DF;

    const GLenum ACTIVE_TEXTURE                 = 0x84E0;

    /* TextureWrapMode */

    const GLenum REPEAT                         = 0x2901;

    const GLenum CLAMP_TO_EDGE                  = 0x812F;

    const GLenum MIRRORED_REPEAT                = 0x8370;

    /* Uniform Types */

    const GLenum FLOAT_VEC2                     = 0x8B50;

    const GLenum FLOAT_VEC3                     = 0x8B51;

    const GLenum FLOAT_VEC4                     = 0x8B52;

    const GLenum INT_VEC2                       = 0x8B53;

    const GLenum INT_VEC3                       = 0x8B54;

    const GLenum INT_VEC4                       = 0x8B55;

    const GLenum BOOL                           = 0x8B56;

    const GLenum BOOL_VEC2                      = 0x8B57;

    const GLenum BOOL_VEC3                      = 0x8B58;

    const GLenum BOOL_VEC4                      = 0x8B59;

    const GLenum FLOAT_MAT2                     = 0x8B5A;

    const GLenum FLOAT_MAT3                     = 0x8B5B;

    const GLenum FLOAT_MAT4                     = 0x8B5C;

    const GLenum SAMPLER_2D                     = 0x8B5E;

    const GLenum SAMPLER_CUBE                   = 0x8B60;

    /* Vertex Arrays */

    const GLenum VERTEX_ATTRIB_ARRAY_ENABLED        = 0x8622;

    const GLenum VERTEX_ATTRIB_ARRAY_SIZE           = 0x8623;

    const GLenum VERTEX_ATTRIB_ARRAY_STRIDE         = 0x8624;

    const GLenum VERTEX_ATTRIB_ARRAY_TYPE           = 0x8625;

    const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED     = 0x886A;

    const GLenum VERTEX_ATTRIB_ARRAY_POINTER        = 0x8645;

    const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;

    /* Shader Source */

    const GLenum COMPILE_STATUS                 = 0x8B81;

    /* Shader Precision-Specified Types */

    const GLenum LOW_FLOAT                      = 0x8DF0;

    const GLenum MEDIUM_FLOAT                   = 0x8DF1;

    const GLenum HIGH_FLOAT                     = 0x8DF2;

    const GLenum LOW_INT                        = 0x8DF3;

    const GLenum MEDIUM_INT                     = 0x8DF4;

    const GLenum HIGH_INT                       = 0x8DF5;

    /* Framebuffer Object. */

    const GLenum FRAMEBUFFER                    = 0x8D40;

    const GLenum RENDERBUFFER                   = 0x8D41;

    const GLenum RGBA4                          = 0x8056;

    const GLenum RGB5_A1                        = 0x8057;

    const GLenum RGB565                         = 0x8D62;

    const GLenum DEPTH_COMPONENT16              = 0x81A5;

    const GLenum STENCIL_INDEX                  = 0x1901;

    const GLenum STENCIL_INDEX8                 = 0x8D48;

    const GLenum DEPTH_STENCIL                  = 0x84F9;

    const GLenum RENDERBUFFER_WIDTH             = 0x8D42;

    const GLenum RENDERBUFFER_HEIGHT            = 0x8D43;

    const GLenum RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;

    const GLenum RENDERBUFFER_RED_SIZE          = 0x8D50;

    const GLenum RENDERBUFFER_GREEN_SIZE        = 0x8D51;

    const GLenum RENDERBUFFER_BLUE_SIZE         = 0x8D52;

    const GLenum RENDERBUFFER_ALPHA_SIZE        = 0x8D53;

    const GLenum RENDERBUFFER_DEPTH_SIZE        = 0x8D54;

    const GLenum RENDERBUFFER_STENCIL_SIZE      = 0x8D55;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           = 0x8CD0;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           = 0x8CD1;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         = 0x8CD2;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;

    const GLenum COLOR_ATTACHMENT0              = 0x8CE0;

    const GLenum DEPTH_ATTACHMENT               = 0x8D00;

    const GLenum STENCIL_ATTACHMENT             = 0x8D20;

    const GLenum DEPTH_STENCIL_ATTACHMENT       = 0x821A;

    const GLenum NONE                           = 0;

    const GLenum FRAMEBUFFER_COMPLETE                      = 0x8CD5;

    const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT         = 0x8CD6;

    const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;

    const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS         = 0x8CD9;

    const GLenum FRAMEBUFFER_UNSUPPORTED                   = 0x8CDD;

    const GLenum FRAMEBUFFER_BINDING            = 0x8CA6;

    const GLenum RENDERBUFFER_BINDING           = 0x8CA7;

    const GLenum MAX_RENDERBUFFER_SIZE          = 0x84E8;

    const GLenum INVALID_FRAMEBUFFER_OPERATION  = 0x0506;

    /* WebGL-specific enums */

    const GLenum UNPACK_FLIP_Y_WEBGL                = 0x9240;

    const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL     = 0x9241;

    const GLenum CONTEXT_LOST_WEBGL                 = 0x9242;

    const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;

    const GLenum BROWSER_DEFAULT_WEBGL              = 0x9244;

    readonly attribute GLsizei drawingBufferWidth;

    readonly attribute GLsizei drawingBufferHeight;

    [StrictTypeChecking, RaisesException] void         activeTexture(GLenum texture);

    [StrictTypeChecking, RaisesException] void         attachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking, RaisesException] void         bindAttribLocation(WebGLProgram program, GLuint index, DOMString name);

    [StrictTypeChecking, RaisesException] void         bindBuffer(GLenum target, WebGLBuffer buffer);

    [StrictTypeChecking, RaisesException] void         bindFramebuffer(GLenum target, WebGLFramebuffer framebuffer);

    [StrictTypeChecking, RaisesException] void         bindRenderbuffer(GLenum target, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         bindTexture(GLenum target, WebGLTexture texture);

    [StrictTypeChecking] void         blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         blendEquation(GLenum mode);

    [StrictTypeChecking] void         blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

    [StrictTypeChecking] void         blendFunc(GLenum sfactor, GLenum dfactor);

    [StrictTypeChecking] void         blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBuffer? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBufferView? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, GLsizeiptr size, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBuffer? data);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBufferView? data);

    [StrictTypeChecking] GLenum       checkFramebufferStatus(GLenum target);

    [StrictTypeChecking] void         clear(GLbitfield mask);

    [StrictTypeChecking] void         clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         clearDepth(GLclampf depth);

    [StrictTypeChecking] void         clearStencil(GLint s);

    [StrictTypeChecking] void         colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

    [StrictTypeChecking, RaisesException] void         compileShader(WebGLShader shader);

    [StrictTypeChecking] void         compressedTexImage2D(GLenum target, GLint level, GLenum internalformat,

                                                           GLsizei width, GLsizei height, GLint border, ArrayBufferView data);

    [StrictTypeChecking] void         compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                              GLsizei width, GLsizei height, GLenum format, ArrayBufferView data);

    [StrictTypeChecking] void         copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

    [StrictTypeChecking] void         copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking] WebGLBuffer createBuffer();

    [StrictTypeChecking] WebGLFramebuffer createFramebuffer();

    [StrictTypeChecking] WebGLProgram createProgram();

    [StrictTypeChecking] WebGLRenderbuffer createRenderbuffer();

    [StrictTypeChecking, RaisesException] WebGLShader createShader(GLenum type);

    [StrictTypeChecking] WebGLTexture createTexture();

    [StrictTypeChecking] void         cullFace(GLenum mode);

    [StrictTypeChecking] void         deleteBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] void         deleteFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] void         deleteProgram(WebGLProgram program);

    [StrictTypeChecking] void         deleteRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] void         deleteShader(WebGLShader shader);

    [StrictTypeChecking] void         deleteTexture(WebGLTexture texture);

    [StrictTypeChecking] void         depthFunc(GLenum func);

    [StrictTypeChecking] void         depthMask(GLboolean flag);

    [StrictTypeChecking] void         depthRange(GLclampf zNear, GLclampf zFar);

    [StrictTypeChecking, RaisesException] void         detachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking] void         disable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         disableVertexAttribArray(GLuint index);

    [StrictTypeChecking, RaisesException] void         drawArrays(GLenum mode, GLint first, GLsizei count);

    [StrictTypeChecking, RaisesException] void         drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);

    [StrictTypeChecking] void         enable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         enableVertexAttribArray(GLuint index);

    [StrictTypeChecking] void         finish();

    [StrictTypeChecking] void         flush();

    [StrictTypeChecking, RaisesException] void         framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture texture, GLint level);

    [StrictTypeChecking] void         frontFace(GLenum mode);

    [StrictTypeChecking] void         generateMipmap(GLenum target);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveAttrib(WebGLProgram program, GLuint index);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveUniform(WebGLProgram program, GLuint index);

    [StrictTypeChecking, Custom, RaisesException] void getAttachedShaders(WebGLProgram program);

    [StrictTypeChecking] GLint        getAttribLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom] any getBufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking] WebGLContextAttributes getContextAttributes();

    [StrictTypeChecking] GLenum getError();

    // object getExtension(DOMString name);

    [StrictTypeChecking, Custom] any getExtension(DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getParameter(GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getProgramParameter(WebGLProgram program, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString getProgramInfoLog(WebGLProgram program);

    [StrictTypeChecking, Custom, RaisesException] any getRenderbufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getShaderParameter(WebGLShader shader, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderInfoLog(WebGLShader shader);

    [StrictTypeChecking, RaisesException] WebGLShaderPrecisionFormat getShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderSource(WebGLShader shader);

    [StrictTypeChecking, Custom] sequence<DOMString> getSupportedExtensions();

    [StrictTypeChecking, Custom, RaisesException] any getTexParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getUniform(WebGLProgram program, WebGLUniformLocation location);

    [StrictTypeChecking, RaisesException] WebGLUniformLocation getUniformLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getVertexAttrib(GLuint index, GLenum pname);

    [StrictTypeChecking] GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);

    [StrictTypeChecking] void         hint(GLenum target, GLenum mode);

    [StrictTypeChecking] GLboolean    isBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] GLboolean    isContextLost();

    [StrictTypeChecking] GLboolean    isEnabled(GLenum cap);

    [StrictTypeChecking] GLboolean    isFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] GLboolean    isProgram(WebGLProgram program);

    [StrictTypeChecking] GLboolean    isRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] GLboolean    isShader(WebGLShader shader);

    [StrictTypeChecking] GLboolean    isTexture(WebGLTexture texture);

    [StrictTypeChecking] void         lineWidth(GLfloat width);

    [StrictTypeChecking, RaisesException] void         linkProgram(WebGLProgram program);

    [StrictTypeChecking] void         pixelStorei(GLenum pname, GLint param);

    [StrictTypeChecking] void         polygonOffset(GLfloat factor, GLfloat units);

    [StrictTypeChecking, RaisesException] void         readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView pixels);

    [StrictTypeChecking] void         releaseShaderCompiler();

    [StrictTypeChecking] void         renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

    [StrictTypeChecking] void         sampleCoverage(GLclampf value, GLboolean invert);

    [StrictTypeChecking] void         scissor(GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking, RaisesException] void         shaderSource(WebGLShader shader, DOMString string);

    [StrictTypeChecking] void         stencilFunc(GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilMask(GLuint mask);

    [StrictTypeChecking] void         stencilMaskSeparate(GLenum face, GLuint mask);

    [StrictTypeChecking] void         stencilOp(GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         texParameterf(GLenum target, GLenum pname, GLfloat param);

    [StrictTypeChecking] void         texParameteri(GLenum target, GLenum pname, GLint param);

    // Supported forms:

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, 

                                                 GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 

                                                    GLsizei width, GLsizei height, 

                                                    GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void uniform1f(WebGLUniformLocation location, GLfloat x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform1i(WebGLUniformLocation location, GLint x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform2f(WebGLUniformLocation location, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform2i(WebGLUniformLocation location, GLint x, GLint y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform3f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform3i(WebGLUniformLocation location, GLint x, GLint y, GLint z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform4f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform4i(WebGLUniformLocation location, GLint x, GLint y, GLint z, GLint w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix2fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix3fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix4fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, RaisesException] void         useProgram(WebGLProgram program);

    [StrictTypeChecking, RaisesException] void         validateProgram(WebGLProgram program);

    [StrictTypeChecking] void         vertexAttrib1f(GLuint indx, GLfloat x);

    [StrictTypeChecking, Custom] void vertexAttrib1fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom] void vertexAttrib2fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom] void vertexAttrib3fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom] void vertexAttrib4fv(GLuint indx, Float32Array values);

    [StrictTypeChecking, RaisesException] void         vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, 

                                                          GLsizei stride, GLintptr offset);

    [StrictTypeChecking] void         viewport(GLint x, GLint y, GLsizei width, GLsizei height);

30] interface WebGL1RenderingContext : WebGLRenderingContextBase {

66931};

working copy

Source/WebCore/html/canvas/WebGL2RenderingContext.cpp

/*

 * Copyright (C) 2015 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#if ENABLE(WEBGL)

#include "WebGL2RenderingContext.h"

namespace WebCore {

WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

    : WebGLRenderingContextBase(passedCanvas, attributes)

{

    m_type = "webgl2";

}

WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,

    GraphicsContext3D::Attributes attributes) : WebGLRenderingContextBase(passedCanvas, context, attributes)

{

    m_type = "webgl2";

}

} // namespace WebCore

#endif // ENABLE(WEBGL)

Source/WebCore/html/canvas/WebGL2RenderingContext.h

/*

 * Copyright (C) 2015 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#ifndef WebGL2RenderingContext_h

#define WebGL2RenderingContext_h

#include "WebGLRenderingContextBase.h"

namespace WebCore {

class WebGL2RenderingContext final : public WebGLRenderingContextBase {

public:

    WebGL2RenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);

    WebGL2RenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);

};

} // namespace WebCore

#endif

Source/WebCore/html/canvas/WebGL2RenderingContext.idl

/*

 * Copyright (C) 2015 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

[

    Conditional=WEBGL,

    JSCustomMarkFunction,

    DoNotCheckConstants,

] interface WebGL2RenderingContext : WebGLRenderingContextBase {

};

Source/WebCore/html/canvas/WebGLBuffer.cpp

#include "WebGLBuffer.h"

#include "WebGLContextGroup.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

namespace WebCore {

37 PassRefPtr<WebGLBuffer> WebGLBuffer::create(WebGLRenderingContext* ctx)

37PassRefPtr<WebGLBuffer> WebGLBuffer::create(WebGLRenderingContextBase* ctx)

{

    return adoptRef(new WebGLBuffer(ctx));

}

42 WebGLBuffer::WebGLBuffer(WebGLRenderingContext* ctx)

42WebGLBuffer::WebGLBuffer(WebGLRenderingContextBase* ctx)

    : WebGLSharedObject(ctx)

    , m_target(0)

    , m_byteLength(0)

178372

Source/WebCore/html/canvas/WebGLBuffer.h

@@class WebGLBuffer final : public WebGLSh

public:

    virtual ~WebGLBuffer();

44 static PassRefPtr<WebGLBuffer> create(WebGLRenderingContext*);

44 static PassRefPtr<WebGLBuffer> create(WebGLRenderingContextBase*);

    bool associateBufferData(GC3Dsizeiptr size);

    bool associateBufferData(JSC::ArrayBuffer*);

@@public:

    bool hasEverBeenBound() const { return object() && m_target; }

protected:

69 WebGLBuffer(WebGLRenderingContext*);

69 WebGLBuffer(WebGLRenderingContextBase*);

    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;

178372

Source/WebCore/html/canvas/WebGLCompressedTextureATC.cpp

namespace WebCore {

36 WebGLCompressedTextureATC::WebGLCompressedTextureATC(WebGLRenderingContext* context)

36WebGLCompressedTextureATC::WebGLCompressedTextureATC(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

    context->addCompressedTextureFormat(Extensions3D::COMPRESSED_ATC_RGB_AMD);

@@WebGLExtension::ExtensionName WebGLCompr

    return WebGLCompressedTextureATCName;

}

53 bool WebGLCompressedTextureATC::supported(WebGLRenderingContext* context)

53bool WebGLCompressedTextureATC::supported(WebGLRenderingContextBase* context)

{

    Extensions3D* extensions = context->graphicsContext3D()->getExtensions();

    return extensions->supports("GL_AMD_compressed_ATC_texture");

178372

Source/WebCore/html/canvas/WebGLCompressedTextureATC.h

@@class WebGLTexture;

class WebGLCompressedTextureATC final : public WebGLExtension {

public:

37 explicit WebGLCompressedTextureATC(WebGLRenderingContext*);

37 explicit WebGLCompressedTextureATC(WebGLRenderingContextBase*);

3838 virtual ~WebGLCompressedTextureATC();

3939

40 static bool supported(WebGLRenderingContext*);

40 static bool supported(WebGLRenderingContextBase*);

    virtual ExtensionName getName() const override;

};

178372

Source/WebCore/html/canvas/WebGLCompressedTexturePVRTC.cpp

#include "WebGLCompressedTexturePVRTC.h"

#include "Extensions3D.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

namespace WebCore {

37 WebGLCompressedTexturePVRTC::WebGLCompressedTexturePVRTC(WebGLRenderingContext* context)

37WebGLCompressedTexturePVRTC::WebGLCompressedTexturePVRTC(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

    context->addCompressedTextureFormat(Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG);

@@WebGLExtension::ExtensionName WebGLCompr

    return WebGLCompressedTexturePVRTCName;

}

55 bool WebGLCompressedTexturePVRTC::supported(WebGLRenderingContext* context)

55bool WebGLCompressedTexturePVRTC::supported(WebGLRenderingContextBase* context)

{

    Extensions3D* extensions = context->graphicsContext3D()->getExtensions();

    return extensions->supports("GL_IMG_texture_compression_pvrtc");

178372

Source/WebCore/html/canvas/WebGLCompressedTexturePVRTC.h

@@namespace WebCore {

class WebGLCompressedTexturePVRTC final : public WebGLExtension {

public:

35 explicit WebGLCompressedTexturePVRTC(WebGLRenderingContext*);

35 explicit WebGLCompressedTexturePVRTC(WebGLRenderingContextBase*);

3636 virtual ~WebGLCompressedTexturePVRTC();

3737

38 static bool supported(WebGLRenderingContext*);

38 static bool supported(WebGLRenderingContextBase*);

    virtual ExtensionName getName() const override;

};

178372

Source/WebCore/html/canvas/WebGLCompressedTextureS3TC.cpp

#include "WebGLCompressedTextureS3TC.h"

#include "Extensions3D.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

namespace WebCore {

37 WebGLCompressedTextureS3TC::WebGLCompressedTextureS3TC(WebGLRenderingContext* context)

37WebGLCompressedTextureS3TC::WebGLCompressedTextureS3TC(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

    context->addCompressedTextureFormat(Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT);

@@WebGLExtension::ExtensionName WebGLCompr

    return WebGLCompressedTextureS3TCName;

}

55 bool WebGLCompressedTextureS3TC::supported(WebGLRenderingContext* context)

55bool WebGLCompressedTextureS3TC::supported(WebGLRenderingContextBase* context)

{

    Extensions3D* extensions = context->graphicsContext3D()->getExtensions();

    return extensions->supports("GL_EXT_texture_compression_s3tc")

178372

Source/WebCore/html/canvas/WebGLCompressedTextureS3TC.h

@@class WebGLTexture;

class WebGLCompressedTextureS3TC final : public WebGLExtension {

public:

37 explicit WebGLCompressedTextureS3TC(WebGLRenderingContext*);

37 explicit WebGLCompressedTextureS3TC(WebGLRenderingContextBase*);

3838 virtual ~WebGLCompressedTextureS3TC();

3939

40 static bool supported(WebGLRenderingContext*);

40 static bool supported(WebGLRenderingContextBase*);

    virtual ExtensionName getName() const override;

};

178372

Source/WebCore/html/canvas/WebGLContextGroup.cpp

#include "WebGLContextGroup.h"

#include "GraphicsContext3D.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

#include "WebGLSharedObject.h"

namespace WebCore {

@@WebGLContextGroup::~WebGLContextGroup()

GraphicsContext3D* WebGLContextGroup::getAGraphicsContext3D()

{

    ASSERT(!m_contexts.isEmpty());

56 HashSet<WebGLRenderingContext*>::iterator it = m_contexts.begin();

56 HashSet<WebGLRenderingContextBase*>::iterator it = m_contexts.begin();

    return (*it)->graphicsContext3D();

}

60 void WebGLContextGroup::addContext(WebGLRenderingContext* context)

60void WebGLContextGroup::addContext(WebGLRenderingContextBase* context)

{

    m_contexts.add(context);

}

65 void WebGLContextGroup::removeContext(WebGLRenderingContext* context)

65void WebGLContextGroup::removeContext(WebGLRenderingContextBase* context)

{

    // We must call detachAndRemoveAllObjects before removing the last context.

    if (m_contexts.size() == 1 && m_contexts.contains(context))

@@void WebGLContextGroup::detachAndRemoveA

    }

}

92 void WebGLContextGroup::loseContextGroup(WebGLRenderingContext::LostContextMode mode)

92void WebGLContextGroup::loseContextGroup(WebGLRenderingContextBase::LostContextMode mode)

9393{

94 for (HashSet<WebGLRenderingContext*>::iterator it = m_contexts.begin(); it != m_contexts.end(); ++it)

94 for (HashSet<WebGLRenderingContextBase*>::iterator it = m_contexts.begin(); it != m_contexts.end(); ++it)

        (*it)->loseContextImpl(mode);

    detachAndRemoveAllObjects();

178372

Source/WebCore/html/canvas/WebGLContextGroup.h

#ifndef WebGLContextGroup_h

#define WebGLContextGroup_h

29 #include <WebGLRenderingContext.h>

29#include <WebGLRenderingContextBase.h>

#include <wtf/HashSet.h>

#include <wtf/PassRefPtr.h>

#include <wtf/RefCounted.h>

@@namespace WebCore {

class GraphicsContext3D;

class WebGLExtension;

class WebGLSharedObject;

39 class WebGLRenderingContext;

39class WebGLRenderingContextBase;

typedef int ExceptionCode;

@@public:

    static PassRefPtr<WebGLContextGroup> create();

    ~WebGLContextGroup();

48 void addContext(WebGLRenderingContext*);

49 void removeContext(WebGLRenderingContext*);

48 void addContext(WebGLRenderingContextBase*);

49 void removeContext(WebGLRenderingContextBase*);

    void addObject(WebGLSharedObject*);

    void removeObject(WebGLSharedObject*);

    GraphicsContext3D* getAGraphicsContext3D();

56 void loseContextGroup(WebGLRenderingContext::LostContextMode);

56 void loseContextGroup(WebGLRenderingContextBase::LostContextMode);

  private:

    friend class WebGLObject;

@@public:

    void detachAndRemoveAllObjects();

65 HashSet<WebGLRenderingContext*> m_contexts;

65 HashSet<WebGLRenderingContextBase*> m_contexts;

    HashSet<WebGLSharedObject*> m_groupObjects;

};

178372

Source/WebCore/html/canvas/WebGLContextObject.cpp

#include "WebGLContextObject.h"

32 #include "WebGLRenderingContext.h"

32#include "WebGLRenderingContextBase.h"

namespace WebCore {

36 WebGLContextObject::WebGLContextObject(WebGLRenderingContext* context)

36WebGLContextObject::WebGLContextObject(WebGLRenderingContextBase* context)

    : WebGLObject(context)

    , m_context(context)

{

178372

Source/WebCore/html/canvas/WebGLContextObject.h

namespace WebCore {

class GraphicsContext3D;

34 class WebGLRenderingContext;

34class WebGLRenderingContextBase;

// WebGLContextObject the base class for objects that are owned by a specific

// WebGLRenderingContext.

@@class WebGLContextObject : public WebGLO

public:

    virtual ~WebGLContextObject();

42 WebGLRenderingContext* context() const { return m_context; }

42 WebGLRenderingContextBase* context() const { return m_context; }

4343

44 virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContext* context) const override

44 virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContextBase* context) const override

    {

        return context == m_context;

    }

@@public:

    void detachContext();

protected:

52 WebGLContextObject(WebGLRenderingContext*);

52 WebGLContextObject(WebGLRenderingContextBase*);

    virtual bool hasGroupOrContext() const override

    {

@@protected:

    virtual GraphicsContext3D* getAGraphicsContext3D() const override;

private:

62 WebGLRenderingContext* m_context;

62 WebGLRenderingContextBase* m_context;

};

} // namespace WebCore

178372

Source/WebCore/html/canvas/WebGLDebugRendererInfo.cpp

#include "WebGLDebugRendererInfo.h"

32 #include "WebGLRenderingContext.h"

32#include "WebGLRenderingContextBase.h"

namespace WebCore {

36 WebGLDebugRendererInfo::WebGLDebugRendererInfo(WebGLRenderingContext* context)

36WebGLDebugRendererInfo::WebGLDebugRendererInfo(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

}

178372

Source/WebCore/html/canvas/WebGLDebugRendererInfo.h

@@public:

        UNMASKED_RENDERER_WEBGL = 0x9246

    };

40 explicit WebGLDebugRendererInfo(WebGLRenderingContext*);

40 explicit WebGLDebugRendererInfo(WebGLRenderingContextBase*);

    virtual ~WebGLDebugRendererInfo();

    virtual ExtensionName getName() const override;

178372

Source/WebCore/html/canvas/WebGLDebugShaders.cpp

#include "WebGLDebugShaders.h"

#include "Extensions3D.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

#include "WebGLShader.h"

namespace WebCore {

38 WebGLDebugShaders::WebGLDebugShaders(WebGLRenderingContext* context)

38WebGLDebugShaders::WebGLDebugShaders(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

}

178372

Source/WebCore/html/canvas/WebGLDebugShaders.h

@@typedef int ExceptionCode;

class WebGLDebugShaders final : public WebGLExtension {

public:

39 explicit WebGLDebugShaders(WebGLRenderingContext*);

39 explicit WebGLDebugShaders(WebGLRenderingContextBase*);

    virtual ~WebGLDebugShaders();

    virtual ExtensionName getName() const override;

178372

Source/WebCore/html/canvas/WebGLDepthTexture.cpp

namespace WebCore {

36 WebGLDepthTexture::WebGLDepthTexture(WebGLRenderingContext* context)

36WebGLDepthTexture::WebGLDepthTexture(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

}

178372

Source/WebCore/html/canvas/WebGLDepthTexture.h

@@namespace WebCore {

class WebGLDepthTexture final : public WebGLExtension {

public:

35 explicit WebGLDepthTexture(WebGLRenderingContext*);

35 explicit WebGLDepthTexture(WebGLRenderingContextBase*);

    virtual ~WebGLDepthTexture();

    static bool supported(GraphicsContext3D*);

178372

Source/WebCore/html/canvas/WebGLDrawBuffers.cpp

namespace WebCore {

35 WebGLDrawBuffers::WebGLDrawBuffers(WebGLRenderingContext* context)

35WebGLDrawBuffers::WebGLDrawBuffers(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

}

@@WebGLExtension::ExtensionName WebGLDrawB

#if (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101000)

51 bool WebGLDrawBuffers::supported(WebGLRenderingContext*)

51bool WebGLDrawBuffers::supported(WebGLRenderingContextBase*)

{

    return false;

}

#else

58 bool WebGLDrawBuffers::supported(WebGLRenderingContext* context)

58bool WebGLDrawBuffers::supported(WebGLRenderingContextBase* context)

{

    Extensions3D* extensions = context->graphicsContext3D()->getExtensions();

    return extensions->supports("GL_EXT_draw_buffers")

@@void WebGLDrawBuffers::drawBuffersWEBGL(

}

// static

102 bool WebGLDrawBuffers::satisfiesWebGLRequirements(WebGLRenderingContext* webglContext)

102bool WebGLDrawBuffers::satisfiesWebGLRequirements(WebGLRenderingContextBase* webglContext)

{

    GraphicsContext3D* context = webglContext->graphicsContext3D();

178372

Source/WebCore/html/canvas/WebGLDrawBuffers.h

@@namespace WebCore {

class WebGLDrawBuffers final : public WebGLExtension {

public:

35 explicit WebGLDrawBuffers(WebGLRenderingContext*);

35 explicit WebGLDrawBuffers(WebGLRenderingContextBase*);

3636 virtual ~WebGLDrawBuffers();

3737

38 static bool supported(WebGLRenderingContext*);

38 static bool supported(WebGLRenderingContextBase*);

    virtual ExtensionName getName() const override;

    void drawBuffersWEBGL(const Vector<GC3Denum>& buffers);

private:

45 static bool satisfiesWebGLRequirements(WebGLRenderingContext*);

45 static bool satisfiesWebGLRequirements(WebGLRenderingContextBase*);

};

} // namespace WebCore

178372

Source/WebCore/html/canvas/WebGLExtension.cpp

namespace WebCore {

34 WebGLExtension::WebGLExtension(WebGLRenderingContext* context)

34WebGLExtension::WebGLExtension(WebGLRenderingContextBase* context)

    : m_context(context)

{

}

178372

Source/WebCore/html/canvas/WebGLExtension.h

#ifndef WebGLExtension_h

#define WebGLExtension_h

29 #include "WebGLRenderingContext.h"

29#include "WebGLRenderingContextBase.h"

namespace WebCore {

@@public:

    void ref() { m_context->ref(); }

    void deref() { m_context->deref(); }

63 WebGLRenderingContext* context() { return m_context; }

63 WebGLRenderingContextBase* context() { return m_context; }

    virtual ~WebGLExtension();

    virtual ExtensionName getName() const = 0;

protected:

69 WebGLExtension(WebGLRenderingContext*);

70 WebGLRenderingContext* m_context;

69 WebGLExtension(WebGLRenderingContextBase*);

70 WebGLRenderingContextBase* m_context;

};

} // namespace WebCore

178372

Source/WebCore/html/canvas/WebGLFramebuffer.cpp

#include "Extensions3D.h"

#include "WebGLContextGroup.h"

#include "WebGLDrawBuffers.h"

35 #include "WebGLRenderingContext.h"

35#include "WebGLRenderingContextBase.h"

namespace WebCore {

@@WebGLFramebuffer::WebGLAttachment::~WebG

{

}

272 PassRefPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContext* ctx)

272PassRefPtr<WebGLFramebuffer> WebGLFramebuffer::create(WebGLRenderingContextBase* ctx)

{

    return adoptRef(new WebGLFramebuffer(ctx));

}

277 WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContext* ctx)

277WebGLFramebuffer::WebGLFramebuffer(WebGLRenderingContextBase* ctx)

    : WebGLContextObject(ctx)

    , m_hasEverBeenBound(false)

{

178372

Source/WebCore/html/canvas/WebGLFramebuffer.h

@@public:

    virtual ~WebGLFramebuffer();

64 static PassRefPtr<WebGLFramebuffer> create(WebGLRenderingContext*);

64 static PassRefPtr<WebGLFramebuffer> create(WebGLRenderingContextBase*);

    void setAttachmentForBoundFramebuffer(GC3Denum attachment, GC3Denum texTarget, WebGLTexture*, GC3Dint level);

    void setAttachmentForBoundFramebuffer(GC3Denum attachment, WebGLRenderbuffer*);

@@public:

    GC3Denum getDrawBuffer(GC3Denum);

protected:

104 WebGLFramebuffer(WebGLRenderingContext*);

104 WebGLFramebuffer(WebGLRenderingContextBase*);

    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;

178372

Source/WebCore/html/canvas/WebGLLoseContext.cpp

#include "WebGLLoseContext.h"

32 #include "WebGLRenderingContext.h"

32#include "WebGLRenderingContextBase.h"

namespace WebCore {

36 WebGLLoseContext::WebGLLoseContext(WebGLRenderingContext* context)

36WebGLLoseContext::WebGLLoseContext(WebGLRenderingContextBase* context)

    : WebGLExtension(context)

{

}

@@WebGLExtension::ExtensionName WebGLLoseC

void WebGLLoseContext::loseContext()

{

52 m_context->forceLostContext(WebGLRenderingContext::SyntheticLostContext);

52 m_context->forceLostContext(WebGLRenderingContextBase::SyntheticLostContext);

}

void WebGLLoseContext::restoreContext()

178372

Source/WebCore/html/canvas/WebGLLoseContext.h

namespace WebCore {

33 class WebGLRenderingContext;

33class WebGLRenderingContextBase;

class WebGLLoseContext final : public WebGLExtension {

public:

37 explicit WebGLLoseContext(WebGLRenderingContext*);

37 explicit WebGLLoseContext(WebGLRenderingContextBase*);

    virtual ~WebGLLoseContext();

    virtual ExtensionName getName() const override;

178372

Source/WebCore/html/canvas/WebGLObject.cpp

#include "WebGLDebugRendererInfo.h"

#include "WebGLDebugShaders.h"

#include "WebGLLoseContext.h"

37 #include "WebGLRenderingContext.h"

37#include "WebGLRenderingContextBase.h"

namespace WebCore {

41 WebGLObject::WebGLObject(WebGLRenderingContext*)

41WebGLObject::WebGLObject(WebGLRenderingContextBase*)

    : m_object(0)

    , m_attachmentCount(0)

    , m_deleted(false)

178372

Source/WebCore/html/canvas/WebGLObject.h

@@namespace WebCore {

class GraphicsContext3D;

class WebGLContextGroup;

37 class WebGLRenderingContext;

37class WebGLRenderingContextBase;

class WebGLObject : public RefCounted<WebGLObject> {

public:

@@public:

    bool isDeleted() { return m_deleted; }

    // True if this object belongs to the group or context.

59 virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContext*) const = 0;

59 virtual bool validate(const WebGLContextGroup*, const WebGLRenderingContextBase*) const = 0;

6060

6161protected:

62 WebGLObject(WebGLRenderingContext*);

62 WebGLObject(WebGLRenderingContextBase*);

    // setObject should be only called once right after creating a WebGLObject.

    void setObject(Platform3DObject);

178372

Source/WebCore/html/canvas/WebGLProgram.cpp

#include "WebGLProgram.h"

#include "WebGLContextGroup.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

namespace WebCore {

37 PassRefPtr<WebGLProgram> WebGLProgram::create(WebGLRenderingContext* ctx)

37PassRefPtr<WebGLProgram> WebGLProgram::create(WebGLRenderingContextBase* ctx)

{

    return adoptRef(new WebGLProgram(ctx));

}

42 WebGLProgram::WebGLProgram(WebGLRenderingContext* ctx)

42WebGLProgram::WebGLProgram(WebGLRenderingContextBase* ctx)

    : WebGLSharedObject(ctx)

    , m_linkStatus(false)

    , m_linkCount(0)

178372

Source/WebCore/html/canvas/WebGLProgram.h

@@class WebGLProgram final : public WebGLS

public:

    virtual ~WebGLProgram();

42 static PassRefPtr<WebGLProgram> create(WebGLRenderingContext*);

42 static PassRefPtr<WebGLProgram> create(WebGLRenderingContextBase*);

    unsigned numActiveAttribLocations();

    GC3Dint getActiveAttribLocation(GC3Duint index);

@@public:

    bool detachShader(WebGLShader*);

protected:

65 WebGLProgram(WebGLRenderingContext*);

65 WebGLProgram(WebGLRenderingContextBase*);

    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;

178372

Source/WebCore/html/canvas/WebGLRenderbuffer.cpp

#include "WebGLRenderbuffer.h"

#include "WebGLContextGroup.h"

33 #include "WebGLRenderingContext.h"

33#include "WebGLRenderingContextBase.h"

namespace WebCore {

37 PassRefPtr<WebGLRenderbuffer> WebGLRenderbuffer::create(WebGLRenderingContext* ctx)

37PassRefPtr<WebGLRenderbuffer> WebGLRenderbuffer::create(WebGLRenderingContextBase* ctx)

{

    return adoptRef(new WebGLRenderbuffer(ctx));

}

@@WebGLRenderbuffer::~WebGLRenderbuffer()

    deleteObject(0);

}

47 WebGLRenderbuffer::WebGLRenderbuffer(WebGLRenderingContext* ctx)

47WebGLRenderbuffer::WebGLRenderbuffer(WebGLRenderingContextBase* ctx)

    : WebGLSharedObject(ctx)

    , m_internalFormat(GraphicsContext3D::RGBA4)

    , m_initialized(false)

178372

Source/WebCore/html/canvas/WebGLRenderbuffer.h

@@class WebGLRenderbuffer final : public W

public:

    virtual ~WebGLRenderbuffer();

40 static PassRefPtr<WebGLRenderbuffer> create(WebGLRenderingContext*);

40 static PassRefPtr<WebGLRenderbuffer> create(WebGLRenderingContextBase*);

    void setInternalFormat(GC3Denum internalformat)

    {

@@public:

    void setHasEverBeenBound() { m_hasEverBeenBound = true; }

protected:

68 WebGLRenderbuffer(WebGLRenderingContext*);

68 WebGLRenderbuffer(WebGLRenderingContextBase*);

    virtual void deleteObjectImpl(GraphicsContext3D*, Platform3DObject) override;

178372

Source/WebCore/html/canvas/WebGLRenderingContext.cpp

/*

 * Copyright (C) 2009, 2013, 2014 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#if ENABLE(WEBGL)

#include "WebGLRenderingContext.h"

#include "ANGLEInstancedArrays.h"

#include "CachedImage.h"

#include "DOMWindow.h"

#include "Document.h"

#include "EXTBlendMinMax.h"

#include "EXTFragDepth.h"

#include "EXTShaderTextureLOD.h"

#include "EXTTextureFilterAnisotropic.h"

#include "EXTsRGB.h"

#include "ExceptionCode.h"

#include "Extensions3D.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "HTMLVideoElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "IntSize.h"

#include "Logging.h"

#include "MainFrame.h"

#include "NotImplemented.h"

#include "OESElementIndexUint.h"

#include "OESStandardDerivatives.h"

#include "OESTextureFloat.h"

#include "OESTextureFloatLinear.h"

#include "OESTextureHalfFloat.h"

#include "OESTextureHalfFloatLinear.h"

#include "OESVertexArrayObject.h"

#include "Page.h"

#include "RenderBox.h"

#include "Settings.h"

#include "WebGLActiveInfo.h"

#include "WebGLBuffer.h"

#include "WebGLCompressedTextureATC.h"

#include "WebGLCompressedTexturePVRTC.h"

#include "WebGLCompressedTextureS3TC.h"

#include "WebGLContextAttributes.h"

#include "WebGLContextEvent.h"

#include "WebGLContextGroup.h"

#include "WebGLDebugRendererInfo.h"

#include "WebGLDebugShaders.h"

#include "WebGLDepthTexture.h"

#include "WebGLDrawBuffers.h"

#include "WebGLFramebuffer.h"

#include "WebGLLoseContext.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLShader.h"

#include "WebGLShaderPrecisionFormat.h"

#include "WebGLTexture.h"

#include "WebGLUniformLocation.h"

#include <runtime/JSCInlines.h>

#include <runtime/TypedArrayInlines.h>

#include <runtime/Uint32Array.h>

#include <wtf/StdLibExtras.h>

#include <wtf/text/CString.h>

#include <wtf/text/StringBuilder.h>

namespace WebCore {

const double secondsBetweenRestoreAttempts = 1.0;

const int maxGLErrorsAllowedToConsole = 256;

namespace {

    class ScopedDrawingBufferBinder {

    public:

        ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)

            : m_drawingBuffer(drawingBuffer)

            , m_framebufferBinding(framebufferBinding)

        {

            // Commit DrawingBuffer if needed (e.g., for multisampling)

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->commit();

        }

        ~ScopedDrawingBufferBinder()

        {

            // Restore DrawingBuffer if needed

            if (!m_framebufferBinding && m_drawingBuffer)

                m_drawingBuffer->bind();

        }

    private:

        DrawingBuffer* m_drawingBuffer;

        WebGLFramebuffer* m_framebufferBinding;

    };

    Platform3DObject objectOrZero(WebGLObject* object)

    {

        return object ? object->object() : 0;

    }

    void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)

    {

        ASSERT(clippedStart && clippedRange);

        if (start < 0) {

            range += start;

            start = 0;

        }

        GC3Dint end = start + range;

        if (end > sourceRange)

            range -= end - sourceRange;

        *clippedStart = start;

        *clippedRange = range;

    }

    // Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.

    bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,

                GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,

                GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)

    {

        ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);

        clip1D(x, width, sourceWidth, clippedX, clippedWidth);

        clip1D(y, height, sourceHeight, clippedY, clippedHeight);

        return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);

    }

    GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)

    {

        if (value < min)

            value = min;

        if (value > max)

            value = max;

        return value;

    }

    // Return true if a character belongs to the ASCII subset as defined in

    // GLSL ES 1.0 spec section 3.1.

    bool validateCharacter(unsigned char c)

    {

        // Printing characters are valid except " $ ` @ \ ' DEL.

        if (c >= 32 && c <= 126

            && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')

            return true;

        // Horizontal tab, line feed, vertical tab, form feed, carriage return

        // are also valid.

        if (c >= 9 && c <= 13)

            return true;

        return false;

    }

    bool isPrefixReserved(const String& name)

    {

        if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))

            return true;

        return false;

    }

    // Strips comments from shader text. This allows non-ASCII characters

    // to be used in comments without potentially breaking OpenGL

    // implementations not expecting characters outside the GLSL ES set.

    class StripComments {

    public:

        StripComments(const String& str)

            : m_parseState(BeginningOfLine)

            , m_sourceString(str)

            , m_length(str.length())

            , m_position(0)

        {

            parse();

        }

        String result()

        {

            return m_builder.toString();

        }

    private:

        bool hasMoreCharacters() const

        {

            return (m_position < m_length);

        }

        void parse()

        {

            while (hasMoreCharacters()) {

                process(current());

                // process() might advance the position.

                if (hasMoreCharacters())

                    advance();

            }

        }

        void process(UChar);

        bool peek(UChar& character) const

        {

            if (m_position + 1 >= m_length)

                return false;

            character = m_sourceString[m_position + 1];

            return true;

        }

        UChar current() const

        {

            ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);

            return m_sourceString[m_position];

        }

        void advance()

        {

            ++m_position;

        }

        bool isNewline(UChar character) const

        {

            // Don't attempt to canonicalize newline related characters.

            return (character == '\n' || character == '\r');

        }

        void emit(UChar character)

        {

            m_builder.append(character);

        }

        enum ParseState {

            // Have not seen an ASCII non-whitespace character yet on

            // this line. Possible that we might see a preprocessor

            // directive.

            BeginningOfLine,

            // Have seen at least one ASCII non-whitespace character

            // on this line.

            MiddleOfLine,

            // Handling a preprocessor directive. Passes through all

            // characters up to the end of the line. Disables comment

            // processing.

            InPreprocessorDirective,

            // Handling a single-line comment. The comment text is

            // replaced with a single space.

            InSingleLineComment,

            // Handling a multi-line comment. Newlines are passed

            // through to preserve line numbers.

            InMultiLineComment

        };

        ParseState m_parseState;

        String m_sourceString;

        unsigned m_length;

        unsigned m_position;

        StringBuilder m_builder;

    };

    void StripComments::process(UChar c)

    {

        if (isNewline(c)) {

            // No matter what state we are in, pass through newlines

            // so we preserve line numbers.

            emit(c);

            if (m_parseState != InMultiLineComment)

                m_parseState = BeginningOfLine;

            return;

        }

        UChar temp = 0;

        switch (m_parseState) {

        case BeginningOfLine:

            if (WTF::isASCIISpace(c)) {

                emit(c);

                break;

            }

            if (c == '#') {

                m_parseState = InPreprocessorDirective;

                emit(c);

                break;

            }

            // Transition to normal state and re-handle character.

            m_parseState = MiddleOfLine;

            process(c);

            break;

        case MiddleOfLine:

            if (c == '/' && peek(temp)) {

                if (temp == '/') {

                    m_parseState = InSingleLineComment;

                    emit(' ');

                    advance();

                    break;

                }

                if (temp == '*') {

                    m_parseState = InMultiLineComment;

                    // Emit the comment start in case the user has

                    // an unclosed comment and we want to later

                    // signal an error.

                    emit('/');

                    emit('*');

                    advance();

                    break;

                }

            }

            emit(c);

            break;

        case InPreprocessorDirective:

            // No matter what the character is, just pass it

            // through. Do not parse comments in this state. This

            // might not be the right thing to do long term, but it

            // should handle the #error preprocessor directive.

            emit(c);

            break;

        case InSingleLineComment:

            // The newline code at the top of this function takes care

            // of resetting our state when we get out of the

            // single-line comment. Swallow all other characters.

            break;

        case InMultiLineComment:

            if (c == '*' && peek(temp) && temp == '/') {

                emit('*');

                emit('/');

                m_parseState = MiddleOfLine;

                advance();

                break;

            }

            // Swallow all other characters. Unclear whether we may

            // want or need to just emit a space per character to try

            // to preserve column numbers for debugging purposes.

            break;

        }

    }

} // namespace anonymous

class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextLostCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onContextLost() override { m_context->forceLostContext(WebGLRenderingContext::RealLostContext); }

    virtual ~WebGLRenderingContextLostCallback() {}

private:

    WebGLRenderingContext* m_context;

};

class WebGLRenderingContextErrorMessageCallback : public GraphicsContext3D::ErrorMessageCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContext* cb) : m_context(cb) { }

    virtual void onErrorMessage(const String& message, GC3Dint) override

    {

        if (m_context->m_synthesizedErrorsToConsole)

            m_context->printGLErrorToConsole(message);

    }

    virtual ~WebGLRenderingContextErrorMessageCallback() { }

private:

    WebGLRenderingContext* m_context;

};

std::unique_ptr<WebGLRenderingContext> WebGLRenderingContext::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs)

{

    Document& document = canvas->document();

    Frame* frame = document.frame();

    if (!frame)

        return nullptr;

    // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in

    // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));

        return nullptr;

    }

    bool isPendingPolicyResolution = false;

    Document& topDocument = document.topDocument();

    Page* page = topDocument.page();

    if (page && !topDocument.url().isLocalFile()) {

        WebGLLoadPolicy policy = page->mainFrame().loader().client().webGLPolicyForURL(topDocument.url());

        if (policy == WebGLBlockCreation) {

            LOG(WebGL, "The policy for this URL (%s) is to block WebGL.", topDocument.url().host().utf8().data());

            return nullptr;

        }

        if (policy == WebGLPendingCreation) {

            LOG(WebGL, "WebGL policy is pending. May need to be resolved later.");

            isPendingPolicyResolution = true;

        }

    }

    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();

    if (attributes.antialias) {

        if (!frame->settings().openGLMultisamplingEnabled())

            attributes.antialias = false;

    }

    attributes.noExtensions = true;

    attributes.shareResources = false;

    attributes.preferDiscreteGPU = true;

    if (frame->settings().forceSoftwareWebGLRendering())

        attributes.forceSoftwareRenderer = true;

    if (page)

        attributes.devicePixelRatio = page->deviceScaleFactor();

    if (isPendingPolicyResolution) {

        LOG(WebGL, "Create a WebGL context that looks real, but will require a policy resolution if used.");

        std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, attributes));

        renderingContext->suspendIfNeeded();

        return renderingContext;

    }

    HostWindow* hostWindow = document.view()->root()->hostWindow();

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));

    if (!context || !context->makeContextCurrent()) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));

        return nullptr;

    }

    Extensions3D* extensions = context->getExtensions();

    if (extensions->supports("GL_EXT_debug_marker"))

        extensions->pushGroupMarkerEXT("WebGLRenderingContext");

    std::unique_ptr<WebGLRenderingContext> renderingContext(new WebGLRenderingContext(canvas, context, attributes));

    renderingContext->suspendIfNeeded();

    return renderingContext;

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(0)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(0)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(true)

    , m_hasRequestedPolicyResolution(false)

{

}

WebGLRenderingContext::WebGLRenderingContext(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,

    GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(context)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContext::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContext::maybeRestoreContext)

    , m_generatedImageCache(4)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(false)

    , m_hasRequestedPolicyResolution(false)

{

    ASSERT(m_context);

    m_contextGroup = WebGLContextGroup::create();

    m_contextGroup->addContext(this);

    m_maxViewportDims[0] = m_maxViewportDims[1] = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);

    if (m_drawingBuffer)

        m_drawingBuffer->bind();

    setupFlags();

    initializeNewContext();

}

void WebGLRenderingContext::initializeNewContext()

{

    ASSERT(!m_contextLost);

    m_needsUpdate = true;

    m_markedCanvasDirty = false;

    m_activeTextureUnit = 0;

    m_packAlignment = 4;

    m_unpackAlignment = 4;

    m_unpackFlipY = false;

    m_unpackPremultiplyAlpha = false;

    m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;

    m_boundArrayBuffer = 0;

    m_currentProgram = 0;

    m_framebufferBinding = 0;

    m_renderbufferBinding = 0;

    m_depthMask = true;

    m_stencilEnabled = false;

    m_stencilMask = 0xFFFFFFFF;

    m_stencilMaskBack = 0xFFFFFFFF;

    m_stencilFuncRef = 0;

    m_stencilFuncRefBack = 0;

    m_stencilFuncMask = 0xFFFFFFFF;

    m_stencilFuncMaskBack = 0xFFFFFFFF;

    m_layerCleared = false;

    m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;

    m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;

    m_scissorEnabled = false;

    m_clearDepth = 1;

    m_clearStencil = 0;

    m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;

    GC3Dint numCombinedTextureImageUnits = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

    m_textureUnits.clear();

    m_textureUnits.resize(numCombinedTextureImageUnits);

    GC3Dint numVertexAttribs = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

    m_maxVertexAttribs = numVertexAttribs;

    m_maxTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

    m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

    m_maxCubeMapTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

    m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

    m_maxRenderbufferSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);

    // These two values from EXT_draw_buffers are lazily queried.

    m_maxDrawBuffers = 0;

    m_maxColorAttachments = 0;

    m_backDrawBuffer = GraphicsContext3D::BACK;

    m_drawBuffersWebGLRequirementsChecked = false;

    m_drawBuffersSupported = false;

    m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);

    addContextObject(m_defaultVertexArrayObject.get());

    m_boundVertexArrayObject = m_defaultVertexArrayObject;

    m_vertexAttribValue.resize(m_maxVertexAttribs);

    if (!isGLES2NPOTStrict())

        createFallbackBlackTextures1x1();

    if (!isGLES2Compliant())

        initVertexAttrib0();

    IntSize canvasSize = clampedCanvasSize();

    if (m_drawingBuffer)

        m_drawingBuffer->reset(canvasSize);

    m_context->reshape(canvasSize.width(), canvasSize.height());

    m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());

    m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());

    m_context->setContextLostCallback(std::make_unique<WebGLRenderingContextLostCallback>(this));

    m_context->setErrorMessageCallback(std::make_unique<WebGLRenderingContextErrorMessageCallback>(this));

}

void WebGLRenderingContext::setupFlags()

{

    ASSERT(m_context);

    if (Page* page = canvas()->document().page())

        m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();

    m_isGLES2Compliant = m_context->isGLES2Compliant();

    m_isErrorGeneratedOnOutOfBoundsAccesses = m_context->getExtensions()->isEnabled("GL_CHROMIUM_strict_attribs");

    m_isResourceSafe = m_context->getExtensions()->isEnabled("GL_CHROMIUM_resource_safe");

    if (m_isGLES2Compliant) {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");

    } else {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_ARB_texture_non_power_of_two");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_EXT_packed_depth_stencil");

    }

    m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");

}

bool WebGLRenderingContext::allowPrivilegedExtensions() const

{

    if (Page* page = canvas()->document().page())

        return page->settings().privilegedWebGLExtensionsEnabled();

    return false;

}

void WebGLRenderingContext::addCompressedTextureFormat(GC3Denum format)

{

    if (!m_compressedTextureFormats.contains(format))

        m_compressedTextureFormats.append(format);

}

WebGLRenderingContext::~WebGLRenderingContext()

{

    // Remove all references to WebGLObjects so if they are the last reference

    // they will be freed before the last context is removed from the context group.

    m_boundArrayBuffer = nullptr;

    m_defaultVertexArrayObject = nullptr;

    m_boundVertexArrayObject = nullptr;

    m_vertexAttrib0Buffer = nullptr;

    m_currentProgram = nullptr;

    m_framebufferBinding = nullptr;

    m_renderbufferBinding = nullptr;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        m_textureUnits[i].texture2DBinding = nullptr;

        m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    m_blackTexture2D = nullptr;

    m_blackTextureCubeMap = nullptr;

    if (!m_isPendingPolicyResolution) {

        detachAndRemoveAllObjects();

        destroyGraphicsContext3D();

        m_contextGroup->removeContext(this);

    }

}

void WebGLRenderingContext::destroyGraphicsContext3D()

{

    if (m_isPendingPolicyResolution)

        return;

    // The drawing buffer holds a context reference. It must also be destroyed

    // in order for the context to be released.

    if (m_drawingBuffer)

        m_drawingBuffer.clear();

    if (m_context) {

        m_context->setContextLostCallback(nullptr);

        m_context->setErrorMessageCallback(nullptr);

        m_context.clear();

    }

}

void WebGLRenderingContext::markContextChanged()

{

    if (m_framebufferBinding)

        return;

    m_context->markContextChanged();

    if (m_drawingBuffer)

        m_drawingBuffer->markContentsChanged();

    m_layerCleared = false;

    RenderBox* renderBox = canvas()->renderBox();

    if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {

        m_markedCanvasDirty = true;

        canvas()->clearCopiedImage();

        renderBox->contentChanged(CanvasChanged);

    } else {

        if (!m_markedCanvasDirty) {

            m_markedCanvasDirty = true;

            canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));

        }

    }

}

bool WebGLRenderingContext::clearIfComposited(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return false;

    if (!m_context->layerComposited() || m_layerCleared

        || m_attributes.preserveDrawingBuffer || (mask && m_framebufferBinding))

        return false;

    RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();

    // Determine if it's possible to combine the clear the user asked for and this clear.

    bool combinedClear = mask && !m_scissorEnabled;

    m_context->disable(GraphicsContext3D::SCISSOR_TEST);

    if (combinedClear && (mask & GraphicsContext3D::COLOR_BUFFER_BIT))

        m_context->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,

                              m_colorMask[1] ? m_clearColor[1] : 0,

                              m_colorMask[2] ? m_clearColor[2] : 0,

                              m_colorMask[3] ? m_clearColor[3] : 0);

    else

        m_context->clearColor(0, 0, 0, 0);

    m_context->colorMask(true, true, true, true);

    GC3Dbitfield clearMask = GraphicsContext3D::COLOR_BUFFER_BIT;

    if (contextAttributes->depth()) {

        if (!combinedClear || !m_depthMask || !(mask & GraphicsContext3D::DEPTH_BUFFER_BIT))

            m_context->clearDepth(1.0f);

        clearMask |= GraphicsContext3D::DEPTH_BUFFER_BIT;

        m_context->depthMask(true);

    }

    if (contextAttributes->stencil()) {

        if (combinedClear && (mask & GraphicsContext3D::STENCIL_BUFFER_BIT))

            m_context->clearStencil(m_clearStencil & m_stencilMask);

        else

            m_context->clearStencil(0);

        clearMask |= GraphicsContext3D::STENCIL_BUFFER_BIT;

        m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, 0xFFFFFFFF);

    }

    if (m_drawingBuffer)

        m_drawingBuffer->clearFramebuffers(clearMask);

    else {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

        m_context->clear(clearMask);

    }

    restoreStateAfterClear();

    if (m_framebufferBinding)

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

    m_layerCleared = true;

    return combinedClear;

}

void WebGLRenderingContext::restoreStateAfterClear()

{

    // Restore the state that the context set.

    if (m_scissorEnabled)

        m_context->enable(GraphicsContext3D::SCISSOR_TEST);

    m_context->clearColor(m_clearColor[0], m_clearColor[1],

                          m_clearColor[2], m_clearColor[3]);

    m_context->colorMask(m_colorMask[0], m_colorMask[1],

                         m_colorMask[2], m_colorMask[3]);

    m_context->clearDepth(m_clearDepth);

    m_context->clearStencil(m_clearStencil);

    m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, m_stencilMask);

    m_context->depthMask(m_depthMask);

}

void WebGLRenderingContext::markLayerComposited()

{

    if (isContextLostOrPending())

        return;

    m_context->markLayerComposited();

}

void WebGLRenderingContext::paintRenderingResultsToCanvas()

{

    if (isContextLostOrPending())

        return;

    if (canvas()->document().printing())

        canvas()->clearPresentationCopy();

    // Until the canvas is written to by the application, the clear that

    // happened after it was composited should be ignored by the compositor.

    if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {

        m_context->paintCompositedResultsToCanvas(canvas()->buffer());

        canvas()->makePresentationCopy();

    } else

        canvas()->clearPresentationCopy();

    clearIfComposited();

    if (!m_markedCanvasDirty && !m_layerCleared)

        return;

    canvas()->clearCopiedImage();

    m_markedCanvasDirty = false;

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    m_context->paintRenderingResultsToCanvas(canvas()->buffer(), m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

}

PassRefPtr<ImageData> WebGLRenderingContext::paintRenderingResultsToImageData()

{

    if (isContextLostOrPending())

        return nullptr;

    clearIfComposited();

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    RefPtr<ImageData> imageData = m_context->paintRenderingResultsToImageData(m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

    return imageData;

}

void WebGLRenderingContext::reshape(int width, int height)

{

    if (isContextLostOrPending())

        return;

    // This is an approximation because at WebGLRenderingContext level we don't

    // know if the underlying FBO uses textures or renderbuffers.

    GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);

    // Limit drawing buffer size to 4k to avoid memory exhaustion.

    const int sizeUpperLimit = 4096;

    maxSize = std::min(maxSize, sizeUpperLimit);

    GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);

    GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);

    width = clamp(width, 1, maxWidth);

    height = clamp(height, 1, maxHeight);

    if (m_needsUpdate) {

        RenderBox* renderBox = canvas()->renderBox();

        if (renderBox && renderBox->hasAcceleratedCompositing())

            renderBox->contentChanged(CanvasChanged);

        m_needsUpdate = false;

    }

    // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off

    // clear (and this matches what reshape will do).

    if (m_drawingBuffer) {

        m_drawingBuffer->reset(IntSize(width, height));

        restoreStateAfterClear();

    } else

        m_context->reshape(width, height);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].texture2DBinding.get()));

    m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));

    if (m_framebufferBinding)

      m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

}

int WebGLRenderingContext::drawingBufferWidth() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().width();

    return m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::drawingBufferHeight() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().height();

    return m_context->getInternalFramebufferSize().height();

}

unsigned int WebGLRenderingContext::sizeInBytes(GC3Denum type)

{

    switch (type) {

    case GraphicsContext3D::BYTE:

        return sizeof(GC3Dbyte);

    case GraphicsContext3D::UNSIGNED_BYTE:

        return sizeof(GC3Dubyte);

    case GraphicsContext3D::SHORT:

        return sizeof(GC3Dshort);

    case GraphicsContext3D::UNSIGNED_SHORT:

        return sizeof(GC3Dushort);

    case GraphicsContext3D::INT:

        return sizeof(GC3Dint);

    case GraphicsContext3D::UNSIGNED_INT:

        return sizeof(GC3Duint);

    case GraphicsContext3D::FLOAT:

        return sizeof(GC3Dfloat);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

void WebGLRenderingContext::activeTexture(GC3Denum texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "activeTexture", "texture unit out of range");

        return;

    }

    m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

    m_context->activeTexture(texture);

    if (m_drawingBuffer)

        m_drawingBuffer->setActiveTextureUnit(texture);

}

void WebGLRenderingContext::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))

        return;

    if (!program->attachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "attachShader", "shader attachment already has shader");

        return;

    }

    m_context->attachShader(objectOrZero(program), objectOrZero(shader));

    shader->onAttached();

}

void WebGLRenderingContext::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))

        return;

    if (!validateLocationLength("bindAttribLocation", name))

        return;

    if (!validateString("bindAttribLocation", name))

        return;

    if (isPrefixReserved(name)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindAttribLocation", "reserved prefix");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bindAttribLocation", "index out of range");

        return;

    }

    m_context->bindAttribLocation(objectOrZero(program), index, name);

}

bool WebGLRenderingContext::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)

{

    deleted = false;

    if (isContextLostOrPending())

        return false;

    if (object) {

        if (!object->validate(contextGroup(), this)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object not from this context");

            return false;

        }

        deleted = !object->object();

    }

    return true;

}

void WebGLRenderingContext::bindBuffer(GC3Denum target, WebGLBuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindBuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindBuffer", "buffers can not be used with multiple targets");

        return;

    }

    if (target == GraphicsContext3D::ARRAY_BUFFER)

        m_boundArrayBuffer = buffer;

    else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

        m_boundVertexArrayObject->setElementArrayBuffer(buffer);

    else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");

        return;

    }

    m_context->bindBuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setTarget(target);

}

void WebGLRenderingContext::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindFramebuffer", "invalid target");

        return;

    }

    m_framebufferBinding = buffer;

    if (m_drawingBuffer)

        m_drawingBuffer->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));

    if (!m_framebufferBinding && m_drawingBuffer) {

        // Instead of binding fb 0, bind the drawing buffer.

        m_drawingBuffer->bind();

    } else

        m_context->bindFramebuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setHasEverBeenBound();

    applyStencilTest();

}

void WebGLRenderingContext::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))

        return;

    if (deleted)

        renderBuffer = 0;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindRenderbuffer", "invalid target");

        return;

    }

    m_renderbufferBinding = renderBuffer;

    m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));

    if (renderBuffer)

        renderBuffer->setHasEverBeenBound();

}

void WebGLRenderingContext::bindTexture(GC3Denum target, WebGLTexture* texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindTexture", texture, deleted))

        return;

    if (deleted)

        texture = 0;

    if (texture && texture->getTarget() && texture->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");

        return;

    }

    GC3Dint maxLevel = 0;

    if (target == GraphicsContext3D::TEXTURE_2D) {

        m_textureUnits[m_activeTextureUnit].texture2DBinding = texture;

        maxLevel = m_maxTextureLevel;

        if (m_drawingBuffer && !m_activeTextureUnit)

            m_drawingBuffer->setTexture2DBinding(objectOrZero(texture));

    } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

        m_textureUnits[m_activeTextureUnit].textureCubeMapBinding = texture;

        maxLevel = m_maxCubeMapTextureLevel;

    } else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindTexture", "invalid target");

        return;

    }

    m_context->bindTexture(target, objectOrZero(texture));

    if (texture)

        texture->setTarget(target, maxLevel);

    // Note: previously we used to automatically set the TEXTURE_WRAP_R

    // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL

    // ES 2.0 doesn't expose this flag (a bug in the specification) and

    // otherwise the application has no control over the seams in this

    // dimension. However, it appears that supporting this properly on all

    // platforms is fairly involved (will require a HashMap from texture ID

    // in all ports), and we have not had any complaints, so the logic has

    // been removed.

}

void WebGLRenderingContext::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)

{

    if (isContextLostOrPending())

        return;

    m_context->blendColor(red, green, blue, alpha);

}

void WebGLRenderingContext::blendEquation(GC3Denum mode)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))

        return;

    m_context->blendEquation(mode);

}

void WebGLRenderingContext::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))

        return;

    m_context->blendEquationSeparate(modeRGB, modeAlpha);

}

void WebGLRenderingContext::blendFunc(GC3Denum sfactor, GC3Denum dfactor)

{

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))

        return;

    m_context->blendFunc(sfactor, dfactor);

}

void WebGLRenderingContext::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)

{

    // Note: Alpha does not have the same restrictions as RGB.

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))

        return;

    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

}

void WebGLRenderingContext::bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (size < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size < 0");

        return;

    }

    if (!size) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size == 0");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->data(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContext::bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

GC3Denum WebGLRenderingContext::checkFramebufferStatus(GC3Denum target)

{

    if (isContextLostOrPending())

        return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "checkFramebufferStatus", "invalid target");

        return 0;

    }

    if (!m_framebufferBinding || !m_framebufferBinding->object())

        return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

    const char* reason = "framebuffer incomplete";

    GC3Denum result = m_framebufferBinding->checkStatus(&reason);

    if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {

        printGLWarningToConsole("checkFramebufferStatus", reason);

        return result;

    }

    result = m_context->checkFramebufferStatus(target);

    return result;

}

void WebGLRenderingContext::clear(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return;

    if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clear", "invalid mask");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);

        return;

    }

    if (!clearIfComposited(mask))

        m_context->clear(mask);

    markContextChanged();

}

void WebGLRenderingContext::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)

{

    if (isContextLostOrPending())

        return;

    if (std::isnan(r))

        r = 0;

    if (std::isnan(g))

        g = 0;

    if (std::isnan(b))

        b = 0;

    if (std::isnan(a))

        a = 1;

    m_clearColor[0] = r;

    m_clearColor[1] = g;

    m_clearColor[2] = b;

    m_clearColor[3] = a;

    m_context->clearColor(r, g, b, a);

}

void WebGLRenderingContext::clearDepth(GC3Dfloat depth)

{

    if (isContextLostOrPending())

        return;

    m_clearDepth = depth;

    m_context->clearDepth(depth);

}

void WebGLRenderingContext::clearStencil(GC3Dint s)

{

    if (isContextLostOrPending())

        return;

    m_clearStencil = s;

    m_context->clearStencil(s);

}

void WebGLRenderingContext::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)

{

    if (isContextLostOrPending())

        return;

    m_colorMask[0] = red;

    m_colorMask[1] = green;

    m_colorMask[2] = blue;

    m_colorMask[3] = alpha;

    m_context->colorMask(red, green, blue, alpha);

}

void WebGLRenderingContext::compileShader(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))

        return;

    m_context->compileShader(objectOrZero(shader));

    GC3Dint value;

    m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);

    shader->setValid(value);

}

void WebGLRenderingContext::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                                                 GC3Dsizei height, GC3Dint border, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(internalformat)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");

        return;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "border not 0");

        return;

    }

    if (!validateCompressedTexDimensions("compressedTexImage2D", target, level, width, height, internalformat))

        return;

    if (!validateCompressedTexFuncData("compressedTexImage2D", width, height, internalformat, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);

    if (!tex)

        return;

    if (!isGLES2NPOTStrict()) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->compressedTexImage2D(target, level, internalformat, width, height,

        border, data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The compressedTexImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

        tex->markInvalid(target, level);

        return;

    }

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

    tex->setCompressed();

}

void WebGLRenderingContext::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                    GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(format)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexSubImage2D", "invalid format");

        return;

    }

    if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);

    if (!tex)

        return;

    if (format != tex->getInternalFormat(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");

        return;

    }

    if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))

        return;

    graphicsContext3D()->compressedTexSubImage2D(target, level, xoffset, yoffset,

                                                 width, height, format, data->byteLength(), data->baseAddress());

    tex->setCompressed();

}

bool WebGLRenderingContext::validateSettableTexFormat(const char* functionName, GC3Denum format)

{

    if (GraphicsContext3D::getClearBitsByFormat(format) & (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format can not be set, only rendered to");

        return false;

    }

    return true;

}

void WebGLRenderingContext::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncParameters("copyTexImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

        return;

    if (!validateSettableTexFormat("copyTexImage2D", internalformat))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexImage2D", target, true);

    if (!tex)

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");

        return;

    }

    if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    } else {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            m_context->texImage2DResourceSafe(target, level, internalformat, width, height, border,

                                              internalformat, GraphicsContext3D::UNSIGNED_BYTE, m_unpackAlignment);

            if (clippedWidth > 0 && clippedHeight > 0) {

                m_context->copyTexSubImage2D(target, level, clippedX - x, clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else

            m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    }

    // FIXME: if the framebuffer is not complete, none of the below should be executed.

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

}

void WebGLRenderingContext::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("copyTexSubImage2D", target, level))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexSubImage2D", target, true);

    if (!tex)

        return;

    if (!validateSize("copyTexSubImage2D", xoffset, yoffset) || !validateSize("copyTexSubImage2D", width, height))

        return;

    // Before checking if it is in the range, check if overflow happens first.

    if (xoffset + width < 0 || yoffset + height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "bad dimensions");

        return;

    }

    if (xoffset + width > tex->getWidth(target, level) || yoffset + height > tex->getHeight(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");

        return;

    }

    GC3Denum internalformat = tex->getInternalFormat(target, level);

    if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

    } else {

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            GC3Denum format = tex->getInternalFormat(target, level);

            GC3Denum type = tex->getType(target, level);

            std::unique_ptr<unsigned char[]> zero;

            if (width && height) {

                unsigned int size;

                GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, 0);

                if (error != GraphicsContext3D::NO_ERROR) {

                    synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");

                    return;

                }

                zero = std::make_unique<unsigned char[]>(size);

                if (!zero) {

                    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "out of memory");

                    return;

                }

                memset(zero.get(), 0, size);

            }

            m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, zero.get());

            if (clippedWidth > 0 && clippedHeight > 0) {

                ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

                m_context->copyTexSubImage2D(target, level, xoffset + clippedX - x, yoffset + clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else {

            ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

            m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

        }

    }

}

PassRefPtr<WebGLBuffer> WebGLRenderingContext::createBuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLFramebuffer> WebGLRenderingContext::createFramebuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);

    addContextObject(o.get());

    return o;

}

PassRefPtr<WebGLTexture> WebGLRenderingContext::createTexture()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLTexture> o = WebGLTexture::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLProgram> WebGLRenderingContext::createProgram()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLProgram> o = WebGLProgram::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLRenderbuffer> WebGLRenderingContext::createRenderbuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLShader> WebGLRenderingContext::createShader(GC3Denum type, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "createShader", "invalid shader type");

        return nullptr;

    }

    RefPtr<WebGLShader> o = WebGLShader::create(this, type);

    addSharedObject(o.get());

    return o;

}

void WebGLRenderingContext::cullFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->cullFace(mode);

}

bool WebGLRenderingContext::deleteObject(WebGLObject* object)

{

    if (isContextLostOrPending() || !object)

        return false;

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "delete", "object does not belong to this context");

        return false;

    }

    if (object->object())

        // We need to pass in context here because we want

        // things in this context unbound.

        object->deleteObject(graphicsContext3D());

    return true;

}

void WebGLRenderingContext::deleteBuffer(WebGLBuffer* buffer)

{

    if (!deleteObject(buffer))

        return;

    if (m_boundArrayBuffer == buffer)

        m_boundArrayBuffer = 0;

    m_boundVertexArrayObject->unbindBuffer(buffer);

}

void WebGLRenderingContext::deleteFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!deleteObject(framebuffer))

        return;

    if (framebuffer == m_framebufferBinding) {

        m_framebufferBinding = 0;

        if (m_drawingBuffer) {

            m_drawingBuffer->setFramebufferBinding(0);

            // Have to call bindFramebuffer here to bind back to internal fbo.

            m_drawingBuffer->bind();

        } else

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

    }

}

void WebGLRenderingContext::deleteProgram(WebGLProgram* program)

{

    deleteObject(program);

    // We don't reset m_currentProgram to 0 here because the deletion of the

    // current program is delayed.

}

void WebGLRenderingContext::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!deleteObject(renderbuffer))

        return;

    if (renderbuffer == m_renderbufferBinding)

        m_renderbufferBinding = 0;

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);

}

void WebGLRenderingContext::deleteShader(WebGLShader* shader)

{

    deleteObject(shader);

}

void WebGLRenderingContext::deleteTexture(WebGLTexture* texture)

{

    if (!deleteObject(texture))

        return;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        if (texture == m_textureUnits[i].texture2DBinding)

            m_textureUnits[i].texture2DBinding = nullptr;

        if (texture == m_textureUnits[i].textureCubeMapBinding)

            m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);

}

void WebGLRenderingContext::depthFunc(GC3Denum func)

{

    if (isContextLostOrPending())

        return;

    m_context->depthFunc(func);

}

void WebGLRenderingContext::depthMask(GC3Dboolean flag)

{

    if (isContextLostOrPending())

        return;

    m_depthMask = flag;

    m_context->depthMask(flag);

}

void WebGLRenderingContext::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)

{

    if (isContextLostOrPending())

        return;

    if (zNear > zFar) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "depthRange", "zNear > zFar");

        return;

    }

    m_context->depthRange(zNear, zFar);

}

void WebGLRenderingContext::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))

        return;

    if (!program->detachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "detachShader", "shader not attached");

        return;

    }

    m_context->detachShader(objectOrZero(program), objectOrZero(shader));

    shader->onDetached(graphicsContext3D());

}

void WebGLRenderingContext::disable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("disable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = false;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = false;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->disable(cap);

}

void WebGLRenderingContext::disableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "disableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = false;

    if (index > 0 || isGLES2Compliant())

        m_context->disableVertexAttribArray(index);

}

bool WebGLRenderingContext::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)

{

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (offset < 0)

        return false;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // For an unsigned int array, offset must be divisible by 4 for alignment reasons.

        if (offset % 4)

            return false;

        // Make uoffset an element offset.

        offset /= 4;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // For an unsigned short array, offset must be divisible by 2 for alignment reasons.

        if (offset % 2)

            return false;

        // Make uoffset an element offset.

        offset /= 2;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        GC3Dsizeiptr n = elementArrayBuffer->byteLength();

        if (offset > n || count > n - offset)

            return false;

    }

    return true;

}

bool WebGLRenderingContext::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)

{

    // Performs conservative validation by caching a maximum index of

    // the given type per element array buffer. If all of the bound

    // array buffers have enough elements to satisfy that maximum

    // index, skips the expensive per-draw-call iteration in

    // validateIndexArrayPrecise.

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();

    // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.

    if (!numElements)

        return false;

    const ArrayBuffer* buffer = elementArrayBuffer->elementArrayBuffer();

    ASSERT(buffer);

    int maxIndex = elementArrayBuffer->getCachedMaxIndex(type);

    if (maxIndex < 0) {

        // Compute the maximum index in the entire buffer for the given type of index.

        switch (type) {

        case GraphicsContext3D::UNSIGNED_BYTE: {

            const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_SHORT: {

            numElements /= sizeof(GC3Dushort);

            const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_INT: {

            if (!m_oesElementIndexUint)

                return false;

            numElements /= sizeof(GC3Duint);

            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        default:

            return false;

        }

        elementArrayBuffer->setCachedMaxIndex(type, maxIndex);

    }

    if (maxIndex >= 0) {

        // The number of required elements is one more than the maximum

        // index that will be accessed.

        numElementsRequired = maxIndex + 1;

        return true;

    }

    return false;

}

bool WebGLRenderingContext::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)

{

    ASSERT(count >= 0 && offset >= 0);

    unsigned lastIndex = 0;

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (!count) {

        numElementsRequired = 0;

        return true;

    }

    if (!elementArrayBuffer->elementArrayBuffer())

        return false;

    unsigned long uoffset = offset;

    unsigned long n = count;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Duint);

        const GC3Duint* p = static_cast<const GC3Duint*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Dushort);

        const GC3Dushort* p = static_cast<const GC3Dushort*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        const GC3Dubyte* p = static_cast<const GC3Dubyte*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    }

    // Then set the last index in the index array and make sure it is valid.

    numElementsRequired = lastIndex + 1;

    return numElementsRequired > 0;

}

bool WebGLRenderingContext::validateVertexAttributes(unsigned elementCount, unsigned primitiveCount)

{

    if (!m_currentProgram)

        return false;

    // Look in each enabled vertex attrib and check if they've been bound to a buffer.

    for (unsigned i = 0; i < m_maxVertexAttribs; ++i) {

        if (!m_boundVertexArrayObject->getVertexAttribState(i).validateBinding())

            return false;

    }

    if (elementCount <= 0)

        return true;

    // Look in each consumed vertex attrib (by the current program).

    bool sawNonInstancedAttrib = false;

    bool sawEnabledAttrib = false;

    int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();

    for (int i = 0; i < numActiveAttribLocations; ++i) {

        int loc = m_currentProgram->getActiveAttribLocation(i);

        if (loc >= 0 && loc < static_cast<int>(m_maxVertexAttribs)) {

            const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(loc);

            if (state.enabled) {

                sawEnabledAttrib = true;

                // Avoid off-by-one errors in numElements computation.

                // For the last element, we will only touch the data for the

                // element and nothing beyond it.

                int bytesRemaining = static_cast<int>(state.bufferBinding->byteLength() - state.offset);

                unsigned numElements = 0;

                ASSERT(state.stride > 0);

                if (bytesRemaining >= state.bytesPerElement)

                    numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;

                unsigned instancesRequired = 0;

                if (state.divisor) {

                    instancesRequired = ceil(static_cast<float>(primitiveCount) / state.divisor);

                    if (instancesRequired > numElements)

                        return false;

                } else {

                    sawNonInstancedAttrib = true;

                    if (elementCount > numElements)

                        return false;

                }

            }

        }

    }

    if (!sawNonInstancedAttrib && sawEnabledAttrib)

        return false;

    return true;

}

bool WebGLRenderingContext::validateWebGLObject(const char* functionName, WebGLObject* object)

{

    if (!object || !object->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no object or object deleted");

        return false;

    }

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object does not belong to this context");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    if (first < 0 || count < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "first or count < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        Checked<GC3Dint, RecordOverflow> checkedFirst(first);

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount;

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedSum.hasOverflowed() || checkedPrimitiveCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimitiveCount.unsafeGet())) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateDrawArrays("drawArrays", mode, first, count, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", true);

    m_context->drawArrays(mode, first, count);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", false);

    markContextChanged();

}

bool WebGLRenderingContext::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT:

        break;

    case GraphicsContext3D::UNSIGNED_INT:

        if (m_oesElementIndexUint)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    }

    if (count < 0 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "count or offset < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!m_boundVertexArrayObject->getElementArrayBuffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");

            return false;

        }

        if (!count)

            return false;

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedCount.hasOverflowed() || checkedPrimitiveCount.hasOverflowed()) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

        if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

            if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

                return false;

            }

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContext::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    unsigned numElements = 0;

    if (!validateDrawElements("drawElements", mode, count, type, offset, numElements, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", true);

    m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", false);

    markContextChanged();

}

void WebGLRenderingContext::enable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("enable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = true;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = true;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->enable(cap);

}

void WebGLRenderingContext::enableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "enableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = true;

    m_context->enableVertexAttribArray(index);

}

void WebGLRenderingContext::finish()

{

    if (isContextLostOrPending())

        return;

    m_context->finish();

}

void WebGLRenderingContext::flush()

{

    if (isContextLostOrPending())

        return;

    m_context->flush();

}

void WebGLRenderingContext::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))

        return;

    if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "framebufferRenderbuffer", "invalid target");

        return;

    }

    if (buffer && !buffer->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");

        return;

    }

    Platform3DObject bufferObject = objectOrZero(buffer);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);

        break;

    default:

        m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);

    applyStencilTest();

}

void WebGLRenderingContext::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))

        return;

    if (level) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "framebufferTexture2D", "level not 0");

        return;

    }

    if (texture && !texture->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");

        return;

    }

    Platform3DObject textureObject = objectOrZero(texture);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, GraphicsContext3D::DEPTH_ATTACHMENT, textarget, textureObject, level);

        m_context->framebufferTexture2D(target, GraphicsContext3D::STENCIL_ATTACHMENT, textarget, textureObject, level);

        break;

    case GraphicsContext3D::DEPTH_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    case GraphicsContext3D::STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    default:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);

    applyStencilTest();

}

void WebGLRenderingContext::frontFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->frontFace(mode);

}

void WebGLRenderingContext::generateMipmap(GC3Denum target)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);

    if (!tex)

        return;

    if (!tex->canGenerateMipmaps()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");

        return;

    }

    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=123916. Compressed textures should be allowed in WebGL 2:

    if (tex->isCompressed()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "trying to generate mipmaps from compressed texture");

        return;

    }

    if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))

        return;

    // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR

    // on Mac.  Remove the hack once this driver bug is fixed.

#if OS(DARWIN)

    bool needToResetMinFilter = false;

    if (tex->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_LINEAR) {

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::NEAREST_MIPMAP_LINEAR);

        needToResetMinFilter = true;

    }

#endif

    m_context->generateMipmap(target);

#if OS(DARWIN)

    if (needToResetMinFilter)

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, tex->getMinFilter());

#endif

    tex->generateMipmapLevelInfo();

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveAttrib(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))

        return nullptr;

    ActiveInfo info;

    if (!m_context->getActiveAttrib(objectOrZero(program), index, info))

        return nullptr;

    LOG(WebGL, "Returning active attribute %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContext::getActiveUniform(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))

        return 0;

    ActiveInfo info;

    if (!m_context->getActiveUniform(objectOrZero(program), index, info))

        return nullptr;

    if (!isGLES2Compliant())

        if (info.size > 1 && !info.name.endsWith("[0]"))

            info.name.append("[0]");

    LOG(WebGL, "Returning active uniform %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

bool WebGLRenderingContext::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    shaderObjects.clear();

    if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))

        return false;

    const GC3Denum shaderType[] = {

        GraphicsContext3D::VERTEX_SHADER,

        GraphicsContext3D::FRAGMENT_SHADER

    };

    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {

        WebGLShader* shader = program->getAttachedShader(shaderType[i]);

        if (shader)

            shaderObjects.append(shader);

    }

    return true;

}

GC3Dint WebGLRenderingContext::getAttribLocation(WebGLProgram* program, const String& name)

{

    if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))

        return -1;

    if (!validateLocationLength("getAttribLocation", name))

        return -1;

    if (!validateString("getAttribLocation", name))

        return -1;

    if (isPrefixReserved(name))

        return -1;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getAttribLocation", "program not linked");

        return -1;

    }

    return m_context->getAttribLocation(objectOrZero(program), name);

}

WebGLGetInfo WebGLRenderingContext::getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (pname != GraphicsContext3D::BUFFER_SIZE && pname != GraphicsContext3D::BUFFER_USAGE) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    GC3Dint value = 0;

    m_context->getBufferParameteriv(target, pname, &value);

    if (pname == GraphicsContext3D::BUFFER_SIZE)

        return WebGLGetInfo(value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

PassRefPtr<WebGLContextAttributes> WebGLRenderingContext::getContextAttributes()

{

    if (isContextLostOrPending())

        return nullptr;

    // We always need to return a new WebGLContextAttributes object to

    // prevent the user from mutating any cached version.

    // Also, we need to enforce requested values of "false" for depth

    // and stencil, regardless of the properties of the underlying

    // GraphicsContext3D or DrawingBuffer.

    RefPtr<WebGLContextAttributes> attributes = WebGLContextAttributes::create(m_context->getContextAttributes());

    if (!m_attributes.depth)

        attributes->setDepth(false);

    if (!m_attributes.stencil)

        attributes->setStencil(false);

    if (m_drawingBuffer) {

        // The DrawingBuffer obtains its parameters from GraphicsContext3D::getContextAttributes(),

        // but it makes its own determination of whether multisampling is supported.

        attributes->setAntialias(m_drawingBuffer->multisample());

    }

    return attributes.release();

}

GC3Denum WebGLRenderingContext::getError()

{

    if (m_isPendingPolicyResolution)

        return GraphicsContext3D::NO_ERROR;

    return m_context->getError();

}

WebGLExtension* WebGLRenderingContext::getExtension(const String& name)

{

    if (isContextLostOrPending())

        return nullptr;

    if (equalIgnoringCase(name, "EXT_blend_minmax")

        && m_context->getExtensions()->supports("GL_EXT_blend_minmax")) {

        if (!m_extBlendMinMax) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_blend_minmax");

            m_extBlendMinMax = std::make_unique<EXTBlendMinMax>(this);

        }

        return m_extBlendMinMax.get();

    }

    if (equalIgnoringCase(name, "EXT_sRGB")

        && m_context->getExtensions()->supports("GL_EXT_sRGB")) {

        if (!m_extsRGB) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_sRGB");

            m_extsRGB = std::make_unique<EXTsRGB>(this);

        }

        return m_extsRGB.get();

    }

    if (equalIgnoringCase(name, "EXT_frag_depth")

        && m_context->getExtensions()->supports("GL_EXT_frag_depth")) {

        if (!m_extFragDepth) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_frag_depth");

            m_extFragDepth = std::make_unique<EXTFragDepth>(this);

        }

        return m_extFragDepth.get();

    }

    if (equalIgnoringCase(name, "EXT_shader_texture_lod")

        && (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))) {

        if (!m_extShaderTextureLOD) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_shader_texture_lod");

            m_extShaderTextureLOD = std::make_unique<EXTShaderTextureLOD>(this);

        }

        return m_extShaderTextureLOD.get();

    }

    if (equalIgnoringCase(name, "WEBKIT_EXT_texture_filter_anisotropic")

        && m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic")) {

        if (!m_extTextureFilterAnisotropic) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_texture_filter_anisotropic");

            m_extTextureFilterAnisotropic = std::make_unique<EXTTextureFilterAnisotropic>(this);

        }

        return m_extTextureFilterAnisotropic.get();

    }

    if (equalIgnoringCase(name, "OES_standard_derivatives")

        && m_context->getExtensions()->supports("GL_OES_standard_derivatives")) {

        if (!m_oesStandardDerivatives) {

            m_context->getExtensions()->ensureEnabled("GL_OES_standard_derivatives");

            m_oesStandardDerivatives = std::make_unique<OESStandardDerivatives>(this);

        }

        return m_oesStandardDerivatives.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float")

        && m_context->getExtensions()->supports("GL_OES_texture_float")) {

        if (!m_oesTextureFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float");

            m_oesTextureFloat = std::make_unique<OESTextureFloat>(this);

        }

        return m_oesTextureFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_float_linear")) {

        if (!m_oesTextureFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float_linear");

            m_oesTextureFloatLinear = std::make_unique<OESTextureFloatLinear>(this);

        }

        return m_oesTextureFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float")) {

        if (!m_oesTextureHalfFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float");

            m_oesTextureHalfFloat = std::make_unique<OESTextureHalfFloat>(this);

        }

        return m_oesTextureHalfFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float_linear")) {

        if (!m_oesTextureHalfFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float_linear");

            m_oesTextureHalfFloatLinear = std::make_unique<OESTextureHalfFloatLinear>(this);

        }

        return m_oesTextureHalfFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_vertex_array_object")

        && m_context->getExtensions()->supports("GL_OES_vertex_array_object")) {

        if (!m_oesVertexArrayObject) {

            m_context->getExtensions()->ensureEnabled("GL_OES_vertex_array_object");

            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(this);

        }

        return m_oesVertexArrayObject.get();

    }

    if (equalIgnoringCase(name, "OES_element_index_uint")

        && m_context->getExtensions()->supports("GL_OES_element_index_uint")) {

        if (!m_oesElementIndexUint) {

            m_context->getExtensions()->ensureEnabled("GL_OES_element_index_uint");

            m_oesElementIndexUint = std::make_unique<OESElementIndexUint>(this);

        }

        return m_oesElementIndexUint.get();

    }

    if (equalIgnoringCase(name, "WEBGL_lose_context")) {

        if (!m_webglLoseContext)

            m_webglLoseContext = std::make_unique<WebGLLoseContext>(this);

        return m_webglLoseContext.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_atc"))

        && WebGLCompressedTextureATC::supported(this)) {

        if (!m_webglCompressedTextureATC)

            m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(this);

        return m_webglCompressedTextureATC.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc"))

        && WebGLCompressedTexturePVRTC::supported(this)) {

        if (!m_webglCompressedTexturePVRTC)

            m_webglCompressedTexturePVRTC = std::make_unique<WebGLCompressedTexturePVRTC>(this);

        return m_webglCompressedTexturePVRTC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_compressed_texture_s3tc")

        && WebGLCompressedTextureS3TC::supported(this)) {

        if (!m_webglCompressedTextureS3TC)

            m_webglCompressedTextureS3TC = std::make_unique<WebGLCompressedTextureS3TC>(this);

        return m_webglCompressedTextureS3TC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_depth_texture")

        && WebGLDepthTexture::supported(graphicsContext3D())) {

        if (!m_webglDepthTexture) {

            m_context->getExtensions()->ensureEnabled("GL_CHROMIUM_depth_texture");

            m_webglDepthTexture = std::make_unique<WebGLDepthTexture>(this);

        }

        return m_webglDepthTexture.get();

    }

    if (equalIgnoringCase(name, "WEBGL_draw_buffers") && supportsDrawBuffers()) {

        if (!m_webglDrawBuffers) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_draw_buffers");

            m_webglDrawBuffers = std::make_unique<WebGLDrawBuffers>(this);

        }

        return m_webglDrawBuffers.get();

    }

    if (equalIgnoringCase(name, "ANGLE_instanced_arrays") && ANGLEInstancedArrays::supported(this)) {

        if (!m_angleInstancedArrays) {

            m_context->getExtensions()->ensureEnabled("GL_ANGLE_instanced_arrays");

            m_angleInstancedArrays = std::make_unique<ANGLEInstancedArrays>(this);

        }

        return m_angleInstancedArrays.get();

    }

    if (allowPrivilegedExtensions()) {

        if (equalIgnoringCase(name, "WEBGL_debug_renderer_info")) {

            if (!m_webglDebugRendererInfo)

                m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(this);

            return m_webglDebugRendererInfo.get();

        }

        if (equalIgnoringCase(name, "WEBGL_debug_shaders")

            && m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source")) {

            if (!m_webglDebugShaders)

                m_webglDebugShaders = std::make_unique<WebGLDebugShaders>(this);

            return m_webglDebugShaders.get();

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))

        return WebGLGetInfo();

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");

        return WebGLGetInfo();

    }

    WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(attachment);

    if (!object) {

        if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)

            return WebGLGetInfo(GraphicsContext3D::NONE);

        // OpenGL ES 2.0 specifies INVALID_ENUM in this case, while desktop GL

        // specifies INVALID_OPERATION.

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    ASSERT(object->isTexture() || object->isRenderbuffer());

    if (object->isTexture()) {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::TEXTURE);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLTexture>(reinterpret_cast<WebGLTexture*>(object)));

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            GC3Dint value = 0;

            m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);

            return WebGLGetInfo(value);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");

            return WebGLGetInfo();

        }

    } else {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::RENDERBUFFER);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(reinterpret_cast<WebGLRenderbuffer*>(object)));

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            WebGLRenderbuffer* renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object);

            GC3Denum renderBufferFormat = renderBuffer->getInternalFormat();

            ASSERT(renderBufferFormat != Extensions3D::SRGB_EXT && renderBufferFormat != Extensions3D::SRGB_ALPHA_EXT);

            if (renderBufferFormat == Extensions3D::SRGB8_ALPHA8_EXT)

                return WebGLGetInfo(Extensions3D::SRGB_EXT);

            return WebGLGetInfo(GraphicsContext3D::LINEAR);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");

            return WebGLGetInfo();

        }

    }

}

WebGLGetInfo WebGLRenderingContext::getParameter(GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    const int intZero = 0;

    switch (pname) {

    case GraphicsContext3D::ACTIVE_TEXTURE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALPHA_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));

    case GraphicsContext3D::BLEND:

        return getBooleanParameter(pname);

    case GraphicsContext3D::BLEND_COLOR:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::BLEND_DST_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_DST_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLUE_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::COLOR_WRITEMASK:

        return getBooleanArrayParameter(pname);

    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:

        return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));

    case GraphicsContext3D::CULL_FACE:

        return getBooleanParameter(pname);

    case GraphicsContext3D::CULL_FACE_MODE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::CURRENT_PROGRAM:

        return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));

    case GraphicsContext3D::DEPTH_BITS:

        if (!m_framebufferBinding && !m_attributes.depth)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::DEPTH_CLEAR_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::DEPTH_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::DEPTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::DEPTH_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DEPTH_WRITEMASK:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DITHER:

        return getBooleanParameter(pname);

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->getElementArrayBuffer()));

    case GraphicsContext3D::FRAMEBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));

    case GraphicsContext3D::FRONT_FACE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GREEN_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::LINE_WIDTH:

        return getFloatParameter(pname);

    case GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_RENDERBUFFER_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VARYING_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_ATTRIBS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::NUM_SHADER_BINARY_FORMATS:

        // FIXME: should we always return 0 for this?

        return getIntParameter(pname);

    case GraphicsContext3D::PACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FACTOR:

        return getFloatParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

        return getBooleanParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_UNITS:

        return getFloatParameter(pname);

    case GraphicsContext3D::RED_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::RENDERBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));

    case GraphicsContext3D::RENDERER:

        return WebGLGetInfo(String("WebKit WebGL"));

    case GraphicsContext3D::SAMPLE_BUFFERS:

        return getIntParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_INVERT:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::SAMPLES:

        return getIntParameter(pname);

    case GraphicsContext3D::SCISSOR_BOX:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::SCISSOR_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SHADING_LANGUAGE_VERSION:

        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + m_context->getString(GraphicsContext3D::SHADING_LANGUAGE_VERSION) + ")");

    case GraphicsContext3D::STENCIL_BACK_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BITS:

        if (!m_framebufferBinding && !m_attributes.stencil)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_CLEAR_VALUE:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::STENCIL_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::SUBPIXEL_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::TEXTURE_BINDING_2D:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].texture2DBinding));

    case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].textureCubeMapBinding));

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        return WebGLGetInfo(m_unpackFlipY);

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        return WebGLGetInfo(m_unpackPremultiplyAlpha);

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        return WebGLGetInfo(m_unpackColorspaceConversion);

    case GraphicsContext3D::VENDOR:

        return WebGLGetInfo(String("WebKit"));

    case GraphicsContext3D::VERSION:

        return WebGLGetInfo("WebGL 1.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")");

    case GraphicsContext3D::VIEWPORT:

        return getWebGLIntArrayParameter(pname);

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            return getUnsignedIntParameter(Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::RENDERER));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::VENDOR));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case Extensions3D::VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object

        if (m_oesVertexArrayObject) {

            if (!m_boundVertexArrayObject->isDefaultObject())

                return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject));

            return WebGLGetInfo();

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic)

            return getUnsignedIntParameter(Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxColorAttachments());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_DRAW_BUFFERS_EXT:

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxDrawBuffers());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    default:

        if (m_webglDrawBuffers

            && pname >= Extensions3D::DRAW_BUFFER0_EXT

            && pname < static_cast<GC3Denum>(Extensions3D::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {

            GC3Dint value = GraphicsContext3D::NONE;

            if (m_framebufferBinding)

                value = m_framebufferBinding->getDrawBuffer(pname);

            else // emulated backbuffer

                value = m_backDrawBuffer;

            return WebGLGetInfo(value);

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getProgramParameter(WebGLProgram* program, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(program->isDeleted());

    case GraphicsContext3D::VALIDATE_STATUS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::LINK_STATUS:

        return WebGLGetInfo(program->getLinkStatus());

    case GraphicsContext3D::ATTACHED_SHADERS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::ACTIVE_ATTRIBUTES:

    case GraphicsContext3D::ACTIVE_UNIFORMS:

        m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getProgramParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getProgramInfoLog(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getProgramInfoLog", program))

        return "";

    return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));

}

WebGLGetInfo WebGLRenderingContext::getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");

        return WebGLGetInfo();

    }

    if (m_renderbufferBinding->getInternalFormat() == GraphicsContext3D::DEPTH_STENCIL

        && !m_renderbufferBinding->isValid()) {

        ASSERT(!isDepthStencilSupported());

        int value = 0;

        switch (pname) {

        case GraphicsContext3D::RENDERBUFFER_WIDTH:

            value = m_renderbufferBinding->getWidth();

            break;

        case GraphicsContext3D::RENDERBUFFER_HEIGHT:

            value = m_renderbufferBinding->getHeight();

            break;

        case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

        case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

        case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

        case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

            value = 0;

            break;

        case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

            value = 24;

            break;

        case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

            value = 8;

            break;

        case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

            return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

            return WebGLGetInfo();

        }

        return WebGLGetInfo(value);

    }

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::RENDERBUFFER_WIDTH:

    case GraphicsContext3D::RENDERBUFFER_HEIGHT:

    case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

    case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

    case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

    case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

    case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

    case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

        m_context->getRenderbufferParameteriv(target, pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

        return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getShaderParameter(WebGLShader* shader, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(shader->isDeleted());

    case GraphicsContext3D::COMPILE_STATUS:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::SHADER_TYPE:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContext::getShaderInfoLog(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderInfoLog", shader))

        return "";

    return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));

}

PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContext::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    switch (shaderType) {

    case GraphicsContext3D::VERTEX_SHADER:

    case GraphicsContext3D::FRAGMENT_SHADER:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");

        return nullptr;

    }

    switch (precisionType) {

    case GraphicsContext3D::LOW_FLOAT:

    case GraphicsContext3D::MEDIUM_FLOAT:

    case GraphicsContext3D::HIGH_FLOAT:

    case GraphicsContext3D::LOW_INT:

    case GraphicsContext3D::MEDIUM_INT:

    case GraphicsContext3D::HIGH_INT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");

        return nullptr;

    }

    GC3Dint range[2] = {0, 0};

    GC3Dint precision = 0;

    m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);

    return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);

}

String WebGLRenderingContext::getShaderSource(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderSource", shader))

        return "";

    return ensureNotNull(shader->getSource());

}

Vector<String> WebGLRenderingContext::getSupportedExtensions()

{

    Vector<String> result;

    if (m_isPendingPolicyResolution)

        return result;

    if (m_context->getExtensions()->supports("GL_EXT_blend_minmax"))

        result.append("EXT_blend_minmax");

    if (m_context->getExtensions()->supports("GL_EXT_sRGB"))

        result.append("EXT_sRGB");

    if (m_context->getExtensions()->supports("GL_EXT_frag_depth"))

        result.append("EXT_frag_depth");

    if (m_context->getExtensions()->supports("GL_OES_texture_float"))

        result.append("OES_texture_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_float_linear"))

        result.append("OES_texture_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float"))

        result.append("OES_texture_half_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float_linear"))

        result.append("OES_texture_half_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_standard_derivatives"))

        result.append("OES_standard_derivatives");

    if (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))

        result.append("EXT_shader_texture_lod");

    if (m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic"))

        result.append("WEBKIT_EXT_texture_filter_anisotropic");

    if (m_context->getExtensions()->supports("GL_OES_vertex_array_object"))

        result.append("OES_vertex_array_object");

    if (m_context->getExtensions()->supports("GL_OES_element_index_uint"))

        result.append("OES_element_index_uint");

    result.append("WEBGL_lose_context");

    if (WebGLCompressedTextureATC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_atc");

    if (WebGLCompressedTexturePVRTC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_pvrtc");

    if (WebGLCompressedTextureS3TC::supported(this))

        result.append("WEBGL_compressed_texture_s3tc");

    if (WebGLDepthTexture::supported(graphicsContext3D()))

        result.append("WEBGL_depth_texture");

    if (supportsDrawBuffers())

        result.append("WEBGL_draw_buffers");

    if (ANGLEInstancedArrays::supported(this))

        result.append("ANGLE_instanced_arrays");

    if (allowPrivilegedExtensions()) {

        if (m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source"))

            result.append("WEBGL_debug_shaders");

        result.append("WEBGL_debug_renderer_info");

    }

    return result;

}

WebGLGetInfo WebGLRenderingContext::getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);

    if (!tex)

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        m_context->getTexParameteriv(target, pname, &value);

        return WebGLGetInfo(static_cast<unsigned int>(value));

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic) {

            m_context->getTexParameteriv(target, pname, &value);

            return WebGLGetInfo(static_cast<unsigned int>(value));

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContext::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniform", program))

        return WebGLGetInfo();

    if (!uniformLocation || uniformLocation->program() != program) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");

        return WebGLGetInfo();

    }

    GC3Dint location = uniformLocation->location();

    GC3Denum baseType;

    unsigned length;

    switch (uniformLocation->type()) {

    case GraphicsContext3D::BOOL:

        baseType = GraphicsContext3D::BOOL;

        length = 1;

        break;

    case GraphicsContext3D::BOOL_VEC2:

        baseType = GraphicsContext3D::BOOL;

        length = 2;

        break;

    case GraphicsContext3D::BOOL_VEC3:

        baseType = GraphicsContext3D::BOOL;

        length = 3;

        break;

    case GraphicsContext3D::BOOL_VEC4:

        baseType = GraphicsContext3D::BOOL;

        length = 4;

        break;

    case GraphicsContext3D::INT:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    case GraphicsContext3D::INT_VEC2:

        baseType = GraphicsContext3D::INT;

        length = 2;

        break;

    case GraphicsContext3D::INT_VEC3:

        baseType = GraphicsContext3D::INT;

        length = 3;

        break;

    case GraphicsContext3D::INT_VEC4:

        baseType = GraphicsContext3D::INT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT:

        baseType = GraphicsContext3D::FLOAT;

        length = 1;

        break;

    case GraphicsContext3D::FLOAT_VEC2:

        baseType = GraphicsContext3D::FLOAT;

        length = 2;

        break;

    case GraphicsContext3D::FLOAT_VEC3:

        baseType = GraphicsContext3D::FLOAT;

        length = 3;

        break;

    case GraphicsContext3D::FLOAT_VEC4:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT2:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT3:

        baseType = GraphicsContext3D::FLOAT;

        length = 9;

        break;

    case GraphicsContext3D::FLOAT_MAT4:

        baseType = GraphicsContext3D::FLOAT;

        length = 16;

        break;

    case GraphicsContext3D::SAMPLER_2D:

    case GraphicsContext3D::SAMPLER_CUBE:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    default:

        // Can't handle this type

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unhandled type");

        return WebGLGetInfo();

    }

    switch (baseType) {

    case GraphicsContext3D::FLOAT: {

        GC3Dfloat value[16] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);

        else

            m_context->getUniformfv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Float32Array::create(value, length));

    }

    case GraphicsContext3D::INT: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Int32Array::create(value, length));

    }

    case GraphicsContext3D::BOOL: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length > 1) {

            bool boolValue[16] = {0};

            for (unsigned j = 0; j < length; j++)

                boolValue[j] = static_cast<bool>(value[j]);

            return WebGLGetInfo(boolValue, length);

        }

        return WebGLGetInfo(static_cast<bool>(value[0]));

    }

    default:

        notImplemented();

    }

    // If we get here, something went wrong in our unfortunately complex logic above

    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unknown error");

    return WebGLGetInfo();

}

PassRefPtr<WebGLUniformLocation> WebGLRenderingContext::getUniformLocation(WebGLProgram* program, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniformLocation", program))

        return nullptr;

    if (!validateLocationLength("getUniformLocation", name))

        return nullptr;

    if (!validateString("getUniformLocation", name))

        return nullptr;

    if (isPrefixReserved(name))

        return nullptr;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniformLocation", "program not linked");

        return nullptr;

    }

    GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);

    if (uniformLocation == -1)

        return nullptr;

    GC3Dint activeUniforms = 0;

    m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContext3D::ACTIVE_UNIFORMS, &activeUniforms);

    for (GC3Dint i = 0; i < activeUniforms; i++) {

        ActiveInfo info;

        if (!m_context->getActiveUniform(objectOrZero(program), i, info))

            return nullptr;

        // Strip "[0]" from the name if it's an array.

        if (info.name.endsWith("[0]"))

            info.name = info.name.left(info.name.length() - 3);

        // If it's an array, we need to iterate through each element, appending "[index]" to the name.

        for (GC3Dint index = 0; index < info.size; ++index) {

            String uniformName = info.name + "[" + String::number(index) + "]";

            if (name == uniformName || name == info.name)

                return WebGLUniformLocation::create(program, uniformLocation, info.type);

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContext::getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getVertexAttrib", "index out of range");

        return WebGLGetInfo();

    }

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    if (m_angleInstancedArrays && pname == GraphicsContext3D::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)

        return WebGLGetInfo(state.divisor);

    switch (pname) {

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:

        if ((!isGLES2Compliant() && !index && m_boundVertexArrayObject->getVertexAttribState(0).bufferBinding == m_vertexAttrib0Buffer)

            || !state.bufferBinding

            || !state.bufferBinding->object())

            return WebGLGetInfo();

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_ENABLED:

        return WebGLGetInfo(state.enabled);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_NORMALIZED:

        return WebGLGetInfo(state.normalized);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_SIZE:

        return WebGLGetInfo(state.size);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_STRIDE:

        return WebGLGetInfo(state.originalStride);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_TYPE:

        return WebGLGetInfo(state.type);

    case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:

        return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");

        return WebGLGetInfo();

    }

}

long long WebGLRenderingContext::getVertexAttribOffset(GC3Duint index, GC3Denum pname)

{

    if (isContextLostOrPending())

        return 0;

    GC3Dsizeiptr result = m_context->getVertexAttribOffset(index, pname);

    return static_cast<long long>(result);

}

void WebGLRenderingContext::hint(GC3Denum target, GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    bool isValid = false;

    switch (target) {

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        isValid = true;

        break;

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            isValid = true;

        break;

    }

    if (!isValid) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");

        return;

    }

    m_context->hint(target, mode);

}

GC3Dboolean WebGLRenderingContext::isBuffer(WebGLBuffer* buffer)

{

    if (!buffer || isContextLostOrPending())

        return 0;

    if (!buffer->hasEverBeenBound())

        return 0;

    return m_context->isBuffer(buffer->object());

}

bool WebGLRenderingContext::isContextLost() const

{

    return m_contextLost;

}

bool WebGLRenderingContext::isContextLostOrPending()

{

    if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {

        LOG(WebGL, "Context is being used. Attempt to resolve the policy.");

        Document& document = canvas()->document().topDocument();

        Page* page = document.page();

        if (page && !document.url().isLocalFile())

            page->mainFrame().loader().client().resolveWebGLPolicyForURL(document.url());

        // FIXME: We don't currently do anything with the result from resolution. A more

        // complete implementation might try to construct a real context, etc and proceed

        // with normal operation.

        // https://bugs.webkit.org/show_bug.cgi?id=129122

        m_hasRequestedPolicyResolution = true;

    }

    return m_contextLost || m_isPendingPolicyResolution;

}

GC3Dboolean WebGLRenderingContext::isEnabled(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("isEnabled", cap))

        return 0;

    if (cap == GraphicsContext3D::STENCIL_TEST)

        return m_stencilEnabled;

    return m_context->isEnabled(cap);

}

GC3Dboolean WebGLRenderingContext::isFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!framebuffer || isContextLostOrPending())

        return 0;

    if (!framebuffer->hasEverBeenBound())

        return 0;

    return m_context->isFramebuffer(framebuffer->object());

}

GC3Dboolean WebGLRenderingContext::isProgram(WebGLProgram* program)

{

    if (!program || isContextLostOrPending())

        return 0;

    return m_context->isProgram(program->object());

}

GC3Dboolean WebGLRenderingContext::isRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!renderbuffer || isContextLostOrPending())

        return 0;

    if (!renderbuffer->hasEverBeenBound())

        return 0;

    return m_context->isRenderbuffer(renderbuffer->object());

}

GC3Dboolean WebGLRenderingContext::isShader(WebGLShader* shader)

{

    if (!shader || isContextLostOrPending())

        return 0;

    return m_context->isShader(shader->object());

}

GC3Dboolean WebGLRenderingContext::isTexture(WebGLTexture* texture)

{

    if (!texture || isContextLostOrPending())

        return 0;

    if (!texture->hasEverBeenBound())

        return 0;

    return m_context->isTexture(texture->object());

}

void WebGLRenderingContext::lineWidth(GC3Dfloat width)

{

    if (isContextLostOrPending())

        return;

    m_context->lineWidth(width);

}

void WebGLRenderingContext::linkProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("linkProgram", program))

        return;

    if (!isGLES2Compliant()) {

        WebGLShader* vertexShader = program->getAttachedShader(GraphicsContext3D::VERTEX_SHADER);

        WebGLShader* fragmentShader = program->getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);

        if (!vertexShader || !vertexShader->isValid() || !fragmentShader || !fragmentShader->isValid() || !m_context->precisionsMatch(objectOrZero(vertexShader), objectOrZero(fragmentShader)) || !m_context->checkVaryingsPacking(objectOrZero(vertexShader), objectOrZero(fragmentShader))) {

            program->setLinkStatus(false);

            return;

        }

    }

    m_context->linkProgram(objectOrZero(program));

    program->increaseLinkCount();

}

void WebGLRenderingContext::pixelStorei(GC3Denum pname, GC3Dint param)

{

    if (isContextLostOrPending())

        return;

    switch (pname) {

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        m_unpackFlipY = param;

        break;

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        m_unpackPremultiplyAlpha = param;

        break;

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        if (param == GraphicsContext3D::BROWSER_DEFAULT_WEBGL || param == GraphicsContext3D::NONE)

            m_unpackColorspaceConversion = static_cast<GC3Denum>(param);

        else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");

            return;

        }

        break;

    case GraphicsContext3D::PACK_ALIGNMENT:

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        if (param == 1 || param == 2 || param == 4 || param == 8) {

            if (pname == GraphicsContext3D::PACK_ALIGNMENT)

                m_packAlignment = param;

            else // GraphicsContext3D::UNPACK_ALIGNMENT:

                m_unpackAlignment = param;

            m_context->pixelStorei(pname, param);

        } else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "pixelStorei", "invalid parameter name");

        return;

    }

}

void WebGLRenderingContext::polygonOffset(GC3Dfloat factor, GC3Dfloat units)

{

    if (isContextLostOrPending())

        return;

    m_context->polygonOffset(factor, units);

}

void WebGLRenderingContext::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&)

{

    if (isContextLostOrPending())

        return;

    // Due to WebGL's same-origin restrictions, it is not possible to

    // taint the origin using the WebGL API.

    ASSERT(canvas()->originClean());

    // Validate input parameters.

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "readPixels", "no destination ArrayBufferView");

        return;

    }

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format");

        return;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid type");

        return;

    }

    if (format != GraphicsContext3D::RGBA || type != GraphicsContext3D::UNSIGNED_BYTE) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");

        return;

    }

    // Validate array type against pixel type.

    if (pixels->getType() != JSC::TypeUint8) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);

        return;

    }

    // Calculate array size, taking into consideration of PACK_ALIGNMENT.

    unsigned int totalBytesRequired = 0;

    unsigned int padding = 0;

    if (!m_isRobustnessEXTSupported) {

        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

        if (error != GraphicsContext3D::NO_ERROR) {

            synthesizeGLError(error, "readPixels", "invalid dimensions");

            return;

        }

        if (pixels->byteLength() < totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");

            return;

        }

    }

    clearIfComposited();

    void* data = pixels->baseAddress();

    {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->readnPixelsEXT(x, y, width, height, format, type, pixels->byteLength(), data);

        else

            m_context->readPixels(x, y, width, height, format, type, data);

    }

#if OS(DARWIN)

    if (m_isRobustnessEXTSupported) // we haven't computed padding

        m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

    // FIXME: remove this section when GL driver bug on Mac AND the GLES driver bug

    // on QC is fixed, i.e., when alpha is off, readPixels should

    // set alpha to 255 instead of 0.

    if (!m_framebufferBinding && !m_context->getContextAttributes().alpha) {

        unsigned char* pixels = reinterpret_cast<unsigned char*>(data);

        for (GC3Dsizei iy = 0; iy < height; ++iy) {

            for (GC3Dsizei ix = 0; ix < width; ++ix) {

                pixels[3] = 255;

                pixels += 4;

            }

            pixels += padding;

        }

    }

#endif

}

void WebGLRenderingContext::releaseShaderCompiler()

{

    if (isContextLostOrPending())

        return;

    m_context->releaseShaderCompiler();

}

void WebGLRenderingContext::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid target");

        return;

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "renderbufferStorage", "no bound renderbuffer");

        return;

    }

    if (!validateSize("renderbufferStorage", width, height))

        return;

    switch (internalformat) {

    case GraphicsContext3D::DEPTH_COMPONENT16:

    case GraphicsContext3D::RGBA4:

    case GraphicsContext3D::RGB5_A1:

    case GraphicsContext3D::RGB565:

    case GraphicsContext3D::STENCIL_INDEX8:

    case Extensions3D::SRGB8_ALPHA8_EXT:

        if (internalformat == Extensions3D::SRGB8_ALPHA8_EXT && !m_extsRGB) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

            return;

        }

        m_context->renderbufferStorage(target, internalformat, width, height);

        m_renderbufferBinding->setInternalFormat(internalformat);

        m_renderbufferBinding->setIsValid(true);

        m_renderbufferBinding->setSize(width, height);

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (isDepthStencilSupported()) {

            m_context->renderbufferStorage(target, Extensions3D::DEPTH24_STENCIL8, width, height);

        }

        m_renderbufferBinding->setSize(width, height);

        m_renderbufferBinding->setIsValid(isDepthStencilSupported());

        m_renderbufferBinding->setInternalFormat(internalformat);

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

        return;

    }

    applyStencilTest();

}

void WebGLRenderingContext::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)

{

    if (isContextLostOrPending())

        return;

    m_context->sampleCoverage(value, invert);

}

void WebGLRenderingContext::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("scissor", width, height))

        return;

    m_context->scissor(x, y, width, height);

}

void WebGLRenderingContext::shaderSource(WebGLShader* shader, const String& string, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("shaderSource", shader))

        return;

    String stringWithoutComments = StripComments(string).result();

    if (!validateString("shaderSource", stringWithoutComments))

        return;

    shader->setSource(string);

    m_context->shaderSource(objectOrZero(shader), stringWithoutComments);

}

void WebGLRenderingContext::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFunc", func))

        return;

    m_stencilFuncRef = ref;

    m_stencilFuncRefBack = ref;

    m_stencilFuncMask = mask;

    m_stencilFuncMaskBack = mask;

    m_context->stencilFunc(func, ref, mask);

}

void WebGLRenderingContext::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFuncSeparate", func))

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilFuncRef = ref;

        m_stencilFuncRefBack = ref;

        m_stencilFuncMask = mask;

        m_stencilFuncMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilFuncRef = ref;

        m_stencilFuncMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilFuncRefBack = ref;

        m_stencilFuncMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilFuncSeparate", "invalid face");

        return;

    }

    m_context->stencilFuncSeparate(face, func, ref, mask);

}

void WebGLRenderingContext::stencilMask(GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    m_stencilMask = mask;

    m_stencilMaskBack = mask;

    m_context->stencilMask(mask);

}

void WebGLRenderingContext::stencilMaskSeparate(GC3Denum face, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilMask = mask;

        m_stencilMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilMaskSeparate", "invalid face");

        return;

    }

    m_context->stencilMaskSeparate(face, mask);

}

void WebGLRenderingContext::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOp(fail, zfail, zpass);

}

void WebGLRenderingContext::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOpSeparate(face, fail, zfail, zpass);

}

void WebGLRenderingContext::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned.

    ec = 0;

    WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);

    ASSERT(validateTexFuncParameters("texImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, format, type));

    ASSERT(tex);

    ASSERT(!level || !WebGLTexture::isNPOT(width, height));

    if (!pixels) {

        // Note: Chromium's OpenGL implementation clears textures and isResourceSafe() is therefore true.

        // For other implementations, if they are using ANGLE_depth_texture, ANGLE depth textures

        // can not be cleared with texImage2D and must be cleared by binding to an fbo and calling

        // clear.

        if (isResourceSafe())

            m_context->texImage2D(target, level, internalformat, width, height, border, format, type, nullptr);

        else {

            bool succeed = m_context->texImage2DResourceSafe(target, level, internalformat, width, height,

                                                             border, format, type, m_unpackAlignment);

            if (!succeed)

                return;

        }

    } else {

        ASSERT(validateSettableTexFormat("texImage2D", internalformat));

        m_context->moveErrorsToSyntheticErrorList();

        m_context->texImage2D(target, level, internalformat, width, height,

                              border, format, type, pixels);

        if (m_context->moveErrorsToSyntheticErrorList()) {

            // The texImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

            tex->markInvalid(target, level);

            return;

        }

    }

    tex->setLevelInfo(target, level, internalformat, width, height, type);

}

void WebGLRenderingContext::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "packImage error");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

bool WebGLRenderingContext::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)

{

    if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))

        return false;

    WebGLTexture* texture = validateTextureBinding(functionName, target, true);

    if (!texture)

        return false;

    if (functionType == NotTexSubImage2D) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level > 0 not power of 2");

            return false;

        }

        // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat

        // by checking if the ArrayBufferView is null or not.

        if (sourceType != SourceArrayBufferView) {

            if (!validateSettableTexFormat(functionName, format))

                return false;

        }

    } else {

        if (!validateSettableTexFormat(functionName, format))

            return false;

        if (!validateSize(functionName, xoffset, yoffset))

            return false;

        // Before checking if it is in the range, check if overflow happens first.

        if (xoffset + width < 0 || yoffset + height < 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "bad dimensions");

            return false;

        }

        if (xoffset + width > texture->getWidth(target, level) || yoffset + height > texture->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "dimensions out of range");

            return false;

        }

        if (texture->getInternalFormat(target, level) != format || texture->getType(target, level) != type) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type and format do not match texture");

            return false;

        }

    }

    return true;

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                       GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, format, type, pixels, NullAllowed)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))

        return;

    void* data = pixels ? pixels->baseAddress() : 0;

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, width, height, border,

                   format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

PassRefPtr<Image> WebGLRenderingContext::drawImageIntoBuffer(Image* image, int width, int height, int deviceScaleFactor)

{

    IntSize size(width, height);

    size.scale(deviceScaleFactor);

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    FloatRect srcRect(FloatPoint(), image->size());

    FloatRect destRect(FloatPoint(), size);

    buf->context()->drawImage(image, ColorSpaceDeviceRGB, destRect, srcRect);

    return buf->copyImage(ImageBuffer::fastCopyImageMode());

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))

        return;

    texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas, ec) || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))

        return;

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    // If possible, copy from the canvas element directly to the texture

    // via the GPU, without a read-back to system memory.

    //

    // FIXME: restriction of (RGB || RGBA)/UNSIGNED_BYTE should be lifted when

    // ImageBuffer::copyToPlatformTexture implementations are fully functional.

    if (GraphicsContext3D::TEXTURE_2D == target && texture && type == texture->getType(target, level)

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) {

        ImageBuffer* buffer = canvas->buffer();

        if (buffer && buffer->copyToPlatformTexture(*m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);

            return;

        }

    }

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texImage2D(target, level, internalformat, format, type, imageData.get(), ec);

    else

        texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

PassRefPtr<Image> WebGLRenderingContext::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy, ExceptionCode&)

{

    IntSize size(video->videoWidth(), video->videoHeight());

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    IntRect destRect(0, 0, size.width(), size.height());

    // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.

    video->paintCurrentFrameInContext(buf->context(), destRect);

    return buf->copyImage(backingStoreCopy);

}

void WebGLRenderingContext::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                       GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video, ec)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))

        return;

    // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.

    // Otherwise, it will fall back to the normal SW path.

    // FIXME: The current restrictions require that format shoud be RGB or RGBA,

    // type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    if (GraphicsContext3D::TEXTURE_2D == target && texture

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)

        && type == GraphicsContext3D::UNSIGNED_BYTE

        && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))

        && !level) {

        if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);

            return;

        }

    }

    // Normal pure SW path.

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("texParameter", target, false);

    if (!tex)

        return;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

        break;

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        if ((isFloat && paramf != GraphicsContext3D::CLAMP_TO_EDGE && paramf != GraphicsContext3D::MIRRORED_REPEAT && paramf != GraphicsContext3D::REPEAT)

            || (!isFloat && parami != GraphicsContext3D::CLAMP_TO_EDGE && parami != GraphicsContext3D::MIRRORED_REPEAT && parami != GraphicsContext3D::REPEAT)) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter");

            return;

        }

        break;

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (!m_extTextureFilterAnisotropic) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter name");

        return;

    }

    if (isFloat) {

        tex->setParameterf(pname, paramf);

        m_context->texParameterf(target, pname, paramf);

    } else {

        tex->setParameteri(pname, parami);

        m_context->texParameteri(target, pname, parami);

    }

}

void WebGLRenderingContext::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)

{

    texParameter(target, pname, param, 0, true);

}

void WebGLRenderingContext::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)

{

    texParameter(target, pname, 0, param, false);

}

void WebGLRenderingContext::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned

    ec = 0;

    ASSERT(!isContextLost());

    ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage2D, target, level, format, width, height, 0, format, type));

    ASSERT(validateSize("texSubImage2D", xoffset, yoffset));

    ASSERT(validateSettableTexFormat("texSubImage2D", format));

    WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);

    if (!tex) {

        ASSERT_NOT_REACHED();

        return;

    }

    ASSERT((xoffset + width) >= 0);

    ASSERT((yoffset + height) >= 0);

    ASSERT(tex->getWidth(target, level) >= (xoffset + width));

    ASSERT(tex->getHeight(target, level) >= (yoffset + height));

    ASSERT(tex->getInternalFormat(target, level) == format);

    ASSERT(tex->getType(target, level) == type);

    m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);

}

void WebGLRenderingContext::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);  

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, type,  needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Dsizei width, GC3Dsizei height,

                                          GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))

        return;

    void* data = pixels->baseAddress();

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLImageElement, target, level, format, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLCanvasElement, target, level, format, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);

    else

        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

void WebGLRenderingContext::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                          GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLVideoElement, target, level, format, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContext::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1f", "location not for current program");

        return;

    }

    m_context->uniform1f(location->location(), x);

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))

        return;

    m_context->uniform1fv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))

        return;

    m_context->uniform1fv(location->location(), size, v);

}

void WebGLRenderingContext::uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");

        return;

    }

    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");

        return;

    }

    m_context->uniform1i(location->location(), x);

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < v->length(); ++i) {

            if (v->data()[i] >= static_cast<int>(m_textureUnits.size())) {

                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v->data()[i], location->type());

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), v->length(), v->data());

}

void WebGLRenderingContext::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE)

        for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {

            if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    m_context->uniform1iv(location->location(), size, v);

}

void WebGLRenderingContext::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");

        return;

    }

    m_context->uniform2f(location->location(), x, y);

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))

        return;

    m_context->uniform2fv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))

        return;

    m_context->uniform2fv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2i", "location not for current program");

        return;

    }

    m_context->uniform2i(location->location(), x, y);

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))

        return;

    m_context->uniform2iv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContext::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))

        return;

    m_context->uniform2iv(location->location(), size / 2, v);

}

void WebGLRenderingContext::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");

        return;

    }

    m_context->uniform3f(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))

        return;

    m_context->uniform3fv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))

        return;

    m_context->uniform3fv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");

        return;

    }

    m_context->uniform3i(location->location(), x, y, z);

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))

        return;

    m_context->uniform3iv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContext::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))

        return;

    m_context->uniform3iv(location->location(), size / 3, v);

}

void WebGLRenderingContext::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");

        return;

    }

    m_context->uniform4f(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))

        return;

    m_context->uniform4fv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))

        return;

    m_context->uniform4fv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");

        return;

    }

    m_context->uniform4i(location->location(), x, y, z, w);

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))

        return;

    m_context->uniform4iv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContext::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))

        return;

    m_context->uniform4iv(location->location(), size / 4, v);

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());

}

void WebGLRenderingContext::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);

}

void WebGLRenderingContext::useProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("useProgram", program, deleted))

        return;

    if (deleted)

        program = 0;

    if (program && !program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "useProgram", "program not valid");

        return;

    }

    if (m_currentProgram != program) {

        if (m_currentProgram)

            m_currentProgram->onDetached(graphicsContext3D());

        m_currentProgram = program;

        m_context->useProgram(objectOrZero(program));

        if (program)

            program->onAttached();

    }

}

void WebGLRenderingContext::validateProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("validateProgram", program))

        return;

    m_context->validateProgram(objectOrZero(program));

}

void WebGLRenderingContext::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)

{

    vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);

}

void WebGLRenderingContext::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);

}

void WebGLRenderingContext::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)

{

    vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);

}

void WebGLRenderingContext::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);

}

void WebGLRenderingContext::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)

{

    vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);

}

void WebGLRenderingContext::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);

}

void WebGLRenderingContext::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);

}

void WebGLRenderingContext::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);

}

void WebGLRenderingContext::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    switch (type) {

    case GraphicsContext3D::BYTE:

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::SHORT:

    case GraphicsContext3D::UNSIGNED_SHORT:

    case GraphicsContext3D::FLOAT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "index out of range");

        return;

    }

    if (size < 1 || size > 4 || stride < 0 || stride > 255 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "bad size, stride or offset");

        return;

    }

    if (!m_boundArrayBuffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");

        return;

    }

    // Determine the number of elements the bound buffer can hold, given the offset, size, type and stride

    unsigned int typeSize = sizeInBytes(type);

    if (!typeSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if ((stride % typeSize) || (static_cast<GC3Dintptr>(offset) % typeSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");

        return;

    }

    GC3Dsizei bytesPerElement = size * typeSize;

    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GC3Dintptr>(offset), m_boundArrayBuffer);

    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GC3Dintptr>(offset));

}

void WebGLRenderingContext::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("viewport", width, height))

        return;

    m_context->viewport(x, y, width, height);

}

void WebGLRenderingContext::forceLostContext(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "loseContext", "context already lost");

        return;

    }

    m_contextGroup->loseContextGroup(mode);

}

void WebGLRenderingContext::loseContextImpl(WebGLRenderingContext::LostContextMode mode)

{

    if (isContextLost())

        return;

    m_contextLost = true;

    m_contextLostMode = mode;

    if (mode == RealLostContext) {

        // Inform the embedder that a lost context was received. In response, the embedder might

        // decide to take action such as asking the user for permission to use WebGL again.

        if (Frame* frame = canvas()->document().frame())

            frame->loader().client().didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());

    }

    detachAndRemoveAllObjects();

    if (m_drawingBuffer) {

        // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.

        m_drawingBuffer->setTexture2DBinding(0);

        m_drawingBuffer->setFramebufferBinding(0);

    }

    // There is no direct way to clear errors from a GL implementation and

    // looping until getError() becomes NO_ERROR might cause an infinite loop if

    // the driver or context implementation had a bug. So, loop a reasonably

    // large number of times to clear any existing errors.

    for (int i = 0; i < 100; ++i) {

        if (m_context->getError() == GraphicsContext3D::NO_ERROR)

            break;

    }

    ConsoleDisplayPreference display = (mode == RealLostContext) ? DisplayInConsole: DontDisplayInConsole;

    synthesizeGLError(GraphicsContext3D::CONTEXT_LOST_WEBGL, "loseContext", "context lost", display);

    // Don't allow restoration unless the context lost event has both been

    // dispatched and its default behavior prevented.

    m_restoreAllowed = false;

    // Always defer the dispatch of the context lost event, to implement

    // the spec behavior of queueing a task.

    m_dispatchContextLostEventTimer.startOneShot(0);

}

void WebGLRenderingContext::forceRestoreContext()

{

    if (!isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context not lost");

        return;

    }

    if (!m_restoreAllowed) {

        if (m_contextLostMode == SyntheticLostContext)

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context restoration not allowed");

        return;

    }

    if (!m_restoreTimer.isActive())

        m_restoreTimer.startOneShot(0);

}

PlatformLayer* WebGLRenderingContext::platformLayer() const

{

    return (!isContextLost() && !m_isPendingPolicyResolution) ? m_context->platformLayer() : 0;

}

void WebGLRenderingContext::removeSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextGroup->removeObject(object);

}

void WebGLRenderingContext::addSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextGroup->addObject(object);

}

void WebGLRenderingContext::removeContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextObjects.remove(object);

}

void WebGLRenderingContext::addContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextObjects.add(object);

}

void WebGLRenderingContext::detachAndRemoveAllObjects()

{

    if (m_isPendingPolicyResolution)

        return;

    while (m_contextObjects.size() > 0) {

        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();

        (*it)->detachContext();

    }

}

bool WebGLRenderingContext::hasPendingActivity() const

{

    return false;

}

void WebGLRenderingContext::stop()

{

    if (!isContextLost() && !m_isPendingPolicyResolution) {

        forceLostContext(SyntheticLostContext);

        destroyGraphicsContext3D();

    }

}

WebGLGetInfo WebGLRenderingContext::getBooleanParameter(GC3Denum pname)

{

    GC3Dboolean value = 0;

    m_context->getBooleanv(pname, &value);

    return WebGLGetInfo(static_cast<bool>(value));

}

WebGLGetInfo WebGLRenderingContext::getBooleanArrayParameter(GC3Denum pname)

{

    if (pname != GraphicsContext3D::COLOR_WRITEMASK) {

        notImplemented();

        return WebGLGetInfo(0, 0);

    }

    GC3Dboolean value[4] = {0};

    m_context->getBooleanv(pname, value);

    bool boolValue[4];

    for (int ii = 0; ii < 4; ++ii)

        boolValue[ii] = static_cast<bool>(value[ii]);

    return WebGLGetInfo(boolValue, 4);

}

WebGLGetInfo WebGLRenderingContext::getFloatParameter(GC3Denum pname)

{

    GC3Dfloat value = 0;

    m_context->getFloatv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContext::getUnsignedIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(static_cast<unsigned int>(value));

}

WebGLGetInfo WebGLRenderingContext::getWebGLFloatArrayParameter(GC3Denum pname)

{

    GC3Dfloat value[4] = {0};

    m_context->getFloatv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

    case GraphicsContext3D::DEPTH_RANGE:

        length = 2;

        break;

    case GraphicsContext3D::BLEND_COLOR:

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Float32Array::create(value, length));

}

WebGLGetInfo WebGLRenderingContext::getWebGLIntArrayParameter(GC3Denum pname)

{

    GC3Dint value[4] = {0};

    m_context->getIntegerv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        length = 2;

        break;

    case GraphicsContext3D::SCISSOR_BOX:

    case GraphicsContext3D::VIEWPORT:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Int32Array::create(value, length));

}

void WebGLRenderingContext::checkTextureCompleteness(const char* functionName, bool prepareToDraw)

{

    bool resetActiveUnit = false;

    WebGLTexture::TextureExtensionFlag extensions = static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureExtensionFloatLinearEnabled : 0) | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureExtensionHalfFloatLinearEnabled : 0));

    for (unsigned ii = 0; ii < m_textureUnits.size(); ++ii) {

        if ((m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

            || (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))) {

            if (ii != m_activeTextureUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = true;

            } else if (resetActiveUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = false;

            }

            WebGLTexture* tex2D;

            WebGLTexture* texCubeMap;

            if (prepareToDraw) {

                String msg(String("texture bound to texture unit ") + String::number(ii)

                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete',"

                    + " or it is a float/half-float type with linear filtering and without the relevant float/half-float linear extension enabled.");

                printGLWarningToConsole(functionName, msg.utf8().data());

                tex2D = m_blackTexture2D.get();

                texCubeMap = m_blackTextureCubeMap.get();

            } else {

                tex2D = m_textureUnits[ii].texture2DBinding.get();

                texCubeMap = m_textureUnits[ii].textureCubeMapBinding.get();

            }

            if (m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));

            if (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));

        }

    }

    if (resetActiveUnit)

        m_context->activeTexture(m_activeTextureUnit);

}

void WebGLRenderingContext::createFallbackBlackTextures1x1()

{

    unsigned char black[] = {0, 0, 0, 255};

    m_blackTexture2D = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_blackTexture2D->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);

    m_blackTextureCubeMap = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, 0);

}

bool WebGLRenderingContext::isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                                           GC3Denum colorBufferFormat)

{

    unsigned need = GraphicsContext3D::getChannelBitsByFormat(texInternalFormat);

    unsigned have = GraphicsContext3D::getChannelBitsByFormat(colorBufferFormat);

    return (need & have) == need;

}

GC3Denum WebGLRenderingContext::getBoundFramebufferColorFormat()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferFormat();

    if (m_attributes.alpha)

        return GraphicsContext3D::RGBA;

    return GraphicsContext3D::RGB;

}

int WebGLRenderingContext::getBoundFramebufferWidth()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferWidth();

    return m_drawingBuffer ? m_drawingBuffer->size().width() : m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContext::getBoundFramebufferHeight()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferHeight();

    return m_drawingBuffer ? m_drawingBuffer->size().height() : m_context->getInternalFramebufferSize().height();

}

WebGLTexture* WebGLRenderingContext::validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap)

{

    WebGLTexture* texture = nullptr;

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        texture = m_textureUnits[m_activeTextureUnit].texture2DBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (!useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP:

        if (useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

        return nullptr;

    }

    if (!texture)

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no texture");

    return texture;

}

bool WebGLRenderingContext::validateLocationLength(const char* functionName, const String& string)

{

    const unsigned maxWebGLLocationLength = 256;

    if (string.length() > maxWebGLLocationLength) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "location length > 256");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateSize(const char* functionName, GC3Dint x, GC3Dint y)

{

    if (x < 0 || y < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "size < 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateString(const char* functionName, const String& string)

{

    for (size_t i = 0; i < string.length(); ++i) {

        if (!validateCharacter(string[i])) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "string not ASCII");

            return false;

        }

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level)

{

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");

        return false;

    case Extensions3D::SRGB_EXT:

    case Extensions3D::SRGB_ALPHA_EXT:

    default:

        if ((format == Extensions3D::SRGB_EXT || format == Extensions3D::SRGB_ALPHA_EXT)

            && m_extsRGB)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture format");

        return false;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    case GraphicsContext3D::FLOAT:

        if (m_oesTextureFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::HALF_FLOAT_OES:

        if (m_oesTextureHalfFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::UNSIGNED_INT:

    case GraphicsContext3D::UNSIGNED_INT_24_8:

    case GraphicsContext3D::UNSIGNED_SHORT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    }

    // Verify that the combination of format and type is supported.

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for format");

            return false;

        }

        break;

    case GraphicsContext3D::RGB:

    case Extensions3D::SRGB_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_6_5

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGB format");

            return false;

        }

        break;

    case GraphicsContext3D::RGBA:

    case Extensions3D::SRGB_ALPHA_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGBA format");

            return false;

        }

        break;

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_COMPONENT not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_SHORT

            && type != GraphicsContext3D::UNSIGNED_INT) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_COMPONENT format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_COMPONENT format");

          return false;

        }

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_STENCIL not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_INT_24_8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_STENCIL format");

            return false;

        }

        if (level > 0) {

          synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_STENCIL format");

          return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level)

{

    if (level < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level < 0");

        return false;

    }

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (level >= m_maxTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (level >= m_maxCubeMapTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    }

    // This function only checks if level is legal, so we return true and don't

    // generate INVALID_ENUM if target is illegal.

    return true;

}

bool WebGLRenderingContext::validateTexFuncParameters(const char* functionName,

                                                      TexFuncValidationFunctionType functionType,

                                                      GC3Denum target, GC3Dint level,

                                                      GC3Denum internalformat,

                                                      GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                                      GC3Denum format, GC3Denum type)

{

    // We absolutely have to validate the format and type combination.

    // The texImage2D entry points taking HTMLImage, etc. will produce

    // temporary data based on this combination, so it must be legal.

    if (!validateTexFuncFormatAndType(functionName, format, type, level) || !validateTexFuncLevel(functionName, target, level))

        return false;

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (functionType != TexSubImage2D && width != height) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");

            return false;

        }

        // No need to check height here. For texImage width == height.

        // For texSubImage that will be checked when checking yoffset + height is in range.

        if (width > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range for cube map");

            return false;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    if (format != internalformat) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format != internalformat");

        return false;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "border != 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateTexFuncData(const char* functionName, GC3Dint level,

                                                GC3Dsizei width, GC3Dsizei height,

                                                GC3Denum format, GC3Denum type,

                                                ArrayBufferView* pixels,

                                                NullDisposition disposition)

{

    if (!pixels) {

        if (disposition == NullAllowed)

            return true;

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (!validateTexFuncFormatAndType(functionName, format, type, level))

        return false;

    if (!validateSettableTexFormat(functionName, format))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

        if (pixels->getType() != JSC::TypeUint8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_BYTE but ArrayBufferView not Uint8Array");

            return false;

        }

        break;

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        if (pixels->getType() != JSC::TypeUint16) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_SHORT but ArrayBufferView not Uint16Array");

            return false;

        }

        break;

    case GraphicsContext3D::FLOAT: // OES_texture_float

        if (pixels->getType() != JSC::TypeFloat32) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");

            return false;

        }

        break;

    case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float

        // As per the specification, ArrayBufferView should be null when

        // OES_texture_half_float is enabled.

        if (pixels) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL");

            return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    unsigned int totalBytesRequired;

    GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);

    if (error != GraphicsContext3D::NO_ERROR) {

        synthesizeGLError(error, functionName, "invalid texture dimensions");

        return false;

    }

    if (pixels->byteLength() < totalBytesRequired) {

        if (m_unpackAlignment != 1) {

          error = m_context->computeImageSizeInBytes(format, type, width, height, 1, &totalBytesRequired, 0);

          if (pixels->byteLength() == totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request with UNPACK_ALIGNMENT > 1");

            return false;

          }

        }

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexFormat(GC3Denum format)

{

    return m_compressedTextureFormats.contains(format);

}

bool WebGLRenderingContext::validateCompressedTexFuncData(const char* functionName,

                                                          GC3Dsizei width, GC3Dsizei height,

                                                          GC3Denum format, ArrayBufferView* pixels)

{

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    unsigned int bytesRequired = 0;

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_ATC_RGB_AMD:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT:

    case Extensions3D::COMPRESSED_ATC_RGBA_EXPLICIT_ALPHA_AMD:

    case Extensions3D::COMPRESSED_ATC_RGBA_INTERPOLATED_ALPHA_AMD:

        {

            const int kBlockSize = 16;

            const int kBlockWidth = 4;

            const int kBlockHeight = 4;

            int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

            int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

            bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 8;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 4 + 7) / kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        {

            const int kBlockSize = 8;

            const int kBlockWidth = 16;

            const int kBlockHeight = 8;

            bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 2 + 7) / kBlockSize;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format");

        return false;

    }

    if (pixels->byteLength() != bytesRequired) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "length of ArrayBufferView is not correct for dimensions");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format)

{

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const GC3Dsizei kBlockWidth = 4;

        const GC3Dsizei kBlockHeight = 4;

        const GC3Dint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;

        const GC3Dsizei maxCompressedDimension = maxTextureSize >> level;

        bool widthValid = (level && width == 1) || (level && width == 2) || (!(width % kBlockWidth) && width <= maxCompressedDimension);

        bool heightValid = (level && height == 1) || (level && height == 2) || (!(height % kBlockHeight) && height <= maxCompressedDimension);

        if (!widthValid || !heightValid) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        // Height and width must be powers of 2.

        if ((width & (width - 1)) || (height & (height - 1))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                               GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture* tex)

{

    if (xoffset < 0 || yoffset < 0) {

      synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "xoffset or yoffset < 0");

      return false;

    }

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset or yoffset not multiple of 4");

            return false;

        }

        if (width - xoffset > tex->getWidth(target, level)

            || height - yoffset > tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions out of range");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: {

        if (xoffset || yoffset) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset and yoffset must be zero");

            return false;

        }

        if (width != tex->getWidth(target, level)

            || height != tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions must match existing level");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    default:

        return false;

    }

}

bool WebGLRenderingContext::validateDrawMode(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::POINTS:

    case GraphicsContext3D::LINE_STRIP:

    case GraphicsContext3D::LINE_LOOP:

    case GraphicsContext3D::LINES:

    case GraphicsContext3D::TRIANGLE_STRIP:

    case GraphicsContext3D::TRIANGLE_FAN:

    case GraphicsContext3D::TRIANGLES:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid draw mode");

        return false;

    }

}

bool WebGLRenderingContext::validateStencilSettings(const char* functionName)

{

    if (m_stencilMask != m_stencilMaskBack || m_stencilFuncRef != m_stencilFuncRefBack || m_stencilFuncMask != m_stencilFuncMaskBack) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "front and back stencils settings do not match");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateStencilFunc(const char* functionName, GC3Denum func)

{

    switch (func) {

    case GraphicsContext3D::NEVER:

    case GraphicsContext3D::LESS:

    case GraphicsContext3D::LEQUAL:

    case GraphicsContext3D::GREATER:

    case GraphicsContext3D::GEQUAL:

    case GraphicsContext3D::EQUAL:

    case GraphicsContext3D::NOTEQUAL:

    case GraphicsContext3D::ALWAYS:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid function");

        return false;

    }

}

void WebGLRenderingContext::printGLErrorToConsole(const String& message)

{

    if (!m_numGLErrorsToConsoleAllowed)

        return;

    --m_numGLErrorsToConsoleAllowed;

    printWarningToConsole(message);

    if (!m_numGLErrorsToConsoleAllowed)

        printWarningToConsole("WebGL: too many errors, no more errors will be reported to the console for this context.");

}

void WebGLRenderingContext::printWarningToConsole(const String& message)

{

    if (!canvas())

        return;

    canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);

}

bool WebGLRenderingContext::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)

{

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    switch (attachment) {

    case GraphicsContext3D::COLOR_ATTACHMENT0:

    case GraphicsContext3D::DEPTH_ATTACHMENT:

    case GraphicsContext3D::STENCIL_ATTACHMENT:

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        break;

    default:

        if (m_webglDrawBuffers

            && attachment > GraphicsContext3D::COLOR_ATTACHMENT0

            && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::FUNC_ADD:

    case GraphicsContext3D::FUNC_SUBTRACT:

    case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:

    case Extensions3D::MIN_EXT:

    case Extensions3D::MAX_EXT:

        if ((mode == Extensions3D::MIN_EXT || mode == Extensions3D::MAX_EXT) && !m_extBlendMinMax) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

            return false;

        }

        return true;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

        return false;

    }

}

bool WebGLRenderingContext::validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst)

{

    if (((src == GraphicsContext3D::CONSTANT_COLOR || src == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

         && (dst == GraphicsContext3D::CONSTANT_ALPHA || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))

        || ((dst == GraphicsContext3D::CONSTANT_COLOR || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

            && (src == GraphicsContext3D::CONSTANT_ALPHA || src == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "incompatible src and dst");

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateCapability(const char* functionName, GC3Denum cap)

{

    switch (cap) {

    case GraphicsContext3D::BLEND:

    case GraphicsContext3D::CULL_FACE:

    case GraphicsContext3D::DEPTH_TEST:

    case GraphicsContext3D::DITHER:

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

    case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:

    case GraphicsContext3D::SAMPLE_COVERAGE:

    case GraphicsContext3D::SCISSOR_TEST:

    case GraphicsContext3D::STENCIL_TEST:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");

        return false;

    }

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Int32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, transpose, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContext::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    if (!location)

        return false;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "location is not from current program");

        return false;

    }

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    if (transpose) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "transpose not FALSE");

        return false;

    }

    if (size < requiredMinSize || (size % requiredMinSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return false;

    }

    return true;

}

WebGLBuffer* WebGLRenderingContext::validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage)

{

    WebGLBuffer* buffer = 0;

    switch (target) {

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER:

        buffer = m_boundVertexArrayObject->getElementArrayBuffer().get();

        break;

    case GraphicsContext3D::ARRAY_BUFFER:

        buffer = m_boundArrayBuffer.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return nullptr;

    }

    if (!buffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no buffer");

        return nullptr;

    }

    switch (usage) {

    case GraphicsContext3D::STREAM_DRAW:

    case GraphicsContext3D::STATIC_DRAW:

    case GraphicsContext3D::DYNAMIC_DRAW:

        return buffer;

    }

    synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid usage");

    return nullptr;

}

bool WebGLRenderingContext::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionCode& ec)

{

    if (!image || !image->cachedImage()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");

        return false;

    }

    const URL& url = image->cachedImage()->response().url();

    if (url.isNull() || url.isEmpty() || !url.isValid()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");

        return false;

    }

    if (wouldTaintOrigin(image)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

bool WebGLRenderingContext::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    if (!canvas || !canvas->buffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no canvas");

        return false;

    }

    if (wouldTaintOrigin(canvas)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#if ENABLE(VIDEO)

bool WebGLRenderingContext::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video, ExceptionCode& ec)

{

    if (!video || !video->videoWidth() || !video->videoHeight()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no video");

        return false;

    }

    if (wouldTaintOrigin(video)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#endif

void WebGLRenderingContext::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1f(index, v0);

            break;

        case 2:

            m_context->vertexAttrib2f(index, v0, v1);

            break;

        case 3:

            m_context->vertexAttrib3f(index, v0, v1, v2);

            break;

        case 4:

            m_context->vertexAttrib4f(index, v0, v1, v2, v3);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.value[0] = v0;

    attribValue.value[1] = v1;

    attribValue.value[2] = v2;

    attribValue.value[3] = v3;

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array* v, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    vertexAttribfvImpl(functionName, index, v->data(), v->length(), expectedSize);

}

void WebGLRenderingContext::vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat* v, GC3Dsizei size, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    if (size < expectedSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1fv(index, v);

            break;

        case 2:

            m_context->vertexAttrib2fv(index, v);

            break;

        case 3:

            m_context->vertexAttrib3fv(index, v);

            break;

        case 4:

            m_context->vertexAttrib4fv(index, v);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.initValue();

    for (int ii = 0; ii < expectedSize; ++ii)

        attribValue.value[ii] = v[ii];

}

void WebGLRenderingContext::initVertexAttrib0()

{

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    m_vertexAttrib0Buffer = createBuffer();

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, 0, GraphicsContext3D::DYNAMIC_DRAW);

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, false, 0, 0);

    state.bufferBinding = m_vertexAttrib0Buffer;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, 0);

    m_context->enableVertexAttribArray(0);

    m_vertexAttrib0BufferSize = 0;

    m_vertexAttrib0BufferValue[0] = 0.0f;

    m_vertexAttrib0BufferValue[1] = 0.0f;

    m_vertexAttrib0BufferValue[2] = 0.0f;

    m_vertexAttrib0BufferValue[3] = 1.0f;

    m_forceAttrib0BufferRefill = false;

    m_vertexAttrib0UsedBefore = false;

}

bool WebGLRenderingContext::simulateVertexAttrib0(GC3Dsizei numVertex)

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    const VertexAttribValue& attribValue = m_vertexAttribValue[0];

    if (!m_currentProgram)

        return false;

    bool usingVertexAttrib0 = m_currentProgram->isUsingVertexAttrib0();

    if (usingVertexAttrib0)

        m_vertexAttrib0UsedBefore = true;

    if (state.enabled && usingVertexAttrib0)

        return false;

    if (!usingVertexAttrib0 && !m_vertexAttrib0UsedBefore)

        return false;

    m_vertexAttrib0UsedBefore = true;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    GC3Dsizeiptr bufferDataSize = (numVertex + 1) * 4 * sizeof(GC3Dfloat);

    if (bufferDataSize > m_vertexAttrib0BufferSize) {

        m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, bufferDataSize, 0, GraphicsContext3D::DYNAMIC_DRAW);

        m_vertexAttrib0BufferSize = bufferDataSize;

        m_forceAttrib0BufferRefill = true;

    }

    if (usingVertexAttrib0

        && (m_forceAttrib0BufferRefill

            || attribValue.value[0] != m_vertexAttrib0BufferValue[0]

            || attribValue.value[1] != m_vertexAttrib0BufferValue[1]

            || attribValue.value[2] != m_vertexAttrib0BufferValue[2]

            || attribValue.value[3] != m_vertexAttrib0BufferValue[3])) {

        auto bufferData = std::make_unique<GC3Dfloat[]>((numVertex + 1) * 4);

        for (GC3Dsizei ii = 0; ii < numVertex + 1; ++ii) {

            bufferData[ii * 4] = attribValue.value[0];

            bufferData[ii * 4 + 1] = attribValue.value[1];

            bufferData[ii * 4 + 2] = attribValue.value[2];

            bufferData[ii * 4 + 3] = attribValue.value[3];

        }

        m_vertexAttrib0BufferValue[0] = attribValue.value[0];

        m_vertexAttrib0BufferValue[1] = attribValue.value[1];

        m_vertexAttrib0BufferValue[2] = attribValue.value[2];

        m_vertexAttrib0BufferValue[3] = attribValue.value[3];

        m_forceAttrib0BufferRefill = false;

        m_context->bufferSubData(GraphicsContext3D::ARRAY_BUFFER, 0, bufferDataSize, bufferData.get());

    }

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, 0, 0, 0);

    return true;

}

void WebGLRenderingContext::restoreStatesAfterVertexAttrib0Simulation()

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    if (state.bufferBinding != m_vertexAttrib0Buffer) {

        m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(state.bufferBinding.get()));

        m_context->vertexAttribPointer(0, state.size, state.type, state.normalized, state.originalStride, state.offset);

    }

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));

}

void WebGLRenderingContext::dispatchContextLostEvent()

{

    RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");

    canvas()->dispatchEvent(event);

    m_restoreAllowed = event->defaultPrevented();

    if (m_contextLostMode == RealLostContext && m_restoreAllowed)

        m_restoreTimer.startOneShot(0);

}

void WebGLRenderingContext::maybeRestoreContext()

{

    ASSERT(m_contextLost);

    if (!m_contextLost)

        return;

    // The rendering context is not restored unless the default behavior of the

    // webglcontextlost event was prevented earlier.

    //

    // Because of the way m_restoreTimer is set up for real vs. synthetic lost

    // context events, we don't have to worry about this test short-circuiting

    // the retry loop for real context lost events.

    if (!m_restoreAllowed)

        return;

    int contextLostReason = m_context->getExtensions()->getGraphicsResetStatusARB();

    switch (contextLostReason) {

    case GraphicsContext3D::NO_ERROR:

        // The GraphicsContext3D implementation might not fully

        // support GL_ARB_robustness semantics yet. Alternatively, the

        // WEBGL_lose_context extension might have been used to force

        // a lost context.

        break;

    case Extensions3D::GUILTY_CONTEXT_RESET_ARB:

        // The rendering context is not restored if this context was

        // guilty of causing the graphics reset.

        printWarningToConsole("WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");

        return;

    case Extensions3D::INNOCENT_CONTEXT_RESET_ARB:

        // Always allow the context to be restored.

        break;

    case Extensions3D::UNKNOWN_CONTEXT_RESET_ARB:

        // Warn. Ideally, prompt the user telling them that WebGL

        // content on the page might have caused the graphics card to

        // reset and ask them whether they want to continue running

        // the content. Only if they say "yes" should we start

        // attempting to restore the context.

        printWarningToConsole("WARNING: WebGL content on the page might have caused the graphics card to reset");

        break;

    }

    Frame* frame = canvas()->document().frame();

    if (!frame)

        return;

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled()))

        return;

    FrameView* view = frame->view();

    if (!view)

        return;

    ScrollView* root = view->root();

    if (!root)

        return;

    HostWindow* hostWindow = root->hostWindow();

    if (!hostWindow)

        return;

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, hostWindow));

    if (!context) {

        if (m_contextLostMode == RealLostContext)

            m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);

        else

            // This likely shouldn't happen but is the best way to report it to the WebGL app.

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "", "error restoring context");

        return;

    }

    // Construct a new drawing buffer with the new GraphicsContext3D.

    if (m_drawingBuffer) {

        m_drawingBuffer->discardResources();

        DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;

        DrawingBuffer::AlphaRequirement alpha = m_attributes.alpha ? DrawingBuffer::Alpha : DrawingBuffer::Opaque;

        m_drawingBuffer = DrawingBuffer::create(context.get(), m_drawingBuffer->size(), preserve, alpha);

        m_drawingBuffer->bind();

    }

    m_context = context;

    m_contextLost = false;

    setupFlags();

    initializeNewContext();

    canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, ""));

}

String WebGLRenderingContext::ensureNotNull(const String& text) const

{

    if (text.isNull())

        return WTF::emptyString();

    return text;

}

WebGLRenderingContext::LRUImageBufferCache::LRUImageBufferCache(int capacity)

    : m_buffers(std::make_unique<std::unique_ptr<ImageBuffer>[]>(capacity))

    , m_capacity(capacity)

{

}

ImageBuffer* WebGLRenderingContext::LRUImageBufferCache::imageBuffer(const IntSize& size)

{

    int i;

    for (i = 0; i < m_capacity; ++i) {

        ImageBuffer* buf = m_buffers[i].get();

        if (!buf)

            break;

        if (buf->logicalSize() != size)

            continue;

        bubbleToFront(i);

        return buf;

    }

    std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, 1);

    if (!temp)

        return nullptr;

    i = std::min(m_capacity - 1, i);

    m_buffers[i] = WTF::move(temp);

    ImageBuffer* buf = m_buffers[i].get();

    bubbleToFront(i);

    return buf;

}

void WebGLRenderingContext::LRUImageBufferCache::bubbleToFront(int idx)

{

    for (int i = idx; i > 0; --i)

        m_buffers[i].swap(m_buffers[i-1]);

}

namespace {

    String GetErrorString(GC3Denum error)

    {

        switch (error) {

        case GraphicsContext3D::INVALID_ENUM:

            return "INVALID_ENUM";

        case GraphicsContext3D::INVALID_VALUE:

            return "INVALID_VALUE";

        case GraphicsContext3D::INVALID_OPERATION:

            return "INVALID_OPERATION";

        case GraphicsContext3D::OUT_OF_MEMORY:

            return "OUT_OF_MEMORY";

        case GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION:

            return "INVALID_FRAMEBUFFER_OPERATION";

        case GraphicsContext3D::CONTEXT_LOST_WEBGL:

            return "CONTEXT_LOST_WEBGL";

        default:

            return String::format("WebGL ERROR(%04x)", error);

        }

    }

} // namespace anonymous

void WebGLRenderingContext::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)

{

    if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {

      String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);

      printGLErrorToConsole(str);

    }

    m_context->synthesizeGLError(error);

}

void WebGLRenderingContext::printGLWarningToConsole(const char* functionName, const char* description)

{

    if (m_synthesizedErrorsToConsole) {

        String str = String("WebGL: ") + String(functionName) + ": " + String(description);

        printGLErrorToConsole(str);

    }

}

void WebGLRenderingContext::applyStencilTest()

{

    bool haveStencilBuffer = false;

    if (m_framebufferBinding)

        haveStencilBuffer = m_framebufferBinding->hasStencilBuffer();

    else {

        RefPtr<WebGLContextAttributes> attributes = getContextAttributes();

        haveStencilBuffer = attributes->stencil();

    }

    enableOrDisable(GraphicsContext3D::STENCIL_TEST,

                    m_stencilEnabled && haveStencilBuffer);

}

void WebGLRenderingContext::enableOrDisable(GC3Denum capability, bool enable)

{

    if (enable)

        m_context->enable(capability);

    else

        m_context->disable(capability);

}

IntSize WebGLRenderingContext::clampedCanvasSize()

{

    return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),

                   clamp(canvas()->height(), 1, m_maxViewportDims[1]));

}

GC3Dint WebGLRenderingContext::getMaxDrawBuffers()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxDrawBuffers)

        m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.

    return std::min(m_maxDrawBuffers, m_maxColorAttachments);

}

GC3Dint WebGLRenderingContext::getMaxColorAttachments()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    return m_maxColorAttachments;

}

void WebGLRenderingContext::setBackDrawBuffer(GC3Denum buf)

{

    m_backDrawBuffer = buf;

}

void WebGLRenderingContext::restoreCurrentFramebuffer()

{

    ExceptionCode ec;

    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);

}

void WebGLRenderingContext::restoreCurrentTexture2D()

{

    ExceptionCode ec;

    bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].texture2DBinding.get(), ec);

}

bool WebGLRenderingContext::supportsDrawBuffers()

{

    if (!m_drawBuffersWebGLRequirementsChecked) {

        m_drawBuffersWebGLRequirementsChecked = true;

        m_drawBuffersSupported = WebGLDrawBuffers::supported(this);

    }

    return m_drawBuffersSupported;

}

void WebGLRenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    if (!validateDrawArrays("drawArraysInstanced", mode, first, count, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", true);

    m_context->drawArraysInstanced(mode, first, count, primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    unsigned numElements = 0;

    if (!validateDrawElements("drawElementsInstanced", mode, count, type, offset, numElements, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", true);

    m_context->drawElementsInstanced(mode, count, type, static_cast<GC3Dintptr>(offset), primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", false);

    markContextChanged();

}

void WebGLRenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribDivisor", "index out of range");

        return;

    }

    m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);

    m_context->vertexAttribDivisor(index, divisor);

}

} // namespace WebCore

#endif // ENABLE(WEBGL)

178372

Source/WebCore/html/canvas/WebGLRenderingContext.h

/*

 * Copyright (C) 2009, 2014 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#ifndef WebGLRenderingContext_h

#define WebGLRenderingContext_h

#include "ActiveDOMObject.h"

#include "CanvasRenderingContext.h"

#include "DrawingBuffer.h"

#include "GraphicsContext3D.h"

#include "ImageBuffer.h"

#include "Timer.h"

#include "WebGLGetInfo.h"

#include <memory>

#include <runtime/Float32Array.h>

#include <runtime/Int32Array.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

class ANGLEInstancedArrays;

class EXTBlendMinMax;

class EXTTextureFilterAnisotropic;

class EXTShaderTextureLOD;

class EXTsRGB;

class EXTFragDepth;

class HTMLImageElement;

class HTMLVideoElement;

class ImageBuffer;

class ImageData;

class IntSize;

class OESStandardDerivatives;

class OESTextureFloat;

class OESTextureFloatLinear;

class OESTextureHalfFloat;

class OESTextureHalfFloatLinear;

class OESVertexArrayObject;

class OESElementIndexUint;

class WebGLActiveInfo;

class WebGLBuffer;

class WebGLContextGroup;

class WebGLContextObject;

class WebGLCompressedTextureATC;

class WebGLCompressedTexturePVRTC;

class WebGLCompressedTextureS3TC;

class WebGLContextAttributes;

class WebGLDebugRendererInfo;

class WebGLDebugShaders;

class WebGLDepthTexture;

class WebGLDrawBuffers;

class WebGLExtension;

class WebGLFramebuffer;

class WebGLLoseContext;

class WebGLObject;

class WebGLProgram;

class WebGLRenderbuffer;

class WebGLShader;

class WebGLSharedObject;

class WebGLShaderPrecisionFormat;

class WebGLTexture;

class WebGLUniformLocation;

class WebGLVertexArrayObjectOES;

typedef int ExceptionCode;

class WebGLRenderingContext final : public CanvasRenderingContext, public ActiveDOMObject {

public:

    static std::unique_ptr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);

    virtual ~WebGLRenderingContext();

    virtual bool is3d() const override { return true; }

#if PLATFORM(WIN)

    // FIXME: Implement accelerated 3d canvas on Windows.

    virtual bool isAccelerated() const override { return false; }

#else

    virtual bool isAccelerated() const override { return true; }

#endif

    int drawingBufferWidth() const;

    int drawingBufferHeight() const;

    void activeTexture(GC3Denum texture, ExceptionCode&);

    void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);

    void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);

    void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);

    void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);

    void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);

    void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void blendEquation(GC3Denum mode);

    void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);

    void blendFunc(GC3Denum sfactor, GC3Denum dfactor);

    void blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha);

    void bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode&);

    void bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode&);

    void bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode&);

    GC3Denum checkFramebufferStatus(GC3Denum target);

    void clear(GC3Dbitfield mask);

    void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);

    void clearDepth(GC3Dfloat);

    void clearStencil(GC3Dint);

    void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);

    void compileShader(WebGLShader*, ExceptionCode&);

    void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                              GC3Dsizei height, GC3Dint border, ArrayBufferView* data);

    void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                 GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);

    void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);

    void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    PassRefPtr<WebGLBuffer> createBuffer();

    PassRefPtr<WebGLFramebuffer> createFramebuffer();

    PassRefPtr<WebGLProgram> createProgram();

    PassRefPtr<WebGLRenderbuffer> createRenderbuffer();

    PassRefPtr<WebGLShader> createShader(GC3Denum type, ExceptionCode&);

    PassRefPtr<WebGLTexture> createTexture();

    void cullFace(GC3Denum mode);

    void deleteBuffer(WebGLBuffer*);

    void deleteFramebuffer(WebGLFramebuffer*);

    void deleteProgram(WebGLProgram*);

    void deleteRenderbuffer(WebGLRenderbuffer*);

    void deleteShader(WebGLShader*);

    void deleteTexture(WebGLTexture*);

    void depthFunc(GC3Denum);

    void depthMask(GC3Dboolean);

    void depthRange(GC3Dfloat zNear, GC3Dfloat zFar);

    void detachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);

    void disable(GC3Denum cap);

    void disableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode&);

    void drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode&);

    void enable(GC3Denum cap);

    void enableVertexAttribArray(GC3Duint index, ExceptionCode&);

    void finish();

    void flush();

    void framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer*, ExceptionCode&);

    void framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture*, GC3Dint level, ExceptionCode&);

    void frontFace(GC3Denum mode);

    void generateMipmap(GC3Denum target);

    PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);

    PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);

    bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader>>&, ExceptionCode&);

    GC3Dint getAttribLocation(WebGLProgram*, const String& name);

    WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    PassRefPtr<WebGLContextAttributes> getContextAttributes();

    GC3Denum getError();

    WebGLExtension* getExtension(const String& name);

    WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);

    String getProgramInfoLog(WebGLProgram*, ExceptionCode&);

    WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);

    String getShaderInfoLog(WebGLShader*, ExceptionCode&);

    PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);

    String getShaderSource(WebGLShader*, ExceptionCode&);

    Vector<String> getSupportedExtensions();

    WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);

    WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);

    PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);

    WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);

    long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);

    void hint(GC3Denum target, GC3Denum mode);

    GC3Dboolean isBuffer(WebGLBuffer*);

    bool isContextLost() const;

    GC3Dboolean isEnabled(GC3Denum cap);

    GC3Dboolean isFramebuffer(WebGLFramebuffer*);

    GC3Dboolean isProgram(WebGLProgram*);

    GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);

    GC3Dboolean isShader(WebGLShader*);

    GC3Dboolean isTexture(WebGLTexture*);

    void lineWidth(GC3Dfloat);

    void linkProgram(WebGLProgram*, ExceptionCode&);

    void pixelStorei(GC3Denum pname, GC3Dint param);

    void polygonOffset(GC3Dfloat factor, GC3Dfloat units);

    void readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&);

    void releaseShaderCompiler();

    void renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height);

    void sampleCoverage(GC3Dfloat value, GC3Dboolean invert);

    void scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    void shaderSource(WebGLShader*, const String&, ExceptionCode&);

    void stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask);

    void stencilMask(GC3Duint);

    void stencilMaskSeparate(GC3Denum face, GC3Duint mask);

    void stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                    GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                    GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param);

    void texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Dsizei width, GC3Dsizei height,

                       GC3Denum format, GC3Denum type, ArrayBufferView*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, ImageData*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLImageElement*, ExceptionCode&);

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    void texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                       GC3Denum format, GC3Denum type, HTMLVideoElement*, ExceptionCode&);

#endif

    void uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode&);

    void uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode&);

    void uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode&);

    void uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* value, ExceptionCode&);

    void uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* value, GC3Dsizei size, ExceptionCode&);

    void useProgram(WebGLProgram*, ExceptionCode&);

    void validateProgram(WebGLProgram*, ExceptionCode&);

    void vertexAttrib1f(GC3Duint index, GC3Dfloat x);

    void vertexAttrib1fv(GC3Duint index, Float32Array* values);

    void vertexAttrib1fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib2f(GC3Duint index, GC3Dfloat x, GC3Dfloat y);

    void vertexAttrib2fv(GC3Duint index, Float32Array* values);

    void vertexAttrib2fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib3f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z);

    void vertexAttrib3fv(GC3Duint index, Float32Array* values);

    void vertexAttrib3fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);

    void vertexAttrib4fv(GC3Duint index, Float32Array* values);

    void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);

    void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,

                             GC3Dsizei stride, long long offset, ExceptionCode&);

    void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);

    // WEBKIT_lose_context support

    enum LostContextMode {

        // Lost context occurred at the graphics system level.

        RealLostContext,

        // Lost context provoked by WEBKIT_lose_context.

        SyntheticLostContext

    };

    void forceLostContext(LostContextMode);

    void forceRestoreContext();

    void loseContextImpl(LostContextMode);

    GraphicsContext3D* graphicsContext3D() const { return m_context.get(); }

    WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }

    virtual PlatformLayer* platformLayer() const override;

    void reshape(int width, int height);

    void markLayerComposited();

    virtual void paintRenderingResultsToCanvas() override;

    PassRefPtr<ImageData> paintRenderingResultsToImageData();

    void removeSharedObject(WebGLSharedObject*);

    void removeContextObject(WebGLContextObject*);

    unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }

    // ANGLE_instanced_arrays extension functions.

    void drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    void drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount);

    void vertexAttribDivisor(GC3Duint index, GC3Duint divisor);

private:

    friend class WebGLDrawBuffers;

    friend class WebGLFramebuffer;

    friend class WebGLObject;

    friend class OESVertexArrayObject;

    friend class WebGLDebugShaders;

    friend class WebGLCompressedTextureATC;

    friend class WebGLCompressedTexturePVRTC;

    friend class WebGLCompressedTextureS3TC;

    friend class WebGLRenderingContextErrorMessageCallback;

    friend class WebGLVertexArrayObjectOES;

    WebGLRenderingContext(HTMLCanvasElement*, GraphicsContext3D::Attributes);

    WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes);

    void initializeNewContext();

    void setupFlags();

    // ActiveDOMObject

    virtual bool hasPendingActivity() const override;

    virtual void stop() override;

    virtual const char* activeDOMObjectName() const override { return "WebGLRenderingContext"; }

    void addSharedObject(WebGLSharedObject*);

    void addContextObject(WebGLContextObject*);

    void detachAndRemoveAllObjects();

    void destroyGraphicsContext3D();

    void markContextChanged();

    // Query whether it is built on top of compliant GLES2 implementation.

    bool isGLES2Compliant() { return m_isGLES2Compliant; }

    // Query if the GL implementation is NPOT strict.

    bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }

    // Query if the GL implementation generates errors on out-of-bounds buffer accesses.

    bool isErrorGeneratedOnOutOfBoundsAccesses() { return m_isErrorGeneratedOnOutOfBoundsAccesses; }

    // Query if the GL implementation initializes textures/renderbuffers to 0.

    bool isResourceSafe() { return m_isResourceSafe; }

    // Query if depth_stencil buffer is supported.

    bool isDepthStencilSupported() { return m_isDepthStencilSupported; }

    // Helper to return the size in bytes of OpenGL data types

    // like GL_FLOAT, GL_INT, etc.

    unsigned int sizeInBytes(GC3Denum type);

    // Basic validation of count and offset against number of elements in element array buffer

    bool validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset);

    // Conservative but quick index validation

    bool validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired);

    // Precise but slow index validation -- only done if conservative checks fail

    bool validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired);

    bool validateVertexAttributes(unsigned elementCount, unsigned primitiveCount = 0);

    bool validateWebGLObject(const char*, WebGLObject*);

    bool validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount);

    bool validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primcount);

    // Adds a compressed texture format.

    void addCompressedTextureFormat(GC3Denum);

    PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, int deviceScaleFactor);

#if ENABLE(VIDEO)

    PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy, ExceptionCode&);

#endif

    RefPtr<GraphicsContext3D> m_context;

    RefPtr<WebGLContextGroup> m_contextGroup;

    // Optional structure for rendering to a DrawingBuffer, instead of directly

    // to the back-buffer of m_context.

    RefPtr<DrawingBuffer> m_drawingBuffer;

    // Dispatches a context lost event once it is determined that one is needed.

    // This is used both for synthetic and real context losses. For real ones, it's

    // likely that there's no JavaScript on the stack, but that might be dependent

    // on how exactly the platform discovers that the context was lost. For better

    // portability we always defer the dispatch of the event.

    Timer m_dispatchContextLostEventTimer;

    bool m_restoreAllowed;

    Timer m_restoreTimer;

    bool m_needsUpdate;

    bool m_markedCanvasDirty;

    HashSet<WebGLContextObject*> m_contextObjects;

    // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER

    RefPtr<WebGLBuffer> m_boundArrayBuffer;

    RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;

    RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;

    void setBoundVertexArrayObject(PassRefPtr<WebGLVertexArrayObjectOES> arrayObject)

    {

        if (arrayObject)

            m_boundVertexArrayObject = arrayObject;

        else

            m_boundVertexArrayObject = m_defaultVertexArrayObject;

    }

    class VertexAttribValue {

    public:

        VertexAttribValue()

        {

            initValue();

        }

        void initValue()

        {

            value[0] = 0.0f;

            value[1] = 0.0f;

            value[2] = 0.0f;

            value[3] = 1.0f;

        }

        GC3Dfloat value[4];

    };

    Vector<VertexAttribValue> m_vertexAttribValue;

    unsigned m_maxVertexAttribs;

    RefPtr<WebGLBuffer> m_vertexAttrib0Buffer;

    long m_vertexAttrib0BufferSize;

    GC3Dfloat m_vertexAttrib0BufferValue[4];

    bool m_forceAttrib0BufferRefill;

    bool m_vertexAttrib0UsedBefore;

    RefPtr<WebGLProgram> m_currentProgram;

    RefPtr<WebGLFramebuffer> m_framebufferBinding;

    RefPtr<WebGLRenderbuffer> m_renderbufferBinding;

    struct TextureUnitState {

        RefPtr<WebGLTexture> texture2DBinding;

        RefPtr<WebGLTexture> textureCubeMapBinding;

    };

    Vector<TextureUnitState> m_textureUnits;

    unsigned long m_activeTextureUnit;

    RefPtr<WebGLTexture> m_blackTexture2D;

    RefPtr<WebGLTexture> m_blackTextureCubeMap;

    Vector<GC3Denum> m_compressedTextureFormats;

    // Fixed-size cache of reusable image buffers for video texImage2D calls.

    class LRUImageBufferCache {

    public:

        LRUImageBufferCache(int capacity);

        // The pointer returned is owned by the image buffer map.

        ImageBuffer* imageBuffer(const IntSize& size);

    private:

        void bubbleToFront(int idx);

        std::unique_ptr<std::unique_ptr<ImageBuffer>[]> m_buffers;

        int m_capacity;

    };

    LRUImageBufferCache m_generatedImageCache;

    GC3Dint m_maxTextureSize;

    GC3Dint m_maxCubeMapTextureSize;

    GC3Dint m_maxRenderbufferSize;

    GC3Dint m_maxViewportDims[2];

    GC3Dint m_maxTextureLevel;

    GC3Dint m_maxCubeMapTextureLevel;

    GC3Dint m_maxDrawBuffers;

    GC3Dint m_maxColorAttachments;

    GC3Denum m_backDrawBuffer;

    bool m_drawBuffersWebGLRequirementsChecked;

    bool m_drawBuffersSupported;

    GC3Dint m_packAlignment;

    GC3Dint m_unpackAlignment;

    bool m_unpackFlipY;

    bool m_unpackPremultiplyAlpha;

    GC3Denum m_unpackColorspaceConversion;

    bool m_contextLost;

    LostContextMode m_contextLostMode;

    GraphicsContext3D::Attributes m_attributes;

    bool m_layerCleared;

    GC3Dfloat m_clearColor[4];

    bool m_scissorEnabled;

    GC3Dfloat m_clearDepth;

    GC3Dint m_clearStencil;

    GC3Dboolean m_colorMask[4];

    GC3Dboolean m_depthMask;

    bool m_stencilEnabled;

    GC3Duint m_stencilMask, m_stencilMaskBack;

    GC3Dint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.

    GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;

    bool m_isGLES2Compliant;

    bool m_isGLES2NPOTStrict;

    bool m_isErrorGeneratedOnOutOfBoundsAccesses;

    bool m_isResourceSafe;

    bool m_isDepthStencilSupported;

    bool m_isRobustnessEXTSupported;

    bool m_synthesizedErrorsToConsole;

    int m_numGLErrorsToConsoleAllowed;

    // A WebGLRenderingContext can be created in a state where it appears as

    // a valid and active context, but will not execute any important operations

    // until its load policy is completely resolved.

    bool m_isPendingPolicyResolution;

    bool m_hasRequestedPolicyResolution;

    bool isContextLostOrPending();

    // Enabled extension objects.

    std::unique_ptr<EXTFragDepth> m_extFragDepth;

    std::unique_ptr<EXTBlendMinMax> m_extBlendMinMax;

    std::unique_ptr<EXTsRGB> m_extsRGB;

    std::unique_ptr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;

    std::unique_ptr<EXTShaderTextureLOD> m_extShaderTextureLOD;

    std::unique_ptr<OESTextureFloat> m_oesTextureFloat;

    std::unique_ptr<OESTextureFloatLinear> m_oesTextureFloatLinear;

    std::unique_ptr<OESTextureHalfFloat> m_oesTextureHalfFloat;

    std::unique_ptr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;

    std::unique_ptr<OESStandardDerivatives> m_oesStandardDerivatives;

    std::unique_ptr<OESVertexArrayObject> m_oesVertexArrayObject;

    std::unique_ptr<OESElementIndexUint> m_oesElementIndexUint;

    std::unique_ptr<WebGLLoseContext> m_webglLoseContext;

    std::unique_ptr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;

    std::unique_ptr<WebGLDebugShaders> m_webglDebugShaders;

    std::unique_ptr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;

    std::unique_ptr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;

    std::unique_ptr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;

    std::unique_ptr<WebGLDepthTexture> m_webglDepthTexture;

    std::unique_ptr<WebGLDrawBuffers> m_webglDrawBuffers;

    std::unique_ptr<ANGLEInstancedArrays> m_angleInstancedArrays;

    // Helpers for getParameter and others

    WebGLGetInfo getBooleanParameter(GC3Denum);

    WebGLGetInfo getBooleanArrayParameter(GC3Denum);

    WebGLGetInfo getFloatParameter(GC3Denum);

    WebGLGetInfo getIntParameter(GC3Denum);

    WebGLGetInfo getUnsignedIntParameter(GC3Denum);

    WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);

    WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);

    // Clear the backbuffer if it was composited since the last operation.

    // clearMask is set to the bitfield of any clear that would happen anyway at this time

    // and the function returns true if that clear is now unnecessary.

    bool clearIfComposited(GC3Dbitfield clearMask = 0);

    // Helper to restore state that clearing the framebuffer may destroy.

    void restoreStateAfterClear();

    void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);

    void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);

    void checkTextureCompleteness(const char*, bool);

    void createFallbackBlackTextures1x1();

    // Helper function for copyTex{Sub}Image, check whether the internalformat

    // and the color buffer format of the current bound framebuffer combination

    // is valid.

    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,

                                                        GC3Denum colorBufferFormat);

    // Helper function to get the bound framebuffer's color buffer format.

    GC3Denum getBoundFramebufferColorFormat();

    // Helper function to get the bound framebuffer's width.

    int getBoundFramebufferWidth();

    // Helper function to get the bound framebuffer's height.

    int getBoundFramebufferHeight();

    // Helper function to verify limits on the length of uniform and attribute locations.

    bool validateLocationLength(const char* functionName, const String&);

    // Helper function to check if size is non-negative.

    // Generate GL error and return false for negative inputs; otherwise, return true.

    bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);

    // Helper function to check if all characters in the string belong to the

    // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.

    bool validateString(const char* functionName, const String&);

    // Helper function to check target and texture bound to the target.

    // Generate GL errors and return 0 if target is invalid or texture bound is

    // null.  Otherwise, return the texture bound to the target.

    WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);

    // Helper function to check input format/type for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level);

    // Helper function to check input level for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if level is invalid.

    bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);

    enum TexFuncValidationFunctionType {

        NotTexSubImage2D,

        TexSubImage2D,

    };

    enum TexFuncValidationSourceType {

        SourceArrayBufferView,

        SourceImageData,

        SourceHTMLImageElement,

        SourceHTMLCanvasElement,

        SourceHTMLVideoElement,

    };

    // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.

    // Otherwise, it would return quickly without doing other work.

    bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

        GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);

    // Helper function to check input parameters for functions {copy}Tex{Sub}Image.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncParameters(const char* functionName,

                                   TexFuncValidationFunctionType,

                                   GC3Denum target, GC3Dint level,

                                   GC3Denum internalformat,

                                   GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                   GC3Denum format, GC3Denum type);

    enum NullDisposition {

        NullAllowed,

        NullNotAllowed

    };

    // Helper function to validate that the given ArrayBufferView

    // is of the correct type and contains enough data for the texImage call.

    // Generates GL error and returns false if parameters are invalid.

    bool validateTexFuncData(const char* functionName, GC3Dint level,

                             GC3Dsizei width, GC3Dsizei height,

                             GC3Denum format, GC3Denum type,

                             ArrayBufferView* pixels,

                             NullDisposition);

    // Helper function to validate a given texture format is settable as in

    // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and

    // copyTexSubImage2D.

    // Generates GL error and returns false if the format is not settable.

    bool validateSettableTexFormat(const char* functionName, GC3Denum format);

    // Helper function to validate compressed texture data is correct size

    // for the given format and dimensions.

    bool validateCompressedTexFuncData(const char* functionName,

                                       GC3Dsizei width, GC3Dsizei height,

                                       GC3Denum format, ArrayBufferView* pixels);

    // Helper function for validating compressed texture formats.

    bool validateCompressedTexFormat(GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);

    // Helper function to validate compressed texture dimensions are valid for

    // the given format.

    bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                            GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);

    // Helper function to validate mode for draw{Arrays/Elements}.

    bool validateDrawMode(const char* functionName, GC3Denum);

    // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.

    bool validateStencilSettings(const char* functionName);

    // Helper function to validate stencil func.

    bool validateStencilFunc(const char* functionName, GC3Denum);

    // Helper function for texParameterf and texParameteri.

    void texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat parami, GC3Dint paramf, bool isFloat);

    // Helper function to print GL errors to console.

    void printGLErrorToConsole(const String&);

    void printGLWarningToConsole(const char* function, const char* reason);

    // Helper function to print warnings to console. Currently

    // used only to warn about use of obsolete functions.

    void printWarningToConsole(const String&);

    // Helper function to validate input parameters for framebuffer functions.

    // Generate GL error if parameters are illegal.

    bool validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment);

    // Helper function to validate blend equation mode.

    bool validateBlendEquation(const char* functionName, GC3Denum);

    // Helper function to validate blend func factors.

    bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);

    // Helper function to validate a GL capability.

    bool validateCapability(const char* functionName, GC3Denum);

    // Helper function to validate input parameters for uniform functions.

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);

    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);

    bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);

    // Helper function to validate parameters for bufferData.

    // Return the current bound buffer to target, or 0 if parameters are invalid.

    WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);

    // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.

    bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionCode&);

    // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.

    bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionCode&);

#if ENABLE(VIDEO)

    // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.

    bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionCode&);

#endif

    // Helper functions for vertexAttribNf{v}.

    void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);

    void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);

    // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.

    // Return false if caller should return without further processing.

    bool deleteObject(WebGLObject*);

    // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.

    // If the object has already been deleted, set deleted to true upon return.

    // Return false if caller should return without further processing.

    bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);

    // Helpers for simulating vertexAttrib0

    void initVertexAttrib0();

    bool simulateVertexAttrib0(GC3Dsizei numVertex);

    void restoreStatesAfterVertexAttrib0Simulation();

    void dispatchContextLostEvent();

    // Helper for restoration after context lost.

    void maybeRestoreContext();

    // Determine if we are running privileged code in the browser, for example,

    // a Safari or Chrome extension.

    bool allowPrivilegedExtensions() const;

    enum ConsoleDisplayPreference {

        DisplayInConsole,

        DontDisplayInConsole

    };

    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message

    // to the JavaScript console.

    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);

    String ensureNotNull(const String&) const;

    // Enable or disable stencil test based on user setting and

    // whether the current FBO has a stencil buffer.

    void applyStencilTest();

    // Helper for enabling or disabling a capability.

    void enableOrDisable(GC3Denum capability, bool enable);

    // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.

    IntSize clampedCanvasSize();

    // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.

    // Later, return the cached value.

    GC3Dint getMaxDrawBuffers();

    GC3Dint getMaxColorAttachments();

    void setBackDrawBuffer(GC3Denum);

    void restoreCurrentFramebuffer();

    void restoreCurrentTexture2D();

    // Check if EXT_draw_buffers extension is supported and if it satisfies the WebGL requirements.

    bool supportsDrawBuffers();

};

} // namespace WebCore

#endif

178372

Source/WebCore/html/canvas/WebGLRenderingContext.idl

/*

 * Copyright (C) 2009 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

typedef unsigned long  GLenum;

typedef boolean        GLboolean;

typedef unsigned long  GLbitfield;

typedef byte           GLbyte;         /* 'byte' should be a signed 8 bit type. */

typedef short          GLshort;

typedef long           GLint;

typedef long           GLsizei;

typedef long long      GLintptr;

typedef long long      GLsizeiptr;

typedef octet          GLubyte;        /* 'octet' should be an unsigned 8 bit type. */

typedef unsigned short GLushort;

typedef unsigned long  GLuint;

typedef unrestricted float GLfloat;

typedef unrestricted float GLclampf;

[

    Conditional=WEBGL,

    JSCustomMarkFunction,

    DoNotCheckConstants,

] interface WebGLRenderingContext : CanvasRenderingContext {

    /* ClearBufferMask */

    const GLenum DEPTH_BUFFER_BIT               = 0x00000100;

    const GLenum STENCIL_BUFFER_BIT             = 0x00000400;

    const GLenum COLOR_BUFFER_BIT               = 0x00004000;

    /* BeginMode */

    const GLenum POINTS                         = 0x0000;

    const GLenum LINES                          = 0x0001;

    const GLenum LINE_LOOP                      = 0x0002;

    const GLenum LINE_STRIP                     = 0x0003;

    const GLenum TRIANGLES                      = 0x0004;

    const GLenum TRIANGLE_STRIP                 = 0x0005;

    const GLenum TRIANGLE_FAN                   = 0x0006;

    /* AlphaFunction (not supported in ES20) */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* BlendingFactorDest */

    const GLenum ZERO                           = 0;

    const GLenum ONE                            = 1;

    const GLenum SRC_COLOR                      = 0x0300;

    const GLenum ONE_MINUS_SRC_COLOR            = 0x0301;

    const GLenum SRC_ALPHA                      = 0x0302;

    const GLenum ONE_MINUS_SRC_ALPHA            = 0x0303;

    const GLenum DST_ALPHA                      = 0x0304;

    const GLenum ONE_MINUS_DST_ALPHA            = 0x0305;

    /* BlendingFactorSrc */

    /*      ZERO */

    /*      ONE */

    const GLenum DST_COLOR                      = 0x0306;

    const GLenum ONE_MINUS_DST_COLOR            = 0x0307;

    const GLenum SRC_ALPHA_SATURATE             = 0x0308;

    /*      SRC_ALPHA */

    /*      ONE_MINUS_SRC_ALPHA */

    /*      DST_ALPHA */

    /*      ONE_MINUS_DST_ALPHA */

    /* BlendEquationSeparate */

    const GLenum FUNC_ADD                       = 0x8006;

    const GLenum BLEND_EQUATION                 = 0x8009;

    const GLenum BLEND_EQUATION_RGB             = 0x8009;   /* same as BLEND_EQUATION */

    const GLenum BLEND_EQUATION_ALPHA           = 0x883D;

    /* BlendSubtract */

    const GLenum FUNC_SUBTRACT                  = 0x800A;

    const GLenum FUNC_REVERSE_SUBTRACT          = 0x800B;

    /* Separate Blend Functions */

    const GLenum BLEND_DST_RGB                  = 0x80C8;

    const GLenum BLEND_SRC_RGB                  = 0x80C9;

    const GLenum BLEND_DST_ALPHA                = 0x80CA;

    const GLenum BLEND_SRC_ALPHA                = 0x80CB;

    const GLenum CONSTANT_COLOR                 = 0x8001;

    const GLenum ONE_MINUS_CONSTANT_COLOR       = 0x8002;

    const GLenum CONSTANT_ALPHA                 = 0x8003;

    const GLenum ONE_MINUS_CONSTANT_ALPHA       = 0x8004;

    const GLenum BLEND_COLOR                    = 0x8005;

    /* Buffer Objects */

    const GLenum ARRAY_BUFFER                   = 0x8892;

    const GLenum ELEMENT_ARRAY_BUFFER           = 0x8893;

    const GLenum ARRAY_BUFFER_BINDING           = 0x8894;

    const GLenum ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;

    const GLenum STREAM_DRAW                    = 0x88E0;

    const GLenum STATIC_DRAW                    = 0x88E4;

    const GLenum DYNAMIC_DRAW                   = 0x88E8;

    const GLenum BUFFER_SIZE                    = 0x8764;

    const GLenum BUFFER_USAGE                   = 0x8765;

    const GLenum CURRENT_VERTEX_ATTRIB          = 0x8626;

    /* CullFaceMode */

    const GLenum FRONT                          = 0x0404;

    const GLenum BACK                           = 0x0405;

    const GLenum FRONT_AND_BACK                 = 0x0408;

    /* DepthFunction */

    /*      NEVER */

    /*      LESS */

    /*      EQUAL */

    /*      LEQUAL */

    /*      GREATER */

    /*      NOTEQUAL */

    /*      GEQUAL */

    /*      ALWAYS */

    /* EnableCap */

    const GLenum TEXTURE_2D                     = 0x0DE1;

    const GLenum CULL_FACE                      = 0x0B44;

    const GLenum BLEND                          = 0x0BE2;

    const GLenum DITHER                         = 0x0BD0;

    const GLenum STENCIL_TEST                   = 0x0B90;

    const GLenum DEPTH_TEST                     = 0x0B71;

    const GLenum SCISSOR_TEST                   = 0x0C11;

    const GLenum POLYGON_OFFSET_FILL            = 0x8037;

    const GLenum SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;

    const GLenum SAMPLE_COVERAGE                = 0x80A0;

    /* ErrorCode */

    const GLenum NO_ERROR                       = 0;

    const GLenum INVALID_ENUM                   = 0x0500;

    const GLenum INVALID_VALUE                  = 0x0501;

    const GLenum INVALID_OPERATION              = 0x0502;

    const GLenum OUT_OF_MEMORY                  = 0x0505;

    /* FrontFaceDirection */

    const GLenum CW                             = 0x0900;

    const GLenum CCW                            = 0x0901;

    /* GetPName */

    const GLenum LINE_WIDTH                     = 0x0B21;

    const GLenum ALIASED_POINT_SIZE_RANGE       = 0x846D;

    const GLenum ALIASED_LINE_WIDTH_RANGE       = 0x846E;

    const GLenum CULL_FACE_MODE                 = 0x0B45;

    const GLenum FRONT_FACE                     = 0x0B46;

    const GLenum DEPTH_RANGE                    = 0x0B70;

    const GLenum DEPTH_WRITEMASK                = 0x0B72;

    const GLenum DEPTH_CLEAR_VALUE              = 0x0B73;

    const GLenum DEPTH_FUNC                     = 0x0B74;

    const GLenum STENCIL_CLEAR_VALUE            = 0x0B91;

    const GLenum STENCIL_FUNC                   = 0x0B92;

    const GLenum STENCIL_FAIL                   = 0x0B94;

    const GLenum STENCIL_PASS_DEPTH_FAIL        = 0x0B95;

    const GLenum STENCIL_PASS_DEPTH_PASS        = 0x0B96;

    const GLenum STENCIL_REF                    = 0x0B97;

    const GLenum STENCIL_VALUE_MASK             = 0x0B93;

    const GLenum STENCIL_WRITEMASK              = 0x0B98;

    const GLenum STENCIL_BACK_FUNC              = 0x8800;

    const GLenum STENCIL_BACK_FAIL              = 0x8801;

    const GLenum STENCIL_BACK_PASS_DEPTH_FAIL   = 0x8802;

    const GLenum STENCIL_BACK_PASS_DEPTH_PASS   = 0x8803;

    const GLenum STENCIL_BACK_REF               = 0x8CA3;

    const GLenum STENCIL_BACK_VALUE_MASK        = 0x8CA4;

    const GLenum STENCIL_BACK_WRITEMASK         = 0x8CA5;

    const GLenum VIEWPORT                       = 0x0BA2;

    const GLenum SCISSOR_BOX                    = 0x0C10;

    /*      SCISSOR_TEST */

    const GLenum COLOR_CLEAR_VALUE              = 0x0C22;

    const GLenum COLOR_WRITEMASK                = 0x0C23;

    const GLenum UNPACK_ALIGNMENT               = 0x0CF5;

    const GLenum PACK_ALIGNMENT                 = 0x0D05;

    const GLenum MAX_TEXTURE_SIZE               = 0x0D33;

    const GLenum MAX_VIEWPORT_DIMS              = 0x0D3A;

    const GLenum SUBPIXEL_BITS                  = 0x0D50;

    const GLenum RED_BITS                       = 0x0D52;

    const GLenum GREEN_BITS                     = 0x0D53;

    const GLenum BLUE_BITS                      = 0x0D54;

    const GLenum ALPHA_BITS                     = 0x0D55;

    const GLenum DEPTH_BITS                     = 0x0D56;

    const GLenum STENCIL_BITS                   = 0x0D57;

    const GLenum POLYGON_OFFSET_UNITS           = 0x2A00;

    /*      POLYGON_OFFSET_FILL */

    const GLenum POLYGON_OFFSET_FACTOR          = 0x8038;

    const GLenum TEXTURE_BINDING_2D             = 0x8069;

    const GLenum SAMPLE_BUFFERS                 = 0x80A8;

    const GLenum SAMPLES                        = 0x80A9;

    const GLenum SAMPLE_COVERAGE_VALUE          = 0x80AA;

    const GLenum SAMPLE_COVERAGE_INVERT         = 0x80AB;

    /* GetTextureParameter */

    /*      TEXTURE_MAG_FILTER */

    /*      TEXTURE_MIN_FILTER */

    /*      TEXTURE_WRAP_S */

    /*      TEXTURE_WRAP_T */

    const GLenum COMPRESSED_TEXTURE_FORMATS     = 0x86A3;

    /* HintMode */

    const GLenum DONT_CARE                      = 0x1100;

    const GLenum FASTEST                        = 0x1101;

    const GLenum NICEST                         = 0x1102;

    /* HintTarget */

    const GLenum GENERATE_MIPMAP_HINT            = 0x8192;

    /* DataType */

    const GLenum BYTE                           = 0x1400;

    const GLenum UNSIGNED_BYTE                  = 0x1401;

    const GLenum SHORT                          = 0x1402;

    const GLenum UNSIGNED_SHORT                 = 0x1403;

    const GLenum INT                            = 0x1404;

    const GLenum UNSIGNED_INT                   = 0x1405;

    const GLenum FLOAT                          = 0x1406;

    /* PixelFormat */

    const GLenum DEPTH_COMPONENT                = 0x1902;

    const GLenum ALPHA                          = 0x1906;

    const GLenum RGB                            = 0x1907;

    const GLenum RGBA                           = 0x1908;

    const GLenum LUMINANCE                      = 0x1909;

    const GLenum LUMINANCE_ALPHA                = 0x190A;

    /* PixelType */

    /*      UNSIGNED_BYTE */

    const GLenum UNSIGNED_SHORT_4_4_4_4         = 0x8033;

    const GLenum UNSIGNED_SHORT_5_5_5_1         = 0x8034;

    const GLenum UNSIGNED_SHORT_5_6_5           = 0x8363;

    /* Shaders */

    const GLenum FRAGMENT_SHADER                  = 0x8B30;

    const GLenum VERTEX_SHADER                    = 0x8B31;

    const GLenum MAX_VERTEX_ATTRIBS               = 0x8869;

    const GLenum MAX_VERTEX_UNIFORM_VECTORS       = 0x8DFB;

    const GLenum MAX_VARYING_VECTORS              = 0x8DFC;

    const GLenum MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;

    const GLenum MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C;

    const GLenum MAX_TEXTURE_IMAGE_UNITS          = 0x8872;

    const GLenum MAX_FRAGMENT_UNIFORM_VECTORS     = 0x8DFD;

    const GLenum SHADER_TYPE                      = 0x8B4F;

    const GLenum DELETE_STATUS                    = 0x8B80;

    const GLenum LINK_STATUS                      = 0x8B82;

    const GLenum VALIDATE_STATUS                  = 0x8B83;

    const GLenum ATTACHED_SHADERS                 = 0x8B85;

    const GLenum ACTIVE_UNIFORMS                  = 0x8B86;

    const GLenum ACTIVE_ATTRIBUTES                = 0x8B89;

    const GLenum SHADING_LANGUAGE_VERSION         = 0x8B8C;

    const GLenum CURRENT_PROGRAM                  = 0x8B8D;

    /* StencilFunction */

    const GLenum NEVER                          = 0x0200;

    const GLenum LESS                           = 0x0201;

    const GLenum EQUAL                          = 0x0202;

    const GLenum LEQUAL                         = 0x0203;

    const GLenum GREATER                        = 0x0204;

    const GLenum NOTEQUAL                       = 0x0205;

    const GLenum GEQUAL                         = 0x0206;

    const GLenum ALWAYS                         = 0x0207;

    /* StencilOp */

    /*      ZERO */

    const GLenum KEEP                           = 0x1E00;

    const GLenum REPLACE                        = 0x1E01;

    const GLenum INCR                           = 0x1E02;

    const GLenum DECR                           = 0x1E03;

    const GLenum INVERT                         = 0x150A;

    const GLenum INCR_WRAP                      = 0x8507;

    const GLenum DECR_WRAP                      = 0x8508;

    /* StringName */

    const GLenum VENDOR                         = 0x1F00;

    const GLenum RENDERER                       = 0x1F01;

    const GLenum VERSION                        = 0x1F02;

    /* TextureMagFilter */

    const GLenum NEAREST                        = 0x2600;

    const GLenum LINEAR                         = 0x2601;

    /* TextureMinFilter */

    /*      NEAREST */

    /*      LINEAR */

    const GLenum NEAREST_MIPMAP_NEAREST         = 0x2700;

    const GLenum LINEAR_MIPMAP_NEAREST          = 0x2701;

    const GLenum NEAREST_MIPMAP_LINEAR          = 0x2702;

    const GLenum LINEAR_MIPMAP_LINEAR           = 0x2703;

    /* TextureParameterName */

    const GLenum TEXTURE_MAG_FILTER             = 0x2800;

    const GLenum TEXTURE_MIN_FILTER             = 0x2801;

    const GLenum TEXTURE_WRAP_S                 = 0x2802;

    const GLenum TEXTURE_WRAP_T                 = 0x2803;

    /* TextureTarget */

    /*      TEXTURE_2D */

    const GLenum TEXTURE                        = 0x1702;

    const GLenum TEXTURE_CUBE_MAP               = 0x8513;

    const GLenum TEXTURE_BINDING_CUBE_MAP       = 0x8514;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;

    const GLenum TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;

    const GLenum TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;

    const GLenum MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;

    /* TextureUnit */

    const GLenum TEXTURE0                       = 0x84C0;

    const GLenum TEXTURE1                       = 0x84C1;

    const GLenum TEXTURE2                       = 0x84C2;

    const GLenum TEXTURE3                       = 0x84C3;

    const GLenum TEXTURE4                       = 0x84C4;

    const GLenum TEXTURE5                       = 0x84C5;

    const GLenum TEXTURE6                       = 0x84C6;

    const GLenum TEXTURE7                       = 0x84C7;

    const GLenum TEXTURE8                       = 0x84C8;

    const GLenum TEXTURE9                       = 0x84C9;

    const GLenum TEXTURE10                      = 0x84CA;

    const GLenum TEXTURE11                      = 0x84CB;

    const GLenum TEXTURE12                      = 0x84CC;

    const GLenum TEXTURE13                      = 0x84CD;

    const GLenum TEXTURE14                      = 0x84CE;

    const GLenum TEXTURE15                      = 0x84CF;

    const GLenum TEXTURE16                      = 0x84D0;

    const GLenum TEXTURE17                      = 0x84D1;

    const GLenum TEXTURE18                      = 0x84D2;

    const GLenum TEXTURE19                      = 0x84D3;

    const GLenum TEXTURE20                      = 0x84D4;

    const GLenum TEXTURE21                      = 0x84D5;

    const GLenum TEXTURE22                      = 0x84D6;

    const GLenum TEXTURE23                      = 0x84D7;

    const GLenum TEXTURE24                      = 0x84D8;

    const GLenum TEXTURE25                      = 0x84D9;

    const GLenum TEXTURE26                      = 0x84DA;

    const GLenum TEXTURE27                      = 0x84DB;

    const GLenum TEXTURE28                      = 0x84DC;

    const GLenum TEXTURE29                      = 0x84DD;

    const GLenum TEXTURE30                      = 0x84DE;

    const GLenum TEXTURE31                      = 0x84DF;

    const GLenum ACTIVE_TEXTURE                 = 0x84E0;

    /* TextureWrapMode */

    const GLenum REPEAT                         = 0x2901;

    const GLenum CLAMP_TO_EDGE                  = 0x812F;

    const GLenum MIRRORED_REPEAT                = 0x8370;

    /* Uniform Types */

    const GLenum FLOAT_VEC2                     = 0x8B50;

    const GLenum FLOAT_VEC3                     = 0x8B51;

    const GLenum FLOAT_VEC4                     = 0x8B52;

    const GLenum INT_VEC2                       = 0x8B53;

    const GLenum INT_VEC3                       = 0x8B54;

    const GLenum INT_VEC4                       = 0x8B55;

    const GLenum BOOL                           = 0x8B56;

    const GLenum BOOL_VEC2                      = 0x8B57;

    const GLenum BOOL_VEC3                      = 0x8B58;

    const GLenum BOOL_VEC4                      = 0x8B59;

    const GLenum FLOAT_MAT2                     = 0x8B5A;

    const GLenum FLOAT_MAT3                     = 0x8B5B;

    const GLenum FLOAT_MAT4                     = 0x8B5C;

    const GLenum SAMPLER_2D                     = 0x8B5E;

    const GLenum SAMPLER_CUBE                   = 0x8B60;

    /* Vertex Arrays */

    const GLenum VERTEX_ATTRIB_ARRAY_ENABLED        = 0x8622;

    const GLenum VERTEX_ATTRIB_ARRAY_SIZE           = 0x8623;

    const GLenum VERTEX_ATTRIB_ARRAY_STRIDE         = 0x8624;

    const GLenum VERTEX_ATTRIB_ARRAY_TYPE           = 0x8625;

    const GLenum VERTEX_ATTRIB_ARRAY_NORMALIZED     = 0x886A;

    const GLenum VERTEX_ATTRIB_ARRAY_POINTER        = 0x8645;

    const GLenum VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;

    /* Shader Source */

    const GLenum COMPILE_STATUS                 = 0x8B81;

    /* Shader Precision-Specified Types */

    const GLenum LOW_FLOAT                      = 0x8DF0;

    const GLenum MEDIUM_FLOAT                   = 0x8DF1;

    const GLenum HIGH_FLOAT                     = 0x8DF2;

    const GLenum LOW_INT                        = 0x8DF3;

    const GLenum MEDIUM_INT                     = 0x8DF4;

    const GLenum HIGH_INT                       = 0x8DF5;

    /* Framebuffer Object. */

    const GLenum FRAMEBUFFER                    = 0x8D40;

    const GLenum RENDERBUFFER                   = 0x8D41;

    const GLenum RGBA4                          = 0x8056;

    const GLenum RGB5_A1                        = 0x8057;

    const GLenum RGB565                         = 0x8D62;

    const GLenum DEPTH_COMPONENT16              = 0x81A5;

    const GLenum STENCIL_INDEX                  = 0x1901;

    const GLenum STENCIL_INDEX8                 = 0x8D48;

    const GLenum DEPTH_STENCIL                  = 0x84F9;

    const GLenum SRGB_EXT                                     = 0x8C40;

    const GLenum SRGB_ALPHA_EXT                               = 0x8C42;

    const GLenum SRGB8_ALPHA8_EXT                             = 0x8C43;

    const GLenum FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT    = 0x8210;

    const GLenum MIN_EXT                        = 0x8007;

    const GLenum MAX_EXT                        = 0x8008;

    const GLenum RENDERBUFFER_WIDTH             = 0x8D42;

    const GLenum RENDERBUFFER_HEIGHT            = 0x8D43;

    const GLenum RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;

    const GLenum RENDERBUFFER_RED_SIZE          = 0x8D50;

    const GLenum RENDERBUFFER_GREEN_SIZE        = 0x8D51;

    const GLenum RENDERBUFFER_BLUE_SIZE         = 0x8D52;

    const GLenum RENDERBUFFER_ALPHA_SIZE        = 0x8D53;

    const GLenum RENDERBUFFER_DEPTH_SIZE        = 0x8D54;

    const GLenum RENDERBUFFER_STENCIL_SIZE      = 0x8D55;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE           = 0x8CD0;

    const GLenum FRAMEBUFFER_ATTACHMENT_OBJECT_NAME           = 0x8CD1;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL         = 0x8CD2;

    const GLenum FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;

    const GLenum COLOR_ATTACHMENT0              = 0x8CE0;

    const GLenum DEPTH_ATTACHMENT               = 0x8D00;

    const GLenum STENCIL_ATTACHMENT             = 0x8D20;

    const GLenum DEPTH_STENCIL_ATTACHMENT       = 0x821A;

    const GLenum NONE                           = 0;

    const GLenum FRAMEBUFFER_COMPLETE                      = 0x8CD5;

    const GLenum FRAMEBUFFER_INCOMPLETE_ATTACHMENT         = 0x8CD6;

    const GLenum FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;

    const GLenum FRAMEBUFFER_INCOMPLETE_DIMENSIONS         = 0x8CD9;

    const GLenum FRAMEBUFFER_UNSUPPORTED                   = 0x8CDD;

    const GLenum FRAMEBUFFER_BINDING            = 0x8CA6;

    const GLenum RENDERBUFFER_BINDING           = 0x8CA7;

    const GLenum MAX_RENDERBUFFER_SIZE          = 0x84E8;

    const GLenum INVALID_FRAMEBUFFER_OPERATION  = 0x0506;

    /* WebGL-specific enums */

    const GLenum UNPACK_FLIP_Y_WEBGL                = 0x9240;

    const GLenum UNPACK_PREMULTIPLY_ALPHA_WEBGL     = 0x9241;

    const GLenum CONTEXT_LOST_WEBGL                 = 0x9242;

    const GLenum UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243;

    const GLenum BROWSER_DEFAULT_WEBGL              = 0x9244;

    readonly attribute GLsizei drawingBufferWidth;

    readonly attribute GLsizei drawingBufferHeight;

    [StrictTypeChecking, RaisesException] void         activeTexture(GLenum texture);

    [StrictTypeChecking, RaisesException] void         attachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking, RaisesException] void         bindAttribLocation(WebGLProgram program, GLuint index, DOMString name);

    [StrictTypeChecking, RaisesException] void         bindBuffer(GLenum target, WebGLBuffer buffer);

    [StrictTypeChecking, RaisesException] void         bindFramebuffer(GLenum target, WebGLFramebuffer framebuffer);

    [StrictTypeChecking, RaisesException] void         bindRenderbuffer(GLenum target, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         bindTexture(GLenum target, WebGLTexture texture);

    [StrictTypeChecking] void         blendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         blendEquation(GLenum mode);

    [StrictTypeChecking] void         blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);

    [StrictTypeChecking] void         blendFunc(GLenum sfactor, GLenum dfactor);

    [StrictTypeChecking] void         blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBuffer? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, ArrayBufferView? data, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferData(GLenum target, GLsizeiptr size, GLenum usage);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBuffer? data);

    [StrictTypeChecking, RaisesException] void         bufferSubData(GLenum target, GLintptr offset, ArrayBufferView? data);

    [StrictTypeChecking] GLenum       checkFramebufferStatus(GLenum target);

    [StrictTypeChecking] void         clear(GLbitfield mask);

    [StrictTypeChecking] void         clearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

    [StrictTypeChecking] void         clearDepth(GLclampf depth);

    [StrictTypeChecking] void         clearStencil(GLint s);

    [StrictTypeChecking] void         colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

    [StrictTypeChecking, RaisesException] void         compileShader(WebGLShader shader);

    [StrictTypeChecking] void         compressedTexImage2D(GLenum target, GLint level, GLenum internalformat,

                                                           GLsizei width, GLsizei height, GLint border, ArrayBufferView data);

    [StrictTypeChecking] void         compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                              GLsizei width, GLsizei height, GLenum format, ArrayBufferView data);

    [StrictTypeChecking] void         copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

    [StrictTypeChecking] void         copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking] WebGLBuffer createBuffer();

    [StrictTypeChecking] WebGLFramebuffer createFramebuffer();

    [StrictTypeChecking] WebGLProgram createProgram();

    [StrictTypeChecking] WebGLRenderbuffer createRenderbuffer();

    [StrictTypeChecking, RaisesException] WebGLShader createShader(GLenum type);

    [StrictTypeChecking] WebGLTexture createTexture();

    [StrictTypeChecking] void         cullFace(GLenum mode);

    [StrictTypeChecking] void         deleteBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] void         deleteFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] void         deleteProgram(WebGLProgram program);

    [StrictTypeChecking] void         deleteRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] void         deleteShader(WebGLShader shader);

    [StrictTypeChecking] void         deleteTexture(WebGLTexture texture);

    [StrictTypeChecking] void         depthFunc(GLenum func);

    [StrictTypeChecking] void         depthMask(GLboolean flag);

    [StrictTypeChecking] void         depthRange(GLclampf zNear, GLclampf zFar);

    [StrictTypeChecking, RaisesException] void         detachShader(WebGLProgram program, WebGLShader shader);

    [StrictTypeChecking] void         disable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         disableVertexAttribArray(GLuint index);

    [StrictTypeChecking, RaisesException] void         drawArrays(GLenum mode, GLint first, GLsizei count);

    [StrictTypeChecking, RaisesException] void         drawElements(GLenum mode, GLsizei count, GLenum type, GLintptr offset);

    [StrictTypeChecking] void         enable(GLenum cap);

    [StrictTypeChecking, RaisesException] void         enableVertexAttribArray(GLuint index);

    [StrictTypeChecking] void         finish();

    [StrictTypeChecking] void         flush();

    [StrictTypeChecking, RaisesException] void         framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking, RaisesException] void         framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture texture, GLint level);

    [StrictTypeChecking] void         frontFace(GLenum mode);

    [StrictTypeChecking] void         generateMipmap(GLenum target);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveAttrib(WebGLProgram program, GLuint index);

    [StrictTypeChecking, RaisesException] WebGLActiveInfo getActiveUniform(WebGLProgram program, GLuint index);

    [StrictTypeChecking, Custom, RaisesException] void getAttachedShaders(WebGLProgram program);

    [StrictTypeChecking] GLint        getAttribLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom] any getBufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking] WebGLContextAttributes getContextAttributes();

    [StrictTypeChecking] GLenum getError();

    // object getExtension(DOMString name);

    [StrictTypeChecking, Custom] any getExtension(DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getParameter(GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getProgramParameter(WebGLProgram program, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString getProgramInfoLog(WebGLProgram program);

    [StrictTypeChecking, Custom, RaisesException] any getRenderbufferParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getShaderParameter(WebGLShader shader, GLenum pname);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderInfoLog(WebGLShader shader);

    [StrictTypeChecking, RaisesException] WebGLShaderPrecisionFormat getShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype);

    [StrictTypeChecking, TreatReturnedNullStringAs=Null, RaisesException] DOMString    getShaderSource(WebGLShader shader);

    [StrictTypeChecking, Custom] sequence<DOMString> getSupportedExtensions();

    [StrictTypeChecking, Custom, RaisesException] any getTexParameter(GLenum target, GLenum pname);

    [StrictTypeChecking, Custom, RaisesException] any getUniform(WebGLProgram program, WebGLUniformLocation location);

    [StrictTypeChecking, RaisesException] WebGLUniformLocation getUniformLocation(WebGLProgram program, DOMString name);

    [StrictTypeChecking, Custom, RaisesException] any getVertexAttrib(GLuint index, GLenum pname);

    [StrictTypeChecking] GLsizeiptr getVertexAttribOffset(GLuint index, GLenum pname);

    [StrictTypeChecking] void         hint(GLenum target, GLenum mode);

    [StrictTypeChecking] GLboolean    isBuffer(WebGLBuffer buffer);

    [StrictTypeChecking] GLboolean    isContextLost();

    [StrictTypeChecking] GLboolean    isEnabled(GLenum cap);

    [StrictTypeChecking] GLboolean    isFramebuffer(WebGLFramebuffer framebuffer);

    [StrictTypeChecking] GLboolean    isProgram(WebGLProgram program);

    [StrictTypeChecking] GLboolean    isRenderbuffer(WebGLRenderbuffer renderbuffer);

    [StrictTypeChecking] GLboolean    isShader(WebGLShader shader);

    [StrictTypeChecking] GLboolean    isTexture(WebGLTexture texture);

    [StrictTypeChecking] void         lineWidth(GLfloat width);

    [StrictTypeChecking, RaisesException] void         linkProgram(WebGLProgram program);

    [StrictTypeChecking] void         pixelStorei(GLenum pname, GLint param);

    [StrictTypeChecking] void         polygonOffset(GLfloat factor, GLfloat units);

    [StrictTypeChecking, RaisesException] void         readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView pixels);

    [StrictTypeChecking] void         releaseShaderCompiler();

    [StrictTypeChecking] void         renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

    [StrictTypeChecking] void         sampleCoverage(GLclampf value, GLboolean invert);

    [StrictTypeChecking] void         scissor(GLint x, GLint y, GLsizei width, GLsizei height);

    [StrictTypeChecking, RaisesException] void         shaderSource(WebGLShader shader, DOMString string);

    [StrictTypeChecking] void         stencilFunc(GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);

    [StrictTypeChecking] void         stencilMask(GLuint mask);

    [StrictTypeChecking] void         stencilMaskSeparate(GLenum face, GLuint mask);

    [StrictTypeChecking] void         stencilOp(GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);

    [StrictTypeChecking] void         texParameterf(GLenum target, GLenum pname, GLfloat param);

    [StrictTypeChecking] void         texParameteri(GLenum target, GLenum pname, GLint param);

    // Supported forms:

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, 

                                                 GLint border, GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texImage2D(GLenum target, GLint level, GLenum internalformat,

                                                 GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, 

                                                    GLsizei width, GLsizei height, 

                                                    GLenum format, GLenum type, ArrayBufferView? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, ImageData? pixels);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLImageElement? image);

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLCanvasElement? canvas);

#if defined(ENABLE_VIDEO) && ENABLE_VIDEO

    [StrictTypeChecking, RaisesException] void         texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,

                                                    GLenum format, GLenum type, HTMLVideoElement? video);

#endif

    [StrictTypeChecking, RaisesException] void uniform1f(WebGLUniformLocation location, GLfloat x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform1i(WebGLUniformLocation location, GLint x);

    [StrictTypeChecking, Custom, RaisesException] void uniform1iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform2f(WebGLUniformLocation location, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform2i(WebGLUniformLocation location, GLint x, GLint y);

    [StrictTypeChecking, Custom, RaisesException] void uniform2iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform3f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform3i(WebGLUniformLocation location, GLint x, GLint y, GLint z);

    [StrictTypeChecking, Custom, RaisesException] void uniform3iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, RaisesException] void uniform4f(WebGLUniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4fv(WebGLUniformLocation location, Float32Array v);

    [StrictTypeChecking, RaisesException] void uniform4i(WebGLUniformLocation location, GLint x, GLint y, GLint z, GLint w);

    [StrictTypeChecking, Custom, RaisesException] void uniform4iv(WebGLUniformLocation location, Int32Array v);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix2fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix3fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, Custom, RaisesException] void uniformMatrix4fv(WebGLUniformLocation location, GLboolean transpose, Float32Array array);

    [StrictTypeChecking, RaisesException] void         useProgram(WebGLProgram program);

    [StrictTypeChecking, RaisesException] void         validateProgram(WebGLProgram program);

    [StrictTypeChecking] void         vertexAttrib1f(GLuint indx, GLfloat x);

    [StrictTypeChecking, Custom] void vertexAttrib1fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib2f(GLuint indx, GLfloat x, GLfloat y);

    [StrictTypeChecking, Custom] void vertexAttrib2fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z);

    [StrictTypeChecking, Custom] void vertexAttrib3fv(GLuint indx, Float32Array values);

    [StrictTypeChecking] void         vertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

    [StrictTypeChecking, Custom] void vertexAttrib4fv(GLuint indx, Float32Array values);

    [StrictTypeChecking, RaisesException] void         vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, 

                                                          GLsizei stride, GLintptr offset);

    [StrictTypeChecking] void         viewport(GLint x, GLint y, GLsizei width, GLsizei height);

};

178372

Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

/*

 * Copyright (C) 2015 Apple Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#if ENABLE(WEBGL)

#include "WebGLRenderingContextBase.h"

#include "ANGLEInstancedArrays.h"

#include "CachedImage.h"

#include "DOMWindow.h"

#include "Document.h"

#include "EXTBlendMinMax.h"

#include "EXTFragDepth.h"

#include "EXTShaderTextureLOD.h"

#include "EXTTextureFilterAnisotropic.h"

#include "EXTsRGB.h"

#include "ExceptionCode.h"

#include "Extensions3D.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "FrameLoaderClient.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLCanvasElement.h"

#include "HTMLImageElement.h"

#include "HTMLVideoElement.h"

#include "ImageBuffer.h"

#include "ImageData.h"

#include "IntSize.h"

#include "Logging.h"

#include "MainFrame.h"

#include "NotImplemented.h"

#include "OESElementIndexUint.h"

#include "OESStandardDerivatives.h"

#include "OESTextureFloat.h"

#include "OESTextureFloatLinear.h"

#include "OESTextureHalfFloat.h"

#include "OESTextureHalfFloatLinear.h"

#include "OESVertexArrayObject.h"

#include "Page.h"

#include "RenderBox.h"

#include "Settings.h"

#include "WebGL1RenderingContext.h"

#include "WebGL2RenderingContext.h"

#include "WebGLActiveInfo.h"

#include "WebGLBuffer.h"

#include "WebGLCompressedTextureATC.h"

#include "WebGLCompressedTexturePVRTC.h"

#include "WebGLCompressedTextureS3TC.h"

#include "WebGLContextAttributes.h"

#include "WebGLContextEvent.h"

#include "WebGLContextGroup.h"

#include "WebGLDebugRendererInfo.h"

#include "WebGLDebugShaders.h"

#include "WebGLDepthTexture.h"

#include "WebGLDrawBuffers.h"

#include "WebGLFramebuffer.h"

#include "WebGLLoseContext.h"

#include "WebGLProgram.h"

#include "WebGLRenderbuffer.h"

#include "WebGLShader.h"

#include "WebGLShaderPrecisionFormat.h"

#include "WebGLTexture.h"

#include "WebGLUniformLocation.h"

#include <runtime/JSCInlines.h>

#include <runtime/TypedArrayInlines.h>

#include <runtime/Uint32Array.h>

#include <wtf/StdLibExtras.h>

#include <wtf/text/CString.h>

#include <wtf/text/StringBuilder.h>

namespace WebCore {

const double secondsBetweenRestoreAttempts = 1.0;

const int maxGLErrorsAllowedToConsole = 256;

namespace {

class ScopedDrawingBufferBinder {

public:

    ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer, WebGLFramebuffer* framebufferBinding)

        : m_drawingBuffer(drawingBuffer)

        , m_framebufferBinding(framebufferBinding)

    {

        // Commit DrawingBuffer if needed (e.g., for multisampling)

        if (!m_framebufferBinding && m_drawingBuffer)

            m_drawingBuffer->commit();

    }

    ~ScopedDrawingBufferBinder()

    {

        // Restore DrawingBuffer if needed

        if (!m_framebufferBinding && m_drawingBuffer)

            m_drawingBuffer->bind();

    }

private:

    DrawingBuffer* m_drawingBuffer;

    WebGLFramebuffer* m_framebufferBinding;

};

Platform3DObject objectOrZero(WebGLObject* object)

{

    return object ? object->object() : 0;

}

void clip1D(GC3Dint start, GC3Dsizei range, GC3Dsizei sourceRange, GC3Dint* clippedStart, GC3Dsizei* clippedRange)

{

    ASSERT(clippedStart && clippedRange);

    if (start < 0) {

        range += start;

        start = 0;

    }

    GC3Dint end = start + range;

    if (end > sourceRange)

        range -= end - sourceRange;

    *clippedStart = start;

    *clippedRange = range;

}

// Returns false if no clipping is necessary, i.e., x, y, width, height stay the same.

bool clip2D(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height,

            GC3Dsizei sourceWidth, GC3Dsizei sourceHeight,

            GC3Dint* clippedX, GC3Dint* clippedY, GC3Dsizei* clippedWidth, GC3Dsizei*clippedHeight)

{

    ASSERT(clippedX && clippedY && clippedWidth && clippedHeight);

    clip1D(x, width, sourceWidth, clippedX, clippedWidth);

    clip1D(y, height, sourceHeight, clippedY, clippedHeight);

    return (*clippedX != x || *clippedY != y || *clippedWidth != width || *clippedHeight != height);

}

GC3Dint clamp(GC3Dint value, GC3Dint min, GC3Dint max)

{

    if (value < min)

        value = min;

    if (value > max)

        value = max;

    return value;

}

// Return true if a character belongs to the ASCII subset as defined in

// GLSL ES 1.0 spec section 3.1.

bool validateCharacter(unsigned char c)

{

    // Printing characters are valid except " $ ` @ \ ' DEL.

    if (c >= 32 && c <= 126

        && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'')

        return true;

    // Horizontal tab, line feed, vertical tab, form feed, carriage return

    // are also valid.

    if (c >= 9 && c <= 13)

        return true;

    return false;

}

bool isPrefixReserved(const String& name)

{

    if (name.startsWith("gl_") || name.startsWith("webgl_") || name.startsWith("_webgl_"))

        return true;

    return false;

}

// Strips comments from shader text. This allows non-ASCII characters

// to be used in comments without potentially breaking OpenGL

// implementations not expecting characters outside the GLSL ES set.

class StripComments {

public:

    StripComments(const String& str)

        : m_parseState(BeginningOfLine)

        , m_sourceString(str)

        , m_length(str.length())

        , m_position(0)

    {

        parse();

    }

    String result()

    {

        return m_builder.toString();

    }

private:

    bool hasMoreCharacters() const

    {

        return (m_position < m_length);

    }

    void parse()

    {

        while (hasMoreCharacters()) {

            process(current());

            // process() might advance the position.

            if (hasMoreCharacters())

                advance();

        }

    }

    void process(UChar);

    bool peek(UChar& character) const

    {

        if (m_position + 1 >= m_length)

            return false;

        character = m_sourceString[m_position + 1];

        return true;

    }

    UChar current() const

    {

        ASSERT_WITH_SECURITY_IMPLICATION(m_position < m_length);

        return m_sourceString[m_position];

    }

    void advance()

    {

        ++m_position;

    }

    bool isNewline(UChar character) const

    {

        // Don't attempt to canonicalize newline related characters.

        return (character == '\n' || character == '\r');

    }

    void emit(UChar character)

    {

        m_builder.append(character);

    }

    enum ParseState {

        // Have not seen an ASCII non-whitespace character yet on

        // this line. Possible that we might see a preprocessor

        // directive.

        BeginningOfLine,

        // Have seen at least one ASCII non-whitespace character

        // on this line.

        MiddleOfLine,

        // Handling a preprocessor directive. Passes through all

        // characters up to the end of the line. Disables comment

        // processing.

        InPreprocessorDirective,

        // Handling a single-line comment. The comment text is

        // replaced with a single space.

        InSingleLineComment,

        // Handling a multi-line comment. Newlines are passed

        // through to preserve line numbers.

        InMultiLineComment

    };

    ParseState m_parseState;

    String m_sourceString;

    unsigned m_length;

    unsigned m_position;

    StringBuilder m_builder;

};

void StripComments::process(UChar c)

{

    if (isNewline(c)) {

        // No matter what state we are in, pass through newlines

        // so we preserve line numbers.

        emit(c);

        if (m_parseState != InMultiLineComment)

            m_parseState = BeginningOfLine;

        return;

    }

    UChar temp = 0;

    switch (m_parseState) {

    case BeginningOfLine:

        if (WTF::isASCIISpace(c)) {

            emit(c);

            break;

        }

        if (c == '#') {

            m_parseState = InPreprocessorDirective;

            emit(c);

            break;

        }

        // Transition to normal state and re-handle character.

        m_parseState = MiddleOfLine;

        process(c);

        break;

    case MiddleOfLine:

        if (c == '/' && peek(temp)) {

            if (temp == '/') {

                m_parseState = InSingleLineComment;

                emit(' ');

                advance();

                break;

            }

            if (temp == '*') {

                m_parseState = InMultiLineComment;

                // Emit the comment start in case the user has

                // an unclosed comment and we want to later

                // signal an error.

                emit('/');

                emit('*');

                advance();

                break;

            }

        }

        emit(c);

        break;

    case InPreprocessorDirective:

        // No matter what the character is, just pass it

        // through. Do not parse comments in this state. This

        // might not be the right thing to do long term, but it

        // should handle the #error preprocessor directive.

        emit(c);

        break;

    case InSingleLineComment:

        // The newline code at the top of this function takes care

        // of resetting our state when we get out of the

        // single-line comment. Swallow all other characters.

        break;

    case InMultiLineComment:

        if (c == '*' && peek(temp) && temp == '/') {

            emit('*');

            emit('/');

            m_parseState = MiddleOfLine;

            advance();

            break;

        }

        // Swallow all other characters. Unclear whether we may

        // want or need to just emit a space per character to try

        // to preserve column numbers for debugging purposes.

        break;

    }

}

} // namespace anonymous

class WebGLRenderingContextLostCallback : public GraphicsContext3D::ContextLostCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextLostCallback(WebGLRenderingContextBase* cb) 

    : m_context(cb) { }

    virtual void onContextLost() override 

    { 

        m_context->forceLostContext(WebGLRenderingContextBase::RealLostContext); 

    }

    virtual ~WebGLRenderingContextLostCallback() { }

private:

    WebGLRenderingContextBase* m_context;

};

class WebGLRenderingContextErrorMessageCallback : public GraphicsContext3D::ErrorMessageCallback {

    WTF_MAKE_FAST_ALLOCATED;

public:

    explicit WebGLRenderingContextErrorMessageCallback(WebGLRenderingContextBase* cb) 

    : m_context(cb) { }

    virtual void onErrorMessage(const String& message, GC3Dint) override

    {

        if (m_context->m_synthesizedErrorsToConsole)

            m_context->printGLErrorToConsole(message);

    }

    virtual ~WebGLRenderingContextErrorMessageCallback() { }

private:

    WebGLRenderingContextBase* m_context;

};

std::unique_ptr<WebGLRenderingContextBase> WebGLRenderingContextBase::create(HTMLCanvasElement* canvas, WebGLContextAttributes* attrs, const String& type)

{

    Document& document = canvas->document();

    Frame* frame = document.frame();

    if (!frame)

        return nullptr;

    // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in

    // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled())) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Web page was not allowed to create a WebGL context."));

        return nullptr;

    }

    bool isPendingPolicyResolution = false;

    Document& topDocument = document.topDocument();

    Page* page = topDocument.page();

    if (page && !topDocument.url().isLocalFile()) {

        WebGLLoadPolicy policy = page->mainFrame().loader().client().webGLPolicyForURL(topDocument.url());

        if (policy == WebGLBlockCreation) {

            LOG(WebGL, "The policy for this URL (%s) is to block WebGL.", topDocument.url().host().utf8().data());

            return nullptr;

        }

        if (policy == WebGLPendingCreation) {

            LOG(WebGL, "WebGL policy is pending. May need to be resolved later.");

            isPendingPolicyResolution = true;

        }

    }

    GraphicsContext3D::Attributes attributes = attrs ? attrs->attributes() : GraphicsContext3D::Attributes();

    if (attributes.antialias) {

        if (!frame->settings().openGLMultisamplingEnabled())

            attributes.antialias = false;

    }

    attributes.noExtensions = true;

    attributes.shareResources = false;

    attributes.preferDiscreteGPU = true;

    if (frame->settings().forceSoftwareWebGLRendering())

        attributes.forceSoftwareRenderer = true;

    if (page)

        attributes.devicePixelRatio = page->deviceScaleFactor();

    if (isPendingPolicyResolution) {

        LOG(WebGL, "Create a WebGL context that looks real, but will require a policy resolution if used.");

        std::unique_ptr<WebGLRenderingContextBase> renderingContext = nil;

        if (type == "experimental-webgl2")

            renderingContext = std::unique_ptr<WebGL2RenderingContext>(new WebGL2RenderingContext(canvas, attributes));

        else

            renderingContext = std::unique_ptr<WebGL1RenderingContext>(new WebGL1RenderingContext(canvas, attributes));

    }

    HostWindow* hostWindow = document.view()->root()->hostWindow();

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(attributes, hostWindow));

    if (!context || !context->makeContextCurrent()) {

        canvas->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextcreationerrorEvent, false, true, "Could not create a WebGL context."));

        return nullptr;

    }

    Extensions3D* extensions = context->getExtensions();

    if (extensions->supports("GL_EXT_debug_marker"))

        extensions->pushGroupMarkerEXT("WebGLRenderingContext");

    std::unique_ptr<WebGLRenderingContextBase> renderingContext = nil;

    if (type == "experimental-webgl2")

        renderingContext = std::unique_ptr<WebGL2RenderingContext>(new WebGL2RenderingContext(canvas, context, attributes));

    else

        renderingContext = std::unique_ptr<WebGL1RenderingContext>(new WebGL1RenderingContext(canvas, context, attributes));

    renderingContext->suspendIfNeeded();

    return renderingContext;

}

WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(0)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContextBase::maybeRestoreContext)

    , m_generatedImageCache(0)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(true)

    , m_hasRequestedPolicyResolution(false)

{

}

WebGLRenderingContextBase::WebGLRenderingContextBase(HTMLCanvasElement* passedCanvas, PassRefPtr<GraphicsContext3D> context,GraphicsContext3D::Attributes attributes)

    : CanvasRenderingContext(passedCanvas)

    , ActiveDOMObject(&passedCanvas->document())

    , m_context(context)

    , m_drawingBuffer(0)

    , m_dispatchContextLostEventTimer(*this, &WebGLRenderingContextBase::dispatchContextLostEvent)

    , m_restoreAllowed(false)

    , m_restoreTimer(*this, &WebGLRenderingContextBase::maybeRestoreContext)

    , m_generatedImageCache(4)

    , m_contextLost(false)

    , m_contextLostMode(SyntheticLostContext)

    , m_attributes(attributes)

    , m_synthesizedErrorsToConsole(true)

    , m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole)

    , m_isPendingPolicyResolution(false)

    , m_hasRequestedPolicyResolution(false)

{

    ASSERT(m_context);

    m_contextGroup = WebGLContextGroup::create();

    m_contextGroup->addContext(this);

    m_maxViewportDims[0] = m_maxViewportDims[1] = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VIEWPORT_DIMS, m_maxViewportDims);

    if (m_drawingBuffer)

        m_drawingBuffer->bind();

    setupFlags();

    initializeNewContext();

}

void WebGLRenderingContextBase::initializeNewContext()

{

    ASSERT(!m_contextLost);

    m_needsUpdate = true;

    m_markedCanvasDirty = false;

    m_activeTextureUnit = 0;

    m_packAlignment = 4;

    m_unpackAlignment = 4;

    m_unpackFlipY = false;

    m_unpackPremultiplyAlpha = false;

    m_unpackColorspaceConversion = GraphicsContext3D::BROWSER_DEFAULT_WEBGL;

    m_boundArrayBuffer = 0;

    m_currentProgram = 0;

    m_framebufferBinding = 0;

    m_renderbufferBinding = 0;

    m_depthMask = true;

    m_stencilEnabled = false;

    m_stencilMask = 0xFFFFFFFF;

    m_stencilMaskBack = 0xFFFFFFFF;

    m_stencilFuncRef = 0;

    m_stencilFuncRefBack = 0;

    m_stencilFuncMask = 0xFFFFFFFF;

    m_stencilFuncMaskBack = 0xFFFFFFFF;

    m_layerCleared = false;

    m_numGLErrorsToConsoleAllowed = maxGLErrorsAllowedToConsole;

    m_clearColor[0] = m_clearColor[1] = m_clearColor[2] = m_clearColor[3] = 0;

    m_scissorEnabled = false;

    m_clearDepth = 1;

    m_clearStencil = 0;

    m_colorMask[0] = m_colorMask[1] = m_colorMask[2] = m_colorMask[3] = true;

    GC3Dint numCombinedTextureImageUnits = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);

    m_textureUnits.clear();

    m_textureUnits.resize(numCombinedTextureImageUnits);

    GC3Dint numVertexAttribs = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_VERTEX_ATTRIBS, &numVertexAttribs);

    m_maxVertexAttribs = numVertexAttribs;

    m_maxTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_TEXTURE_SIZE, &m_maxTextureSize);

    m_maxTextureLevel = WebGLTexture::computeLevelCount(m_maxTextureSize, m_maxTextureSize);

    m_maxCubeMapTextureSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE, &m_maxCubeMapTextureSize);

    m_maxCubeMapTextureLevel = WebGLTexture::computeLevelCount(m_maxCubeMapTextureSize, m_maxCubeMapTextureSize);

    m_maxRenderbufferSize = 0;

    m_context->getIntegerv(GraphicsContext3D::MAX_RENDERBUFFER_SIZE, &m_maxRenderbufferSize);

    // These two values from EXT_draw_buffers are lazily queried.

    m_maxDrawBuffers = 0;

    m_maxColorAttachments = 0;

    m_backDrawBuffer = GraphicsContext3D::BACK;

    m_drawBuffersWebGLRequirementsChecked = false;

    m_drawBuffersSupported = false;

    m_defaultVertexArrayObject = WebGLVertexArrayObjectOES::create(this, WebGLVertexArrayObjectOES::VaoTypeDefault);

    addContextObject(m_defaultVertexArrayObject.get());

    m_boundVertexArrayObject = m_defaultVertexArrayObject;

    m_vertexAttribValue.resize(m_maxVertexAttribs);

    if (!isGLES2NPOTStrict())

        createFallbackBlackTextures1x1();

    if (!isGLES2Compliant())

        initVertexAttrib0();

    IntSize canvasSize = clampedCanvasSize();

    if (m_drawingBuffer)

        m_drawingBuffer->reset(canvasSize);

    m_context->reshape(canvasSize.width(), canvasSize.height());

    m_context->viewport(0, 0, canvasSize.width(), canvasSize.height());

    m_context->scissor(0, 0, canvasSize.width(), canvasSize.height());

    m_context->setContextLostCallback(std::make_unique<WebGLRenderingContextLostCallback>(this));

    m_context->setErrorMessageCallback(std::make_unique<WebGLRenderingContextErrorMessageCallback>(this));

}

void WebGLRenderingContextBase::setupFlags()

{

    ASSERT(m_context);

    if (Page* page = canvas()->document().page())

        m_synthesizedErrorsToConsole = page->settings().webGLErrorsToConsoleEnabled();

    m_isGLES2Compliant = m_context->isGLES2Compliant();

    m_isErrorGeneratedOnOutOfBoundsAccesses = m_context->getExtensions()->isEnabled("GL_CHROMIUM_strict_attribs");

    m_isResourceSafe = m_context->getExtensions()->isEnabled("GL_CHROMIUM_resource_safe");

    if (m_isGLES2Compliant) {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_OES_texture_npot");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_OES_packed_depth_stencil");

    } else {

        m_isGLES2NPOTStrict = !m_context->getExtensions()->isEnabled("GL_ARB_texture_non_power_of_two");

        m_isDepthStencilSupported = m_context->getExtensions()->isEnabled("GL_EXT_packed_depth_stencil");

    }

    m_isRobustnessEXTSupported = m_context->getExtensions()->isEnabled("GL_EXT_robustness");

}

bool WebGLRenderingContextBase::allowPrivilegedExtensions() const

{

    if (Page* page = canvas()->document().page())

        return page->settings().privilegedWebGLExtensionsEnabled();

    return false;

}

void WebGLRenderingContextBase::addCompressedTextureFormat(GC3Denum format)

{

    if (!m_compressedTextureFormats.contains(format))

        m_compressedTextureFormats.append(format);

}

WebGLRenderingContextBase::~WebGLRenderingContextBase()

{

    // Remove all references to WebGLObjects so if they are the last reference

    // they will be freed before the last context is removed from the context group.

    m_boundArrayBuffer = nullptr;

    m_defaultVertexArrayObject = nullptr;

    m_boundVertexArrayObject = nullptr;

    m_vertexAttrib0Buffer = nullptr;

    m_currentProgram = nullptr;

    m_framebufferBinding = nullptr;

    m_renderbufferBinding = nullptr;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        m_textureUnits[i].texture2DBinding = nullptr;

        m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    m_blackTexture2D = nullptr;

    m_blackTextureCubeMap = nullptr;

    if (!m_isPendingPolicyResolution) {

        detachAndRemoveAllObjects();

        destroyGraphicsContext3D();

        m_contextGroup->removeContext(this);

    }

}

void WebGLRenderingContextBase::destroyGraphicsContext3D()

{

    if (m_isPendingPolicyResolution)

        return;

    // The drawing buffer holds a context reference. It must also be destroyed

    // in order for the context to be released.

    if (m_drawingBuffer)

        m_drawingBuffer.clear();

    if (m_context) {

        m_context->setContextLostCallback(nullptr);

        m_context->setErrorMessageCallback(nullptr);

        m_context.clear();

    }

}

void WebGLRenderingContextBase::markContextChanged()

{

    if (m_framebufferBinding)

        return;

    m_context->markContextChanged();

    if (m_drawingBuffer)

        m_drawingBuffer->markContentsChanged();

    m_layerCleared = false;

    RenderBox* renderBox = canvas()->renderBox();

    if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {

        m_markedCanvasDirty = true;

        canvas()->clearCopiedImage();

        renderBox->contentChanged(CanvasChanged);

    } else {

        if (!m_markedCanvasDirty) {

            m_markedCanvasDirty = true;

            canvas()->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));

        }

    }

}

bool WebGLRenderingContextBase::clearIfComposited(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return false;

    if (!m_context->layerComposited() || m_layerCleared

        || m_attributes.preserveDrawingBuffer || (mask && m_framebufferBinding))

        return false;

    RefPtr<WebGLContextAttributes> contextAttributes = getContextAttributes();

    // Determine if it's possible to combine the clear the user asked for and this clear.

    bool combinedClear = mask && !m_scissorEnabled;

    m_context->disable(GraphicsContext3D::SCISSOR_TEST);

    if (combinedClear && (mask & GraphicsContext3D::COLOR_BUFFER_BIT)) {

        m_context->clearColor(m_colorMask[0] ? m_clearColor[0] : 0,

                              m_colorMask[1] ? m_clearColor[1] : 0,

                              m_colorMask[2] ? m_clearColor[2] : 0,

                              m_colorMask[3] ? m_clearColor[3] : 0);

    } else

        m_context->clearColor(0, 0, 0, 0);

    m_context->colorMask(true, true, true, true);

    GC3Dbitfield clearMask = GraphicsContext3D::COLOR_BUFFER_BIT;

    if (contextAttributes->depth()) {

        if (!combinedClear || !m_depthMask || !(mask & GraphicsContext3D::DEPTH_BUFFER_BIT))

            m_context->clearDepth(1.0f);

        clearMask |= GraphicsContext3D::DEPTH_BUFFER_BIT;

        m_context->depthMask(true);

    }

    if (contextAttributes->stencil()) {

        if (combinedClear && (mask & GraphicsContext3D::STENCIL_BUFFER_BIT))

            m_context->clearStencil(m_clearStencil & m_stencilMask);

        else

            m_context->clearStencil(0);

        clearMask |= GraphicsContext3D::STENCIL_BUFFER_BIT;

        m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, 0xFFFFFFFF);

    }

    if (m_drawingBuffer)

        m_drawingBuffer->clearFramebuffers(clearMask);

    else {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

        m_context->clear(clearMask);

    }

    restoreStateAfterClear();

    if (m_framebufferBinding)

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

    m_layerCleared = true;

    return combinedClear;

}

void WebGLRenderingContextBase::restoreStateAfterClear()

{

    // Restore the state that the context set.

    if (m_scissorEnabled)

        m_context->enable(GraphicsContext3D::SCISSOR_TEST);

    m_context->clearColor(m_clearColor[0], m_clearColor[1],

                          m_clearColor[2], m_clearColor[3]);

    m_context->colorMask(m_colorMask[0], m_colorMask[1],

                         m_colorMask[2], m_colorMask[3]);

    m_context->clearDepth(m_clearDepth);

    m_context->clearStencil(m_clearStencil);

    m_context->stencilMaskSeparate(GraphicsContext3D::FRONT, m_stencilMask);

    m_context->depthMask(m_depthMask);

}

void WebGLRenderingContextBase::markLayerComposited()

{

    if (isContextLostOrPending())

        return;

    m_context->markLayerComposited();

}

void WebGLRenderingContextBase::paintRenderingResultsToCanvas()

{

    if (isContextLostOrPending())

        return;

    if (canvas()->document().printing())

        canvas()->clearPresentationCopy();

    // Until the canvas is written to by the application, the clear that

    // happened after it was composited should be ignored by the compositor.

    if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {

        m_context->paintCompositedResultsToCanvas(canvas()->buffer());

        canvas()->makePresentationCopy();

    } else

        canvas()->clearPresentationCopy();

    clearIfComposited();

    if (!m_markedCanvasDirty && !m_layerCleared)

        return;

    canvas()->clearCopiedImage();

    m_markedCanvasDirty = false;

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    m_context->paintRenderingResultsToCanvas(canvas()->buffer(), m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

}

PassRefPtr<ImageData> WebGLRenderingContextBase::paintRenderingResultsToImageData()

{

    if (isContextLostOrPending())

        return nullptr;

    clearIfComposited();

    if (m_drawingBuffer)

        m_drawingBuffer->commit();

    RefPtr<ImageData> imageData = m_context->paintRenderingResultsToImageData(m_drawingBuffer.get());

    if (m_drawingBuffer) {

        if (m_framebufferBinding)

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

        else

            m_drawingBuffer->bind();

    }

    return imageData;

}

void WebGLRenderingContextBase::reshape(int width, int height)

{

    if (isContextLostOrPending())

        return;

    // This is an approximation because at WebGLRenderingContext level we don't

    // know if the underlying FBO uses textures or renderbuffers.

    GC3Dint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);

    // Limit drawing buffer size to 4k to avoid memory exhaustion.

    const int sizeUpperLimit = 4096;

    maxSize = std::min(maxSize, sizeUpperLimit);

    GC3Dint maxWidth = std::min(maxSize, m_maxViewportDims[0]);

    GC3Dint maxHeight = std::min(maxSize, m_maxViewportDims[1]);

    width = clamp(width, 1, maxWidth);

    height = clamp(height, 1, maxHeight);

    if (m_needsUpdate) {

        RenderBox* renderBox = canvas()->renderBox();

        if (renderBox && renderBox->hasAcceleratedCompositing())

            renderBox->contentChanged(CanvasChanged);

        m_needsUpdate = false;

    }

    // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off

    // clear (and this matches what reshape will do).

    if (m_drawingBuffer) {

        m_drawingBuffer->reset(IntSize(width, height));

        restoreStateAfterClear();

    } else

        m_context->reshape(width, height);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(m_textureUnits[m_activeTextureUnit].texture2DBinding.get()));

    m_context->bindRenderbuffer(GraphicsContext3D::RENDERBUFFER, objectOrZero(m_renderbufferBinding.get()));

    if (m_framebufferBinding)

        m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, objectOrZero(m_framebufferBinding.get()));

}

int WebGLRenderingContextBase::drawingBufferWidth() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().width();

    return m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContextBase::drawingBufferHeight() const

{

    if (m_drawingBuffer)

        return m_drawingBuffer->size().height();

    return m_context->getInternalFramebufferSize().height();

}

unsigned WebGLRenderingContextBase::sizeInBytes(GC3Denum type)

{

    switch (type) {

    case GraphicsContext3D::BYTE:

        return sizeof(GC3Dbyte);

    case GraphicsContext3D::UNSIGNED_BYTE:

        return sizeof(GC3Dubyte);

    case GraphicsContext3D::SHORT:

        return sizeof(GC3Dshort);

    case GraphicsContext3D::UNSIGNED_SHORT:

        return sizeof(GC3Dushort);

    case GraphicsContext3D::INT:

        return sizeof(GC3Dint);

    case GraphicsContext3D::UNSIGNED_INT:

        return sizeof(GC3Duint);

    case GraphicsContext3D::FLOAT:

        return sizeof(GC3Dfloat);

    }

    ASSERT_NOT_REACHED();

    return 0;

}

void WebGLRenderingContextBase::activeTexture(GC3Denum texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (texture - GraphicsContext3D::TEXTURE0 >= m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "activeTexture", "texture unit out of range");

        return;

    }

    m_activeTextureUnit = texture - GraphicsContext3D::TEXTURE0;

    m_context->activeTexture(texture);

    if (m_drawingBuffer)

        m_drawingBuffer->setActiveTextureUnit(texture);

}

void WebGLRenderingContextBase::attachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("attachShader", program) || !validateWebGLObject("attachShader", shader))

        return;

    if (!program->attachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "attachShader", "shader attachment already has shader");

        return;

    }

    m_context->attachShader(objectOrZero(program), objectOrZero(shader));

    shader->onAttached();

}

void WebGLRenderingContextBase::bindAttribLocation(WebGLProgram* program, GC3Duint index, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("bindAttribLocation", program))

        return;

    if (!validateLocationLength("bindAttribLocation", name))

        return;

    if (!validateString("bindAttribLocation", name))

        return;

    if (isPrefixReserved(name)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindAttribLocation", "reserved prefix");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bindAttribLocation", "index out of range");

        return;

    }

    m_context->bindAttribLocation(objectOrZero(program), index, name);

}

bool WebGLRenderingContextBase::checkObjectToBeBound(const char* functionName, WebGLObject* object, bool& deleted)

{

    deleted = false;

    if (isContextLostOrPending())

        return false;

    if (object) {

        if (!object->validate(contextGroup(), this)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object not from this context");

            return false;

        }

        deleted = !object->object();

    }

    return true;

}

void WebGLRenderingContextBase::bindBuffer(GC3Denum target, WebGLBuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindBuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (buffer && buffer->getTarget() && buffer->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindBuffer", "buffers can not be used with multiple targets");

        return;

    }

    if (target == GraphicsContext3D::ARRAY_BUFFER)

        m_boundArrayBuffer = buffer;

    else if (target == GraphicsContext3D::ELEMENT_ARRAY_BUFFER)

        m_boundVertexArrayObject->setElementArrayBuffer(buffer);

    else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindBuffer", "invalid target");

        return;

    }

    m_context->bindBuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setTarget(target);

}

void WebGLRenderingContextBase::bindFramebuffer(GC3Denum target, WebGLFramebuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))

        return;

    if (deleted)

        buffer = 0;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindFramebuffer", "invalid target");

        return;

    }

    m_framebufferBinding = buffer;

    if (m_drawingBuffer)

        m_drawingBuffer->setFramebufferBinding(objectOrZero(m_framebufferBinding.get()));

    if (!m_framebufferBinding && m_drawingBuffer) {

        // Instead of binding fb 0, bind the drawing buffer.

        m_drawingBuffer->bind();

    } else

        m_context->bindFramebuffer(target, objectOrZero(buffer));

    if (buffer)

        buffer->setHasEverBeenBound();

    applyStencilTest();

}

void WebGLRenderingContextBase::bindRenderbuffer(GC3Denum target, WebGLRenderbuffer* renderBuffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindRenderbuffer", renderBuffer, deleted))

        return;

    if (deleted)

        renderBuffer = 0;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindRenderbuffer", "invalid target");

        return;

    }

    m_renderbufferBinding = renderBuffer;

    m_context->bindRenderbuffer(target, objectOrZero(renderBuffer));

    if (renderBuffer)

        renderBuffer->setHasEverBeenBound();

}

void WebGLRenderingContextBase::bindTexture(GC3Denum target, WebGLTexture* texture, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("bindTexture", texture, deleted))

        return;

    if (deleted)

        texture = 0;

    if (texture && texture->getTarget() && texture->getTarget() != target) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bindTexture", "textures can not be used with multiple targets");

        return;

    }

    GC3Dint maxLevel = 0;

    if (target == GraphicsContext3D::TEXTURE_2D) {

        m_textureUnits[m_activeTextureUnit].texture2DBinding = texture;

        maxLevel = m_maxTextureLevel;

        if (m_drawingBuffer && !m_activeTextureUnit)

            m_drawingBuffer->setTexture2DBinding(objectOrZero(texture));

    } else if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {

        m_textureUnits[m_activeTextureUnit].textureCubeMapBinding = texture;

        maxLevel = m_maxCubeMapTextureLevel;

    } else {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "bindTexture", "invalid target");

        return;

    }

    m_context->bindTexture(target, objectOrZero(texture));

    if (texture)

        texture->setTarget(target, maxLevel);

    // Note: previously we used to automatically set the TEXTURE_WRAP_R

    // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL

    // ES 2.0 doesn't expose this flag (a bug in the specification) and

    // otherwise the application has no control over the seams in this

    // dimension. However, it appears that supporting this properly on all

    // platforms is fairly involved (will require a HashMap from texture ID

    // in all ports), and we have not had any complaints, so the logic has

    // been removed.

}

void WebGLRenderingContextBase::blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha)

{

    if (isContextLostOrPending())

        return;

    m_context->blendColor(red, green, blue, alpha);

}

void WebGLRenderingContextBase::blendEquation(GC3Denum mode)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", mode))

        return;

    m_context->blendEquation(mode);

}

void WebGLRenderingContextBase::blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha)

{

    if (isContextLostOrPending() || !validateBlendEquation("blendEquation", modeRGB) || !validateBlendEquation("blendEquation", modeAlpha))

        return;

    m_context->blendEquationSeparate(modeRGB, modeAlpha);

}

void WebGLRenderingContextBase::blendFunc(GC3Denum sfactor, GC3Denum dfactor)

{

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", sfactor, dfactor))

        return;

    m_context->blendFunc(sfactor, dfactor);

}

void WebGLRenderingContextBase::blendFuncSeparate(GC3Denum srcRGB, GC3Denum dstRGB, GC3Denum srcAlpha, GC3Denum dstAlpha)

{

    // Note: Alpha does not have the same restrictions as RGB.

    if (isContextLostOrPending() || !validateBlendFuncFactors("blendFunc", srcRGB, dstRGB))

        return;

    m_context->blendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);

}

void WebGLRenderingContextBase::bufferData(GC3Denum target, long long size, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (size < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size < 0");

        return;

    }

    if (!size) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "size == 0");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(static_cast<GC3Dsizeiptr>(size))) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, static_cast<GC3Dsizeiptr>(size), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContextBase::bufferData(GC3Denum target, ArrayBuffer* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->data(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContextBase::bufferData(GC3Denum target, ArrayBufferView* data, GC3Denum usage, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferData", target, usage);

    if (!buffer)

        return;

    if (!data) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "no data");

        return;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferData(data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "invalid buffer");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferData(target, data->byteLength(), data->baseAddress(), usage);

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset, ArrayBuffer* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->data());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

void WebGLRenderingContextBase::bufferSubData(GC3Denum target, long long offset, ArrayBufferView* data, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);

    if (!buffer)

        return;

    if (offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset < 0");

        return;

    }

    if (!data)

        return;

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        if (!buffer->associateBufferSubData(static_cast<GC3Dintptr>(offset), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "offset out of range");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->bufferSubData(target, static_cast<GC3Dintptr>(offset), data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.

        buffer->disassociateBufferData();

    }

}

GC3Denum WebGLRenderingContextBase::checkFramebufferStatus(GC3Denum target)

{

    if (isContextLostOrPending())

        return GraphicsContext3D::FRAMEBUFFER_UNSUPPORTED;

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "checkFramebufferStatus", "invalid target");

        return 0;

    }

    if (!m_framebufferBinding || !m_framebufferBinding->object())

        return GraphicsContext3D::FRAMEBUFFER_COMPLETE;

    const char* reason = "framebuffer incomplete";

    GC3Denum result = m_framebufferBinding->checkStatus(&reason);

    if (result != GraphicsContext3D::FRAMEBUFFER_COMPLETE) {

        printGLWarningToConsole("checkFramebufferStatus", reason);

        return result;

    }

    result = m_context->checkFramebufferStatus(target);

    return result;

}

void WebGLRenderingContextBase::clear(GC3Dbitfield mask)

{

    if (isContextLostOrPending())

        return;

    if (mask & ~(GraphicsContext3D::COLOR_BUFFER_BIT | GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clear", "invalid mask");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);

        return;

    }

    if (!clearIfComposited(mask))

        m_context->clear(mask);

    markContextChanged();

}

void WebGLRenderingContextBase::clearColor(GC3Dfloat r, GC3Dfloat g, GC3Dfloat b, GC3Dfloat a)

{

    if (isContextLostOrPending())

        return;

    if (std::isnan(r))

        r = 0;

    if (std::isnan(g))

        g = 0;

    if (std::isnan(b))

        b = 0;

    if (std::isnan(a))

        a = 1;

    m_clearColor[0] = r;

    m_clearColor[1] = g;

    m_clearColor[2] = b;

    m_clearColor[3] = a;

    m_context->clearColor(r, g, b, a);

}

void WebGLRenderingContextBase::clearDepth(GC3Dfloat depth)

{

    if (isContextLostOrPending())

        return;

    m_clearDepth = depth;

    m_context->clearDepth(depth);

}

void WebGLRenderingContextBase::clearStencil(GC3Dint s)

{

    if (isContextLostOrPending())

        return;

    m_clearStencil = s;

    m_context->clearStencil(s);

}

void WebGLRenderingContextBase::colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha)

{

    if (isContextLostOrPending())

        return;

    m_colorMask[0] = red;

    m_colorMask[1] = green;

    m_colorMask[2] = blue;

    m_colorMask[3] = alpha;

    m_context->colorMask(red, green, blue, alpha);

}

void WebGLRenderingContextBase::compileShader(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("compileShader", shader))

        return;

    m_context->compileShader(objectOrZero(shader));

    GC3Dint value;

    m_context->getShaderiv(objectOrZero(shader), GraphicsContext3D::COMPILE_STATUS, &value);

    shader->setValid(value);

}

void WebGLRenderingContextBase::compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,

                                                     GC3Dsizei height, GC3Dint border, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(internalformat)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexImage2D", "invalid internalformat");

        return;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "border not 0");

        return;

    }

    if (!validateCompressedTexDimensions("compressedTexImage2D", target, level, width, height, internalformat))

        return;

    if (!validateCompressedTexFuncData("compressedTexImage2D", width, height, internalformat, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexImage2D", target, true);

    if (!tex)

        return;

    if (!isGLES2NPOTStrict()) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "compressedTexImage2D", "level > 0 not power of 2");

            return;

        }

    }

    m_context->moveErrorsToSyntheticErrorList();

    m_context->compressedTexImage2D(target, level, internalformat, width, height,

                                    border, data->byteLength(), data->baseAddress());

    if (m_context->moveErrorsToSyntheticErrorList()) {

        // The compressedTexImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

        tex->markInvalid(target, level);

        return;

    }

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

    tex->setCompressed();

}

void WebGLRenderingContextBase::compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                        GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("compressedTexSubImage2D", target, level))

        return;

    if (!validateCompressedTexFormat(format)) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "compressedTexSubImage2D", "invalid format");

        return;

    }

    if (!validateCompressedTexFuncData("compressedTexSubImage2D", width, height, format, data))

        return;

    WebGLTexture* tex = validateTextureBinding("compressedTexSubImage2D", target, true);

    if (!tex)

        return;

    if (format != tex->getInternalFormat(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "compressedTexSubImage2D", "format does not match texture format");

        return;

    }

    if (!validateCompressedTexSubDimensions("compressedTexSubImage2D", target, level, xoffset, yoffset, width, height, format, tex))

        return;

    graphicsContext3D()->compressedTexSubImage2D(target, level, xoffset, yoffset,

                                                 width, height, format, data->byteLength(), data->baseAddress());

    tex->setCompressed();

}

bool WebGLRenderingContextBase::validateSettableTexFormat(const char* functionName, GC3Denum format)

{

    if (GraphicsContext3D::getClearBitsByFormat(format) & (GraphicsContext3D::DEPTH_BUFFER_BIT | GraphicsContext3D::STENCIL_BUFFER_BIT)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format can not be set, only rendered to");

        return false;

    }

    return true;

}

void WebGLRenderingContextBase::copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncParameters("copyTexImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, internalformat, GraphicsContext3D::UNSIGNED_BYTE))

        return;

    if (!validateSettableTexFormat("copyTexImage2D", internalformat))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexImage2D", target, true);

    if (!tex)

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexImage2D", "framebuffer is incompatible format");

        return;

    }

    if (!isGLES2NPOTStrict() && level && WebGLTexture::isNPOT(width, height)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexImage2D", "level > 0 not power of 2");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    } else {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            m_context->texImage2DResourceSafe(target, level, internalformat, width, height, border,

                                              internalformat, GraphicsContext3D::UNSIGNED_BYTE, m_unpackAlignment);

            if (clippedWidth > 0 && clippedHeight > 0) {

                m_context->copyTexSubImage2D(target, level, clippedX - x, clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else

            m_context->copyTexImage2D(target, level, internalformat, x, y, width, height, border);

    }

    // FIXME: if the framebuffer is not complete, none of the below should be executed.

    tex->setLevelInfo(target, level, internalformat, width, height, GraphicsContext3D::UNSIGNED_BYTE);

}

void WebGLRenderingContextBase::copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateTexFuncLevel("copyTexSubImage2D", target, level))

        return;

    WebGLTexture* tex = validateTextureBinding("copyTexSubImage2D", target, true);

    if (!tex)

        return;

    if (!validateSize("copyTexSubImage2D", xoffset, yoffset) || !validateSize("copyTexSubImage2D", width, height))

        return;

    // Before checking if it is in the range, check if overflow happens first.

    if (xoffset + width < 0 || yoffset + height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "bad dimensions");

        return;

    }

    if (xoffset + width > tex->getWidth(target, level) || yoffset + height > tex->getHeight(target, level)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "rectangle out of range");

        return;

    }

    GC3Denum internalformat = tex->getInternalFormat(target, level);

    if (!validateSettableTexFormat("copyTexSubImage2D", internalformat))

        return;

    if (!isTexInternalFormatColorBufferCombinationValid(internalformat, getBoundFramebufferColorFormat())) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyTexSubImage2D", "framebuffer is incompatible format");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "copyTexSubImage2D", reason);

        return;

    }

    clearIfComposited();

    if (isResourceSafe()) {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

    } else {

        GC3Dint clippedX, clippedY;

        GC3Dsizei clippedWidth, clippedHeight;

        if (clip2D(x, y, width, height, getBoundFramebufferWidth(), getBoundFramebufferHeight(), &clippedX, &clippedY, &clippedWidth, &clippedHeight)) {

            GC3Denum format = tex->getInternalFormat(target, level);

            GC3Denum type = tex->getType(target, level);

            std::unique_ptr<unsigned char[]> zero;

            if (width && height) {

                unsigned size;

                GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, 0);

                if (error != GraphicsContext3D::NO_ERROR) {

                    synthesizeGLError(error, "copyTexSubImage2D", "bad dimensions");

                    return;

                }

                zero = std::make_unique<unsigned char[]>(size);

                if (!zero) {

                    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyTexSubImage2D", "out of memory");

                    return;

                }

                memset(zero.get(), 0, size);

            }

            m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, zero.get());

            if (clippedWidth > 0 && clippedHeight > 0) {

                ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

                m_context->copyTexSubImage2D(target, level, xoffset + clippedX - x, yoffset + clippedY - y,

                                             clippedX, clippedY, clippedWidth, clippedHeight);

            }

        } else {

            ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

            m_context->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);

        }

    }

}

PassRefPtr<WebGLBuffer> WebGLRenderingContextBase::createBuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLBuffer> o = WebGLBuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLFramebuffer> WebGLRenderingContextBase::createFramebuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLFramebuffer> o = WebGLFramebuffer::create(this);

    addContextObject(o.get());

    return o;

}

PassRefPtr<WebGLTexture> WebGLRenderingContextBase::createTexture()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLTexture> o = WebGLTexture::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLProgram> WebGLRenderingContextBase::createProgram()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLProgram> o = WebGLProgram::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLRenderbuffer> WebGLRenderingContextBase::createRenderbuffer()

{

    if (isContextLostOrPending())

        return nullptr;

    RefPtr<WebGLRenderbuffer> o = WebGLRenderbuffer::create(this);

    addSharedObject(o.get());

    return o;

}

PassRefPtr<WebGLShader> WebGLRenderingContextBase::createShader(GC3Denum type, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    if (type != GraphicsContext3D::VERTEX_SHADER && type != GraphicsContext3D::FRAGMENT_SHADER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "createShader", "invalid shader type");

        return nullptr;

    }

    RefPtr<WebGLShader> o = WebGLShader::create(this, type);

    addSharedObject(o.get());

    return o;

}

void WebGLRenderingContextBase::cullFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->cullFace(mode);

}

bool WebGLRenderingContextBase::deleteObject(WebGLObject* object)

{

    if (isContextLostOrPending() || !object)

        return false;

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "delete", "object does not belong to this context");

        return false;

    }

    if (object->object()) {

        // We need to pass in context here because we want

        // things in this context unbound.

        object->deleteObject(graphicsContext3D());

    }

    return true;

}

void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)

{

    if (!deleteObject(buffer))

        return;

    if (m_boundArrayBuffer == buffer)

        m_boundArrayBuffer = 0;

    m_boundVertexArrayObject->unbindBuffer(buffer);

}

void WebGLRenderingContextBase::deleteFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!deleteObject(framebuffer))

        return;

    if (framebuffer == m_framebufferBinding) {

        m_framebufferBinding = 0;

        if (m_drawingBuffer) {

            m_drawingBuffer->setFramebufferBinding(0);

            // Have to call bindFramebuffer here to bind back to internal fbo.

            m_drawingBuffer->bind();

        } else

            m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, 0);

    }

}

void WebGLRenderingContextBase::deleteProgram(WebGLProgram* program)

{

    deleteObject(program);

    // We don't reset m_currentProgram to 0 here because the deletion of the

    // current program is delayed.

}

void WebGLRenderingContextBase::deleteRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!deleteObject(renderbuffer))

        return;

    if (renderbuffer == m_renderbufferBinding)

        m_renderbufferBinding = 0;

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(renderbuffer);

}

void WebGLRenderingContextBase::deleteShader(WebGLShader* shader)

{

    deleteObject(shader);

}

void WebGLRenderingContextBase::deleteTexture(WebGLTexture* texture)

{

    if (!deleteObject(texture))

        return;

    for (size_t i = 0; i < m_textureUnits.size(); ++i) {

        if (texture == m_textureUnits[i].texture2DBinding)

            m_textureUnits[i].texture2DBinding = nullptr;

        if (texture == m_textureUnits[i].textureCubeMapBinding)

            m_textureUnits[i].textureCubeMapBinding = nullptr;

    }

    if (m_framebufferBinding)

        m_framebufferBinding->removeAttachmentFromBoundFramebuffer(texture);

}

void WebGLRenderingContextBase::depthFunc(GC3Denum func)

{

    if (isContextLostOrPending())

        return;

    m_context->depthFunc(func);

}

void WebGLRenderingContextBase::depthMask(GC3Dboolean flag)

{

    if (isContextLostOrPending())

        return;

    m_depthMask = flag;

    m_context->depthMask(flag);

}

void WebGLRenderingContextBase::depthRange(GC3Dfloat zNear, GC3Dfloat zFar)

{

    if (isContextLostOrPending())

        return;

    if (zNear > zFar) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "depthRange", "zNear > zFar");

        return;

    }

    m_context->depthRange(zNear, zFar);

}

void WebGLRenderingContextBase::detachShader(WebGLProgram* program, WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))

        return;

    if (!program->detachShader(shader)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "detachShader", "shader not attached");

        return;

    }

    m_context->detachShader(objectOrZero(program), objectOrZero(shader));

    shader->onDetached(graphicsContext3D());

}

void WebGLRenderingContextBase::disable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("disable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = false;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = false;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->disable(cap);

}

void WebGLRenderingContextBase::disableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "disableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = false;

    if (index > 0 || isGLES2Compliant())

        m_context->disableVertexAttribArray(index);

}

bool WebGLRenderingContextBase::validateElementArraySize(GC3Dsizei count, GC3Denum type, GC3Dintptr offset)

{

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (offset < 0)

        return false;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // For an unsigned array, offset must be divisible by 4 for alignment reasons.

        if (offset % 4)

            return false;

        // Make uoffset an element offset.

        offset /= 4;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 4;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // For an unsigned short array, offset must be divisible by 2 for alignment reasons.

        if (offset % 2)

            return false;

        // Make uoffset an element offset.

        offset /= 2;

        GC3Dsizeiptr n = elementArrayBuffer->byteLength() / 2;

        if (offset > n || count > n - offset)

            return false;

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        GC3Dsizeiptr n = elementArrayBuffer->byteLength();

        if (offset > n || count > n - offset)

            return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateIndexArrayConservative(GC3Denum type, unsigned& numElementsRequired)

{

    // Performs conservative validation by caching a maximum index of

    // the given type per element array buffer. If all of the bound

    // array buffers have enough elements to satisfy that maximum

    // index, skips the expensive per-draw-call iteration in

    // validateIndexArrayPrecise.

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    GC3Dsizeiptr numElements = elementArrayBuffer->byteLength();

    // The case count==0 is already dealt with in drawElements before validateIndexArrayConservative.

    if (!numElements)

        return false;

    const ArrayBuffer* buffer = elementArrayBuffer->elementArrayBuffer();

    ASSERT(buffer);

    int maxIndex = elementArrayBuffer->getCachedMaxIndex(type);

    if (maxIndex < 0) {

        // Compute the maximum index in the entire buffer for the given type of index.

        switch (type) {

        case GraphicsContext3D::UNSIGNED_BYTE: {

            const GC3Dubyte* p = static_cast<const GC3Dubyte*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_SHORT: {

            numElements /= sizeof(GC3Dushort);

            const GC3Dushort* p = static_cast<const GC3Dushort*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        case GraphicsContext3D::UNSIGNED_INT: {

            if (!m_oesElementIndexUint)

                return false;

            numElements /= sizeof(GC3Duint);

            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());

            for (GC3Dsizeiptr i = 0; i < numElements; i++)

                maxIndex = std::max(maxIndex, static_cast<int>(p[i]));

            break;

        }

        default:

            return false;

        }

        elementArrayBuffer->setCachedMaxIndex(type, maxIndex);

    }

    if (maxIndex >= 0) {

        // The number of required elements is one more than the maximum

        // index that will be accessed.

        numElementsRequired = maxIndex + 1;

        return true;

    }

    return false;

}

bool WebGLRenderingContextBase::validateIndexArrayPrecise(GC3Dsizei count, GC3Denum type, GC3Dintptr offset, unsigned& numElementsRequired)

{

    ASSERT(count >= 0 && offset >= 0);

    unsigned lastIndex = 0;

    RefPtr<WebGLBuffer> elementArrayBuffer = m_boundVertexArrayObject->getElementArrayBuffer();

    if (!elementArrayBuffer)

        return false;

    if (!count) {

        numElementsRequired = 0;

        return true;

    }

    if (!elementArrayBuffer->elementArrayBuffer())

        return false;

    unsigned long uoffset = offset;

    unsigned long n = count;

    if (type == GraphicsContext3D::UNSIGNED_INT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Duint);

        const GC3Duint* p = static_cast<const GC3Duint*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_SHORT) {

        // Make uoffset an element offset.

        uoffset /= sizeof(GC3Dushort);

        const GC3Dushort* p = static_cast<const GC3Dushort*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    } else if (type == GraphicsContext3D::UNSIGNED_BYTE) {

        const GC3Dubyte* p = static_cast<const GC3Dubyte*>(elementArrayBuffer->elementArrayBuffer()->data()) + uoffset;

        while (n-- > 0) {

            if (*p > lastIndex)

                lastIndex = *p;

            ++p;

        }

    }

    // Then set the last index in the index array and make sure it is valid.

    numElementsRequired = lastIndex + 1;

    return numElementsRequired > 0;

}

bool WebGLRenderingContextBase::validateVertexAttributes(unsigned elementCount, unsigned primitiveCount)

{

    if (!m_currentProgram)

        return false;

    // Look in each enabled vertex attrib and check if they've been bound to a buffer.

    for (unsigned i = 0; i < m_maxVertexAttribs; ++i) {

        if (!m_boundVertexArrayObject->getVertexAttribState(i).validateBinding())

            return false;

    }

    if (elementCount <= 0)

        return true;

    // Look in each consumed vertex attrib (by the current program).

    bool sawNonInstancedAttrib = false;

    bool sawEnabledAttrib = false;

    int numActiveAttribLocations = m_currentProgram->numActiveAttribLocations();

    for (int i = 0; i < numActiveAttribLocations; ++i) {

        int loc = m_currentProgram->getActiveAttribLocation(i);

        if (loc >= 0 && loc < static_cast<int>(m_maxVertexAttribs)) {

            const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(loc);

            if (state.enabled) {

                sawEnabledAttrib = true;

                // Avoid off-by-one errors in numElements computation.

                // For the last element, we will only touch the data for the

                // element and nothing beyond it.

                int bytesRemaining = static_cast<int>(state.bufferBinding->byteLength() - state.offset);

                unsigned numElements = 0;

                ASSERT(state.stride > 0);

                if (bytesRemaining >= state.bytesPerElement)

                    numElements = 1 + (bytesRemaining - state.bytesPerElement) / state.stride;

                unsigned instancesRequired = 0;

                if (state.divisor) {

                    instancesRequired = ceil(static_cast<float>(primitiveCount) / state.divisor);

                    if (instancesRequired > numElements)

                        return false;

                } else {

                    sawNonInstancedAttrib = true;

                    if (elementCount > numElements)

                        return false;

                }

            }

        }

    }

    if (!sawNonInstancedAttrib && sawEnabledAttrib)

        return false;

    return true;

}

bool WebGLRenderingContextBase::validateWebGLObject(const char* functionName, WebGLObject* object)

{

    if (!object || !object->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no object or object deleted");

        return false;

    }

    if (!object->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "object does not belong to this context");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateDrawArrays(const char* functionName, GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    if (first < 0 || count < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "first or count < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        Checked<GC3Dint, RecordOverflow> checkedFirst(first);

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedSum = checkedFirst + checkedCount;

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedSum.hasOverflowed() || checkedPrimitiveCount.hasOverflowed() || !validateVertexAttributes(checkedSum.unsafeGet(), checkedPrimitiveCount.unsafeGet())) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContextBase::drawArrays(GC3Denum mode, GC3Dint first, GC3Dsizei count, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (!validateDrawArrays("drawArrays", mode, first, count, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", true);

    m_context->drawArrays(mode, first, count);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArrays", false);

    markContextChanged();

}

bool WebGLRenderingContextBase::validateDrawElements(const char* functionName, GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, unsigned& numElements, GC3Dsizei primitiveCount)

{

    if (isContextLostOrPending() || !validateDrawMode(functionName, mode))

        return false;

    if (!validateStencilSettings(functionName))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT:

        break;

    case GraphicsContext3D::UNSIGNED_INT:

        if (m_oesElementIndexUint)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid type");

        return false;

    }

    if (count < 0 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "count or offset < 0");

        return false;

    }

    if (!count) {

        markContextChanged();

        return false;

    }

    if (primitiveCount < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "primcount < 0");

        return false;

    }

    if (!m_boundVertexArrayObject->getElementArrayBuffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no ELEMENT_ARRAY_BUFFER bound");

        return false;

    }

    if (!isErrorGeneratedOnOutOfBoundsAccesses()) {

        // Ensure we have a valid rendering state

        if (!validateElementArraySize(count, type, static_cast<GC3Dintptr>(offset))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "request out of bounds for current ELEMENT_ARRAY_BUFFER");

            return false;

        }

        if (!count)

            return false;

        Checked<GC3Dint, RecordOverflow> checkedCount(count);

        Checked<GC3Dint, RecordOverflow> checkedPrimitiveCount(primitiveCount);

        if (checkedCount.hasOverflowed() || checkedPrimitiveCount.hasOverflowed()) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

            return false;

        }

        if (!validateIndexArrayConservative(type, numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

            if (!validateIndexArrayPrecise(checkedCount.unsafeGet(), type, static_cast<GC3Dintptr>(offset), numElements) || !validateVertexAttributes(numElements, checkedPrimitiveCount.unsafeGet())) {

                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attempt to access out of bounds arrays");

                return false;

            }

        }

    } else {

        if (!validateVertexAttributes(0)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "attribs not setup correctly");

            return false;

        }

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, functionName, reason);

        return false;

    }

    return true;

}

void WebGLRenderingContextBase::drawElements(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    unsigned numElements = 0;

    if (!validateDrawElements("drawElements", mode, count, type, offset, numElements, 0))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", true);

    m_context->drawElements(mode, count, type, static_cast<GC3Dintptr>(offset));

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElements", false);

    markContextChanged();

}

void WebGLRenderingContextBase::enable(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("enable", cap))

        return;

    if (cap == GraphicsContext3D::STENCIL_TEST) {

        m_stencilEnabled = true;

        applyStencilTest();

        return;

    }

    if (cap == GraphicsContext3D::SCISSOR_TEST) {

        m_scissorEnabled = true;

        if (m_drawingBuffer)

            m_drawingBuffer->setScissorEnabled(m_scissorEnabled);

    }

    m_context->enable(cap);

}

void WebGLRenderingContextBase::enableVertexAttribArray(GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "enableVertexAttribArray", "index out of range");

        return;

    }

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    state.enabled = true;

    m_context->enableVertexAttribArray(index);

}

void WebGLRenderingContextBase::finish()

{

    if (isContextLostOrPending())

        return;

    m_context->finish();

}

void WebGLRenderingContextBase::flush()

{

    if (isContextLostOrPending())

        return;

    m_context->flush();

}

void WebGLRenderingContextBase::framebufferRenderbuffer(GC3Denum target, GC3Denum attachment, GC3Denum renderbuffertarget, WebGLRenderbuffer* buffer, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferRenderbuffer", target, attachment))

        return;

    if (renderbuffertarget != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "framebufferRenderbuffer", "invalid target");

        return;

    }

    if (buffer && !buffer->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no buffer or buffer not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferRenderbuffer", "no framebuffer bound");

        return;

    }

    Platform3DObject bufferObject = objectOrZero(buffer);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::DEPTH_ATTACHMENT, renderbuffertarget, bufferObject);

        m_context->framebufferRenderbuffer(target, GraphicsContext3D::STENCIL_ATTACHMENT, renderbuffertarget, bufferObject);

        break;

    default:

        m_context->framebufferRenderbuffer(target, attachment, renderbuffertarget, bufferObject);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, buffer);

    applyStencilTest();

}

void WebGLRenderingContextBase::framebufferTexture2D(GC3Denum target, GC3Denum attachment, GC3Denum textarget, WebGLTexture* texture, GC3Dint level, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("framebufferTexture2D", target, attachment))

        return;

    if (level) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "framebufferTexture2D", "level not 0");

        return;

    }

    if (texture && !texture->validate(contextGroup(), this)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no texture or texture not from this context");

        return;

    }

    // Don't allow the default framebuffer to be mutated; all current

    // implementations use an FBO internally in place of the default

    // FBO.

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "framebufferTexture2D", "no framebuffer bound");

        return;

    }

    Platform3DObject textureObject = objectOrZero(texture);

    switch (attachment) {

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, GraphicsContext3D::DEPTH_ATTACHMENT, textarget, textureObject, level);

        m_context->framebufferTexture2D(target, GraphicsContext3D::STENCIL_ATTACHMENT, textarget, textureObject, level);

        break;

    case GraphicsContext3D::DEPTH_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    case GraphicsContext3D::STENCIL_ATTACHMENT:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

        break;

    default:

        m_context->framebufferTexture2D(target, attachment, textarget, textureObject, level);

    }

    m_framebufferBinding->setAttachmentForBoundFramebuffer(attachment, textarget, texture, level);

    applyStencilTest();

}

void WebGLRenderingContextBase::frontFace(GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    m_context->frontFace(mode);

}

void WebGLRenderingContextBase::generateMipmap(GC3Denum target)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("generateMipmap", target, false);

    if (!tex)

        return;

    if (!tex->canGenerateMipmaps()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "level 0 not power of 2 or not all the same size");

        return;

    }

    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=123916. Compressed textures should be allowed in WebGL 2:

    if (tex->isCompressed()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "generateMipmap", "trying to generate mipmaps from compressed texture");

        return;

    }

    if (!validateSettableTexFormat("generateMipmap", tex->getInternalFormat(target, 0)))

        return;

    // generateMipmap won't work properly if minFilter is not NEAREST_MIPMAP_LINEAR

    // on Mac. Remove the hack once this driver bug is fixed.

#if OS(DARWIN)

    bool needToResetMinFilter = false;

    if (tex->getMinFilter() != GraphicsContext3D::NEAREST_MIPMAP_LINEAR) {

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, GraphicsContext3D::NEAREST_MIPMAP_LINEAR);

        needToResetMinFilter = true;

    }

#endif

    m_context->generateMipmap(target);

#if OS(DARWIN)

    if (needToResetMinFilter)

        m_context->texParameteri(target, GraphicsContext3D::TEXTURE_MIN_FILTER, tex->getMinFilter());

#endif

    tex->generateMipmapLevelInfo();

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveAttrib(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveAttrib", program))

        return nullptr;

    ActiveInfo info;

    if (!m_context->getActiveAttrib(objectOrZero(program), index, info))

        return nullptr;

    LOG(WebGL, "Returning active attribute %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

PassRefPtr<WebGLActiveInfo> WebGLRenderingContextBase::getActiveUniform(WebGLProgram* program, GC3Duint index, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getActiveUniform", program))

        return 0;

    ActiveInfo info;

    if (!m_context->getActiveUniform(objectOrZero(program), index, info))

        return nullptr;

    if (!isGLES2Compliant()) {

        if (info.size > 1 && !info.name.endsWith("[0]"))

            info.name.append("[0]");

    }

    LOG(WebGL, "Returning active uniform %d: %s", index, info.name.utf8().data());

    return WebGLActiveInfo::create(info.name, info.type, info.size);

}

bool WebGLRenderingContextBase::getAttachedShaders(WebGLProgram* program, Vector<RefPtr<WebGLShader>>& shaderObjects, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    shaderObjects.clear();

    if (isContextLostOrPending() || !validateWebGLObject("getAttachedShaders", program))

        return false;

    const GC3Denum shaderType[] = {

        GraphicsContext3D::VERTEX_SHADER,

        GraphicsContext3D::FRAGMENT_SHADER

    };

    for (unsigned i = 0; i < sizeof(shaderType) / sizeof(GC3Denum); ++i) {

        WebGLShader* shader = program->getAttachedShader(shaderType[i]);

        if (shader)

            shaderObjects.append(shader);

    }

    return true;

}

GC3Dint WebGLRenderingContextBase::getAttribLocation(WebGLProgram* program, const String& name)

{

    if (isContextLostOrPending() || !validateWebGLObject("getAttribLocation", program))

        return -1;

    if (!validateLocationLength("getAttribLocation", name))

        return -1;

    if (!validateString("getAttribLocation", name))

        return -1;

    if (isPrefixReserved(name))

        return -1;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getAttribLocation", "program not linked");

        return -1;

    }

    return m_context->getAttribLocation(objectOrZero(program), name);

}

WebGLGetInfo WebGLRenderingContextBase::getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::ARRAY_BUFFER && target != GraphicsContext3D::ELEMENT_ARRAY_BUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (pname != GraphicsContext3D::BUFFER_SIZE && pname != GraphicsContext3D::BUFFER_USAGE) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getBufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    GC3Dint value = 0;

    m_context->getBufferParameteriv(target, pname, &value);

    if (pname == GraphicsContext3D::BUFFER_SIZE)

        return WebGLGetInfo(value);

    return WebGLGetInfo(static_cast<unsigned>(value));

}

PassRefPtr<WebGLContextAttributes> WebGLRenderingContextBase::getContextAttributes()

{

    if (isContextLostOrPending())

        return nullptr;

    // We always need to return a new WebGLContextAttributes object to

    // prevent the user from mutating any cached version.

    // Also, we need to enforce requested values of "false" for depth

    // and stencil, regardless of the properties of the underlying

    // GraphicsContext3D or DrawingBuffer.

    RefPtr<WebGLContextAttributes> attributes = WebGLContextAttributes::create(m_context->getContextAttributes());

    if (!m_attributes.depth)

        attributes->setDepth(false);

    if (!m_attributes.stencil)

        attributes->setStencil(false);

    if (m_drawingBuffer) {

        // The DrawingBuffer obtains its parameters from GraphicsContext3D::getContextAttributes(),

        // but it makes its own determination of whether multisampling is supported.

        attributes->setAntialias(m_drawingBuffer->multisample());

    }

    return attributes.release();

}

GC3Denum WebGLRenderingContextBase::getError()

{

    if (m_isPendingPolicyResolution)

        return GraphicsContext3D::NO_ERROR;

    return m_context->getError();

}

WebGLExtension* WebGLRenderingContextBase::getExtension(const String& name)

{

    if (isContextLostOrPending())

        return nullptr;

    if (equalIgnoringCase(name, "EXT_blend_minmax")

        && m_context->getExtensions()->supports("GL_EXT_blend_minmax")) {

        if (!m_extBlendMinMax) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_blend_minmax");

            m_extBlendMinMax = std::make_unique<EXTBlendMinMax>(this);

        }

        return m_extBlendMinMax.get();

    }

    if (equalIgnoringCase(name, "EXT_sRGB")

        && m_context->getExtensions()->supports("GL_EXT_sRGB")) {

        if (!m_extsRGB) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_sRGB");

            m_extsRGB = std::make_unique<EXTsRGB>(this);

        }

        return m_extsRGB.get();

    }

    if (equalIgnoringCase(name, "EXT_frag_depth")

        && m_context->getExtensions()->supports("GL_EXT_frag_depth")) {

        if (!m_extFragDepth) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_frag_depth");

            m_extFragDepth = std::make_unique<EXTFragDepth>(this);

        }

        return m_extFragDepth.get();

    }

    if (equalIgnoringCase(name, "EXT_shader_texture_lod")

        && (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))) {

        if (!m_extShaderTextureLOD) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_shader_texture_lod");

            m_extShaderTextureLOD = std::make_unique<EXTShaderTextureLOD>(this);

        }

        return m_extShaderTextureLOD.get();

    }

    if (equalIgnoringCase(name, "WEBKIT_EXT_texture_filter_anisotropic")

        && m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic")) {

        if (!m_extTextureFilterAnisotropic) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_texture_filter_anisotropic");

            m_extTextureFilterAnisotropic = std::make_unique<EXTTextureFilterAnisotropic>(this);

        }

        return m_extTextureFilterAnisotropic.get();

    }

    if (equalIgnoringCase(name, "OES_standard_derivatives")

        && m_context->getExtensions()->supports("GL_OES_standard_derivatives")) {

        if (!m_oesStandardDerivatives) {

            m_context->getExtensions()->ensureEnabled("GL_OES_standard_derivatives");

            m_oesStandardDerivatives = std::make_unique<OESStandardDerivatives>(this);

        }

        return m_oesStandardDerivatives.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float")

        && m_context->getExtensions()->supports("GL_OES_texture_float")) {

        if (!m_oesTextureFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float");

            m_oesTextureFloat = std::make_unique<OESTextureFloat>(this);

        }

        return m_oesTextureFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_float_linear")) {

        if (!m_oesTextureFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_float_linear");

            m_oesTextureFloatLinear = std::make_unique<OESTextureFloatLinear>(this);

        }

        return m_oesTextureFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float")) {

        if (!m_oesTextureHalfFloat) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float");

            m_oesTextureHalfFloat = std::make_unique<OESTextureHalfFloat>(this);

        }

        return m_oesTextureHalfFloat.get();

    }

    if (equalIgnoringCase(name, "OES_texture_half_float_linear")

        && m_context->getExtensions()->supports("GL_OES_texture_half_float_linear")) {

        if (!m_oesTextureHalfFloatLinear) {

            m_context->getExtensions()->ensureEnabled("GL_OES_texture_half_float_linear");

            m_oesTextureHalfFloatLinear = std::make_unique<OESTextureHalfFloatLinear>(this);

        }

        return m_oesTextureHalfFloatLinear.get();

    }

    if (equalIgnoringCase(name, "OES_vertex_array_object")

        && m_context->getExtensions()->supports("GL_OES_vertex_array_object")) {

        if (!m_oesVertexArrayObject) {

            m_context->getExtensions()->ensureEnabled("GL_OES_vertex_array_object");

            m_oesVertexArrayObject = std::make_unique<OESVertexArrayObject>(this);

        }

        return m_oesVertexArrayObject.get();

    }

    if (equalIgnoringCase(name, "OES_element_index_uint")

        && m_context->getExtensions()->supports("GL_OES_element_index_uint")) {

        if (!m_oesElementIndexUint) {

            m_context->getExtensions()->ensureEnabled("GL_OES_element_index_uint");

            m_oesElementIndexUint = std::make_unique<OESElementIndexUint>(this);

        }

        return m_oesElementIndexUint.get();

    }

    if (equalIgnoringCase(name, "WEBGL_lose_context")) {

        if (!m_webglLoseContext)

            m_webglLoseContext = std::make_unique<WebGLLoseContext>(this);

        return m_webglLoseContext.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_atc"))

        && WebGLCompressedTextureATC::supported(this)) {

        if (!m_webglCompressedTextureATC)

            m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(this);

        return m_webglCompressedTextureATC.get();

    }

    if ((equalIgnoringCase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc"))

        && WebGLCompressedTexturePVRTC::supported(this)) {

        if (!m_webglCompressedTexturePVRTC)

            m_webglCompressedTexturePVRTC = std::make_unique<WebGLCompressedTexturePVRTC>(this);

        return m_webglCompressedTexturePVRTC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_compressed_texture_s3tc")

        && WebGLCompressedTextureS3TC::supported(this)) {

        if (!m_webglCompressedTextureS3TC)

            m_webglCompressedTextureS3TC = std::make_unique<WebGLCompressedTextureS3TC>(this);

        return m_webglCompressedTextureS3TC.get();

    }

    if (equalIgnoringCase(name, "WEBGL_depth_texture")

        && WebGLDepthTexture::supported(graphicsContext3D())) {

        if (!m_webglDepthTexture) {

            m_context->getExtensions()->ensureEnabled("GL_CHROMIUM_depth_texture");

            m_webglDepthTexture = std::make_unique<WebGLDepthTexture>(this);

        }

        return m_webglDepthTexture.get();

    }

    if (equalIgnoringCase(name, "WEBGL_draw_buffers") && supportsDrawBuffers()) {

        if (!m_webglDrawBuffers) {

            m_context->getExtensions()->ensureEnabled("GL_EXT_draw_buffers");

            m_webglDrawBuffers = std::make_unique<WebGLDrawBuffers>(this);

        }

        return m_webglDrawBuffers.get();

    }

    if (equalIgnoringCase(name, "ANGLE_instanced_arrays") && ANGLEInstancedArrays::supported(this)) {

        if (!m_angleInstancedArrays) {

            m_context->getExtensions()->ensureEnabled("GL_ANGLE_instanced_arrays");

            m_angleInstancedArrays = std::make_unique<ANGLEInstancedArrays>(this);

        }

        return m_angleInstancedArrays.get();

    }

    if (allowPrivilegedExtensions()) {

        if (equalIgnoringCase(name, "WEBGL_debug_renderer_info")) {

            if (!m_webglDebugRendererInfo)

                m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(this);

            return m_webglDebugRendererInfo.get();

        }

        if (equalIgnoringCase(name, "WEBGL_debug_shaders")

            && m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source")) {

            if (!m_webglDebugShaders)

                m_webglDebugShaders = std::make_unique<WebGLDebugShaders>(this);

            return m_webglDebugShaders.get();

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContextBase::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))

        return WebGLGetInfo();

    if (!m_framebufferBinding || !m_framebufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");

        return WebGLGetInfo();

    }

    WebGLSharedObject* object = m_framebufferBinding->getAttachmentObject(attachment);

    if (!object) {

        if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)

            return WebGLGetInfo(GraphicsContext3D::NONE);

        // OpenGL ES 2.0 specifies INVALID_ENUM in this case, while desktop GL

        // specifies INVALID_OPERATION.

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

    ASSERT(object->isTexture() || object->isRenderbuffer());

    if (object->isTexture()) {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::TEXTURE);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLTexture>(reinterpret_cast<WebGLTexture*>(object)));

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            GC3Dint value = 0;

            m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);

            return WebGLGetInfo(value);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");

            return WebGLGetInfo();

        }

    } else {

        switch (pname) {

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:

            return WebGLGetInfo(GraphicsContext3D::RENDERBUFFER);

        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:

            return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(reinterpret_cast<WebGLRenderbuffer*>(object)));

        case Extensions3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT: {

            WebGLRenderbuffer* renderBuffer = reinterpret_cast<WebGLRenderbuffer*>(object);

            GC3Denum renderBufferFormat = renderBuffer->getInternalFormat();

            ASSERT(renderBufferFormat != Extensions3D::SRGB_EXT && renderBufferFormat != Extensions3D::SRGB_ALPHA_EXT);

            if (renderBufferFormat == Extensions3D::SRGB8_ALPHA8_EXT)

                return WebGLGetInfo(Extensions3D::SRGB_EXT);

            return WebGLGetInfo(GraphicsContext3D::LINEAR);

        }

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");

            return WebGLGetInfo();

        }

    }

}

WebGLGetInfo WebGLRenderingContextBase::getParameter(GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    const int intZero = 0;

    switch (pname) {

    case GraphicsContext3D::ACTIVE_TEXTURE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::ALPHA_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundArrayBuffer));

    case GraphicsContext3D::BLEND:

        return getBooleanParameter(pname);

    case GraphicsContext3D::BLEND_COLOR:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::BLEND_DST_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_DST_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_EQUATION_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_ALPHA:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLEND_SRC_RGB:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::BLUE_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::COLOR_WRITEMASK:

        return getBooleanArrayParameter(pname);

    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:

        return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()));

    case GraphicsContext3D::CULL_FACE:

        return getBooleanParameter(pname);

    case GraphicsContext3D::CULL_FACE_MODE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::CURRENT_PROGRAM:

        return WebGLGetInfo(PassRefPtr<WebGLProgram>(m_currentProgram));

    case GraphicsContext3D::DEPTH_BITS:

        if (!m_framebufferBinding && !m_attributes.depth)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::DEPTH_CLEAR_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::DEPTH_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::DEPTH_RANGE:

        return getWebGLFloatArrayParameter(pname);

    case GraphicsContext3D::DEPTH_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DEPTH_WRITEMASK:

        return getBooleanParameter(pname);

    case GraphicsContext3D::DITHER:

        return getBooleanParameter(pname);

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(m_boundVertexArrayObject->getElementArrayBuffer()));

    case GraphicsContext3D::FRAMEBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLFramebuffer>(m_framebufferBinding));

    case GraphicsContext3D::FRONT_FACE:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::GREEN_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::LINE_WIDTH:

        return getFloatParameter(pname);

    case GraphicsContext3D::MAX_COMBINED_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_CUBE_MAP_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_RENDERBUFFER_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_TEXTURE_SIZE:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VARYING_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_ATTRIBS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_TEXTURE_IMAGE_UNITS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VERTEX_UNIFORM_VECTORS:

        return getIntParameter(pname);

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::NUM_SHADER_BINARY_FORMATS:

        // FIXME: should we always return 0 for this?

        return getIntParameter(pname);

    case GraphicsContext3D::PACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FACTOR:

        return getFloatParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

        return getBooleanParameter(pname);

    case GraphicsContext3D::POLYGON_OFFSET_UNITS:

        return getFloatParameter(pname);

    case GraphicsContext3D::RED_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::RENDERBUFFER_BINDING:

        return WebGLGetInfo(PassRefPtr<WebGLRenderbuffer>(m_renderbufferBinding));

    case GraphicsContext3D::RENDERER:

        return WebGLGetInfo(String("WebKit WebGL"));

    case GraphicsContext3D::SAMPLE_BUFFERS:

        return getIntParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_INVERT:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SAMPLE_COVERAGE_VALUE:

        return getFloatParameter(pname);

    case GraphicsContext3D::SAMPLES:

        return getIntParameter(pname);

    case GraphicsContext3D::SCISSOR_BOX:

        return getWebGLIntArrayParameter(pname);

    case GraphicsContext3D::SCISSOR_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::SHADING_LANGUAGE_VERSION:

        return WebGLGetInfo("WebGL GLSL ES 1.0 (" + m_context->getString(GraphicsContext3D::SHADING_LANGUAGE_VERSION) + ")");

    case GraphicsContext3D::STENCIL_BACK_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BACK_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_BITS:

        if (!m_framebufferBinding && !m_attributes.stencil)

            return WebGLGetInfo(intZero);

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_CLEAR_VALUE:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_FUNC:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_FAIL:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_PASS_DEPTH_PASS:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_REF:

        return getIntParameter(pname);

    case GraphicsContext3D::STENCIL_TEST:

        return getBooleanParameter(pname);

    case GraphicsContext3D::STENCIL_VALUE_MASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::STENCIL_WRITEMASK:

        return getUnsignedIntParameter(pname);

    case GraphicsContext3D::SUBPIXEL_BITS:

        return getIntParameter(pname);

    case GraphicsContext3D::TEXTURE_BINDING_2D:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].texture2DBinding));

    case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:

        return WebGLGetInfo(PassRefPtr<WebGLTexture>(m_textureUnits[m_activeTextureUnit].textureCubeMapBinding));

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        return getIntParameter(pname);

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        return WebGLGetInfo(m_unpackFlipY);

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        return WebGLGetInfo(m_unpackPremultiplyAlpha);

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        return WebGLGetInfo(m_unpackColorspaceConversion);

    case GraphicsContext3D::VENDOR:

        return WebGLGetInfo(String("WebKit"));

    case GraphicsContext3D::VERSION:

        return WebGLGetInfo("WebGL 1.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")");

    case GraphicsContext3D::VIEWPORT:

        return getWebGLIntArrayParameter(pname);

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            return getUnsignedIntParameter(Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_standard_derivatives not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::RENDERER));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:

        if (m_webglDebugRendererInfo)

            return WebGLGetInfo(m_context->getString(GraphicsContext3D::VENDOR));

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");

        return WebGLGetInfo();

    case Extensions3D::VERTEX_ARRAY_BINDING_OES: // OES_vertex_array_object

        if (m_oesVertexArrayObject) {

            if (!m_boundVertexArrayObject->isDefaultObject())

                return WebGLGetInfo(PassRefPtr<WebGLVertexArrayObjectOES>(m_boundVertexArrayObject));

            return WebGLGetInfo();

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, OES_vertex_array_object not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic)

            return getUnsignedIntParameter(Extensions3D::MAX_TEXTURE_MAX_ANISOTROPY_EXT);

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_COLOR_ATTACHMENTS_EXT: // EXT_draw_buffers BEGIN

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxColorAttachments());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    case Extensions3D::MAX_DRAW_BUFFERS_EXT:

        if (m_webglDrawBuffers)

            return WebGLGetInfo(getMaxDrawBuffers());

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_draw_buffers not enabled");

        return WebGLGetInfo();

    default:

        if (m_webglDrawBuffers

            && pname >= Extensions3D::DRAW_BUFFER0_EXT

            && pname < static_cast<GC3Denum>(Extensions3D::DRAW_BUFFER0_EXT + getMaxDrawBuffers())) {

            GC3Dint value = GraphicsContext3D::NONE;

            if (m_framebufferBinding)

                value = m_framebufferBinding->getDrawBuffer(pname);

            else // emulated backbuffer

                value = m_backDrawBuffer;

            return WebGLGetInfo(value);

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContextBase::getProgramParameter(WebGLProgram* program, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getProgramParameter", program))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(program->isDeleted());

    case GraphicsContext3D::VALIDATE_STATUS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::LINK_STATUS:

        return WebGLGetInfo(program->getLinkStatus());

    case GraphicsContext3D::ATTACHED_SHADERS:

        m_context->getProgramiv(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::ACTIVE_ATTRIBUTES:

    case GraphicsContext3D::ACTIVE_UNIFORMS:

        m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), pname, &value);

        return WebGLGetInfo(value);

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getProgramParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContextBase::getProgramInfoLog(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getProgramInfoLog", program))

        return "";

    return ensureNotNull(m_context->getProgramInfoLog(objectOrZero(program)));

}

WebGLGetInfo WebGLRenderingContextBase::getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid target");

        return WebGLGetInfo();

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getRenderbufferParameter", "no renderbuffer bound");

        return WebGLGetInfo();

    }

    if (m_renderbufferBinding->getInternalFormat() == GraphicsContext3D::DEPTH_STENCIL

        && !m_renderbufferBinding->isValid()) {

        ASSERT(!isDepthStencilSupported());

        int value = 0;

        switch (pname) {

        case GraphicsContext3D::RENDERBUFFER_WIDTH:

            value = m_renderbufferBinding->getWidth();

            break;

        case GraphicsContext3D::RENDERBUFFER_HEIGHT:

            value = m_renderbufferBinding->getHeight();

            break;

        case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

        case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

        case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

        case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

            value = 0;

            break;

        case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

            value = 24;

            break;

        case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

            value = 8;

            break;

        case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

            return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

        default:

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

            return WebGLGetInfo();

        }

        return WebGLGetInfo(value);

    }

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::RENDERBUFFER_WIDTH:

    case GraphicsContext3D::RENDERBUFFER_HEIGHT:

    case GraphicsContext3D::RENDERBUFFER_RED_SIZE:

    case GraphicsContext3D::RENDERBUFFER_GREEN_SIZE:

    case GraphicsContext3D::RENDERBUFFER_BLUE_SIZE:

    case GraphicsContext3D::RENDERBUFFER_ALPHA_SIZE:

    case GraphicsContext3D::RENDERBUFFER_DEPTH_SIZE:

    case GraphicsContext3D::RENDERBUFFER_STENCIL_SIZE:

        m_context->getRenderbufferParameteriv(target, pname, &value);

        return WebGLGetInfo(value);

    case GraphicsContext3D::RENDERBUFFER_INTERNAL_FORMAT:

        return WebGLGetInfo(m_renderbufferBinding->getInternalFormat());

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getRenderbufferParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContextBase::getShaderParameter(WebGLShader* shader, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getShaderParameter", shader))

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::DELETE_STATUS:

        return WebGLGetInfo(shader->isDeleted());

    case GraphicsContext3D::COMPILE_STATUS:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<bool>(value));

    case GraphicsContext3D::SHADER_TYPE:

        m_context->getShaderiv(objectOrZero(shader), pname, &value);

        return WebGLGetInfo(static_cast<unsigned>(value));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

String WebGLRenderingContextBase::getShaderInfoLog(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderInfoLog", shader))

        return "";

    return ensureNotNull(m_context->getShaderInfoLog(objectOrZero(shader)));

}

PassRefPtr<WebGLShaderPrecisionFormat> WebGLRenderingContextBase::getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return nullptr;

    switch (shaderType) {

    case GraphicsContext3D::VERTEX_SHADER:

    case GraphicsContext3D::FRAGMENT_SHADER:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid shader type");

        return nullptr;

    }

    switch (precisionType) {

    case GraphicsContext3D::LOW_FLOAT:

    case GraphicsContext3D::MEDIUM_FLOAT:

    case GraphicsContext3D::HIGH_FLOAT:

    case GraphicsContext3D::LOW_INT:

    case GraphicsContext3D::MEDIUM_INT:

    case GraphicsContext3D::HIGH_INT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getShaderPrecisionFormat", "invalid precision type");

        return nullptr;

    }

    GC3Dint range[2] = {0, 0};

    GC3Dint precision = 0;

    m_context->getShaderPrecisionFormat(shaderType, precisionType, range, &precision);

    return WebGLShaderPrecisionFormat::create(range[0], range[1], precision);

}

String WebGLRenderingContextBase::getShaderSource(WebGLShader* shader, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return String();

    if (!validateWebGLObject("getShaderSource", shader))

        return "";

    return ensureNotNull(shader->getSource());

}

Vector<String> WebGLRenderingContextBase::getSupportedExtensions()

{

    Vector<String> result;

    if (m_isPendingPolicyResolution)

        return result;

    if (m_context->getExtensions()->supports("GL_EXT_blend_minmax"))

        result.append("EXT_blend_minmax");

    if (m_context->getExtensions()->supports("GL_EXT_sRGB"))

        result.append("EXT_sRGB");

    if (m_context->getExtensions()->supports("GL_EXT_frag_depth"))

        result.append("EXT_frag_depth");

    if (m_context->getExtensions()->supports("GL_OES_texture_float"))

        result.append("OES_texture_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_float_linear"))

        result.append("OES_texture_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float"))

        result.append("OES_texture_half_float");

    if (m_context->getExtensions()->supports("GL_OES_texture_half_float_linear"))

        result.append("OES_texture_half_float_linear");

    if (m_context->getExtensions()->supports("GL_OES_standard_derivatives"))

        result.append("OES_standard_derivatives");

    if (m_context->getExtensions()->supports("GL_EXT_shader_texture_lod") || m_context->getExtensions()->supports("GL_ARB_shader_texture_lod"))

        result.append("EXT_shader_texture_lod");

    if (m_context->getExtensions()->supports("GL_EXT_texture_filter_anisotropic"))

        result.append("WEBKIT_EXT_texture_filter_anisotropic");

    if (m_context->getExtensions()->supports("GL_OES_vertex_array_object"))

        result.append("OES_vertex_array_object");

    if (m_context->getExtensions()->supports("GL_OES_element_index_uint"))

        result.append("OES_element_index_uint");

    result.append("WEBGL_lose_context");

    if (WebGLCompressedTextureATC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_atc");

    if (WebGLCompressedTexturePVRTC::supported(this))

        result.append("WEBKIT_WEBGL_compressed_texture_pvrtc");

    if (WebGLCompressedTextureS3TC::supported(this))

        result.append("WEBGL_compressed_texture_s3tc");

    if (WebGLDepthTexture::supported(graphicsContext3D()))

        result.append("WEBGL_depth_texture");

    if (supportsDrawBuffers())

        result.append("WEBGL_draw_buffers");

    if (ANGLEInstancedArrays::supported(this))

        result.append("ANGLE_instanced_arrays");

    if (allowPrivilegedExtensions()) {

        if (m_context->getExtensions()->supports("GL_ANGLE_translated_shader_source"))

            result.append("WEBGL_debug_shaders");

        result.append("WEBGL_debug_renderer_info");

    }

    return result;

}

WebGLGetInfo WebGLRenderingContextBase::getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    WebGLTexture* tex = validateTextureBinding("getTexParameter", target, false);

    if (!tex)

        return WebGLGetInfo();

    GC3Dint value = 0;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        m_context->getTexParameteriv(target, pname, &value);

        return WebGLGetInfo(static_cast<unsigned>(value));

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (m_extTextureFilterAnisotropic) {

            m_context->getTexParameteriv(target, pname, &value);

            return WebGLGetInfo(static_cast<unsigned>(value));

        }

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name, EXT_texture_filter_anisotropic not enabled");

        return WebGLGetInfo();

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getTexParameter", "invalid parameter name");

        return WebGLGetInfo();

    }

}

WebGLGetInfo WebGLRenderingContextBase::getUniform(WebGLProgram* program, const WebGLUniformLocation* uniformLocation, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniform", program))

        return WebGLGetInfo();

    if (!uniformLocation || uniformLocation->program() != program) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniform", "no uniformlocation or not valid for this program");

        return WebGLGetInfo();

    }

    GC3Dint location = uniformLocation->location();

    GC3Denum baseType;

    unsigned length;

    switch (uniformLocation->type()) {

    case GraphicsContext3D::BOOL:

        baseType = GraphicsContext3D::BOOL;

        length = 1;

        break;

    case GraphicsContext3D::BOOL_VEC2:

        baseType = GraphicsContext3D::BOOL;

        length = 2;

        break;

    case GraphicsContext3D::BOOL_VEC3:

        baseType = GraphicsContext3D::BOOL;

        length = 3;

        break;

    case GraphicsContext3D::BOOL_VEC4:

        baseType = GraphicsContext3D::BOOL;

        length = 4;

        break;

    case GraphicsContext3D::INT:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    case GraphicsContext3D::INT_VEC2:

        baseType = GraphicsContext3D::INT;

        length = 2;

        break;

    case GraphicsContext3D::INT_VEC3:

        baseType = GraphicsContext3D::INT;

        length = 3;

        break;

    case GraphicsContext3D::INT_VEC4:

        baseType = GraphicsContext3D::INT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT:

        baseType = GraphicsContext3D::FLOAT;

        length = 1;

        break;

    case GraphicsContext3D::FLOAT_VEC2:

        baseType = GraphicsContext3D::FLOAT;

        length = 2;

        break;

    case GraphicsContext3D::FLOAT_VEC3:

        baseType = GraphicsContext3D::FLOAT;

        length = 3;

        break;

    case GraphicsContext3D::FLOAT_VEC4:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT2:

        baseType = GraphicsContext3D::FLOAT;

        length = 4;

        break;

    case GraphicsContext3D::FLOAT_MAT3:

        baseType = GraphicsContext3D::FLOAT;

        length = 9;

        break;

    case GraphicsContext3D::FLOAT_MAT4:

        baseType = GraphicsContext3D::FLOAT;

        length = 16;

        break;

    case GraphicsContext3D::SAMPLER_2D:

    case GraphicsContext3D::SAMPLER_CUBE:

        baseType = GraphicsContext3D::INT;

        length = 1;

        break;

    default:

        // Can't handle this type

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unhandled type");

        return WebGLGetInfo();

    }

    switch (baseType) {

    case GraphicsContext3D::FLOAT: {

        GC3Dfloat value[16] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformfvEXT(objectOrZero(program), location, 16 * sizeof(GC3Dfloat), value);

        else

            m_context->getUniformfv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Float32Array::create(value, length));

    }

    case GraphicsContext3D::INT: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length == 1)

            return WebGLGetInfo(value[0]);

        return WebGLGetInfo(Int32Array::create(value, length));

    }

    case GraphicsContext3D::BOOL: {

        GC3Dint value[4] = {0};

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->getnUniformivEXT(objectOrZero(program), location, 4 * sizeof(GC3Dint), value);

        else

            m_context->getUniformiv(objectOrZero(program), location, value);

        if (length > 1) {

            bool boolValue[16] = {0};

            for (unsigned j = 0; j < length; j++)

                boolValue[j] = static_cast<bool>(value[j]);

            return WebGLGetInfo(boolValue, length);

        }

        return WebGLGetInfo(static_cast<bool>(value[0]));

    }

    default:

        notImplemented();

    }

    // If we get here, something went wrong in our unfortunately complex logic above

    synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getUniform", "unknown error");

    return WebGLGetInfo();

}

PassRefPtr<WebGLUniformLocation> WebGLRenderingContextBase::getUniformLocation(WebGLProgram* program, const String& name, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("getUniformLocation", program))

        return nullptr;

    if (!validateLocationLength("getUniformLocation", name))

        return nullptr;

    if (!validateString("getUniformLocation", name))

        return nullptr;

    if (isPrefixReserved(name))

        return nullptr;

    if (!program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getUniformLocation", "program not linked");

        return nullptr;

    }

    GC3Dint uniformLocation = m_context->getUniformLocation(objectOrZero(program), name);

    if (uniformLocation == -1)

        return nullptr;

    GC3Dint activeUniforms = 0;

    m_context->getNonBuiltInActiveSymbolCount(objectOrZero(program), GraphicsContext3D::ACTIVE_UNIFORMS, &activeUniforms);

    for (GC3Dint i = 0; i < activeUniforms; i++) {

        ActiveInfo info;

        if (!m_context->getActiveUniform(objectOrZero(program), i, info))

            return nullptr;

        // Strip "[0]" from the name if it's an array.

        if (info.name.endsWith("[0]"))

            info.name = info.name.left(info.name.length() - 3);

        // If it's an array, we need to iterate through each element, appending "[index]" to the name.

        for (GC3Dint index = 0; index < info.size; ++index) {

            String uniformName = info.name + "[" + String::number(index) + "]";

            if (name == uniformName || name == info.name)

                return WebGLUniformLocation::create(program, uniformLocation, info.type);

        }

    }

    return nullptr;

}

WebGLGetInfo WebGLRenderingContextBase::getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return WebGLGetInfo();

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "getVertexAttrib", "index out of range");

        return WebGLGetInfo();

    }

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(index);

    if (m_angleInstancedArrays && pname == GraphicsContext3D::VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE)

        return WebGLGetInfo(state.divisor);

    switch (pname) {

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:

        if ((!isGLES2Compliant() && !index && m_boundVertexArrayObject->getVertexAttribState(0).bufferBinding == m_vertexAttrib0Buffer)

            || !state.bufferBinding

            || !state.bufferBinding->object())

            return WebGLGetInfo();

        return WebGLGetInfo(PassRefPtr<WebGLBuffer>(state.bufferBinding));

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_ENABLED:

        return WebGLGetInfo(state.enabled);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_NORMALIZED:

        return WebGLGetInfo(state.normalized);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_SIZE:

        return WebGLGetInfo(state.size);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_STRIDE:

        return WebGLGetInfo(state.originalStride);

    case GraphicsContext3D::VERTEX_ATTRIB_ARRAY_TYPE:

        return WebGLGetInfo(state.type);

    case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:

        return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4));

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");

        return WebGLGetInfo();

    }

}

long long WebGLRenderingContextBase::getVertexAttribOffset(GC3Duint index, GC3Denum pname)

{

    if (isContextLostOrPending())

        return 0;

    GC3Dsizeiptr result = m_context->getVertexAttribOffset(index, pname);

    return static_cast<long long>(result);

}

void WebGLRenderingContextBase::hint(GC3Denum target, GC3Denum mode)

{

    if (isContextLostOrPending())

        return;

    bool isValid = false;

    switch (target) {

    case GraphicsContext3D::GENERATE_MIPMAP_HINT:

        isValid = true;

        break;

    case Extensions3D::FRAGMENT_SHADER_DERIVATIVE_HINT_OES: // OES_standard_derivatives

        if (m_oesStandardDerivatives)

            isValid = true;

        break;

    }

    if (!isValid) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");

        return;

    }

    m_context->hint(target, mode);

}

GC3Dboolean WebGLRenderingContextBase::isBuffer(WebGLBuffer* buffer)

{

    if (!buffer || isContextLostOrPending())

        return 0;

    if (!buffer->hasEverBeenBound())

        return 0;

    return m_context->isBuffer(buffer->object());

}

bool WebGLRenderingContextBase::isContextLost() const

{

    return m_contextLost;

}

bool WebGLRenderingContextBase::isContextLostOrPending()

{

    if (m_isPendingPolicyResolution && !m_hasRequestedPolicyResolution) {

        LOG(WebGL, "Context is being used. Attempt to resolve the policy.");

        Document& document = canvas()->document().topDocument();

        Page* page = document.page();

        if (page && !document.url().isLocalFile())

            page->mainFrame().loader().client().resolveWebGLPolicyForURL(document.url());

        // FIXME: We don't currently do anything with the result from resolution. A more

        // complete implementation might try to construct a real context, etc and proceed

        // with normal operation.

        // https://bugs.webkit.org/show_bug.cgi?id=129122

        m_hasRequestedPolicyResolution = true;

    }

    return m_contextLost || m_isPendingPolicyResolution;

}

GC3Dboolean WebGLRenderingContextBase::isEnabled(GC3Denum cap)

{

    if (isContextLostOrPending() || !validateCapability("isEnabled", cap))

        return 0;

    if (cap == GraphicsContext3D::STENCIL_TEST)

        return m_stencilEnabled;

    return m_context->isEnabled(cap);

}

GC3Dboolean WebGLRenderingContextBase::isFramebuffer(WebGLFramebuffer* framebuffer)

{

    if (!framebuffer || isContextLostOrPending())

        return 0;

    if (!framebuffer->hasEverBeenBound())

        return 0;

    return m_context->isFramebuffer(framebuffer->object());

}

GC3Dboolean WebGLRenderingContextBase::isProgram(WebGLProgram* program)

{

    if (!program || isContextLostOrPending())

        return 0;

    return m_context->isProgram(program->object());

}

GC3Dboolean WebGLRenderingContextBase::isRenderbuffer(WebGLRenderbuffer* renderbuffer)

{

    if (!renderbuffer || isContextLostOrPending())

        return 0;

    if (!renderbuffer->hasEverBeenBound())

        return 0;

    return m_context->isRenderbuffer(renderbuffer->object());

}

GC3Dboolean WebGLRenderingContextBase::isShader(WebGLShader* shader)

{

    if (!shader || isContextLostOrPending())

        return 0;

    return m_context->isShader(shader->object());

}

GC3Dboolean WebGLRenderingContextBase::isTexture(WebGLTexture* texture)

{

    if (!texture || isContextLostOrPending())

        return 0;

    if (!texture->hasEverBeenBound())

        return 0;

    return m_context->isTexture(texture->object());

}

void WebGLRenderingContextBase::lineWidth(GC3Dfloat width)

{

    if (isContextLostOrPending())

        return;

    m_context->lineWidth(width);

}

void WebGLRenderingContextBase::linkProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("linkProgram", program))

        return;

    if (!isGLES2Compliant()) {

        WebGLShader* vertexShader = program->getAttachedShader(GraphicsContext3D::VERTEX_SHADER);

        WebGLShader* fragmentShader = program->getAttachedShader(GraphicsContext3D::FRAGMENT_SHADER);

        if (!vertexShader || !vertexShader->isValid() || !fragmentShader || !fragmentShader->isValid() || !m_context->precisionsMatch(objectOrZero(vertexShader), objectOrZero(fragmentShader)) || !m_context->checkVaryingsPacking(objectOrZero(vertexShader), objectOrZero(fragmentShader))) {

            program->setLinkStatus(false);

            return;

        }

    }

    m_context->linkProgram(objectOrZero(program));

    program->increaseLinkCount();

}

void WebGLRenderingContextBase::pixelStorei(GC3Denum pname, GC3Dint param)

{

    if (isContextLostOrPending())

        return;

    switch (pname) {

    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:

        m_unpackFlipY = param;

        break;

    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:

        m_unpackPremultiplyAlpha = param;

        break;

    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:

        if (param == GraphicsContext3D::BROWSER_DEFAULT_WEBGL || param == GraphicsContext3D::NONE)

            m_unpackColorspaceConversion = static_cast<GC3Denum>(param);

        else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for UNPACK_COLORSPACE_CONVERSION_WEBGL");

            return;

        }

        break;

    case GraphicsContext3D::PACK_ALIGNMENT:

    case GraphicsContext3D::UNPACK_ALIGNMENT:

        if (param == 1 || param == 2 || param == 4 || param == 8) {

            if (pname == GraphicsContext3D::PACK_ALIGNMENT)

                m_packAlignment = param;

            else // GraphicsContext3D::UNPACK_ALIGNMENT:

                m_unpackAlignment = param;

            m_context->pixelStorei(pname, param);

        } else {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "pixelStorei", "invalid parameter for alignment");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "pixelStorei", "invalid parameter name");

        return;

    }

}

void WebGLRenderingContextBase::polygonOffset(GC3Dfloat factor, GC3Dfloat units)

{

    if (isContextLostOrPending())

        return;

    m_context->polygonOffset(factor, units);

}

void WebGLRenderingContextBase::readPixels(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode&)

{

    if (isContextLostOrPending())

        return;

    // Due to WebGL's same-origin restrictions, it is not possible to

    // taint the origin using the WebGL API.

    ASSERT(canvas()->originClean());

    // Validate input parameters.

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "readPixels", "no destination ArrayBufferView");

        return;

    }

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid format");

        return;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "readPixels", "invalid type");

        return;

    }

    if (format != GraphicsContext3D::RGBA || type != GraphicsContext3D::UNSIGNED_BYTE) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "format not RGBA or type not UNSIGNED_BYTE");

        return;

    }

    // Validate array type against pixel type.

    if (pixels->getType() != JSC::TypeUint8) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not Uint8Array");

        return;

    }

    const char* reason = "framebuffer incomplete";

    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), !isResourceSafe(), &reason)) {

        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "readPixels", reason);

        return;

    }

    // Calculate array size, taking into consideration of PACK_ALIGNMENT.

    unsigned totalBytesRequired = 0;

    unsigned padding = 0;

    if (!m_isRobustnessEXTSupported) {

        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

        if (error != GraphicsContext3D::NO_ERROR) {

            synthesizeGLError(error, "readPixels", "invalid dimensions");

            return;

        }

        if (pixels->byteLength() < totalBytesRequired) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "readPixels", "ArrayBufferView not large enough for dimensions");

            return;

        }

    }

    clearIfComposited();

    void* data = pixels->baseAddress();

    {

        ScopedDrawingBufferBinder binder(m_drawingBuffer.get(), m_framebufferBinding.get());

        if (m_isRobustnessEXTSupported)

            m_context->getExtensions()->readnPixelsEXT(x, y, width, height, format, type, pixels->byteLength(), data);

        else

            m_context->readPixels(x, y, width, height, format, type, data);

    }

#if OS(DARWIN)

    if (m_isRobustnessEXTSupported) // we haven't computed padding

        m_context->computeImageSizeInBytes(format, type, width, height, m_packAlignment, &totalBytesRequired, &padding);

    // FIXME: remove this section when GL driver bug on Mac AND the GLES driver bug

    // on QC is fixed, i.e., when alpha is off, readPixels should

    // set alpha to 255 instead of 0.

    if (!m_framebufferBinding && !m_context->getContextAttributes().alpha) {

        unsigned char* pixels = reinterpret_cast<unsigned char*>(data);

        for (GC3Dsizei iy = 0; iy < height; ++iy) {

            for (GC3Dsizei ix = 0; ix < width; ++ix) {

                pixels[3] = 255;

                pixels += 4;

            }

            pixels += padding;

        }

    }

#endif

}

void WebGLRenderingContextBase::releaseShaderCompiler()

{

    if (isContextLostOrPending())

        return;

    m_context->releaseShaderCompiler();

}

void WebGLRenderingContextBase::renderbufferStorage(GC3Denum target, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (target != GraphicsContext3D::RENDERBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid target");

        return;

    }

    if (!m_renderbufferBinding || !m_renderbufferBinding->object()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "renderbufferStorage", "no bound renderbuffer");

        return;

    }

    if (!validateSize("renderbufferStorage", width, height))

        return;

    switch (internalformat) {

    case GraphicsContext3D::DEPTH_COMPONENT16:

    case GraphicsContext3D::RGBA4:

    case GraphicsContext3D::RGB5_A1:

    case GraphicsContext3D::RGB565:

    case GraphicsContext3D::STENCIL_INDEX8:

    case Extensions3D::SRGB8_ALPHA8_EXT:

        if (internalformat == Extensions3D::SRGB8_ALPHA8_EXT && !m_extsRGB) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

            return;

        }

        m_context->renderbufferStorage(target, internalformat, width, height);

        m_renderbufferBinding->setInternalFormat(internalformat);

        m_renderbufferBinding->setIsValid(true);

        m_renderbufferBinding->setSize(width, height);

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (isDepthStencilSupported())

            m_context->renderbufferStorage(target, Extensions3D::DEPTH24_STENCIL8, width, height);

        m_renderbufferBinding->setSize(width, height);

        m_renderbufferBinding->setIsValid(isDepthStencilSupported());

        m_renderbufferBinding->setInternalFormat(internalformat);

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");

        return;

    }

    applyStencilTest();

}

void WebGLRenderingContextBase::sampleCoverage(GC3Dfloat value, GC3Dboolean invert)

{

    if (isContextLostOrPending())

        return;

    m_context->sampleCoverage(value, invert);

}

void WebGLRenderingContextBase::scissor(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("scissor", width, height))

        return;

    m_context->scissor(x, y, width, height);

}

void WebGLRenderingContextBase::shaderSource(WebGLShader* shader, const String& string, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("shaderSource", shader))

        return;

    String stringWithoutComments = StripComments(string).result();

    if (!validateString("shaderSource", stringWithoutComments))

        return;

    shader->setSource(string);

    m_context->shaderSource(objectOrZero(shader), stringWithoutComments);

}

void WebGLRenderingContextBase::stencilFunc(GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFunc", func))

        return;

    m_stencilFuncRef = ref;

    m_stencilFuncRefBack = ref;

    m_stencilFuncMask = mask;

    m_stencilFuncMaskBack = mask;

    m_context->stencilFunc(func, ref, mask);

}

void WebGLRenderingContextBase::stencilFuncSeparate(GC3Denum face, GC3Denum func, GC3Dint ref, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    if (!validateStencilFunc("stencilFuncSeparate", func))

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilFuncRef = ref;

        m_stencilFuncRefBack = ref;

        m_stencilFuncMask = mask;

        m_stencilFuncMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilFuncRef = ref;

        m_stencilFuncMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilFuncRefBack = ref;

        m_stencilFuncMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilFuncSeparate", "invalid face");

        return;

    }

    m_context->stencilFuncSeparate(face, func, ref, mask);

}

void WebGLRenderingContextBase::stencilMask(GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    m_stencilMask = mask;

    m_stencilMaskBack = mask;

    m_context->stencilMask(mask);

}

void WebGLRenderingContextBase::stencilMaskSeparate(GC3Denum face, GC3Duint mask)

{

    if (isContextLostOrPending())

        return;

    switch (face) {

    case GraphicsContext3D::FRONT_AND_BACK:

        m_stencilMask = mask;

        m_stencilMaskBack = mask;

        break;

    case GraphicsContext3D::FRONT:

        m_stencilMask = mask;

        break;

    case GraphicsContext3D::BACK:

        m_stencilMaskBack = mask;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "stencilMaskSeparate", "invalid face");

        return;

    }

    m_context->stencilMaskSeparate(face, mask);

}

void WebGLRenderingContextBase::stencilOp(GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOp(fail, zfail, zpass);

}

void WebGLRenderingContextBase::stencilOpSeparate(GC3Denum face, GC3Denum fail, GC3Denum zfail, GC3Denum zpass)

{

    if (isContextLostOrPending())

        return;

    m_context->stencilOpSeparate(face, fail, zfail, zpass);

}

void WebGLRenderingContextBase::texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned.

    ec = 0;

    WebGLTexture* tex = validateTextureBinding("texImage2D", target, true);

    ASSERT(validateTexFuncParameters("texImage2D", NotTexSubImage2D, target, level, internalformat, width, height, border, format, type));

    ASSERT(tex);

    ASSERT(!level || !WebGLTexture::isNPOT(width, height));

    if (!pixels) {

        // Note: Chromium's OpenGL implementation clears textures and isResourceSafe() is therefore true.

        // For other implementations, if they are using ANGLE_depth_texture, ANGLE depth textures

        // can not be cleared with texImage2D and must be cleared by binding to an fbo and calling

        // clear.

        if (isResourceSafe())

            m_context->texImage2D(target, level, internalformat, width, height, border, format, type, nullptr);

        else {

            bool succeed = m_context->texImage2DResourceSafe(target, level, internalformat, width, height,

                                                             border, format, type, m_unpackAlignment);

            if (!succeed)

                return;

        }

    } else {

        ASSERT(validateSettableTexFormat("texImage2D", internalformat));

        m_context->moveErrorsToSyntheticErrorList();

        m_context->texImage2D(target, level, internalformat, width, height,

                              border, format, type, pixels);

        if (m_context->moveErrorsToSyntheticErrorList()) {

            // The texImage2D function failed. Tell the WebGLTexture it doesn't have the data for this level.

            tex->markInvalid(target, level);

            return;

        }

    }

    tex->setLevelInfo(target, level, internalformat, width, height, type);

}

void WebGLRenderingContextBase::texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "packImage error");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, image->width(), image->height(), 0, format, type, needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

bool WebGLRenderingContextBase::validateTexFunc(const char* functionName, TexFuncValidationFunctionType functionType, TexFuncValidationSourceType sourceType, GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset)

{

    if (!validateTexFuncParameters(functionName, functionType, target, level, internalformat, width, height, border, format, type))

        return false;

    WebGLTexture* texture = validateTextureBinding(functionName, target, true);

    if (!texture)

        return false;

    if (functionType == NotTexSubImage2D) {

        if (level && WebGLTexture::isNPOT(width, height)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level > 0 not power of 2");

            return false;

        }

        // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat

        // by checking if the ArrayBufferView is null or not.

        if (sourceType != SourceArrayBufferView) {

            if (!validateSettableTexFormat(functionName, format))

                return false;

        }

    } else {

        if (!validateSettableTexFormat(functionName, format))

            return false;

        if (!validateSize(functionName, xoffset, yoffset))

            return false;

        // Before checking if it is in the range, check if overflow happens first.

        if (xoffset + width < 0 || yoffset + height < 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "bad dimensions");

            return false;

        }

        if (xoffset + width > texture->getWidth(target, level) || yoffset + height > texture->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "dimensions out of range");

            return false;

        }

        if (texture->getInternalFormat(target, level) != format || texture->getType(target, level) != type) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type and format do not match texture");

            return false;

        }

    }

    return true;

}

void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                           GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                           GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texImage2D", level, width, height, format, type, pixels, NullAllowed)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceArrayBufferView, target, level, internalformat, width, height, border, format, type, 0, 0))

        return;

    void* data = pixels ? pixels->baseAddress() : 0;

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, width, height, border,

                   format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                           GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, 0, 0))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

PassRefPtr<Image> WebGLRenderingContextBase::drawImageIntoBuffer(Image* image, int width, int height, int deviceScaleFactor)

{

    IntSize size(width, height);

    size.scale(deviceScaleFactor);

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    FloatRect srcRect(FloatPoint(), image->size());

    FloatRect destRect(FloatPoint(), size);

    buf->context()->drawImage(image, ColorSpaceDeviceRGB, destRect, srcRect);

    return buf->copyImage(ImageBuffer::fastCopyImageMode());

}

void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                           GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 0, format, type, 0, 0))

        return;

    texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                           GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texImage2D", canvas, ec) || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0, 0))

        return;

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    // If possible, copy from the canvas element directly to the texture

    // via the GPU, without a read-back to system memory.

    //

    // FIXME: restriction of (RGB || RGBA)/UNSIGNED_BYTE should be lifted when

    // ImageBuffer::copyToPlatformTexture implementations are fully functional.

    if (GraphicsContext3D::TEXTURE_2D == target && texture && type == texture->getType(target, level)

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA) && type == GraphicsContext3D::UNSIGNED_BYTE) {

        ImageBuffer* buffer = canvas->buffer();

        if (buffer && buffer->copyToPlatformTexture(*m_context.get(), texture->object(), internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, canvas->width(), canvas->height(), type);

            return;

        }

    }

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texImage2D(target, level, internalformat, format, type, imageData.get(), ec);

    else

        texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

PassRefPtr<Image> WebGLRenderingContextBase::videoFrameToImage(HTMLVideoElement* video, BackingStoreCopy backingStoreCopy, ExceptionCode&)

{

    IntSize size(video->videoWidth(), video->videoHeight());

    ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);

    if (!buf) {

        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "texImage2D", "out of memory");

        return nullptr;

    }

    IntRect destRect(0, 0, size.width(), size.height());

    // FIXME: Turn this into a GPU-GPU texture copy instead of CPU readback.

    video->paintCurrentFrameInContext(buf->context(), destRect);

    return buf->copyImage(backingStoreCopy);

}

void WebGLRenderingContextBase::texImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat,

                                           GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texImage2D", video, ec)

        || !validateTexFunc("texImage2D", NotTexSubImage2D, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 0, format, type, 0, 0))

        return;

    // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.

    // Otherwise, it will fall back to the normal SW path.

    // FIXME: The current restrictions require that format shoud be RGB or RGBA,

    // type should be UNSIGNED_BYTE and level should be 0. It may be lifted in the future.

    WebGLTexture* texture = validateTextureBinding("texImage2D", target, true);

    if (GraphicsContext3D::TEXTURE_2D == target && texture

        && (format == GraphicsContext3D::RGB || format == GraphicsContext3D::RGBA)

        && type == GraphicsContext3D::UNSIGNED_BYTE

        && (texture->getType(target, level) == GraphicsContext3D::UNSIGNED_BYTE || !texture->isValid(target, level))

        && !level) {

        if (video->copyVideoTextureToPlatformTexture(m_context.get(), texture->object(), level, type, internalformat, m_unpackPremultiplyAlpha, m_unpackFlipY)) {

            texture->setLevelInfo(target, level, internalformat, video->videoWidth(), video->videoHeight(), type);

            return;

        }

    }

    // Normal pure SW path.

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texImage2DImpl(target, level, internalformat, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContextBase::texParameter(GC3Denum target, GC3Denum pname, GC3Dfloat paramf, GC3Dint parami, bool isFloat)

{

    if (isContextLostOrPending())

        return;

    WebGLTexture* tex = validateTextureBinding("texParameter", target, false);

    if (!tex)

        return;

    switch (pname) {

    case GraphicsContext3D::TEXTURE_MIN_FILTER:

    case GraphicsContext3D::TEXTURE_MAG_FILTER:

        break;

    case GraphicsContext3D::TEXTURE_WRAP_S:

    case GraphicsContext3D::TEXTURE_WRAP_T:

        if ((isFloat && paramf != GraphicsContext3D::CLAMP_TO_EDGE && paramf != GraphicsContext3D::MIRRORED_REPEAT && paramf != GraphicsContext3D::REPEAT)

            || (!isFloat && parami != GraphicsContext3D::CLAMP_TO_EDGE && parami != GraphicsContext3D::MIRRORED_REPEAT && parami != GraphicsContext3D::REPEAT)) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter");

            return;

        }

        break;

    case Extensions3D::TEXTURE_MAX_ANISOTROPY_EXT: // EXT_texture_filter_anisotropic

        if (!m_extTextureFilterAnisotropic) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter, EXT_texture_filter_anisotropic not enabled");

            return;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texParameter", "invalid parameter name");

        return;

    }

    if (isFloat) {

        tex->setParameterf(pname, paramf);

        m_context->texParameterf(target, pname, paramf);

    } else {

        tex->setParameteri(pname, parami);

        m_context->texParameteri(target, pname, parami);

    }

}

void WebGLRenderingContextBase::texParameterf(GC3Denum target, GC3Denum pname, GC3Dfloat param)

{

    texParameter(target, pname, param, 0, true);

}

void WebGLRenderingContextBase::texParameteri(GC3Denum target, GC3Denum pname, GC3Dint param)

{

    texParameter(target, pname, 0, param, false);

}

void WebGLRenderingContextBase::texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode& ec)

{

    // FIXME: For now we ignore any errors returned

    ec = 0;

    ASSERT(!isContextLost());

    ASSERT(validateTexFuncParameters("texSubImage2D", TexSubImage2D, target, level, format, width, height, 0, format, type));

    ASSERT(validateSize("texSubImage2D", xoffset, yoffset));

    ASSERT(validateSettableTexFormat("texSubImage2D", format));

    WebGLTexture* tex = validateTextureBinding("texSubImage2D", target, true);

    if (!tex) {

        ASSERT_NOT_REACHED();

        return;

    }

    ASSERT((xoffset + width) >= 0);

    ASSERT((yoffset + height) >= 0);

    ASSERT(tex->getWidth(target, level) >= (xoffset + width));

    ASSERT(tex->getHeight(target, level) >= (yoffset + height));

    ASSERT(tex->getInternalFormat(target, level) == format);

    ASSERT(tex->getType(target, level) == type);

    m_context->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);

}

void WebGLRenderingContextBase::texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image* image, GraphicsContext3D::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha, ExceptionCode& ec)

{

    ec = 0;

    Vector<uint8_t> data;

    GraphicsContext3D::ImageExtractor imageExtractor(image, domSource, premultiplyAlpha, m_unpackColorspaceConversion == GraphicsContext3D::NONE);  

    if (!imageExtractor.extractSucceeded()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image");

        return;

    }

    GraphicsContext3D::DataFormat sourceDataFormat = imageExtractor.imageSourceFormat();

    GraphicsContext3D::AlphaOp alphaOp = imageExtractor.imageAlphaOp();

    const void* imagePixelData = imageExtractor.imagePixelData();

    bool needConversion = true;

    if (type == GraphicsContext3D::UNSIGNED_BYTE && sourceDataFormat == GraphicsContext3D::DataFormatRGBA8 && format == GraphicsContext3D::RGBA && alphaOp == GraphicsContext3D::AlphaDoNothing && !flipY)

        needConversion = false;

    else {

        if (!m_context->packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, image->width(), image->height(), format, type,  needConversion ? data.data() : imagePixelData, ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                              GC3Dsizei width, GC3Dsizei height,

                                              GC3Denum format, GC3Denum type, ArrayBufferView* pixels, ExceptionCode& ec)

{

    if (isContextLostOrPending() || !validateTexFuncData("texSubImage2D", level, width, height, format, type, pixels, NullNotAllowed)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceArrayBufferView, target, level, format, width, height, 0, format, type, xoffset, yoffset))

        return;

    void* data = pixels->baseAddress();

    Vector<uint8_t> tempData;

    bool changeUnpackAlignment = false;

    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {

        if (!m_context->extractTextureData(width, height, format, type,

                                           m_unpackAlignment,

                                           m_unpackFlipY, m_unpackPremultiplyAlpha,

                                           data,

                                           tempData))

            return;

        data = tempData.data();

        changeUnpackAlignment = true;

    }

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, width, height, format, type, data, ec);

    if (changeUnpackAlignment)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                              GC3Denum format, GC3Denum type, ImageData* pixels, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !pixels || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceImageData, target, level, format,  pixels->width(), pixels->height(), 0, format, type, xoffset, yoffset))

        return;

    Vector<uint8_t> data;

    bool needConversion = true;

    // The data from ImageData is always of format RGBA8.

    // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.

    if (format == GraphicsContext3D::RGBA && type == GraphicsContext3D::UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha)

        needConversion = false;

    else {

        if (!m_context->extractImageData(pixels, format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "texSubImage2D", "bad image data");

            return;

        }

    }

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, 1);

    texSubImage2DBase(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data(), ec);

    if (m_unpackAlignment != 1)

        m_context->pixelStorei(GraphicsContext3D::UNPACK_ALIGNMENT, m_unpackAlignment);

}

void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                              GC3Denum format, GC3Denum type, HTMLImageElement* image, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLImageElement("texSubImage2D", image, ec))

        return;

    RefPtr<Image> imageForRender = image->cachedImage()->imageForRenderer(image->renderer());

    if (imageForRender->isSVGImage())

        imageForRender = drawImageIntoBuffer(imageForRender.get(), image->width(), image->height(), 1);

    if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLImageElement, target, level, format, imageForRender->width(), imageForRender->height(), 0, format, type, xoffset, yoffset))

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), GraphicsContext3D::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                              GC3Denum format, GC3Denum type, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLCanvasElement("texSubImage2D", canvas, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLCanvasElement, target, level, format, canvas->width(), canvas->height(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<ImageData> imageData = canvas->getImageData();

    if (imageData)

        texSubImage2D(target, level, xoffset, yoffset, format, type, imageData.get(), ec);

    else

        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(), GraphicsContext3D::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#if ENABLE(VIDEO)

void WebGLRenderingContextBase::texSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                              GC3Denum format, GC3Denum type, HTMLVideoElement* video, ExceptionCode& ec)

{

    ec = 0;

    if (isContextLostOrPending() || !validateHTMLVideoElement("texSubImage2D", video, ec)

        || !validateTexFunc("texSubImage2D", TexSubImage2D, SourceHTMLVideoElement, target, level, format, video->videoWidth(), video->videoHeight(), 0, format, type, xoffset, yoffset))

        return;

    RefPtr<Image> image = videoFrameToImage(video, ImageBuffer::fastCopyImageMode(), ec);

    if (!image)

        return;

    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), GraphicsContext3D::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha, ec);

}

#endif

void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GC3Dfloat x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1f", "location not for current program");

        return;

    }

    m_context->uniform1f(location->location(), x);

}

void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, 1))

        return;

    m_context->uniform1fv(location->location(), v->length(), v->data());

}

void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1fv", location, v, size, 1))

        return;

    m_context->uniform1fv(location->location(), size, v);

}

void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GC3Dint x, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform1i", "location not for current program");

        return;

    }

    if ((location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) && x >= (int)m_textureUnits.size()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1i", "invalid texture unit");

        return;

    }

    m_context->uniform1i(location->location(), x);

}

void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) {

        for (unsigned i = 0; i < v->length(); ++i) {

            if (v->data()[i] >= static_cast<int>(m_textureUnits.size())) {

                LOG(WebGL, "Texture unit size=%zu, v[%d]=%d. Location type = %04X.", m_textureUnits.size(), i, v->data()[i], location->type());

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    }

    m_context->uniform1iv(location->location(), v->length(), v->data());

}

void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform1iv", location, v, size, 1))

        return;

    if (location->type() == GraphicsContext3D::SAMPLER_2D || location->type() == GraphicsContext3D::SAMPLER_CUBE) {

        for (unsigned i = 0; i < static_cast<unsigned>(size); ++i) {

            if (((GC3Dint*)v)[i] >= static_cast<int>(m_textureUnits.size())) {

                synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "uniform1iv", "invalid texture unit");

                return;

            }

        }

    }

    m_context->uniform1iv(location->location(), size, v);

}

void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2f", "location not for current program");

        return;

    }

    m_context->uniform2f(location->location(), x, y);

}

void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, 2))

        return;

    m_context->uniform2fv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2fv", location, v, size, 2))

        return;

    m_context->uniform2fv(location->location(), size / 2, v);

}

void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform2i", "location not for current program");

        return;

    }

    m_context->uniform2i(location->location(), x, y);

}

void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, 2))

        return;

    m_context->uniform2iv(location->location(), v->length() / 2, v->data());

}

void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform2iv", location, v, size, 2))

        return;

    m_context->uniform2iv(location->location(), size / 2, v);

}

void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3f", "location not for current program");

        return;

    }

    m_context->uniform3f(location->location(), x, y, z);

}

void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, 3))

        return;

    m_context->uniform3fv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3fv", location, v, size, 3))

        return;

    m_context->uniform3fv(location->location(), size / 3, v);

}

void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform3i", "location not for current program");

        return;

    }

    m_context->uniform3i(location->location(), x, y, z);

}

void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, 3))

        return;

    m_context->uniform3iv(location->location(), v->length() / 3, v->data());

}

void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform3iv", location, v, size, 3))

        return;

    m_context->uniform3iv(location->location(), size / 3, v);

}

void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4f", "location not for current program");

        return;

    }

    m_context->uniform4f(location->location(), x, y, z, w);

}

void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, 4))

        return;

    m_context->uniform4fv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4fv", location, v, size, 4))

        return;

    m_context->uniform4fv(location->location(), size / 4, v);

}

void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GC3Dint x, GC3Dint y, GC3Dint z, GC3Dint w, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !location)

        return;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "uniform4i", "location not for current program");

        return;

    }

    m_context->uniform4i(location->location(), x, y, z, w);

}

void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Int32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, 4))

        return;

    m_context->uniform4iv(location->location(), v->length() / 4, v->data());

}

void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, GC3Dint* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformParameters("uniform4iv", location, v, size, 4))

        return;

    m_context->uniform4iv(location->location(), size / 4, v);

}

void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), v->length() / 4, transpose, v->data());

}

void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, size, 4))

        return;

    m_context->uniformMatrix2fv(location->location(), size / 4, transpose, v);

}

void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());

}

void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, size, 9))

        return;

    m_context->uniformMatrix3fv(location->location(), size / 9, transpose, v);

}

void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), v->length() / 16, transpose, v->data());

}

void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GC3Dboolean transpose, GC3Dfloat* v, GC3Dsizei size, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, size, 16))

        return;

    m_context->uniformMatrix4fv(location->location(), size / 16, transpose, v);

}

void WebGLRenderingContextBase::useProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    bool deleted;

    if (!checkObjectToBeBound("useProgram", program, deleted))

        return;

    if (deleted)

        program = 0;

    if (program && !program->getLinkStatus()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "useProgram", "program not valid");

        return;

    }

    if (m_currentProgram != program) {

        if (m_currentProgram)

            m_currentProgram->onDetached(graphicsContext3D());

        m_currentProgram = program;

        m_context->useProgram(objectOrZero(program));

        if (program)

            program->onAttached();

    }

}

void WebGLRenderingContextBase::validateProgram(WebGLProgram* program, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending() || !validateWebGLObject("validateProgram", program))

        return;

    m_context->validateProgram(objectOrZero(program));

}

void WebGLRenderingContextBase::vertexAttrib1f(GC3Duint index, GC3Dfloat v0)

{

    vertexAttribfImpl("vertexAttrib1f", index, 1, v0, 0.0f, 0.0f, 1.0f);

}

void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, 1);

}

void WebGLRenderingContextBase::vertexAttrib1fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib1fv", index, v, size, 1);

}

void WebGLRenderingContextBase::vertexAttrib2f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1)

{

    vertexAttribfImpl("vertexAttrib2f", index, 2, v0, v1, 0.0f, 1.0f);

}

void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, 2);

}

void WebGLRenderingContextBase::vertexAttrib2fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib2fv", index, v, size, 2);

}

void WebGLRenderingContextBase::vertexAttrib3f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2)

{

    vertexAttribfImpl("vertexAttrib3f", index, 3, v0, v1, v2, 1.0f);

}

void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, 3);

}

void WebGLRenderingContextBase::vertexAttrib3fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib3fv", index, v, size, 3);

}

void WebGLRenderingContextBase::vertexAttrib4f(GC3Duint index, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    vertexAttribfImpl("vertexAttrib4f", index, 4, v0, v1, v2, v3);

}

void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, Float32Array* v)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, 4);

}

void WebGLRenderingContextBase::vertexAttrib4fv(GC3Duint index, GC3Dfloat* v, GC3Dsizei size)

{

    vertexAttribfvImpl("vertexAttrib4fv", index, v, size, 4);

}

void WebGLRenderingContextBase::vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized, GC3Dsizei stride, long long offset, ExceptionCode& ec)

{

    UNUSED_PARAM(ec);

    if (isContextLostOrPending())

        return;

    switch (type) {

    case GraphicsContext3D::BYTE:

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::SHORT:

    case GraphicsContext3D::UNSIGNED_SHORT:

    case GraphicsContext3D::FLOAT:

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "index out of range");

        return;

    }

    if (size < 1 || size > 4 || stride < 0 || stride > 255 || offset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribPointer", "bad size, stride or offset");

        return;

    }

    if (!m_boundArrayBuffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "no bound ARRAY_BUFFER");

        return;

    }

    // Determine the number of elements the bound buffer can hold, given the offset, size, type and stride

    unsigned typeSize = sizeInBytes(type);

    if (!typeSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "vertexAttribPointer", "invalid type");

        return;

    }

    if ((stride % typeSize) || (static_cast<GC3Dintptr>(offset) % typeSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "vertexAttribPointer", "stride or offset not valid for type");

        return;

    }

    GC3Dsizei bytesPerElement = size * typeSize;

    m_boundVertexArrayObject->setVertexAttribState(index, bytesPerElement, size, type, normalized, stride, static_cast<GC3Dintptr>(offset), m_boundArrayBuffer);

    m_context->vertexAttribPointer(index, size, type, normalized, stride, static_cast<GC3Dintptr>(offset));

}

void WebGLRenderingContextBase::viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height)

{

    if (isContextLostOrPending())

        return;

    if (!validateSize("viewport", width, height))

        return;

    m_context->viewport(x, y, width, height);

}

void WebGLRenderingContextBase::forceLostContext(WebGLRenderingContextBase::LostContextMode mode)

{

    if (isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "loseContext", "context already lost");

        return;

    }

    m_contextGroup->loseContextGroup(mode);

}

void WebGLRenderingContextBase::loseContextImpl(WebGLRenderingContextBase::LostContextMode mode)

{

    if (isContextLost())

        return;

    m_contextLost = true;

    m_contextLostMode = mode;

    if (mode == RealLostContext) {

        // Inform the embedder that a lost context was received. In response, the embedder might

        // decide to take action such as asking the user for permission to use WebGL again.

        if (Frame* frame = canvas()->document().frame())

            frame->loader().client().didLoseWebGLContext(m_context->getExtensions()->getGraphicsResetStatusARB());

    }

    detachAndRemoveAllObjects();

    if (m_drawingBuffer) {

        // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.

        m_drawingBuffer->setTexture2DBinding(0);

        m_drawingBuffer->setFramebufferBinding(0);

    }

    // There is no direct way to clear errors from a GL implementation and

    // looping until getError() becomes NO_ERROR might cause an infinite loop if

    // the driver or context implementation had a bug. So, loop a reasonably

    // large number of times to clear any existing errors.

    for (int i = 0; i < 100; ++i) {

        if (m_context->getError() == GraphicsContext3D::NO_ERROR)

            break;

    }

    ConsoleDisplayPreference display = (mode == RealLostContext) ? DisplayInConsole: DontDisplayInConsole;

    synthesizeGLError(GraphicsContext3D::CONTEXT_LOST_WEBGL, "loseContext", "context lost", display);

    // Don't allow restoration unless the context lost event has both been

    // dispatched and its default behavior prevented.

    m_restoreAllowed = false;

    // Always defer the dispatch of the context lost event, to implement

    // the spec behavior of queueing a task.

    m_dispatchContextLostEventTimer.startOneShot(0);

}

void WebGLRenderingContextBase::forceRestoreContext()

{

    if (!isContextLostOrPending()) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context not lost");

        return;

    }

    if (!m_restoreAllowed) {

        if (m_contextLostMode == SyntheticLostContext)

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "restoreContext", "context restoration not allowed");

        return;

    }

    if (!m_restoreTimer.isActive())

        m_restoreTimer.startOneShot(0);

}

PlatformLayer* WebGLRenderingContextBase::platformLayer() const

{

    return (!isContextLost() && !m_isPendingPolicyResolution) ? m_context->platformLayer() : 0;

}

void WebGLRenderingContextBase::removeSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextGroup->removeObject(object);

}

void WebGLRenderingContextBase::addSharedObject(WebGLSharedObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextGroup->addObject(object);

}

void WebGLRenderingContextBase::removeContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    m_contextObjects.remove(object);

}

void WebGLRenderingContextBase::addContextObject(WebGLContextObject* object)

{

    if (m_isPendingPolicyResolution)

        return;

    ASSERT(!isContextLost());

    m_contextObjects.add(object);

}

void WebGLRenderingContextBase::detachAndRemoveAllObjects()

{

    if (m_isPendingPolicyResolution)

        return;

    while (m_contextObjects.size() > 0) {

        HashSet<WebGLContextObject*>::iterator it = m_contextObjects.begin();

        (*it)->detachContext();

    }

}

bool WebGLRenderingContextBase::hasPendingActivity() const

{

    return false;

}

void WebGLRenderingContextBase::stop()

{

    if (!isContextLost() && !m_isPendingPolicyResolution) {

        forceLostContext(SyntheticLostContext);

        destroyGraphicsContext3D();

    }

}

WebGLGetInfo WebGLRenderingContextBase::getBooleanParameter(GC3Denum pname)

{

    GC3Dboolean value = 0;

    m_context->getBooleanv(pname, &value);

    return WebGLGetInfo(static_cast<bool>(value));

}

WebGLGetInfo WebGLRenderingContextBase::getBooleanArrayParameter(GC3Denum pname)

{

    if (pname != GraphicsContext3D::COLOR_WRITEMASK) {

        notImplemented();

        return WebGLGetInfo(0, 0);

    }

    GC3Dboolean value[4] = {0};

    m_context->getBooleanv(pname, value);

    bool boolValue[4];

    for (int ii = 0; ii < 4; ++ii)

        boolValue[ii] = static_cast<bool>(value[ii]);

    return WebGLGetInfo(boolValue, 4);

}

WebGLGetInfo WebGLRenderingContextBase::getFloatParameter(GC3Denum pname)

{

    GC3Dfloat value = 0;

    m_context->getFloatv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContextBase::getIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(value);

}

WebGLGetInfo WebGLRenderingContextBase::getUnsignedIntParameter(GC3Denum pname)

{

    GC3Dint value = 0;

    m_context->getIntegerv(pname, &value);

    return WebGLGetInfo(static_cast<unsigned>(value));

}

WebGLGetInfo WebGLRenderingContextBase::getWebGLFloatArrayParameter(GC3Denum pname)

{

    GC3Dfloat value[4] = {0};

    m_context->getFloatv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::ALIASED_POINT_SIZE_RANGE:

    case GraphicsContext3D::ALIASED_LINE_WIDTH_RANGE:

    case GraphicsContext3D::DEPTH_RANGE:

        length = 2;

        break;

    case GraphicsContext3D::BLEND_COLOR:

    case GraphicsContext3D::COLOR_CLEAR_VALUE:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Float32Array::create(value, length));

}

WebGLGetInfo WebGLRenderingContextBase::getWebGLIntArrayParameter(GC3Denum pname)

{

    GC3Dint value[4] = {0};

    m_context->getIntegerv(pname, value);

    unsigned length = 0;

    switch (pname) {

    case GraphicsContext3D::MAX_VIEWPORT_DIMS:

        length = 2;

        break;

    case GraphicsContext3D::SCISSOR_BOX:

    case GraphicsContext3D::VIEWPORT:

        length = 4;

        break;

    default:

        notImplemented();

    }

    return WebGLGetInfo(Int32Array::create(value, length));

}

void WebGLRenderingContextBase::checkTextureCompleteness(const char* functionName, bool prepareToDraw)

{

    bool resetActiveUnit = false;

    WebGLTexture::TextureExtensionFlag extensions = static_cast<WebGLTexture::TextureExtensionFlag>((m_oesTextureFloatLinear ? WebGLTexture::TextureExtensionFloatLinearEnabled : 0) | (m_oesTextureHalfFloatLinear ? WebGLTexture::TextureExtensionHalfFloatLinearEnabled : 0));

    for (unsigned ii = 0; ii < m_textureUnits.size(); ++ii) {

        if ((m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

            || (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))) {

            if (ii != m_activeTextureUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = true;

            } else if (resetActiveUnit) {

                m_context->activeTexture(ii);

                resetActiveUnit = false;

            }

            WebGLTexture* tex2D;

            WebGLTexture* texCubeMap;

            if (prepareToDraw) {

                String msg(String("texture bound to texture unit ") + String::number(ii)

                    + " is not renderable. It maybe non-power-of-2 and have incompatible texture filtering or is not 'texture complete',"

                    + " or it is a float/half-float type with linear filtering and without the relevant float/half-float linear extension enabled.");

                printGLWarningToConsole(functionName, msg.utf8().data());

                tex2D = m_blackTexture2D.get();

                texCubeMap = m_blackTextureCubeMap.get();

            } else {

                tex2D = m_textureUnits[ii].texture2DBinding.get();

                texCubeMap = m_textureUnits[ii].textureCubeMapBinding.get();

            }

            if (m_textureUnits[ii].texture2DBinding && m_textureUnits[ii].texture2DBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, objectOrZero(tex2D));

            if (m_textureUnits[ii].textureCubeMapBinding && m_textureUnits[ii].textureCubeMapBinding->needToUseBlackTexture(extensions))

                m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, objectOrZero(texCubeMap));

        }

    }

    if (resetActiveUnit)

        m_context->activeTexture(m_activeTextureUnit);

}

void WebGLRenderingContextBase::createFallbackBlackTextures1x1()

{

    unsigned char black[] = {0, 0, 0, 255};

    m_blackTexture2D = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, m_blackTexture2D->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_2D, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_2D, 0);

    m_blackTextureCubeMap = createTexture();

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, m_blackTextureCubeMap->object());

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->texImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, GraphicsContext3D::RGBA, 1, 1,

                          0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE, black);

    m_context->bindTexture(GraphicsContext3D::TEXTURE_CUBE_MAP, 0);

}

bool WebGLRenderingContextBase::isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat, GC3Denum colorBufferFormat)

{

    unsigned need = GraphicsContext3D::getChannelBitsByFormat(texInternalFormat);

    unsigned have = GraphicsContext3D::getChannelBitsByFormat(colorBufferFormat);

    return (need & have) == need;

}

GC3Denum WebGLRenderingContextBase::getBoundFramebufferColorFormat()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferFormat();

    if (m_attributes.alpha)

        return GraphicsContext3D::RGBA;

    return GraphicsContext3D::RGB;

}

int WebGLRenderingContextBase::getBoundFramebufferWidth()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferWidth();

    return m_drawingBuffer ? m_drawingBuffer->size().width() : m_context->getInternalFramebufferSize().width();

}

int WebGLRenderingContextBase::getBoundFramebufferHeight()

{

    if (m_framebufferBinding && m_framebufferBinding->object())

        return m_framebufferBinding->getColorBufferHeight();

    return m_drawingBuffer ? m_drawingBuffer->size().height() : m_context->getInternalFramebufferSize().height();

}

WebGLTexture* WebGLRenderingContextBase::validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap)

{

    WebGLTexture* texture = nullptr;

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        texture = m_textureUnits[m_activeTextureUnit].texture2DBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (!useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP:

        if (useSixEnumsForCubeMap) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

            return nullptr;

        }

        texture = m_textureUnits[m_activeTextureUnit].textureCubeMapBinding.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture target");

        return nullptr;

    }

    if (!texture)

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no texture");

    return texture;

}

bool WebGLRenderingContextBase::validateLocationLength(const char* functionName, const String& string)

{

    const unsigned maxWebGLLocationLength = 256;

    if (string.length() > maxWebGLLocationLength) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "location length > 256");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateSize(const char* functionName, GC3Dint x, GC3Dint y)

{

    if (x < 0 || y < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "size < 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateString(const char* functionName, const String& string)

{

    for (size_t i = 0; i < string.length(); ++i) {

        if (!validateCharacter(string[i])) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "string not ASCII");

            return false;

        }

    }

    return true;

}

bool WebGLRenderingContextBase::validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level)

{

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

    case GraphicsContext3D::RGB:

    case GraphicsContext3D::RGBA:

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "depth texture formats not enabled");

        return false;

    case Extensions3D::SRGB_EXT:

    case Extensions3D::SRGB_ALPHA_EXT:

    default:

        if ((format == Extensions3D::SRGB_EXT || format == Extensions3D::SRGB_ALPHA_EXT)

            && m_extsRGB)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture format");

        return false;

    }

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        break;

    case GraphicsContext3D::FLOAT:

        if (m_oesTextureFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::HALF_FLOAT_OES:

        if (m_oesTextureHalfFloat)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    case GraphicsContext3D::UNSIGNED_INT:

    case GraphicsContext3D::UNSIGNED_INT_24_8:

    case GraphicsContext3D::UNSIGNED_SHORT:

        if (m_webglDepthTexture)

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid texture type");

        return false;

    }

    // Verify that the combination of format and type is supported.

    switch (format) {

    case GraphicsContext3D::ALPHA:

    case GraphicsContext3D::LUMINANCE:

    case GraphicsContext3D::LUMINANCE_ALPHA:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for format");

            return false;

        }

        break;

    case GraphicsContext3D::RGB:

    case Extensions3D::SRGB_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_6_5

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGB format");

            return false;

        }

        break;

    case GraphicsContext3D::RGBA:

    case Extensions3D::SRGB_ALPHA_EXT:

        if (type != GraphicsContext3D::UNSIGNED_BYTE

            && type != GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4

            && type != GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1

            && type != GraphicsContext3D::FLOAT

            && type != GraphicsContext3D::HALF_FLOAT_OES) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for RGBA format");

            return false;

        }

        break;

    case GraphicsContext3D::DEPTH_COMPONENT:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_COMPONENT not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_SHORT

            && type != GraphicsContext3D::UNSIGNED_INT) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_COMPONENT format");

            return false;

        }

        if (level > 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_COMPONENT format");

            return false;

        }

        break;

    case GraphicsContext3D::DEPTH_STENCIL:

        if (!m_webglDepthTexture) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format. DEPTH_STENCIL not enabled");

            return false;

        }

        if (type != GraphicsContext3D::UNSIGNED_INT_24_8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "invalid type for DEPTH_STENCIL format");

            return false;

        }

        if (level > 0) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "level must be 0 for DEPTH_STENCIL format");

            return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    return true;

}

bool WebGLRenderingContextBase::validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level)

{

    if (level < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level < 0");

        return false;

    }

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (level >= m_maxTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (level >= m_maxCubeMapTextureLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "level out of range");

            return false;

        }

        break;

    }

    // This function only checks if level is legal, so we return true and don't

    // generate INVALID_ENUM if target is illegal.

    return true;

}

bool WebGLRenderingContextBase::validateTexFuncParameters(const char* functionName,

                                                          TexFuncValidationFunctionType functionType,

                                                          GC3Denum target, GC3Dint level,

                                                          GC3Denum internalformat,

                                                          GC3Dsizei width, GC3Dsizei height, GC3Dint border,

                                                          GC3Denum format, GC3Denum type)

{

    // We absolutely have to validate the format and type combination.

    // The texImage2D entry points taking HTMLImage, etc. will produce

    // temporary data based on this combination, so it must be legal.

    if (!validateTexFuncFormatAndType(functionName, format, type, level) || !validateTexFuncLevel(functionName, target, level))

        return false;

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    GC3Dint maxTextureSizeForLevel = pow(2.0, m_maxTextureLevel - 1 - level);

    switch (target) {

    case GraphicsContext3D::TEXTURE_2D:

        if (width > maxTextureSizeForLevel || height > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range");

            return false;

        }

        break;

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z:

    case GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z:

        if (functionType != TexSubImage2D && width != height) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");

            return false;

        }

        // No need to check height here. For texImage width == height.

        // For texSubImage that will be checked when checking yoffset + height is in range.

        if (width > maxTextureSizeForLevel) {

            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height out of range for cube map");

            return false;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    if (format != internalformat) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "format != internalformat");

        return false;

    }

    if (border) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "border != 0");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateTexFuncData(const char* functionName, GC3Dint level,

                                                    GC3Dsizei width, GC3Dsizei height,

                                                    GC3Denum format, GC3Denum type,

                                                    ArrayBufferView* pixels,

                                                    NullDisposition disposition)

{

    if (!pixels) {

        if (disposition == NullAllowed)

            return true;

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (!validateTexFuncFormatAndType(functionName, format, type, level))

        return false;

    if (!validateSettableTexFormat(functionName, format))

        return false;

    switch (type) {

    case GraphicsContext3D::UNSIGNED_BYTE:

        if (pixels->getType() != JSC::TypeUint8) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_BYTE but ArrayBufferView not Uint8Array");

            return false;

        }

        break;

    case GraphicsContext3D::UNSIGNED_SHORT_5_6_5:

    case GraphicsContext3D::UNSIGNED_SHORT_4_4_4_4:

    case GraphicsContext3D::UNSIGNED_SHORT_5_5_5_1:

        if (pixels->getType() != JSC::TypeUint16) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type UNSIGNED_SHORT but ArrayBufferView not Uint16Array");

            return false;

        }

        break;

    case GraphicsContext3D::FLOAT: // OES_texture_float

        if (pixels->getType() != JSC::TypeFloat32) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type FLOAT but ArrayBufferView not Float32Array");

            return false;

        }

        break;

    case GraphicsContext3D::HALF_FLOAT_OES: // OES_texture_half_float

        // As per the specification, ArrayBufferView should be null when

        // OES_texture_half_float is enabled.

        if (pixels) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "type HALF_FLOAT_OES but ArrayBufferView is not NULL");

            return false;

        }

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    unsigned totalBytesRequired;

    GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &totalBytesRequired, 0);

    if (error != GraphicsContext3D::NO_ERROR) {

        synthesizeGLError(error, functionName, "invalid texture dimensions");

        return false;

    }

    if (pixels->byteLength() < totalBytesRequired) {

        if (m_unpackAlignment != 1) {

            error = m_context->computeImageSizeInBytes(format, type, width, height, 1, &totalBytesRequired, 0);

            if (pixels->byteLength() == totalBytesRequired) {

                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request with UNPACK_ALIGNMENT > 1");

                return false;

            }

        }

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "ArrayBufferView not big enough for request");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateCompressedTexFormat(GC3Denum format)

{

    return m_compressedTextureFormats.contains(format);

}

bool WebGLRenderingContextBase::validateCompressedTexFuncData(const char* functionName,

                                                              GC3Dsizei width, GC3Dsizei height,

                                                              GC3Denum format, ArrayBufferView* pixels)

{

    if (!pixels) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no pixels");

        return false;

    }

    if (width < 0 || height < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");

        return false;

    }

    unsigned bytesRequired = 0;

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_ATC_RGB_AMD:

        {

        const int kBlockSize = 8;

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

        int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

        bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT:

    case Extensions3D::COMPRESSED_ATC_RGBA_EXPLICIT_ALPHA_AMD:

    case Extensions3D::COMPRESSED_ATC_RGBA_INTERPOLATED_ALPHA_AMD:

        {

        const int kBlockSize = 16;

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        int numBlocksAcross = (width + kBlockWidth - 1) / kBlockWidth;

        int numBlocksDown = (height + kBlockHeight - 1) / kBlockHeight;

        bytesRequired = numBlocksAcross * numBlocksDown * kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

        {

        const int kBlockSize = 8;

        const int kBlockWidth = 8;

        const int kBlockHeight = 8;

        bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 4 + 7) / kBlockSize;

        }

        break;

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        {

        const int kBlockSize = 8;

        const int kBlockWidth = 16;

        const int kBlockHeight = 8;

        bytesRequired = (std::max(width, kBlockWidth) * std::max(height, kBlockHeight) * 2 + 7) / kBlockSize;

        }

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid format");

        return false;

    }

    if (pixels->byteLength() != bytesRequired) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "length of ArrayBufferView is not correct for dimensions");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateCompressedTexDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format)

{

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const GC3Dsizei kBlockWidth = 4;

        const GC3Dsizei kBlockHeight = 4;

        const GC3Dint maxTextureSize = target ? m_maxTextureSize : m_maxCubeMapTextureSize;

        const GC3Dsizei maxCompressedDimension = maxTextureSize >> level;

        bool widthValid = (level && width == 1) || (level && width == 2) || (!(width % kBlockWidth) && width <= maxCompressedDimension);

        bool heightValid = (level && height == 1) || (level && height == 2) || (!(height % kBlockHeight) && height <= maxCompressedDimension);

        if (!widthValid || !heightValid) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG:

        // Height and width must be powers of 2.

        if ((width & (width - 1)) || (height & (height - 1))) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "width or height invalid for level");

            return false;

        }

        return true;

    default:

        return false;

    }

}

bool WebGLRenderingContextBase::validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,

                                                                   GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture* tex)

{

    if (xoffset < 0 || yoffset < 0) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "xoffset or yoffset < 0");

        return false;

    }

    switch (format) {

    case Extensions3D::COMPRESSED_RGB_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT1_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT3_EXT:

    case Extensions3D::COMPRESSED_RGBA_S3TC_DXT5_EXT: {

        const int kBlockWidth = 4;

        const int kBlockHeight = 4;

        if ((xoffset % kBlockWidth) || (yoffset % kBlockHeight)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset or yoffset not multiple of 4");

            return false;

        }

        if (width - xoffset > tex->getWidth(target, level)

            || height - yoffset > tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions out of range");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    case Extensions3D::COMPRESSED_RGB_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGB_PVRTC_2BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_4BPPV1_IMG:

    case Extensions3D::COMPRESSED_RGBA_PVRTC_2BPPV1_IMG: {

        if (xoffset || yoffset) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "xoffset and yoffset must be zero");

            return false;

        }

        if (width != tex->getWidth(target, level)

            || height != tex->getHeight(target, level)) {

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "dimensions must match existing level");

            return false;

        }

        return validateCompressedTexDimensions(functionName, target, level, width, height, format);

    }

    default:

        return false;

    }

}

bool WebGLRenderingContextBase::validateDrawMode(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::POINTS:

    case GraphicsContext3D::LINE_STRIP:

    case GraphicsContext3D::LINE_LOOP:

    case GraphicsContext3D::LINES:

    case GraphicsContext3D::TRIANGLE_STRIP:

    case GraphicsContext3D::TRIANGLE_FAN:

    case GraphicsContext3D::TRIANGLES:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid draw mode");

        return false;

    }

}

bool WebGLRenderingContextBase::validateStencilSettings(const char* functionName)

{

    if (m_stencilMask != m_stencilMaskBack || m_stencilFuncRef != m_stencilFuncRefBack || m_stencilFuncMask != m_stencilFuncMaskBack) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "front and back stencils settings do not match");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateStencilFunc(const char* functionName, GC3Denum func)

{

    switch (func) {

    case GraphicsContext3D::NEVER:

    case GraphicsContext3D::LESS:

    case GraphicsContext3D::LEQUAL:

    case GraphicsContext3D::GREATER:

    case GraphicsContext3D::GEQUAL:

    case GraphicsContext3D::EQUAL:

    case GraphicsContext3D::NOTEQUAL:

    case GraphicsContext3D::ALWAYS:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid function");

        return false;

    }

}

void WebGLRenderingContextBase::printGLErrorToConsole(const String& message)

{

    if (!m_numGLErrorsToConsoleAllowed)

        return;

    --m_numGLErrorsToConsoleAllowed;

    printWarningToConsole(message);

    if (!m_numGLErrorsToConsoleAllowed)

        printWarningToConsole("WebGL: too many errors, no more errors will be reported to the console for this context.");

}

void WebGLRenderingContextBase::printWarningToConsole(const String& message)

{

    if (!canvas())

        return;

    canvas()->document().addConsoleMessage(MessageSource::Rendering, MessageLevel::Warning, message);

}

bool WebGLRenderingContextBase::validateFramebufferFuncParameters(const char* functionName, GC3Denum target, GC3Denum attachment)

{

    if (target != GraphicsContext3D::FRAMEBUFFER) {

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return false;

    }

    switch (attachment) {

    case GraphicsContext3D::COLOR_ATTACHMENT0:

    case GraphicsContext3D::DEPTH_ATTACHMENT:

    case GraphicsContext3D::STENCIL_ATTACHMENT:

    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:

        break;

    default:

        if (m_webglDrawBuffers

            && attachment > GraphicsContext3D::COLOR_ATTACHMENT0

            && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))

            break;

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateBlendEquation(const char* functionName, GC3Denum mode)

{

    switch (mode) {

    case GraphicsContext3D::FUNC_ADD:

    case GraphicsContext3D::FUNC_SUBTRACT:

    case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:

    case Extensions3D::MIN_EXT:

    case Extensions3D::MAX_EXT:

        if ((mode == Extensions3D::MIN_EXT || mode == Extensions3D::MAX_EXT) && !m_extBlendMinMax) {

            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

            return false;

        }

        return true;

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");

        return false;

    }

}

bool WebGLRenderingContextBase::validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst)

{

    if (((src == GraphicsContext3D::CONSTANT_COLOR || src == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

        && (dst == GraphicsContext3D::CONSTANT_ALPHA || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))

        || ((dst == GraphicsContext3D::CONSTANT_COLOR || dst == GraphicsContext3D::ONE_MINUS_CONSTANT_COLOR)

        && (src == GraphicsContext3D::CONSTANT_ALPHA || src == GraphicsContext3D::ONE_MINUS_CONSTANT_ALPHA))) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "incompatible src and dst");

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateCapability(const char* functionName, GC3Denum cap)

{

    switch (cap) {

    case GraphicsContext3D::BLEND:

    case GraphicsContext3D::CULL_FACE:

    case GraphicsContext3D::DEPTH_TEST:

    case GraphicsContext3D::DITHER:

    case GraphicsContext3D::POLYGON_OFFSET_FILL:

    case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:

    case GraphicsContext3D::SAMPLE_COVERAGE:

    case GraphicsContext3D::SCISSOR_TEST:

    case GraphicsContext3D::STENCIL_TEST:

        return true;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");

        return false;

    }

}

bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, Int32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, false, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContextBase::validateUniformParameters(const char* functionName, const WebGLUniformLocation* location, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    return validateUniformMatrixParameters(functionName, location, false, v, size, requiredMinSize);

}

bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, Float32Array* v, GC3Dsizei requiredMinSize)

{

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    return validateUniformMatrixParameters(functionName, location, transpose, v->data(), v->length(), requiredMinSize);

}

bool WebGLRenderingContextBase::validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation* location, GC3Dboolean transpose, void* v, GC3Dsizei size, GC3Dsizei requiredMinSize)

{

    if (!location)

        return false;

    if (location->program() != m_currentProgram) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "location is not from current program");

        return false;

    }

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return false;

    }

    if (transpose) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "transpose not FALSE");

        return false;

    }

    if (size < requiredMinSize || (size % requiredMinSize)) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return false;

    }

    return true;

}

WebGLBuffer* WebGLRenderingContextBase::validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage)

{

    WebGLBuffer* buffer = 0;

    switch (target) {

    case GraphicsContext3D::ELEMENT_ARRAY_BUFFER:

        buffer = m_boundVertexArrayObject->getElementArrayBuffer().get();

        break;

    case GraphicsContext3D::ARRAY_BUFFER:

        buffer = m_boundArrayBuffer.get();

        break;

    default:

        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");

        return nullptr;

    }

    if (!buffer) {

        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, functionName, "no buffer");

        return nullptr;

    }

    switch (usage) {

    case GraphicsContext3D::STREAM_DRAW:

    case GraphicsContext3D::STATIC_DRAW:

    case GraphicsContext3D::DYNAMIC_DRAW:

        return buffer;

    }

    synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid usage");

    return nullptr;

}

bool WebGLRenderingContextBase::validateHTMLImageElement(const char* functionName, HTMLImageElement* image, ExceptionCode& ec)

{

    if (!image || !image->cachedImage()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no image");

        return false;

    }

    const URL& url = image->cachedImage()->response().url();

    if (url.isNull() || url.isEmpty() || !url.isValid()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid image");

        return false;

    }

    if (wouldTaintOrigin(image)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

bool WebGLRenderingContextBase::validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement* canvas, ExceptionCode& ec)

{

    if (!canvas || !canvas->buffer()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no canvas");

        return false;

    }

    if (wouldTaintOrigin(canvas)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#if ENABLE(VIDEO)

bool WebGLRenderingContextBase::validateHTMLVideoElement(const char* functionName, HTMLVideoElement* video, ExceptionCode& ec)

{

    if (!video || !video->videoWidth() || !video->videoHeight()) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no video");

        return false;

    }

    if (wouldTaintOrigin(video)) {

        ec = SECURITY_ERR;

        return false;

    }

    return true;

}

#endif

void WebGLRenderingContextBase::vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat v0, GC3Dfloat v1, GC3Dfloat v2, GC3Dfloat v3)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1f(index, v0);

            break;

        case 2:

            m_context->vertexAttrib2f(index, v0, v1);

            break;

        case 3:

            m_context->vertexAttrib3f(index, v0, v1, v2);

            break;

        case 4:

            m_context->vertexAttrib4f(index, v0, v1, v2, v3);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.value[0] = v0;

    attribValue.value[1] = v1;

    attribValue.value[2] = v2;

    attribValue.value[3] = v3;

}

void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array* v, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    vertexAttribfvImpl(functionName, index, v->data(), v->length(), expectedSize);

}

void WebGLRenderingContextBase::vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat* v, GC3Dsizei size, GC3Dsizei expectedSize)

{

    if (isContextLostOrPending())

        return;

    if (!v) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "no array");

        return;

    }

    if (size < expectedSize) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "invalid size");

        return;

    }

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "index out of range");

        return;

    }

    // In GL, we skip setting vertexAttrib0 values.

    if (index || isGLES2Compliant()) {

        switch (expectedSize) {

        case 1:

            m_context->vertexAttrib1fv(index, v);

            break;

        case 2:

            m_context->vertexAttrib2fv(index, v);

            break;

        case 3:

            m_context->vertexAttrib3fv(index, v);

            break;

        case 4:

            m_context->vertexAttrib4fv(index, v);

            break;

        }

    }

    VertexAttribValue& attribValue = m_vertexAttribValue[index];

    attribValue.initValue();

    for (int ii = 0; ii < expectedSize; ++ii)

        attribValue.value[ii] = v[ii];

}

void WebGLRenderingContextBase::initVertexAttrib0()

{

    WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    m_vertexAttrib0Buffer = createBuffer();

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, 0, GraphicsContext3D::DYNAMIC_DRAW);

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, false, 0, 0);

    state.bufferBinding = m_vertexAttrib0Buffer;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, 0);

    m_context->enableVertexAttribArray(0);

    m_vertexAttrib0BufferSize = 0;

    m_vertexAttrib0BufferValue[0] = 0.0f;

    m_vertexAttrib0BufferValue[1] = 0.0f;

    m_vertexAttrib0BufferValue[2] = 0.0f;

    m_vertexAttrib0BufferValue[3] = 1.0f;

    m_forceAttrib0BufferRefill = false;

    m_vertexAttrib0UsedBefore = false;

}

bool WebGLRenderingContextBase::simulateVertexAttrib0(GC3Dsizei numVertex)

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    const VertexAttribValue& attribValue = m_vertexAttribValue[0];

    if (!m_currentProgram)

        return false;

    bool usingVertexAttrib0 = m_currentProgram->isUsingVertexAttrib0();

    if (usingVertexAttrib0)

        m_vertexAttrib0UsedBefore = true;

    if (state.enabled && usingVertexAttrib0)

        return false;

    if (!usingVertexAttrib0 && !m_vertexAttrib0UsedBefore)

        return false;

    m_vertexAttrib0UsedBefore = true;

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, m_vertexAttrib0Buffer->object());

    GC3Dsizeiptr bufferDataSize = (numVertex + 1) * 4 * sizeof(GC3Dfloat);

    if (bufferDataSize > m_vertexAttrib0BufferSize) {

        m_context->bufferData(GraphicsContext3D::ARRAY_BUFFER, bufferDataSize, 0, GraphicsContext3D::DYNAMIC_DRAW);

        m_vertexAttrib0BufferSize = bufferDataSize;

        m_forceAttrib0BufferRefill = true;

    }

    if (usingVertexAttrib0

        && (m_forceAttrib0BufferRefill

            || attribValue.value[0] != m_vertexAttrib0BufferValue[0]

            || attribValue.value[1] != m_vertexAttrib0BufferValue[1]

            || attribValue.value[2] != m_vertexAttrib0BufferValue[2]

            || attribValue.value[3] != m_vertexAttrib0BufferValue[3])) {

            auto bufferData = std::make_unique<GC3Dfloat[]>((numVertex + 1) * 4);

            for (GC3Dsizei ii = 0; ii < numVertex + 1; ++ii) {

                bufferData[ii * 4] = attribValue.value[0];

                bufferData[ii * 4 + 1] = attribValue.value[1];

                bufferData[ii * 4 + 2] = attribValue.value[2];

                bufferData[ii * 4 + 3] = attribValue.value[3];

            }

            m_vertexAttrib0BufferValue[0] = attribValue.value[0];

            m_vertexAttrib0BufferValue[1] = attribValue.value[1];

            m_vertexAttrib0BufferValue[2] = attribValue.value[2];

            m_vertexAttrib0BufferValue[3] = attribValue.value[3];

            m_forceAttrib0BufferRefill = false;

            m_context->bufferSubData(GraphicsContext3D::ARRAY_BUFFER, 0, bufferDataSize, bufferData.get());

        }

    m_context->vertexAttribPointer(0, 4, GraphicsContext3D::FLOAT, 0, 0, 0);

    return true;

}

void WebGLRenderingContextBase::restoreStatesAfterVertexAttrib0Simulation()

{

    const WebGLVertexArrayObjectOES::VertexAttribState& state = m_boundVertexArrayObject->getVertexAttribState(0);

    if (state.bufferBinding != m_vertexAttrib0Buffer) {

        m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(state.bufferBinding.get()));

        m_context->vertexAttribPointer(0, state.size, state.type, state.normalized, state.originalStride, state.offset);

    }

    m_context->bindBuffer(GraphicsContext3D::ARRAY_BUFFER, objectOrZero(m_boundArrayBuffer.get()));

}

void WebGLRenderingContextBase::dispatchContextLostEvent()

{

    RefPtr<WebGLContextEvent> event = WebGLContextEvent::create(eventNames().webglcontextlostEvent, false, true, "");

    canvas()->dispatchEvent(event);

    m_restoreAllowed = event->defaultPrevented();

    if (m_contextLostMode == RealLostContext && m_restoreAllowed)

        m_restoreTimer.startOneShot(0);

}

void WebGLRenderingContextBase::maybeRestoreContext()

{

    ASSERT(m_contextLost);

    if (!m_contextLost)

        return;

    // The rendering context is not restored unless the default behavior of the

    // webglcontextlost event was prevented earlier.

    //

    // Because of the way m_restoreTimer is set up for real vs. synthetic lost

    // context events, we don't have to worry about this test short-circuiting

    // the retry loop for real context lost events.

    if (!m_restoreAllowed)

        return;

    int contextLostReason = m_context->getExtensions()->getGraphicsResetStatusARB();

    switch (contextLostReason) {

    case GraphicsContext3D::NO_ERROR:

        // The GraphicsContext3D implementation might not fully

        // support GL_ARB_robustness semantics yet. Alternatively, the

        // WEBGL_lose_context extension might have been used to force

        // a lost context.

        break;

    case Extensions3D::GUILTY_CONTEXT_RESET_ARB:

        // The rendering context is not restored if this context was

        // guilty of causing the graphics reset.

        printWarningToConsole("WARNING: WebGL content on the page caused the graphics card to reset; not restoring the context");

        return;

    case Extensions3D::INNOCENT_CONTEXT_RESET_ARB:

        // Always allow the context to be restored.

        break;

    case Extensions3D::UNKNOWN_CONTEXT_RESET_ARB:

        // Warn. Ideally, prompt the user telling them that WebGL

        // content on the page might have caused the graphics card to

        // reset and ask them whether they want to continue running

        // the content. Only if they say "yes" should we start

        // attempting to restore the context.

        printWarningToConsole("WARNING: WebGL content on the page might have caused the graphics card to reset");

        break;

    }

    Frame* frame = canvas()->document().frame();

    if (!frame)

        return;

    if (!frame->loader().client().allowWebGL(frame->settings().webGLEnabled()))

        return;

    FrameView* view = frame->view();

    if (!view)

        return;

    ScrollView* root = view->root();

    if (!root)

        return;

    HostWindow* hostWindow = root->hostWindow();

    if (!hostWindow)

        return;

    RefPtr<GraphicsContext3D> context(GraphicsContext3D::create(m_attributes, hostWindow));

    if (!context) {

        if (m_contextLostMode == RealLostContext)

            m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts);

        else

            // This likely shouldn't happen but is the best way to report it to the WebGL app.

            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "", "error restoring context");

        return;

    }

    // Construct a new drawing buffer with the new GraphicsContext3D.

    if (m_drawingBuffer) {

        m_drawingBuffer->discardResources();

        DrawingBuffer::PreserveDrawingBuffer preserve = m_attributes.preserveDrawingBuffer ? DrawingBuffer::Preserve : DrawingBuffer::Discard;

        DrawingBuffer::AlphaRequirement alpha = m_attributes.alpha ? DrawingBuffer::Alpha : DrawingBuffer::Opaque;

        m_drawingBuffer = DrawingBuffer::create(context.get(), m_drawingBuffer->size(), preserve, alpha);

        m_drawingBuffer->bind();

    }

    m_context = context;

    m_contextLost = false;

    setupFlags();

    initializeNewContext();

    canvas()->dispatchEvent(WebGLContextEvent::create(eventNames().webglcontextrestoredEvent, false, true, ""));

}

String WebGLRenderingContextBase::ensureNotNull(const String& text) const

{

    if (text.isNull())

        return WTF::emptyString();

    return text;

}

WebGLRenderingContextBase::LRUImageBufferCache::LRUImageBufferCache(int capacity)

    : m_buffers(std::make_unique<std::unique_ptr<ImageBuffer>[]>(capacity))

    , m_capacity(capacity)

{

}

ImageBuffer* WebGLRenderingContextBase::LRUImageBufferCache::imageBuffer(const IntSize& size)

{

    int i;

    for (i = 0; i < m_capacity; ++i) {

        ImageBuffer* buf = m_buffers[i].get();

        if (!buf)

            break;

        if (buf->logicalSize() != size)

            continue;

        bubbleToFront(i);

        return buf;

    }

    std::unique_ptr<ImageBuffer> temp = ImageBuffer::create(size, 1);

    if (!temp)

        return nullptr;

    i = std::min(m_capacity - 1, i);

    m_buffers[i] = WTF::move(temp);

    ImageBuffer* buf = m_buffers[i].get();

    bubbleToFront(i);

    return buf;

}

void WebGLRenderingContextBase::LRUImageBufferCache::bubbleToFront(int idx)

{

    for (int i = idx; i > 0; --i)

        m_buffers[i].swap(m_buffers[i-1]);

}

namespace {

    String GetErrorString(GC3Denum error)

    {

        switch (error) {

        case GraphicsContext3D::INVALID_ENUM:

            return "INVALID_ENUM";

        case GraphicsContext3D::INVALID_VALUE:

            return "INVALID_VALUE";

        case GraphicsContext3D::INVALID_OPERATION:

            return "INVALID_OPERATION";

        case GraphicsContext3D::OUT_OF_MEMORY:

            return "OUT_OF_MEMORY";

        case GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION:

            return "INVALID_FRAMEBUFFER_OPERATION";

        case GraphicsContext3D::CONTEXT_LOST_WEBGL:

            return "CONTEXT_LOST_WEBGL";

        default:

            return String::format("WebGL ERROR(%04x)", error);

        }

    }

} // namespace anonymous

void WebGLRenderingContextBase::synthesizeGLError(GC3Denum error, const char* functionName, const char* description, ConsoleDisplayPreference display)

{

    if (m_synthesizedErrorsToConsole && display == DisplayInConsole) {

        String str = String("WebGL: ") + GetErrorString(error) +  ": " + String(functionName) + ": " + String(description);

        printGLErrorToConsole(str);

    }

    m_context->synthesizeGLError(error);

}

void WebGLRenderingContextBase::printGLWarningToConsole(const char* functionName, const char* description)

{

    if (m_synthesizedErrorsToConsole) {

        String str = String("WebGL: ") + String(functionName) + ": " + String(description);

        printGLErrorToConsole(str);

    }

}

void WebGLRenderingContextBase::applyStencilTest()

{

    bool haveStencilBuffer = false;

    if (m_framebufferBinding)

        haveStencilBuffer = m_framebufferBinding->hasStencilBuffer();

    else {

        RefPtr<WebGLContextAttributes> attributes = getContextAttributes();

        haveStencilBuffer = attributes->stencil();

    }

    enableOrDisable(GraphicsContext3D::STENCIL_TEST,

                    m_stencilEnabled && haveStencilBuffer);

}

void WebGLRenderingContextBase::enableOrDisable(GC3Denum capability, bool enable)

{

    if (enable)

        m_context->enable(capability);

    else

        m_context->disable(capability);

}

IntSize WebGLRenderingContextBase::clampedCanvasSize()

{

    return IntSize(clamp(canvas()->width(), 1, m_maxViewportDims[0]),

                   clamp(canvas()->height(), 1, m_maxViewportDims[1]));

}

GC3Dint WebGLRenderingContextBase::getMaxDrawBuffers()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxDrawBuffers)

        m_context->getIntegerv(Extensions3D::MAX_DRAW_BUFFERS_EXT, &m_maxDrawBuffers);

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    // WEBGL_draw_buffers requires MAX_COLOR_ATTACHMENTS >= MAX_DRAW_BUFFERS.

    return std::min(m_maxDrawBuffers, m_maxColorAttachments);

}

GC3Dint WebGLRenderingContextBase::getMaxColorAttachments()

{

    if (!supportsDrawBuffers())

        return 0;

    if (!m_maxColorAttachments)

        m_context->getIntegerv(Extensions3D::MAX_COLOR_ATTACHMENTS_EXT, &m_maxColorAttachments);

    return m_maxColorAttachments;

}

void WebGLRenderingContextBase::setBackDrawBuffer(GC3Denum buf)

{

    m_backDrawBuffer = buf;

}

void WebGLRenderingContextBase::restoreCurrentFramebuffer()

{

    ExceptionCode ec;

    bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_framebufferBinding.get(), ec);

}

void WebGLRenderingContextBase::restoreCurrentTexture2D()

{

    ExceptionCode ec;

    bindTexture(GraphicsContext3D::TEXTURE_2D, m_textureUnits[m_activeTextureUnit].texture2DBinding.get(), ec);

}

bool WebGLRenderingContextBase::supportsDrawBuffers()

{

    if (!m_drawBuffersWebGLRequirementsChecked) {

        m_drawBuffersWebGLRequirementsChecked = true;

        m_drawBuffersSupported = WebGLDrawBuffers::supported(this);

    }

    return m_drawBuffersSupported;

}

void WebGLRenderingContextBase::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    if (!validateDrawArrays("drawArraysInstanced", mode, first, count, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant())

        vertexAttrib0Simulated = simulateVertexAttrib0(first + count - 1);

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", true);

    m_context->drawArraysInstanced(mode, first, count, primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawArraysInstanced", false);

    markContextChanged();

}

void WebGLRenderingContextBase::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, long long offset, GC3Dsizei primcount)

{

    if (!primcount) {

        markContextChanged();

        return;

    }

    unsigned numElements = 0;

    if (!validateDrawElements("drawElementsInstanced", mode, count, type, offset, numElements, primcount))

        return;

    clearIfComposited();

    bool vertexAttrib0Simulated = false;

    if (!isGLES2Compliant()) {

        if (!numElements)

            validateIndexArrayPrecise(count, type, static_cast<GC3Dintptr>(offset), numElements);

        vertexAttrib0Simulated = simulateVertexAttrib0(numElements);

    }

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", true);

    m_context->drawElementsInstanced(mode, count, type, static_cast<GC3Dintptr>(offset), primcount);

    if (!isGLES2Compliant() && vertexAttrib0Simulated)

        restoreStatesAfterVertexAttrib0Simulation();

    if (!isGLES2NPOTStrict())

        checkTextureCompleteness("drawElementsInstanced", false);

    markContextChanged();

}

void WebGLRenderingContextBase::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)

{

    if (isContextLostOrPending())

        return;

    if (index >= m_maxVertexAttribs) {

        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "vertexAttribDivisor", "index out of range");

        return;

    }

    m_boundVertexArrayObject->setVertexAttribDivisor(index, divisor);

    m_context->vertexAttribDivisor(index, divisor);

}

} // namespace WebCore

#endif // ENABLE(WEBGL)