Move simple methods [T-Z] from WebGraphicsContext3D to GLES2Interface.

third_party/WebKit/Source/modules/webgl/WebGL2RenderingContextBase.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/webgl/WebGL2RenderingContextBase.h"
 
 #include "bindings/modules/v8/WebGLAny.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
@@ skipping 834 matching lines @@
 {
     if (isContextLost())
         return;
     if (!validateTexture2DBinding("texImage2D", target))
         return;
     if (!validateTexFunc("texImage2D", TexImage, SourceUnpackBuffer, target, level, internalformat, width, height, 1, border, format, type, 0, 0, 0))
         return;
     if (!validateValueFitNonNegInt32("texImage2D", "offset", offset))
         return;
 
-    webContext()->texImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, reinterpret_cast<const void *>(offset));
+    contextGL()->TexImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, reinterpret_cast<const void *>(offset));
 }
 
 void WebGL2RenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLintptr offset)
 {
     if (isContextLost())
         return;
     if (!validateTexture2DBinding("texSubImage2D", target))
         return;
     if (!validateTexFunc("texSubImage2D", TexSubImage, SourceUnpackBuffer, target, level, 0, width, height, 1, 0, format, type, xoffset, yoffset, 0))
         return;
     if (!validateValueFitNonNegInt32("texSubImage2D", "offset", offset))
         return;
 
-    webContext()->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, reinterpret_cast<const void*>(offset));
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, reinterpret_cast<const void*>(offset));
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, DOMArrayBufferView* data)
 {
     WebGLRenderingContextBase::texImage2D(target, level, internalformat, width, height, border, format, type, data);
 }
 
 void WebGL2RenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat, GLenum format, GLenum type, ImageData* imageData)
 {
     WebGLRenderingContextBase::texImage2D(target, level, internalformat, format, type, imageData);
@@ skipping 53 matching lines @@
     GLenum format, GLenum type, PassRefPtrWillBeRawPtr<ImageBitmap> bitmap, ExceptionState& exceptionState)
 {
     WebGLRenderingContextBase::texSubImage2D(target, level, xoffset, yoffset, format, type, bitmap, exceptionState);
 }
 
 void WebGL2RenderingContextBase::texStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
     if (isContextLost() || !validateTexStorage("texStorage2D", target, levels, internalformat, width, height, 1, TexStorageType2D))
         return;
 
-    webContext()->texStorage2DEXT(target, levels, internalformat, width, height);
+    contextGL()->TexStorage2DEXT(target, levels, internalformat, width, height);
 }
 
 void WebGL2RenderingContextBase::texStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
     if (isContextLost() || !validateTexStorage("texStorage3D", target, levels, internalformat, width, height, depth, TexStorageType3D))
         return;
 
-    webContext()->texStorage3D(target, levels, internalformat, width, height, depth);
+    contextGL()->TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     if (!validateTexture3DBinding("texImage3D", target))
         return;
     if (!validateTexFunc("texImage3D", TexImage, SourceArrayBufferView, target, level, internalformat, width, height, depth, border, format, type, 0, 0, 0))
         return;
     if (!validateTexFuncData("texImage3D", Tex3D, level, width, height, depth, format, type, pixels, NullAllowed))
         return;
 
     void* data = pixels ? pixels->baseAddress() : 0;
     Vector<uint8_t> tempData;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         // FIXME: WebGLImageConversion needs to be updated to accept image depth.
         notImplemented();
         return;
     }
 
