webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 1830 insertions, 0 deletions

diff --git a/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp b/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp
new file mode 100644
index 000000000..92eefac0c
--- /dev/null
+++ b/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp
@@ -0,0 +1,1830 @@
+/*
+ * Copyright (C) 2015-2017 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"
+#include "WebGL2RenderingContext.h"
+
+#if ENABLE(WEBGL2)
+
+#include "CachedImage.h"
+#include "EXTTextureFilterAnisotropic.h"
+#include "Extensions3D.h"
+#include "HTMLCanvasElement.h"
+#include "HTMLImageElement.h"
+#include "HTMLVideoElement.h"
+#include "ImageData.h"
+#include "OESTextureFloat.h"
+#include "OESTextureFloatLinear.h"
+#include "OESTextureHalfFloat.h"
+#include "OESTextureHalfFloatLinear.h"
+#include "RenderBox.h"
+#include "WebGLActiveInfo.h"
+#include "WebGLCompressedTextureATC.h"
+#include "WebGLCompressedTexturePVRTC.h"
+#include "WebGLCompressedTextureS3TC.h"
+#include "WebGLDebugRendererInfo.h"
+#include "WebGLDebugShaders.h"
+#include "WebGLDepthTexture.h"
+#include "WebGLLoseContext.h"
+#include "WebGLQuery.h"
+#include "WebGLSampler.h"
+#include "WebGLSync.h"
+#include "WebGLTransformFeedback.h"
+#include "WebGLVertexArrayObject.h"
+#include <JavaScriptCore/GenericTypedArrayViewInlines.h>
+#include <JavaScriptCore/JSGenericTypedArrayViewInlines.h>
+
+namespace WebCore {
+
+WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement& passedCanvas, GraphicsContext3DAttributes attributes)
+    : WebGLRenderingContextBase(passedCanvas, attributes)
+{
+}
+
+WebGL2RenderingContext::WebGL2RenderingContext(HTMLCanvasElement& passedCanvas, Ref<GraphicsContext3D>&& context, GraphicsContext3DAttributes attributes)
+    : WebGLRenderingContextBase(passedCanvas, WTFMove(context), attributes)
+{
+    initializeShaderExtensions();
+    initializeVertexArrayObjects();
+}
+
+void WebGL2RenderingContext::initializeVertexArrayObjects()
+{
+    m_defaultVertexArrayObject = WebGLVertexArrayObject::create(*this, WebGLVertexArrayObject::Type::Default);
+    addContextObject(*m_defaultVertexArrayObject);
+    m_boundVertexArrayObject = m_defaultVertexArrayObject;
+    if (!isGLES2Compliant())
+        initVertexAttrib0();
+}
+
+void WebGL2RenderingContext::initializeShaderExtensions()
+{
+    m_context->getExtensions().ensureEnabled("GL_OES_standard_derivatives");
+    m_context->getExtensions().ensureEnabled("GL_EXT_draw_buffers");
+    m_context->getExtensions().ensureEnabled("GL_EXT_shader_texture_lod");
+    m_context->getExtensions().ensureEnabled("GL_EXT_frag_depth");
+}
+
+inline static std::optional<unsigned> arrayBufferViewElementSize(const ArrayBufferView& data)
+{
+    switch (data.getType()) {
+    case JSC::NotTypedArray:
+    case JSC::TypeDataView:
+        return std::nullopt;
+    case JSC::TypeInt8:
+    case JSC::TypeUint8:
+    case JSC::TypeUint8Clamped:
+    case JSC::TypeInt16:
+    case JSC::TypeUint16:
+    case JSC::TypeInt32:
+    case JSC::TypeUint32:
+    case JSC::TypeFloat32:
+    case JSC::TypeFloat64:
+        return elementSize(data.getType());
+    }
+}
+
+void WebGL2RenderingContext::bufferData(GC3Denum target, const ArrayBufferView& data, GC3Denum usage, GC3Duint srcOffset, GC3Duint length)
+{
+    auto optionalElementSize = arrayBufferViewElementSize(data);
+    if (!optionalElementSize) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bufferData", "Invalid type of Array Buffer View");
+        return;
+    }
+    auto elementSize = optionalElementSize.value();
+    Checked<GC3Duint, RecordOverflow> checkedElementSize(elementSize);
+
+    Checked<GC3Duint, RecordOverflow> checkedSrcOffset(srcOffset);
+    Checked<GC3Duint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
+    Checked<GC3Duint, RecordOverflow> checkedlength(length);
+    Checked<GC3Duint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
+
+    if (checkedByteSrcOffset.hasOverflowed()
+        || checkedByteLength.hasOverflowed()
+        || checkedByteSrcOffset.unsafeGet() > data.byteLength()
+        || checkedByteLength.unsafeGet() > data.byteLength() - checkedByteSrcOffset.unsafeGet()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferData", "srcOffset or length is out of bounds");
+        return;
+    }
+
+    auto slice = Uint8Array::create(data.possiblySharedBuffer(), data.byteOffset() + checkedByteSrcOffset.unsafeGet(), checkedByteLength.unsafeGet());
+    if (!slice) {
+        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "bufferData", "Could not create intermediate ArrayBufferView");
+        return;
+    }
+    WebGLRenderingContextBase::bufferData(target, BufferDataSource(slice.get()), usage);
+}
+
+void WebGL2RenderingContext::bufferSubData(GC3Denum target, long long offset, const ArrayBufferView& data, GC3Duint srcOffset, GC3Duint length)
+{
+    auto optionalElementSize = arrayBufferViewElementSize(data);
+    if (!optionalElementSize) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "bufferSubData", "Invalid type of Array Buffer View");
+        return;
+    }
+    auto elementSize = optionalElementSize.value();
+    Checked<GC3Duint, RecordOverflow> checkedElementSize(elementSize);
+
+    Checked<GC3Duint, RecordOverflow> checkedSrcOffset(srcOffset);
+    Checked<GC3Duint, RecordOverflow> checkedByteSrcOffset = checkedSrcOffset * checkedElementSize;
+    Checked<GC3Duint, RecordOverflow> checkedlength(length);
+    Checked<GC3Duint, RecordOverflow> checkedByteLength = checkedlength * checkedElementSize;
+
+    if (checkedByteSrcOffset.hasOverflowed()
+        || checkedByteLength.hasOverflowed()
+        || checkedByteSrcOffset.unsafeGet() > data.byteLength()
+        || checkedByteLength.unsafeGet() > data.byteLength() - checkedByteSrcOffset.unsafeGet()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "bufferSubData", "srcOffset or length is out of bounds");
+        return;
+    }
+
+    auto slice = Uint8Array::create(data.possiblySharedBuffer(), data.byteOffset() + checkedByteSrcOffset.unsafeGet(), checkedByteLength.unsafeGet());
+    if (!slice) {
+        synthesizeGLError(GraphicsContext3D::OUT_OF_MEMORY, "bufferSubData", "Could not create intermediate ArrayBufferView");
+        return;
+    }
+
+    WebGLRenderingContextBase::bufferSubData(target, offset, BufferDataSource(slice.get()));
+}
+
+void WebGL2RenderingContext::copyBufferSubData(GC3Denum readTarget, GC3Denum writeTarget, GC3Dint64 readOffset, GC3Dint64 writeOffset, GC3Dint64 size)
+{
+    if (isContextLostOrPending())
+        return;
+    if ((readTarget == GraphicsContext3D::ELEMENT_ARRAY_BUFFER && writeTarget != GraphicsContext3D::ELEMENT_ARRAY_BUFFER)
+        || (writeTarget == GraphicsContext3D::ELEMENT_ARRAY_BUFFER && readTarget != GraphicsContext3D::ELEMENT_ARRAY_BUFFER)) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "copyBufferSubData", "Either both targets need to be ELEMENT_ARRAY_BUFFER or neither should be ELEMENT_ARRAY_BUFFER.");
+        return;
+    }
+    if (readOffset < 0 || writeOffset < 0 || size < 0) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyBufferSubData", "offset < 0");
+        return;
+    }
+    WebGLBuffer* readBuffer = validateBufferDataParameters("copyBufferSubData", readTarget, GraphicsContext3D::STATIC_DRAW);
+    WebGLBuffer* writeBuffer = validateBufferDataParameters("copyBufferSubData", writeTarget, GraphicsContext3D::STATIC_DRAW);
+    if (!readBuffer || !writeBuffer) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyBufferSubData", "Invalid readTarget or writeTarget");
+        return;
+    }
+
+    Checked<GC3Dintptr, RecordOverflow> checkedReadOffset(readOffset);
+    Checked<GC3Dintptr, RecordOverflow> checkedWriteOffset(writeOffset);
+    Checked<GC3Dsizeiptr, RecordOverflow> checkedSize(size);
+    if (checkedReadOffset.hasOverflowed() || checkedWriteOffset.hasOverflowed() || checkedSize.hasOverflowed()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyBufferSubData", "Offset or size is too big");
+        return;
+    }
+
+    if (!writeBuffer->associateCopyBufferSubData(*readBuffer, checkedReadOffset.unsafeGet(), checkedWriteOffset.unsafeGet(), checkedSize.unsafeGet())) {
+        this->synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "copyBufferSubData", "offset out of range");
+        return;
+    }
+
+    m_context->moveErrorsToSyntheticErrorList();
+#if PLATFORM(COCOA)
+    m_context->copyBufferSubData(readTarget, writeTarget, checkedReadOffset.unsafeGet(), checkedWriteOffset.unsafeGet(), checkedSize.unsafeGet());
+#endif
+    if (m_context->moveErrorsToSyntheticErrorList()) {
+        // The bufferSubData function failed. Tell the buffer it doesn't have the data it thinks it does.
+        writeBuffer->disassociateBufferData();
+    }
+}
+
+void WebGL2RenderingContext::getBufferSubData(GC3Denum target, long long srcByteOffset, RefPtr<ArrayBufferView>&& dstData, GC3Duint dstOffset, GC3Duint length)
+{
+    if (isContextLostOrPending())
+        return;
+    WebGLBuffer* buffer = validateBufferDataParameters("bufferSubData", target, GraphicsContext3D::STATIC_DRAW);
+    if (!buffer) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "No WebGLBuffer is bound to target");
+        return;
+    }
+
+    // FIXME: Implement "If target is TRANSFORM_FEEDBACK_BUFFER, and any transform feedback object is currently active, an INVALID_OPERATION error is generated."
+
+    if (!dstData) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "Null dstData");
+        return;
+    }
+
+    auto optionalElementSize = arrayBufferViewElementSize(*dstData);
+    if (!optionalElementSize) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "Invalid type of Array Buffer View");
+        return;
+    }
+    auto elementSize = optionalElementSize.value();
+    auto dstDataLength = dstData->byteLength() / elementSize;
+
+    if (dstOffset > dstDataLength) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "dstOffset is larger than the length of the destination buffer.");
+        return;
+    }
+
+    GC3Duint copyLength = length ? length : dstDataLength - dstOffset;
+
+    Checked<GC3Duint, RecordOverflow> checkedDstOffset(dstOffset);
+    Checked<GC3Duint, RecordOverflow> checkedCopyLength(copyLength);
+    auto checkedDestinationEnd = checkedDstOffset + checkedCopyLength;
+    if (checkedDestinationEnd.hasOverflowed()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "dstOffset + copyLength is too high");
+        return;
+    }
+
+    if (checkedDestinationEnd.unsafeGet() > dstDataLength) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "end of written destination is past the end of the buffer");
+        return;
+    }
+
+    if (srcByteOffset < 0) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "srcByteOffset is less than 0");
+        return;
+    }
+
+    Checked<GC3Dintptr, RecordOverflow> checkedSrcByteOffset(srcByteOffset);
+    Checked<GC3Dintptr, RecordOverflow> checkedCopyLengthPtr(copyLength);
+    Checked<GC3Dintptr, RecordOverflow> checkedElementSize(elementSize);
+    auto checkedSourceEnd = checkedSrcByteOffset + checkedCopyLengthPtr * checkedElementSize;
+    if (checkedSourceEnd.hasOverflowed() || checkedSourceEnd.unsafeGet() > buffer->byteLength()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getBufferSubData", "Parameters would read outside the bounds of the source buffer");
+        return;
+    }
+
+    m_context->moveErrorsToSyntheticErrorList();
+#if PLATFORM(COCOA)
+    // FIXME: Coalesce multiple getBufferSubData() calls to use a single map() call
+    void* ptr = m_context->mapBufferRange(target, checkedSrcByteOffset.unsafeGet(), static_cast<GC3Dsizeiptr>(checkedCopyLengthPtr.unsafeGet() * checkedElementSize.unsafeGet()), GraphicsContext3D::MAP_READ_BIT);
+    memcpy(static_cast<char*>(dstData->baseAddress()) + dstData->byteOffset() + dstOffset * elementSize, ptr, copyLength * elementSize);
+    bool success = m_context->unmapBuffer(target);
+    ASSERT_UNUSED(success, success);
+#endif
+    m_context->moveErrorsToSyntheticErrorList();
+}
+
+void WebGL2RenderingContext::blitFramebuffer(GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dbitfield, GC3Denum)
+{
+}
+
+void WebGL2RenderingContext::framebufferTextureLayer(GC3Denum, GC3Denum, GC3Duint, GC3Dint, GC3Dint)
+{
+}
+
+WebGLAny WebGL2RenderingContext::getInternalformatParameter(GC3Denum, GC3Denum, GC3Denum)
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::invalidateFramebuffer(GC3Denum, const Vector<GC3Denum>&)
+{
+}
+
+void WebGL2RenderingContext::invalidateSubFramebuffer(GC3Denum, const Vector<GC3Denum>&, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei)
+{
+}
+
+void WebGL2RenderingContext::readBuffer(GC3Denum)
+{
+}
+
+void WebGL2RenderingContext::renderbufferStorageMultisample(GC3Denum, GC3Dsizei, GC3Denum, GC3Dsizei, GC3Dsizei)
+{
+}
+
+bool WebGL2RenderingContext::validateTexStorageFuncParameters(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height, const char* functionName)
+{
+    if (width < 0 || height < 0) {
+        synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width or height < 0");
+        return false;
+    }
+
+    if (width > m_maxTextureSize || height > m_maxTextureSize) {
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "texture dimensions are larger than the maximum texture size");
+        return false;
+    }
+
+    if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {
+        if (width != height) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, functionName, "width != height for cube map");
+            return false;
+        }
+    } else if (target != GraphicsContext3D::TEXTURE_2D) {
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid target");
+        return false;
+    }
+
+    if (levels < 0 || levels > m_maxTextureLevel) {
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "number of levels is out of bounds");
+        return false;
+    }
+
+    switch (internalFormat) {
+    case GraphicsContext3D::R8:
+    case GraphicsContext3D::R8_SNORM:
+    case GraphicsContext3D::R16F:
+    case GraphicsContext3D::R32F:
+    case GraphicsContext3D::R8UI:
+    case GraphicsContext3D::R8I:
+    case GraphicsContext3D::R16UI:
+    case GraphicsContext3D::R16I:
+    case GraphicsContext3D::R32UI:
+    case GraphicsContext3D::R32I:
+    case GraphicsContext3D::RG8:
+    case GraphicsContext3D::RG8_SNORM:
+    case GraphicsContext3D::RG16F:
+    case GraphicsContext3D::RG32F:
+    case GraphicsContext3D::RG8UI:
+    case GraphicsContext3D::RG8I:
+    case GraphicsContext3D::RG16UI:
+    case GraphicsContext3D::RG16I:
+    case GraphicsContext3D::RG32UI:
+    case GraphicsContext3D::RG32I:
+    case GraphicsContext3D::RGB8:
+    case GraphicsContext3D::SRGB8:
+    case GraphicsContext3D::RGB565:
+    case GraphicsContext3D::RGB8_SNORM:
+    case GraphicsContext3D::R11F_G11F_B10F:
+    case GraphicsContext3D::RGB9_E5:
+    case GraphicsContext3D::RGB16F:
+    case GraphicsContext3D::RGB32F:
+    case GraphicsContext3D::RGB8UI:
+    case GraphicsContext3D::RGB8I:
+    case GraphicsContext3D::RGB16UI:
+    case GraphicsContext3D::RGB16I:
+    case GraphicsContext3D::RGB32UI:
+    case GraphicsContext3D::RGB32I:
+    case GraphicsContext3D::RGBA8:
+    case GraphicsContext3D::SRGB8_ALPHA8:
+    case GraphicsContext3D::RGBA8_SNORM:
+    case GraphicsContext3D::RGB5_A1:
+    case GraphicsContext3D::RGBA4:
+    case GraphicsContext3D::RGB10_A2:
+    case GraphicsContext3D::RGBA16F:
+    case GraphicsContext3D::RGBA32F:
+    case GraphicsContext3D::RGBA8UI:
+    case GraphicsContext3D::RGBA8I:
+    case GraphicsContext3D::RGB10_A2UI:
+    case GraphicsContext3D::RGBA16UI:
+    case GraphicsContext3D::RGBA16I:
+    case GraphicsContext3D::RGBA32I:
+    case GraphicsContext3D::RGBA32UI:
+    case GraphicsContext3D::DEPTH_COMPONENT16:
+    case GraphicsContext3D::DEPTH_COMPONENT24:
+    case GraphicsContext3D::DEPTH_COMPONENT32F:
+    case GraphicsContext3D::DEPTH24_STENCIL8:
+    case GraphicsContext3D::DEPTH32F_STENCIL8:
+        break;
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "Unknown internalFormat");
+        return false;
+    }
+
+    return true;
+}
+
+void WebGL2RenderingContext::texStorage2D(GC3Denum target, GC3Dsizei levels, GC3Denum internalFormat, GC3Dsizei width, GC3Dsizei height)
+{
+    if (isContextLostOrPending())
+        return;
+
+    auto* texture = validateTextureBinding("texStorage2D", target, false);
+    if (!texture)
+        return;
+
+    if (!validateTexStorageFuncParameters(target, levels, internalFormat, width, height, "texStorage2D"))
+        return;
+
+    if (!validateNPOTTextureLevel(width, height, levels, "texStorage2D"))
+        return;
+
+    if (texture->immutable()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "texStorage2D", "texStorage2D already called on this texture");
+        return;
+    }
+    texture->setImmutable();
+
+    m_context->texStorage2D(target, levels, internalFormat, width, height);
+
+    {
+        GC3Denum format;
+        GC3Denum type;
+        if (!GraphicsContext3D::possibleFormatAndTypeForInternalFormat(internalFormat, format, type)) {
+            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "texStorage2D", "Texture has unknown internal format");
+            return;
+        }
+
+        GC3Dsizei levelWidth = width;
+        GC3Dsizei levelHeight = height;
+
+        unsigned size;
+        GC3Denum error = m_context->computeImageSizeInBytes(format, type, width, height, m_unpackAlignment, &size, nullptr);
+        if (error != GraphicsContext3D::NO_ERROR) {
+            synthesizeGLError(error, "texStorage2D", "bad dimensions");
+            return;
+        }
+
+        Vector<char> data(size);
+        memset(data.data(), 0, size);
+
+        for (GC3Dsizei level = 0; level < levels; ++level) {
+            if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+                m_context->texSubImage2D(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+            } else
+                m_context->texSubImage2D(target, level, 0, 0, levelWidth, levelHeight, format, type, data.data());
+            levelWidth = std::max(1, levelWidth / 2);
+            levelHeight = std::max(1, levelHeight / 2);
+        }
+    }
+
+    for (GC3Dsizei level = 0; level < levels; ++level) {
+        if (target == GraphicsContext3D::TEXTURE_CUBE_MAP) {
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_X, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_X, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Y, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Y, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_POSITIVE_Z, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+            texture->setLevelInfo(GraphicsContext3D::TEXTURE_CUBE_MAP_NEGATIVE_Z, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+        } else
+            texture->setLevelInfo(target, level, internalFormat, width, height, GraphicsContext3D::UNSIGNED_BYTE);
+    }
+}
+
+void WebGL2RenderingContext::texStorage3D(GC3Denum, GC3Dsizei, GC3Denum, GC3Dsizei, GC3Dsizei, GC3Dsizei)
+{
+}
+
+void WebGL2RenderingContext::texImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&)
+{
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Denum, RefPtr<ArrayBufferView>&&)
+{
+}
+
+void WebGL2RenderingContext::texSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Denum, GC3Denum, TexImageSource&&)
+{
+}
+
+void WebGL2RenderingContext::copyTexSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei)
+{
+}
+
+void WebGL2RenderingContext::compressedTexImage3D(GC3Denum, GC3Dint, GC3Denum, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Dint, GC3Dsizei, RefPtr<ArrayBufferView>&&)
+{
+}
+
+void WebGL2RenderingContext::compressedTexSubImage3D(GC3Denum, GC3Dint, GC3Dint, GC3Dint, GC3Dint, GC3Dsizei, GC3Dsizei, GC3Dsizei, GC3Denum, GC3Dsizei, RefPtr<ArrayBufferView>&&)
+{
+}
+
+GC3Dint WebGL2RenderingContext::getFragDataLocation(WebGLProgram*, const String&)
+{
+    return 0;
+}
+
+void WebGL2RenderingContext::uniform1ui(WebGLUniformLocation*, GC3Duint)
+{
+}
+
+void WebGL2RenderingContext::uniform2ui(WebGLUniformLocation*, GC3Duint, GC3Duint)
+{
+}
+
+void WebGL2RenderingContext::uniform3ui(WebGLUniformLocation*, GC3Duint, GC3Duint, GC3Duint)
+{
+}
+
+void WebGL2RenderingContext::uniform4ui(WebGLUniformLocation*, GC3Duint, GC3Duint, GC3Duint, GC3Duint)
+{
+}
+
+void WebGL2RenderingContext::uniform1uiv(WebGLUniformLocation*, RefPtr<Uint32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniform2uiv(WebGLUniformLocation*, RefPtr<Uint32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniform3uiv(WebGLUniformLocation*, RefPtr<Uint32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniform4uiv(WebGLUniformLocation*, RefPtr<Uint32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix2x3fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix3x2fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix2x4fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix4x2fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix3x4fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::uniformMatrix4x3fv(WebGLUniformLocation*, GC3Dboolean, RefPtr<Float32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::vertexAttribI4i(GC3Duint, GC3Dint, GC3Dint, GC3Dint, GC3Dint)
+{
+}
+
+void WebGL2RenderingContext::vertexAttribI4iv(GC3Duint, RefPtr<Int32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::vertexAttribI4ui(GC3Duint, GC3Duint, GC3Duint, GC3Duint, GC3Duint)
+{
+}
+
+void WebGL2RenderingContext::vertexAttribI4uiv(GC3Duint, RefPtr<Uint32Array>&&)
+{
+}
+
+void WebGL2RenderingContext::vertexAttribIPointer(GC3Duint, GC3Dint, GC3Denum, GC3Dsizei, GC3Dint64)
+{
+}
+
+void WebGL2RenderingContext::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;
+    }
+    if (m_framebufferBinding && (mask & GraphicsContext3D::COLOR_BUFFER_BIT) && isIntegerFormat(m_framebufferBinding->getColorBufferFormat())) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clear", "cannot clear an integer buffer");
+        return;
+    }
+    const char* reason = "framebuffer incomplete";
+    if (m_framebufferBinding && !m_framebufferBinding->onAccess(graphicsContext3D(), &reason)) {
+        synthesizeGLError(GraphicsContext3D::INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
+        return;
+    }
+    if (!clearIfComposited(mask))
+        m_context->clear(mask);
+    markContextChanged();
+}
+
+void WebGL2RenderingContext::vertexAttribDivisor(GC3Duint index, GC3Duint divisor)
+{
+    if (isContextLostOrPending())
+        return;
+    
+    WebGLRenderingContextBase::vertexAttribDivisor(index, divisor);
+}
+
+void WebGL2RenderingContext::drawArraysInstanced(GC3Denum mode, GC3Dint first, GC3Dsizei count, GC3Dsizei instanceCount)
+{
+    if (isContextLostOrPending())
+        return;
+
+    WebGLRenderingContextBase::drawArraysInstanced(mode, first, count, instanceCount);
+}
+
+void WebGL2RenderingContext::drawElementsInstanced(GC3Denum mode, GC3Dsizei count, GC3Denum type, GC3Dint64 offset, GC3Dsizei instanceCount)
+{
+    if (isContextLostOrPending())
+        return;
+
+    WebGLRenderingContextBase::drawElementsInstanced(mode, count, type, offset, instanceCount);
+}
+
+void WebGL2RenderingContext::drawRangeElements(GC3Denum, GC3Duint, GC3Duint, GC3Dsizei, GC3Denum, GC3Dint64)
+{
+}
+
+void WebGL2RenderingContext::drawBuffers(const Vector<GC3Denum>& buffers)
+{
+    if (isContextLost())
+        return;
+    GC3Dsizei n = buffers.size();
+    const GC3Denum* bufs = buffers.data();
+    if (!m_framebufferBinding) {
+        if (n != 1) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawBuffers", "more than one buffer");
+            return;
+        }
+        if (bufs[0] != GraphicsContext3D::BACK && bufs[0] != GraphicsContext3D::NONE) {
+            synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "drawBuffers", "BACK or NONE");
+            return;
+        }
+        // Because the backbuffer is simulated on all current WebKit ports, we need to change BACK to COLOR_ATTACHMENT0.
+        GC3Denum value = (bufs[0] == GraphicsContext3D::BACK) ? GraphicsContext3D::COLOR_ATTACHMENT0 : GraphicsContext3D::NONE;
+        graphicsContext3D()->getExtensions().drawBuffersEXT(1, &value);
+        setBackDrawBuffer(bufs[0]);
+    } else {
+        if (n > getMaxDrawBuffers()) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "drawBuffers", "more than max draw buffers");
+            return;
+        }
+        for (GC3Dsizei i = 0; i < n; ++i) {
+            if (bufs[i] != GraphicsContext3D::NONE && bufs[i] != static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + i)) {
+                synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "drawBuffers", "COLOR_ATTACHMENTi or NONE");
+                return;
+            }
+        }
+        m_framebufferBinding->drawBuffers(buffers);
+    }
+}
+
+void WebGL2RenderingContext::clearBufferiv(GC3Denum buffer, GC3Dint drawbuffer, RefPtr<Int32Array>&&)
+{
+    switch (buffer) {
+    case GraphicsContext3D::COLOR:
+        if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferiv", "buffer index out of range");
+            return;
+        }
+        // TODO: Call clearBufferiv, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::STENCIL:
+        if (drawbuffer) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferiv", "buffer index must be 0");
+            return;
+        }
+        // TODO: Call clearBufferiv, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::DEPTH:
+    case GraphicsContext3D::DEPTH_STENCIL:
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferiv", "buffer argument must be COLOR or STENCIL");
+        break;
+    }
+}
+
+void WebGL2RenderingContext::clearBufferuiv(GC3Denum buffer, GC3Dint drawbuffer, RefPtr<Uint32Array>&&)
+{
+    switch (buffer) {
+    case GraphicsContext3D::COLOR:
+        if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferuiv", "buffer index out of range");
+            return;
+        }
+        // TODO: Call clearBufferuiv, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::DEPTH:
+    case GraphicsContext3D::STENCIL:
+    case GraphicsContext3D::DEPTH_STENCIL:
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferuiv", "buffer argument must be COLOR");
+        break;
+    }
+}
+
+void WebGL2RenderingContext::clearBufferfv(GC3Denum buffer, GC3Dint drawbuffer, RefPtr<Float32Array>&&)
+{
+    switch (buffer) {
+    case GraphicsContext3D::COLOR:
+        if (drawbuffer < 0 || drawbuffer >= getMaxDrawBuffers()) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index out of range");
+            return;
+        }
+        // TODO: Call clearBufferfv, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::DEPTH:
+        if (drawbuffer) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index must be 0");
+            return;
+        }
+        // TODO: Call clearBufferfv, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::STENCIL:
+    case GraphicsContext3D::DEPTH_STENCIL:
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferfv", "buffer argument must be COLOR OR DEPTH");
+        break;
+    }
+}
+
+void WebGL2RenderingContext::clearBufferfi(GC3Denum buffer, GC3Dint drawbuffer, GC3Dfloat, GC3Dint)
+{
+    switch (buffer) {
+    case GraphicsContext3D::DEPTH_STENCIL:
+        if (drawbuffer) {
+            synthesizeGLError(GraphicsContext3D::INVALID_VALUE, "clearBufferfv", "buffer index must be 0");
+            return;
+        }
+        // TODO: Call clearBufferfi, requires gl3.h and ES3/gl.h
+        break;
+    case GraphicsContext3D::COLOR:
+    case GraphicsContext3D::DEPTH:
+    case GraphicsContext3D::STENCIL:
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "clearBufferfv", "buffer argument must be DEPTH_STENCIL");
+        break;
+    }
+}
+
+RefPtr<WebGLQuery> WebGL2RenderingContext::createQuery()
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::deleteQuery(WebGLQuery*)
+{
+}
+
+GC3Dboolean WebGL2RenderingContext::isQuery(WebGLQuery*)
+{
+    return false;
+}
+
+void WebGL2RenderingContext::beginQuery(GC3Denum, WebGLQuery*)
+{
+}
+
+void WebGL2RenderingContext::endQuery(GC3Denum)
+{
+}
+
+RefPtr<WebGLQuery> WebGL2RenderingContext::getQuery(GC3Denum, GC3Denum)
+{
+    return nullptr;
+}
+
+WebGLAny WebGL2RenderingContext::getQueryParameter(WebGLQuery*, GC3Denum)
+{
+    return nullptr;
+}
+
+RefPtr<WebGLSampler> WebGL2RenderingContext::createSampler()
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::deleteSampler(WebGLSampler*)
+{
+}
+
+GC3Dboolean WebGL2RenderingContext::isSampler(WebGLSampler*)
+{
+    return false;
+}
+
+void WebGL2RenderingContext::bindSampler(GC3Duint, WebGLSampler*)
+{
+}
+
+void WebGL2RenderingContext::samplerParameteri(WebGLSampler*, GC3Denum, GC3Dint)
+{
+}
+
+void WebGL2RenderingContext::samplerParameterf(WebGLSampler*, GC3Denum, GC3Dfloat)
+{
+}
+
+WebGLAny WebGL2RenderingContext::getSamplerParameter(WebGLSampler*, GC3Denum)
+{
+    return nullptr;
+}
+
+RefPtr<WebGLSync> WebGL2RenderingContext::fenceSync(GC3Denum, GC3Dbitfield)
+{
+    return nullptr;
+}
+
+GC3Dboolean WebGL2RenderingContext::isSync(WebGLSync*)
+{
+    return false;
+}
+
+void WebGL2RenderingContext::deleteSync(WebGLSync*)
+{
+}
+
+GC3Denum WebGL2RenderingContext::clientWaitSync(WebGLSync*, GC3Dbitfield, GC3Duint64)
+{
+    return 0;
+}
+
+void WebGL2RenderingContext::waitSync(WebGLSync*, GC3Dbitfield, GC3Duint64)
+{
+}
+
+WebGLAny WebGL2RenderingContext::getSyncParameter(WebGLSync*, GC3Denum)
+{
+    return nullptr;
+}
+
+RefPtr<WebGLTransformFeedback> WebGL2RenderingContext::createTransformFeedback()
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::deleteTransformFeedback(WebGLTransformFeedback*)
+{
+}
+
+GC3Dboolean WebGL2RenderingContext::isTransformFeedback(WebGLTransformFeedback*)
+{
+    return false;
+}
+
+void WebGL2RenderingContext::bindTransformFeedback(GC3Denum, WebGLTransformFeedback*)
+{
+}
+
+void WebGL2RenderingContext::beginTransformFeedback(GC3Denum)
+{
+}
+
+void WebGL2RenderingContext::endTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::transformFeedbackVaryings(WebGLProgram*, const Vector<String>&, GC3Denum)
+{
+}
+
+RefPtr<WebGLActiveInfo> WebGL2RenderingContext::getTransformFeedbackVarying(WebGLProgram*, GC3Duint)
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::pauseTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::resumeTransformFeedback()
+{
+}
+
+void WebGL2RenderingContext::bindBufferBase(GC3Denum, GC3Duint, WebGLBuffer*)
+{
+}
+
+void WebGL2RenderingContext::bindBufferRange(GC3Denum, GC3Duint, WebGLBuffer*, GC3Dint64, GC3Dint64)
+{
+}
+
+WebGLAny WebGL2RenderingContext::getIndexedParameter(GC3Denum target, GC3Duint)
+{
+    switch (target) {
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_BINDING:
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_SIZE:
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_START:
+    case GraphicsContext3D::UNIFORM_BUFFER_BINDING:
+    case GraphicsContext3D::UNIFORM_BUFFER_SIZE:
+    case GraphicsContext3D::UNIFORM_BUFFER_START:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getIndexedParameter", "parameter name not yet supported");
+        return nullptr;
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getIndexedParameter", "invalid parameter name");
+        return nullptr;
+    }
+}
+
+Uint32Array* WebGL2RenderingContext::getUniformIndices(WebGLProgram*, const Vector<String>&)
+{
+    return nullptr;
+}
+
+Int32Array* WebGL2RenderingContext::getActiveUniforms(WebGLProgram*, RefPtr<Uint32Array>&&, GC3Denum)
+{
+    return nullptr;
+}
+
+GC3Duint WebGL2RenderingContext::getUniformBlockIndex(WebGLProgram*, const String&)
+{
+    return 0;
+}
+
+WebGLAny WebGL2RenderingContext::getActiveUniformBlockParameter(WebGLProgram*, GC3Duint, GC3Denum)
+{
+    return nullptr;
+}
+
+WebGLAny WebGL2RenderingContext::getActiveUniformBlockName(WebGLProgram*, GC3Duint)
+{
+    return nullptr;
+}
+
+void WebGL2RenderingContext::uniformBlockBinding(WebGLProgram*, GC3Duint, GC3Duint)
+{
+}
+
+RefPtr<WebGLVertexArrayObject> WebGL2RenderingContext::createVertexArray()
+{
+    if (isContextLost())
+        return nullptr;
+    
+    auto object = WebGLVertexArrayObject::create(*this, WebGLVertexArrayObject::Type::User);
+    addContextObject(object.get());
+    return WTFMove(object);
+}
+
+void WebGL2RenderingContext::deleteVertexArray(WebGLVertexArrayObject* arrayObject)
+{
+    if (!arrayObject || isContextLost())
+        return;
+    
+    if (arrayObject->isDeleted())
+        return;
+    
+    if (!arrayObject->isDefaultObject() && arrayObject == m_boundVertexArrayObject)
+        setBoundVertexArrayObject(nullptr);
+    
+    arrayObject->deleteObject(graphicsContext3D());
+}
+
+GC3Dboolean WebGL2RenderingContext::isVertexArray(WebGLVertexArrayObject* arrayObject)
+{
+    if (!arrayObject || isContextLost())
+        return false;
+    
+    if (!arrayObject->hasEverBeenBound() || !arrayObject->validate(0, *this))
+        return false;
+    
+    return m_context->isVertexArray(arrayObject->object());
+}
+
+void WebGL2RenderingContext::bindVertexArray(WebGLVertexArrayObject* arrayObject)
+{
+    if (isContextLost())
+        return;
+    
+    if (arrayObject && (arrayObject->isDeleted() || !arrayObject->validate(0, *this) || !m_contextObjects.contains(arrayObject))) {
+        m_context->synthesizeGLError(GraphicsContext3D::INVALID_OPERATION);
+        return;
+    }
+    if (arrayObject && !arrayObject->isDefaultObject() && arrayObject->object()) {
+        m_context->bindVertexArray(arrayObject->object());
+        
+        arrayObject->setHasEverBeenBound();
+        setBoundVertexArrayObject(arrayObject);
+    } else {
+        m_context->bindVertexArray(m_defaultVertexArrayObject->object());
+        setBoundVertexArrayObject(m_defaultVertexArrayObject.get());
+    }
+}
+
+WebGLExtension* WebGL2RenderingContext::getExtension(const String& name)
+{
+    if (isContextLostOrPending())
+        return nullptr;
+
+    if (equalIgnoringASCIICase(name, "EXT_texture_filter_anisotropic") || equalIgnoringASCIICase(name, "WEBKIT_EXT_texture_filter_anisotropic")) {
+        if (!m_extTextureFilterAnisotropic) {
+            m_extTextureFilterAnisotropic = enableSupportedExtension("GL_EXT_texture_filter_anisotropic")
+                ? std::make_unique<EXTTextureFilterAnisotropic>(*this) : nullptr;
+        }
+        return m_extTextureFilterAnisotropic.get();
+    }
+    if (equalIgnoringASCIICase(name, "OES_texture_float")) {
+        if (!m_oesTextureFloat) {
+            m_oesTextureFloat = enableSupportedExtension("GL_OES_texture_float")
+                ? std::make_unique<OESTextureFloat>(*this) : nullptr;
+        }
+        return m_oesTextureFloat.get();
+    }
+    if (equalIgnoringASCIICase(name, "OES_texture_float_linear")) {
+        if (!m_oesTextureFloatLinear) {
+            m_oesTextureFloatLinear = enableSupportedExtension("GL_OES_texture_float_linear")
+                ? std::make_unique<OESTextureFloatLinear>(*this) : nullptr;
+        }
+        return m_oesTextureFloatLinear.get();
+    }
+    if (equalIgnoringASCIICase(name, "OES_texture_half_float")) {
+        if (!m_oesTextureHalfFloat) {
+            m_oesTextureHalfFloat = enableSupportedExtension("GL_OES_texture_half_float")
+                ? std::make_unique<OESTextureHalfFloat>(*this) : nullptr;
+        }
+        return m_oesTextureHalfFloat.get();
+    }
+    if (equalIgnoringASCIICase(name, "OES_texture_half_float_linear")) {
+        if (!m_oesTextureHalfFloatLinear) {
+            m_oesTextureHalfFloatLinear = enableSupportedExtension("GL_OES_texture_half_float_linear")
+                ? std::make_unique<OESTextureHalfFloatLinear>(*this) : nullptr;
+        }
+        return m_oesTextureHalfFloatLinear.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBGL_lose_context")) {
+        if (!m_webglLoseContext)
+            m_webglLoseContext = std::make_unique<WebGLLoseContext>(*this);
+        return m_webglLoseContext.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBKIT_WEBGL_compressed_texture_atc")) {
+        if (!m_webglCompressedTextureATC) {
+            if (WebGLCompressedTextureATC::supported(*this))
+                m_webglCompressedTextureATC = std::make_unique<WebGLCompressedTextureATC>(*this);
+        }
+        return m_webglCompressedTextureATC.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBKIT_WEBGL_compressed_texture_pvrtc")) {
+        if (!m_webglCompressedTexturePVRTC) {
+            m_webglCompressedTexturePVRTC = WebGLCompressedTexturePVRTC::supported(*this)
+                ? std::make_unique<WebGLCompressedTexturePVRTC>(*this) : nullptr;
+        }
+        return m_webglCompressedTexturePVRTC.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBGL_compressed_texture_s3tc")) {
+        if (!m_webglCompressedTextureS3TC) {
+            m_webglCompressedTextureS3TC = WebGLCompressedTextureS3TC::supported(*this)
+                ? std::make_unique<WebGLCompressedTextureS3TC>(*this) : nullptr;
+        }
+        return m_webglCompressedTextureS3TC.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBGL_depth_texture")) {
+        if (!m_webglDepthTexture) {
+            m_webglDepthTexture = WebGLDepthTexture::supported(*graphicsContext3D())
+                ? std::make_unique<WebGLDepthTexture>(*this) : nullptr;
+        }
+        return m_webglDepthTexture.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBGL_debug_renderer_info")) {
+        if (!m_webglDebugRendererInfo)
+            m_webglDebugRendererInfo = std::make_unique<WebGLDebugRendererInfo>(*this);
+        return m_webglDebugRendererInfo.get();
+    }
+    if (equalIgnoringASCIICase(name, "WEBGL_debug_shaders")) {
+        if (!m_webglDebugShaders) {
+            m_webglDebugShaders = m_context->getExtensions().supports(ASCIILiteral { "GL_ANGLE_translated_shader_source" })
+                ? std::make_unique<WebGLDebugShaders>(*this) : nullptr;
+        }
+        return m_webglDebugShaders.get();
+    }
+
+    return nullptr;
+}
+
+std::optional<Vector<String>> WebGL2RenderingContext::getSupportedExtensions()
+{
+    if (isContextLost())
+        return std::nullopt;
+
+    Vector<String> result;
+    
+    if (m_isPendingPolicyResolution)
+        return result;
+
+    auto& extensions = m_context->getExtensions();
+    if (extensions.supports(ASCIILiteral { "GL_OES_texture_float" }))
+        result.append(ASCIILiteral { "OES_texture_float" });
+    if (extensions.supports(ASCIILiteral { "GL_OES_texture_float_linear" }))
+        result.append(ASCIILiteral { "OES_texture_float_linear" });
+    if (extensions.supports(ASCIILiteral { "GL_OES_texture_half_float" }))
+        result.append(ASCIILiteral { "OES_texture_half_float" });
+    if (extensions.supports(ASCIILiteral { "GL_OES_texture_half_float_linear" }))
+        result.append(ASCIILiteral { "OES_texture_half_float_linear" });
+    if (extensions.supports(ASCIILiteral { "GL_EXT_texture_filter_anisotropic" }))
+        result.append(ASCIILiteral { "WEBKIT_EXT_texture_filter_anisotropic" });
+    if (WebGLCompressedTextureATC::supported(*this))
+        result.append(ASCIILiteral { "WEBKIT_WEBGL_compressed_texture_atc" });
+    if (WebGLCompressedTexturePVRTC::supported(*this))
+        result.append(ASCIILiteral { "WEBKIT_WEBGL_compressed_texture_pvrtc" });
+    if (WebGLCompressedTextureS3TC::supported(*this))
+        result.append(ASCIILiteral { "WEBGL_compressed_texture_s3tc" });
+    if (WebGLDepthTexture::supported(*graphicsContext3D()))
+        result.append(ASCIILiteral { "WEBGL_depth_texture" });
+    result.append(ASCIILiteral { "WEBGL_lose_context" });
+    if (extensions.supports(ASCIILiteral { "GL_ANGLE_translated_shader_source" }))
+        result.append(ASCIILiteral { "WEBGL_debug_shaders" });
+    result.append(ASCIILiteral { "WEBGL_debug_renderer_info" });
+
+    return result;
+}
+
+WebGLAny WebGL2RenderingContext::getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname)
+{
+    if (isContextLostOrPending() || !validateFramebufferFuncParameters("getFramebufferAttachmentParameter", target, attachment))
+        return nullptr;
+    
+    if (!m_framebufferBinding || !m_framebufferBinding->object()) {
+        synthesizeGLError(GraphicsContext3D::INVALID_OPERATION, "getFramebufferAttachmentParameter", "no framebuffer bound");
+        return nullptr;
+    }
+    
+    auto* object = m_framebufferBinding->getAttachmentObject(attachment);
+    if (!object) {
+        if (pname == GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE)
+            return static_cast<unsigned>(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 nullptr;
+    }
+    
+    if (object->isTexture()) {
+        switch (pname) {
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
+            return static_cast<unsigned>(GraphicsContext3D::TEXTURE);
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
+            return makeRefPtr(reinterpret_cast<WebGLTexture&>(*object));
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING: {
+            GC3Dint value = 0;
+            m_context->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
+            return value;
+        }
+        default:
+            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for texture attachment");
+            return nullptr;
+        }
+    } else {
+        ASSERT(object->isRenderbuffer());
+        switch (pname) {
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
+            return static_cast<unsigned>(GraphicsContext3D::RENDERBUFFER);
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
+            return makeRefPtr(reinterpret_cast<WebGLRenderbuffer&>(*object));
+        case GraphicsContext3D::FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING : {
+            auto& renderBuffer = reinterpret_cast<WebGLRenderbuffer&>(*object);
+            auto format = renderBuffer.getInternalFormat();
+            if (format == GraphicsContext3D::SRGB8_ALPHA8
+                || format == GraphicsContext3D::COMPRESSED_SRGB8_ETC2
+                || format == GraphicsContext3D::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
+                || format == GraphicsContext3D::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) {
+                return static_cast<unsigned>(GraphicsContext3D::SRGB);
+            }
+            return static_cast<unsigned>(GraphicsContext3D::LINEAR);
+        }
+        default:
+            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getFramebufferAttachmentParameter", "invalid parameter name for renderbuffer attachment");
+            return nullptr;
+        }
+    }
+}
+
+bool WebGL2RenderingContext::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::DEPTH_ATTACHMENT:
+    case GraphicsContext3D::STENCIL_ATTACHMENT:
+    case GraphicsContext3D::DEPTH_STENCIL_ATTACHMENT:
+        return true;
+    default:
+        if (attachment >= GraphicsContext3D::COLOR_ATTACHMENT0 && attachment < static_cast<GC3Denum>(GraphicsContext3D::COLOR_ATTACHMENT0 + getMaxColorAttachments()))
+            return true;
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid attachment");
+        return false;
+    }
+}
+
+GC3Dint WebGL2RenderingContext::getMaxDrawBuffers()
+{
+    if (!m_maxDrawBuffers)
+        m_context->getIntegerv(GraphicsContext3D::MAX_DRAW_BUFFERS, &m_maxDrawBuffers);
+    return m_maxDrawBuffers;
+}
+
+GC3Dint WebGL2RenderingContext::getMaxColorAttachments()
+{
+    // DrawBuffers requires MAX_COLOR_ATTACHMENTS == MAX_DRAW_BUFFERS
+    if (!m_maxColorAttachments)
+        m_context->getIntegerv(GraphicsContext3D::MAX_DRAW_BUFFERS, &m_maxColorAttachments);
+    return m_maxColorAttachments;
+}
+
+void WebGL2RenderingContext::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::DEPTH_COMPONENT32F:
+    case GraphicsContext3D::DEPTH_COMPONENT24:
+    case GraphicsContext3D::RGBA32I:
+    case GraphicsContext3D::RGBA32UI:
+    case GraphicsContext3D::RGBA16I:
+    case GraphicsContext3D::RGBA16UI:
+    case GraphicsContext3D::RGBA8:
+    case GraphicsContext3D::RGBA8I:
+    case GraphicsContext3D::RGBA8UI:
+    case GraphicsContext3D::RGB10_A2:
+    case GraphicsContext3D::RGB10_A2UI:
+    case GraphicsContext3D::RGBA4:
+    case GraphicsContext3D::RG32I:
+    case GraphicsContext3D::RG32UI:
+    case GraphicsContext3D::RG16I:
+    case GraphicsContext3D::RG16UI:
+    case GraphicsContext3D::RG8:
+    case GraphicsContext3D::RG8I:
+    case GraphicsContext3D::RG8UI:
+    case GraphicsContext3D::R32I:
+    case GraphicsContext3D::R32UI:
+    case GraphicsContext3D::R16I:
+    case GraphicsContext3D::R16UI:
+    case GraphicsContext3D::R8:
+    case GraphicsContext3D::R8I:
+    case GraphicsContext3D::R8UI:
+    case GraphicsContext3D::RGB5_A1:
+    case GraphicsContext3D::RGB565:
+    case GraphicsContext3D::STENCIL_INDEX8:
+    case GraphicsContext3D::SRGB8_ALPHA8:
+        m_context->renderbufferStorage(target, internalformat, width, height);
+        m_renderbufferBinding->setInternalFormat(internalformat);
+        m_renderbufferBinding->setIsValid(true);
+        m_renderbufferBinding->setSize(width, height);
+        break;
+    case GraphicsContext3D::DEPTH32F_STENCIL8:
+    case GraphicsContext3D::DEPTH24_STENCIL8:
+        if (!isDepthStencilSupported()) {
+            synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "renderbufferStorage", "invalid internalformat");
+            return;
+        }
+        m_context->renderbufferStorage(target, internalformat, 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 WebGL2RenderingContext::hint(GC3Denum target, GC3Denum mode)
+{
+    if (isContextLostOrPending())
+        return;
+    bool isValid = false;
+    switch (target) {
+    case GraphicsContext3D::GENERATE_MIPMAP_HINT:
+    case GraphicsContext3D::FRAGMENT_SHADER_DERIVATIVE_HINT:
+        isValid = true;
+        break;
+    }
+    if (!isValid) {
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "hint", "invalid target");
+        return;
+    }
+    m_context->hint(target, mode);
+}
+
+GC3Denum WebGL2RenderingContext::baseInternalFormatFromInternalFormat(GC3Denum internalformat)
+{
+    // Handles sized, unsized, and compressed internal formats.
+    switch (internalformat) {
+    case GraphicsContext3D::R8:
+    case GraphicsContext3D::R8_SNORM:
+    case GraphicsContext3D::R16F:
+    case GraphicsContext3D::R32F:
+    case GraphicsContext3D::R8I:
+    case GraphicsContext3D::R8UI:
+    case GraphicsContext3D::R16I:
+    case GraphicsContext3D::R16UI:
+    case GraphicsContext3D::R32I:
+    case GraphicsContext3D::R32UI:
+    case GraphicsContext3D::COMPRESSED_R11_EAC:
+    case GraphicsContext3D::COMPRESSED_SIGNED_R11_EAC:
+        return GraphicsContext3D::RED;
+    case GraphicsContext3D::RG8:
+    case GraphicsContext3D::RG8_SNORM:
+    case GraphicsContext3D::RG16F:
+    case GraphicsContext3D::RG32F:
+    case GraphicsContext3D::RG8I:
+    case GraphicsContext3D::RG8UI:
+    case GraphicsContext3D::RG16I:
+    case GraphicsContext3D::RG16UI:
+    case GraphicsContext3D::RG32I:
+    case GraphicsContext3D::RG32UI:
+    case GraphicsContext3D::COMPRESSED_RG11_EAC:
+    case GraphicsContext3D::COMPRESSED_SIGNED_RG11_EAC:
+        return GraphicsContext3D::RG;
+    case GraphicsContext3D::RGB8:
+    case GraphicsContext3D::RGB8_SNORM:
+    case GraphicsContext3D::RGB565:
+    case GraphicsContext3D::SRGB8:
+    case GraphicsContext3D::RGB16F:
+    case GraphicsContext3D::RGB32F:
+    case GraphicsContext3D::RGB8I:
+    case GraphicsContext3D::RGB8UI:
+    case GraphicsContext3D::RGB16I:
+    case GraphicsContext3D::RGB16UI:
+    case GraphicsContext3D::RGB32I:
+    case GraphicsContext3D::RGB32UI:
+    case GraphicsContext3D::RGB:
+    case GraphicsContext3D::COMPRESSED_RGB8_ETC2:
+    case GraphicsContext3D::COMPRESSED_SRGB8_ETC2:
+        return GraphicsContext3D::RGB;
+    case GraphicsContext3D::RGBA4:
+    case GraphicsContext3D::RGB5_A1:
+    case GraphicsContext3D::RGBA8:
+    case GraphicsContext3D::RGBA8_SNORM:
+    case GraphicsContext3D::RGB10_A2:
+    case GraphicsContext3D::RGB10_A2UI:
+    case GraphicsContext3D::SRGB8_ALPHA8:
+    case GraphicsContext3D::RGBA16F:
+    case GraphicsContext3D::RGBA32F:
+    case GraphicsContext3D::RGBA8I:
+    case GraphicsContext3D::RGBA8UI:
+    case GraphicsContext3D::RGBA16I:
+    case GraphicsContext3D::RGBA16UI:
+    case GraphicsContext3D::RGBA32I:
+    case GraphicsContext3D::RGBA32UI:
+    case GraphicsContext3D::RGBA:
+    case GraphicsContext3D::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+    case GraphicsContext3D::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
+    case GraphicsContext3D::COMPRESSED_RGBA8_ETC2_EAC:
+    case GraphicsContext3D::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
+        return GraphicsContext3D::RGBA;
+    case GraphicsContext3D::DEPTH_COMPONENT16:
+    case GraphicsContext3D::DEPTH_COMPONENT24:
+    case GraphicsContext3D::DEPTH_COMPONENT32F:
+        return GraphicsContext3D::DEPTH_COMPONENT;
+    case GraphicsContext3D::DEPTH24_STENCIL8:
+    case GraphicsContext3D::DEPTH32F_STENCIL8:
+        return GraphicsContext3D::DEPTH_STENCIL;
+    case GraphicsContext3D::LUMINANCE:
+    case GraphicsContext3D::LUMINANCE_ALPHA:
+    case GraphicsContext3D::ALPHA:
+        return internalformat;
+    default:
+        ASSERT_NOT_REACHED();
+        return GraphicsContext3D::NONE;
+    }
+}
+
+bool WebGL2RenderingContext::isIntegerFormat(GC3Denum internalformat)
+{
+    // FIXME: baseInternalFormatFromInternalFormat() never returns any of these enums.
+    // Because of that, this function erroneously always returns false!
+    switch (baseInternalFormatFromInternalFormat(internalformat)) {
+    case GraphicsContext3D::RED_INTEGER:
+    case GraphicsContext3D::RG_INTEGER:
+    case GraphicsContext3D::RGB_INTEGER:
+    case GraphicsContext3D::RGBA_INTEGER:
+        return true;
+    }
+    return false;
+}
+
+WebGLAny WebGL2RenderingContext::getParameter(GC3Denum pname)
+{
+    if (isContextLostOrPending())
+        return nullptr;
+    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 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 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 m_currentProgram;
+    case GraphicsContext3D::DEPTH_BITS:
+        if (!m_framebufferBinding && !m_attributes.depth)
+            return 0;
+        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 makeRefPtr(m_boundVertexArrayObject->getElementArrayBuffer());
+    case GraphicsContext3D::FRAMEBUFFER_BINDING:
+        return 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::IMPLEMENTATION_COLOR_READ_FORMAT:
+        return getIntParameter(pname);
+    case GraphicsContext3D::IMPLEMENTATION_COLOR_READ_TYPE:
+        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:
+        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 m_renderbufferBinding;
+    case GraphicsContext3D::RENDERER:
+        return String { ASCIILiteral { "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 "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 0;
+        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 m_textureUnits[m_activeTextureUnit].texture2DBinding;
+    case GraphicsContext3D::TEXTURE_BINDING_CUBE_MAP:
+        return m_textureUnits[m_activeTextureUnit].textureCubeMapBinding;
+    case GraphicsContext3D::UNPACK_ALIGNMENT:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_FLIP_Y_WEBGL:
+        return m_unpackFlipY;
+    case GraphicsContext3D::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
+        return m_unpackPremultiplyAlpha;
+    case GraphicsContext3D::UNPACK_COLORSPACE_CONVERSION_WEBGL:
+        return m_unpackColorspaceConversion;
+    case GraphicsContext3D::VENDOR:
+        return String { ASCIILiteral { "WebKit" } };
+    case GraphicsContext3D::VERSION:
+        return "WebGL 2.0 (" + m_context->getString(GraphicsContext3D::VERSION) + ")";
+    case GraphicsContext3D::VIEWPORT:
+        return getWebGLIntArrayParameter(pname);
+    case WebGLDebugRendererInfo::UNMASKED_RENDERER_WEBGL:
+        if (m_webglDebugRendererInfo)
+            return m_context->getString(GraphicsContext3D::RENDERER);
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
+        return nullptr;
+    case WebGLDebugRendererInfo::UNMASKED_VENDOR_WEBGL:
+        if (m_webglDebugRendererInfo)
+            return m_context->getString(GraphicsContext3D::VENDOR);
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name, WEBGL_debug_renderer_info not enabled");
+        return nullptr;
+    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 nullptr;
+    case GraphicsContext3D::FRAGMENT_SHADER_DERIVATIVE_HINT:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_3D_TEXTURE_SIZE:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_ARRAY_TEXTURE_LAYERS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_COLOR_ATTACHMENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
+        return getInt64Parameter(pname);
+    case GraphicsContext3D::MAX_COMBINED_UNIFORM_BLOCKS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
+        return getInt64Parameter(pname);
+    case GraphicsContext3D::MAX_DRAW_BUFFERS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_ELEMENT_INDEX:
+        return getInt64Parameter(pname);
+    case GraphicsContext3D::MAX_ELEMENTS_INDICES:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_ELEMENTS_VERTICES:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_COMPONENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_FRAGMENT_UNIFORM_BLOCKS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_PROGRAM_TEXEL_OFFSET:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_SAMPLES:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_SERVER_WAIT_TIMEOUT:
+        return getInt64Parameter(pname);
+    case GraphicsContext3D::MAX_TEXTURE_LOD_BIAS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_UNIFORM_BLOCK_SIZE:
+        return getInt64Parameter(pname);
+    case GraphicsContext3D::MAX_UNIFORM_BUFFER_BINDINGS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_VARYING_COMPONENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_VERTEX_OUTPUT_COMPONENTS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_VERTEX_UNIFORM_BLOCKS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::MAX_VERTEX_UNIFORM_COMPONENTS: 
+        return getIntParameter(pname);                            
+    case GraphicsContext3D::MIN_PROGRAM_TEXEL_OFFSET:
+        return getIntParameter(pname);
+    case GraphicsContext3D::PACK_ROW_LENGTH:
+        return getIntParameter(pname);
+    case GraphicsContext3D::PACK_SKIP_PIXELS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::PACK_SKIP_ROWS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_IMAGE_HEIGHT:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_ROW_LENGTH:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_SKIP_IMAGES:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_SKIP_PIXELS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::UNPACK_SKIP_ROWS:
+        return getIntParameter(pname);
+    case GraphicsContext3D::RASTERIZER_DISCARD:
+        return getBooleanParameter(pname);
+    case GraphicsContext3D::SAMPLE_ALPHA_TO_COVERAGE:
+        return getBooleanParameter(pname);
+    case GraphicsContext3D::SAMPLE_COVERAGE:
+        return getBooleanParameter(pname);
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_ACTIVE:
+        return getBooleanParameter(pname);
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_PAUSED:
+        return getBooleanParameter(pname);
+    case GraphicsContext3D::UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+        return getIntParameter(pname);
+    case GraphicsContext3D::VERTEX_ARRAY_BINDING:
+        if (m_boundVertexArrayObject->isDefaultObject())
+            return nullptr;
+        return makeRefPtr(static_cast<WebGLVertexArrayObject&>(*m_boundVertexArrayObject));
+    case GraphicsContext3D::DRAW_BUFFER0:
+    case GraphicsContext3D::DRAW_BUFFER1:
+    case GraphicsContext3D::DRAW_BUFFER2:
+    case GraphicsContext3D::DRAW_BUFFER3:
+    case GraphicsContext3D::DRAW_BUFFER4:
+    case GraphicsContext3D::DRAW_BUFFER5:
+    case GraphicsContext3D::DRAW_BUFFER6:
+    case GraphicsContext3D::DRAW_BUFFER7:
+    case GraphicsContext3D::DRAW_BUFFER8:
+    case GraphicsContext3D::DRAW_BUFFER9:
+    case GraphicsContext3D::DRAW_BUFFER10:
+    case GraphicsContext3D::DRAW_BUFFER11:
+    case GraphicsContext3D::DRAW_BUFFER12:
+    case GraphicsContext3D::DRAW_BUFFER13:
+    case GraphicsContext3D::DRAW_BUFFER14:
+    case GraphicsContext3D::DRAW_BUFFER15:
+        if (m_framebufferBinding)
+            return m_framebufferBinding->getDrawBuffer(pname);
+        return m_backDrawBuffer; // emulated backbuffer
+    case GraphicsContext3D::COPY_READ_BUFFER:
+    case GraphicsContext3D::COPY_WRITE_BUFFER:
+    case GraphicsContext3D::PIXEL_PACK_BUFFER_BINDING:   
+    case GraphicsContext3D::PIXEL_UNPACK_BUFFER_BINDING:
+    case GraphicsContext3D::READ_BUFFER:
+    case GraphicsContext3D::SAMPLER_BINDING:
+    case GraphicsContext3D::TEXTURE_BINDING_2D_ARRAY:
+    case GraphicsContext3D::TEXTURE_BINDING_3D:
+    case GraphicsContext3D::READ_FRAMEBUFFER_BINDING:
+    case GraphicsContext3D::TRANSFORM_FEEDBACK_BUFFER_BINDING:
+    case GraphicsContext3D::UNIFORM_BUFFER_BINDING:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "parameter name not yet supported");
+        return nullptr;
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getParameter", "invalid parameter name");
+        return nullptr;
+    }
+}
+
+bool WebGL2RenderingContext::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;
+    auto* buffer = elementArrayBuffer->elementArrayBuffer();
+    ASSERT(buffer);
+    
+    std::optional<unsigned> maxIndex = elementArrayBuffer->getCachedMaxIndex(type);
+    if (!maxIndex) {
+        // 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 = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(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 = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(p[i]);
+            break;
+        }
+        case GraphicsContext3D::UNSIGNED_INT: {
+            numElements /= sizeof(GC3Duint);
+            const GC3Duint* p = static_cast<const GC3Duint*>(buffer->data());
+            for (GC3Dsizeiptr i = 0; i < numElements; i++)
+                maxIndex = maxIndex ? std::max(maxIndex.value(), static_cast<unsigned>(p[i])) : static_cast<unsigned>(p[i]);
+            break;
+        }
+        default:
+            return false;
+        }
+        if (maxIndex)
+            elementArrayBuffer->setCachedMaxIndex(type, maxIndex.value());
+    }
+    
+    if (!maxIndex)
+        return false;
+
+    // The number of required elements is one more than the maximum
+    // index that will be accessed.
+    numElementsRequired = maxIndex.value() + 1;
+
+    // Check for overflow.
+    return numElementsRequired > 0;
+}
+
+bool WebGL2RenderingContext::validateBlendEquation(const char* functionName, GC3Denum mode)
+{
+    switch (mode) {
+    case GraphicsContext3D::FUNC_ADD:
+    case GraphicsContext3D::FUNC_SUBTRACT:
+    case GraphicsContext3D::FUNC_REVERSE_SUBTRACT:
+    case GraphicsContext3D::MIN:
+    case GraphicsContext3D::MAX:
+        return true;
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid mode");
+        return false;
+    }
+}
+
+bool WebGL2RenderingContext::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:
+    case GraphicsContext3D::RASTERIZER_DISCARD:
+        return true;
+    default:
+        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, functionName, "invalid capability");
+        return false;
+    }
+}
+
+} // namespace WebCore
+
+#endif // ENABLE(WEBGL)