-    webContext()->texImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, data);
+    contextGL()->TexImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, data);
 }
 
 void WebGL2RenderingContextBase::texImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLintptr offset)
 {
     if (isContextLost())
         return;
     if (!validateTexture3DBinding("texImage3D", target))
         return;
     if (!validateTexFunc("texImage3D", TexImage, SourceUnpackBuffer, target, level, internalformat, width, height, depth, border, format, type, 0, 0, 0))
         return;
     if (!validateValueFitNonNegInt32("texImage3D", "offset", offset))
         return;
 
-    webContext()->texImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, reinterpret_cast<const void *>(offset));
+    contextGL()->TexImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, reinterpret_cast<const void *>(offset));
 }
 
 void WebGL2RenderingContextBase::texSubImage3DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, Image* image, WebGLImageConversion::ImageHtmlDomSource domSource, bool flipY, bool premultiplyAlpha)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
         // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
         type = GL_FLOAT;
     }
     Vector<uint8_t> data;
@@ skipping 10 matching lines @@
     if (type == GL_UNSIGNED_BYTE && sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 && format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing && !flipY) {
         needConversion = false;
     } else {
         if (!WebGLImageConversion::packImageData(image, imagePixelData, format, type, flipY, alphaOp, sourceDataFormat, imageExtractor.imageWidth(), imageExtractor.imageHeight(), imageExtractor.imageSourceUnpackAlignment(), data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "bad image data");
             return;
         }
     }
 
     resetUnpackParameters();
-    webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 1, format, type, needConversion ? data.data() : imagePixelData);
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), 1, format, type, needConversion ? data.data() : imagePixelData);
     restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     if (!validateTexture3DBinding("texSubImage3D", target))
         return;
     if (!validateTexFunc("texSubImage3D", TexSubImage, SourceArrayBufferView, target, level, 0, width, height, depth, 0, format, type, xoffset, yoffset, zoffset))
         return;
     if (!validateTexFuncData("texSubImage3D", Tex3D, level, width, height, depth, format, type, pixels, NullNotAllowed))
         return;
 
     void* data = pixels->baseAddress();
     Vector<uint8_t> tempData;
     bool changeUnpackParameters = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         // FIXME: WebGLImageConversion needs to be updated to accept image depth.
         notImplemented();
         changeUnpackParameters = true;
     }
     if (changeUnpackParameters)
         resetUnpackParameters();
-    webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
     if (changeUnpackParameters)
         restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLintptr offset)
 {
     if (isContextLost())
         return;
     if (!validateTexture3DBinding("texSubImage3D", target))
         return;
     if (!validateTexFunc("texSubImage3D", TexSubImage, SourceUnpackBuffer, target, level, 0, width, height, depth, 0, format, type, xoffset, yoffset, zoffset))
         return;
     if (!validateValueFitNonNegInt32("texSubImage3D", "offset", offset))
         return;
 
-    webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, reinterpret_cast<const void*>(offset));
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, reinterpret_cast<const void*>(offset));
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, ImageData* pixels)
 {
     if (isContextLost())
         return;
     if (!pixels) {
         synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "no image data");
         return;
     }
@@ skipping 16 matching lines @@
     // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
     if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha) {
         needConversion = false;
     } else {
         if (!WebGLImageConversion::extractImageData(pixels->data()->data(), pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, pixels->width(), pixels->height(), 1, format, type, needConversion ? data.data() : pixels->data()->data());
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, pixels->width(), pixels->height(), 1, format, type, needConversion ? data.data() : pixels->data()->data());
     restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::texSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (isContextLost())
         return;
     if (!validateHTMLImageElement("texSubImage3D", image, exceptionState))
         return;
     if (!validateTexture3DBinding("texSubImage3D", target))
@@ skipping 63 matching lines @@
     if (format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
         needConversion = false;
     } else {
         // In the case of ImageBitmap, we do not need to apply flipY or premultiplyAlpha.
         if (!WebGLImageConversion::extractImageData(pixelData.get(), bitmap->size(), format, type, false, false, data)) {
             synthesizeGLError(GL_INVALID_VALUE, "texSubImage3D", "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    webContext()->texSubImage3D(target, level, xoffset, yoffset, zoffset, bitmap->width(), bitmap->height(), 1, format, type, needConversion ? data.data() : pixelData.get());
+    contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, bitmap->width(), bitmap->height(), 1, format, type, needConversion ? data.data() : pixelData.get());
     restoreUnpackParameters();
 }
 
 void WebGL2RenderingContextBase::copyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
     if (!validateTexture3DBinding("copyTexSubImage3D", target))
         return;
     WebGLFramebuffer* readFramebufferBinding = nullptr;
@@ skipping 38 matching lines @@
 void WebGL2RenderingContextBase::uniform1ui(const WebGLUniformLocation* location, GLuint v0)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1ui", "location not for current program");
         return;
     }
 
-    webContext()->uniform1ui(location->location(), v0);
+    contextGL()->Uniform1ui(location->location(), v0);
 }
 
 void WebGL2RenderingContextBase::uniform2ui(const WebGLUniformLocation* location, GLuint v0, GLuint v1)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform2ui", "location not for current program");
         return;
     }
 
-    webContext()->uniform2ui(location->location(), v0, v1);
+    contextGL()->Uniform2ui(location->location(), v0, v1);
 }
 
 void WebGL2RenderingContextBase::uniform3ui(const WebGLUniformLocation* location, GLuint v0, GLuint v1, GLuint v2)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform3ui", "location not for current program");
         return;
     }
 
-    webContext()->uniform3ui(location->location(), v0, v1, v2);
+    contextGL()->Uniform3ui(location->location(), v0, v1, v2);
 }
 
 void WebGL2RenderingContextBase::uniform4ui(const WebGLUniformLocation* location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform4ui", "location not for current program");
         return;
     }
 
-    webContext()->uniform4ui(location->location(), v0, v1, v2, v3);
+    contextGL()->Uniform4ui(location->location(), v0, v1, v2, v3);
 }
 
 void WebGL2RenderingContextBase::uniform1uiv(const WebGLUniformLocation* location, const FlexibleUint32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Uint32Array>("uniform1uiv", location, v, 1))
         return;
 
-    webContext()->uniform1uiv(location->location(), v.length(), v.dataMaybeOnStack());
+    contextGL()->Uniform1uiv(location->location(), v.length(), v.dataMaybeOnStack());
 }
 
 void WebGL2RenderingContextBase::uniform1uiv(const WebGLUniformLocation* location, Vector<GLuint>& value)
 {
     if (isContextLost() || !validateUniformParameters("uniform1uiv", location, value.data(), value.size(), 1))
         return;
 
-    webContext()->uniform1uiv(location->location(), value.size(), value.data());
+    contextGL()->Uniform1uiv(location->location(), value.size(), value.data());
 }
 
 void WebGL2RenderingContextBase::uniform2uiv(const WebGLUniformLocation* location, const FlexibleUint32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Uint32Array>("uniform2uiv", location, v, 2))
         return;
 
-    webContext()->uniform2uiv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
+    contextGL()->Uniform2uiv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
 }
 
 void WebGL2RenderingContextBase::uniform2uiv(const WebGLUniformLocation* location, Vector<GLuint>& value)
 {
     if (isContextLost() || !validateUniformParameters("uniform2uiv", location, value.data(), value.size(), 2))
         return;
 
-    webContext()->uniform2uiv(location->location(), value.size() / 2, value.data());
+    contextGL()->Uniform2uiv(location->location(), value.size() / 2, value.data());
 }
 
 void WebGL2RenderingContextBase::uniform3uiv(const WebGLUniformLocation* location, const FlexibleUint32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Uint32Array>("uniform3uiv", location, v, 3))
         return;
 
-    webContext()->uniform3uiv(location->location(), v.length() / 3, v.dataMaybeOnStack());
+    contextGL()->Uniform3uiv(location->location(), v.length() / 3, v.dataMaybeOnStack());
 }
 
 void WebGL2RenderingContextBase::uniform3uiv(const WebGLUniformLocation* location, Vector<GLuint>& value)
 {
     if (isContextLost() || !validateUniformParameters("uniform3uiv", location, value.data(), value.size(), 3))
         return;
 
-    webContext()->uniform3uiv(location->location(), value.size() / 3, value.data());
+    contextGL()->Uniform3uiv(location->location(), value.size() / 3, value.data());
 }
 
 void WebGL2RenderingContextBase::uniform4uiv(const WebGLUniformLocation* location, const FlexibleUint32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Uint32Array>("uniform4uiv", location, v, 4))
         return;
 
-    webContext()->uniform4uiv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
+    contextGL()->Uniform4uiv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
 }
 
 void WebGL2RenderingContextBase::uniform4uiv(const WebGLUniformLocation* location, Vector<GLuint>& value)
 {
     if (isContextLost() || !validateUniformParameters("uniform4uiv", location, value.data(), value.size(), 4))
         return;
 
-    webContext()->uniform4uiv(location->location(), value.size() / 4, value.data());
+    contextGL()->Uniform4uiv(location->location(), value.size() / 4, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2x3fv", location, transpose, value, 6))
         return;
-    webContext()->uniformMatrix2x3fv(location->location(), value->length() / 6, transpose, value->data());
+    contextGL()->UniformMatrix2x3fv(location->location(), value->length() / 6, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x3fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2x3fv", location, transpose, value.data(), value.size(), 6))
         return;
-    webContext()->uniformMatrix2x3fv(location->location(), value.size() / 6, transpose, value.data());
+    contextGL()->UniformMatrix2x3fv(location->location(), value.size() / 6, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3x2fv", location, transpose, value, 6))
         return;
-    webContext()->uniformMatrix3x2fv(location->location(), value->length() / 6, transpose, value->data());
+    contextGL()->UniformMatrix3x2fv(location->location(), value->length() / 6, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x2fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3x2fv", location, transpose, value.data(), value.size(), 6))
         return;
-    webContext()->uniformMatrix3x2fv(location->location(), value.size() / 6, transpose, value.data());
+    contextGL()->UniformMatrix3x2fv(location->location(), value.size() / 6, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2x4fv", location, transpose, value, 8))
         return;
-    webContext()->uniformMatrix2x4fv(location->location(), value->length() / 8, transpose, value->data());
+    contextGL()->UniformMatrix2x4fv(location->location(), value->length() / 8, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix2x4fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2x4fv", location, transpose, value.data(), value.size(), 8))
         return;
-    webContext()->uniformMatrix2x4fv(location->location(), value.size() / 8, transpose, value.data());
+    contextGL()->UniformMatrix2x4fv(location->location(), value.size() / 8, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4x2fv", location, transpose, value, 8))
         return;
-    webContext()->uniformMatrix4x2fv(location->location(), value->length() / 8, transpose, value->data());
+    contextGL()->UniformMatrix4x2fv(location->location(), value->length() / 8, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x2fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4x2fv", location, transpose, value.data(), value.size(), 8))
         return;
-    webContext()->uniformMatrix4x2fv(location->location(), value.size() / 8, transpose, value.data());
+    contextGL()->UniformMatrix4x2fv(location->location(), value.size() / 8, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3x4fv", location, transpose, value, 12))
         return;
-    webContext()->uniformMatrix3x4fv(location->location(), value->length() / 12, transpose, value->data());
+    contextGL()->UniformMatrix3x4fv(location->location(), value->length() / 12, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix3x4fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3x4fv", location, transpose, value.data(), value.size(), 12))
         return;
-    webContext()->uniformMatrix3x4fv(location->location(), value.size() / 12, transpose, value.data());
+    contextGL()->UniformMatrix3x4fv(location->location(), value.size() / 12, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4x3fv", location, transpose, value, 12))
         return;
-    webContext()->uniformMatrix4x3fv(location->location(), value->length() / 12, transpose, value->data());
+    contextGL()->UniformMatrix4x3fv(location->location(), value->length() / 12, transpose, value->data());
 }
 
 void WebGL2RenderingContextBase::uniformMatrix4x3fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& value)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4x3fv", location, transpose, value.data(), value.size(), 12))
         return;
-    webContext()->uniformMatrix4x3fv(location->location(), value.size() / 12, transpose, value.data());
+    contextGL()->UniformMatrix4x3fv(location->location(), value.size() / 12, transpose, value.data());
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttribI4i(index, x, y, z, w);
+    contextGL()->VertexAttribI4i(index, x, y, z, w);
     setVertexAttribType(index, Int32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index, const DOMInt32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
         return;
     }
-    webContext()->vertexAttribI4iv(index, v->data());
+    contextGL()->VertexAttribI4iv(index, v->data());
     setVertexAttribType(index, Int32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4iv(GLuint index, const Vector<GLint>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4iv", "invalid array");
         return;
     }
-    webContext()->vertexAttribI4iv(index, v.data());
+    contextGL()->VertexAttribI4iv(index, v.data());
     setVertexAttribType(index, Int32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttribI4ui(index, x, y, z, w);
+    contextGL()->VertexAttribI4ui(index, x, y, z, w);
     setVertexAttribType(index, Uint32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4uiv(GLuint index, const DOMUint32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
         return;
     }
-    webContext()->vertexAttribI4uiv(index, v->data());
+    contextGL()->VertexAttribI4uiv(index, v->data());
     setVertexAttribType(index, Uint32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribI4uiv(GLuint index, const Vector<GLuint>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribI4uiv", "invalid array");
         return;
     }
-    webContext()->vertexAttribI4uiv(index, v.data());
+    contextGL()->VertexAttribI4uiv(index, v.data());
     setVertexAttribType(index, Uint32ArrayType);
 }
 
 void WebGL2RenderingContextBase::vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, long long offset)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribIPointer", "index out of range");
         return;
@@ skipping 13 matching lines @@
 void WebGL2RenderingContextBase::vertexAttribDivisor(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisor", "index out of range");
         return;
     }
 
-    webContext()->vertexAttribDivisorANGLE(index, divisor);
+    contextGL()->VertexAttribDivisorANGLE(index, divisor);
 }
 
 void WebGL2RenderingContextBase::drawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
 {
     if (!validateDrawArrays("drawArraysInstanced"))
         return;
 
     clearIfComposited();
-    webContext()->drawArraysInstancedANGLE(mode, first, count, instanceCount);
+    contextGL()->DrawArraysInstancedANGLE(mode, first, count, instanceCount);
     markContextChanged(CanvasChanged);
 }
 
 void WebGL2RenderingContextBase::drawElementsInstanced(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei instanceCount)
 {
     if (!validateDrawElements("drawElementsInstanced", type, offset))
         return;
 
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "drawElementsInstanced", "transform feedback is active and not paused");
         return;
     }
 
     clearIfComposited();
-    webContext()->drawElementsInstancedANGLE(mode, count, type, static_cast<GLintptr>(offset), instanceCount);
+    contextGL()->DrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)), instanceCount);
     markContextChanged(CanvasChanged);
 }
 
 void WebGL2RenderingContextBase::drawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, long long offset)
 {
     if (!validateDrawElements("drawRangeElements", type, offset))
         return;
 
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "drawRangeElements", "transform feedback is active and not paused");
@@ skipping 30 matching lines @@
         if (n != 1) {
             synthesizeGLError(GL_INVALID_OPERATION, "drawBuffers", "the number of buffers is not 1");
             return;
         }
         if (bufs[0] != GL_BACK && bufs[0] != GL_NONE) {
             synthesizeGLError(GL_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.
         GLenum value = (bufs[0] == GL_BACK) ? GL_COLOR_ATTACHMENT0 : GL_NONE;
-        webContext()->drawBuffersEXT(1, &value);
+        contextGL()->DrawBuffersEXT(1, &value);
         setBackDrawBuffer(bufs[0]);
     } else {
         if (n > maxDrawBuffers()) {
             synthesizeGLError(GL_INVALID_VALUE, "drawBuffers", "more than max draw buffers");
             return;
         }
         for (GLsizei i = 0; i < n; ++i) {
             if (bufs[i] != GL_NONE && bufs[i] != static_cast<GLenum>(GL_COLOR_ATTACHMENT0_EXT + i)) {
                 synthesizeGLError(GL_INVALID_OPERATION, "drawBuffers", "COLOR_ATTACHMENTi_EXT or NONE");
                 return;
@@ skipping 1034 matching lines @@
 }
 
 void WebGL2RenderingContextBase::uniformBlockBinding(WebGLProgram* program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
     if (isContextLost() || !validateWebGLObject("uniformBlockBinding", program))
         return;
 
     if (!validateUniformBlockIndex("uniformBlockBinding", program, uniformBlockIndex))
         return;
 
-    webContext()->uniformBlockBinding(objectOrZero(program), uniformBlockIndex, uniformBlockBinding);
+    contextGL()->UniformBlockBinding(objectOrZero(program), uniformBlockIndex, uniformBlockBinding);
 }
 
 WebGLVertexArrayObject* WebGL2RenderingContextBase::createVertexArray()
 {
     if (isContextLost())
         return nullptr;
 
     WebGLVertexArrayObject* o = WebGLVertexArrayObject::create(this, WebGLVertexArrayObjectBase::VaoTypeUser);
     addContextObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteVertexArray(ScriptState* scriptState, WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return;
 
     if (!vertexArray->isDefaultObject() && vertexArray == m_boundVertexArrayObject)
         setBoundVertexArrayObject(scriptState, nullptr);
 
-    vertexArray->deleteObject(webContext());
+    vertexArray->deleteObject(webContext(), contextGL());
 }
 
 GLboolean WebGL2RenderingContextBase::isVertexArray(WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost() || !vertexArray)
         return 0;
 
     if (!vertexArray->hasEverBeenBound())
         return 0;
 
-    return webContext()->isVertexArrayOES(vertexArray->object());
+    return contextGL()->IsVertexArrayOES(vertexArray->object());
 }
 
 void WebGL2RenderingContextBase::bindVertexArray(ScriptState* scriptState, WebGLVertexArrayObject* vertexArray)
 {
     if (isContextLost())
         return;
 
     if (vertexArray && (vertexArray->isDeleted() || !vertexArray->validate(0, this))) {
         webContext()->synthesizeGLError(GL_INVALID_OPERATION);
         return;
     }
 
     if (vertexArray && !vertexArray->isDefaultObject() && vertexArray->object()) {
-        webContext()->bindVertexArrayOES(objectOrZero(vertexArray));
+        contextGL()->BindVertexArrayOES(objectOrZero(vertexArray));
 
         vertexArray->setHasEverBeenBound();
         setBoundVertexArrayObject(scriptState, vertexArray);
     } else {
-        webContext()->bindVertexArrayOES(0);
+        contextGL()->BindVertexArrayOES(0);
         setBoundVertexArrayObject(scriptState, nullptr);
     }
 }
 
 void WebGL2RenderingContextBase::bindFramebuffer(ScriptState* scriptState, GLenum target, WebGLFramebuffer* buffer)
 {
     bool deleted;
     if (!checkObjectToBeBound("bindFramebuffer", buffer, deleted))
         return;
 
@@ skipping 877 matching lines @@
     params.skipPixels = m_unpackSkipPixels;
     params.skipRows = m_unpackSkipRows;
     if (dimension == Tex3D) {
         params.imageHeight = m_unpackImageHeight;
         params.skipImages = m_unpackSkipImages;
     }
     return params;
 }
 
 } // namespace blink