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

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

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 962 matching lines @@
     // It's not convenient or necessary to pass a ScriptState this far down; while one is available
     // during WebGLRenderingContext construction, the wrapper for the context itself hasn't been
     // created yet. It's simpler to instead lazily instantiate and preserve the JavaScript wrapper
     // for the default VAO. (This object is never exposed to JavaScript, but we need to link other
     // JavaScript wrappers to it.)
     m_preservedDefaultVAOObjectWrapper = false;
     m_boundVertexArrayObject = m_defaultVertexArrayObject;
 
     m_vertexAttribType.resize(m_maxVertexAttribs);
 
-    webContext()->viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
+    contextGL()->Viewport(0, 0, drawingBufferWidth(), drawingBufferHeight());
     contextGL()->Scissor(0, 0, drawingBufferWidth(), drawingBufferHeight());
 
     m_contextLostCallbackAdapter = WebGLRenderingContextLostCallback::create(this);
     m_errorMessageCallbackAdapter = WebGLRenderingContextErrorMessageCallback::create(this);
 
     webContext()->setContextLostCallback(m_contextLostCallbackAdapter.get());
     webContext()->setErrorMessageCallback(m_errorMessageCallbackAdapter.get());
 
     // This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
     contextGL()->Flush();
@@ skipping 929 matching lines @@
 {
     if (isContextLost() || !object)
         return false;
     if (!object->validate(contextGroup(), this)) {
         synthesizeGLError(GL_INVALID_OPERATION, "delete", "object does not belong to this context");
         return false;
     }
     if (object->hasObject()) {
         // We need to pass in context here because we want
         // things in this context unbound.
-        object->deleteObject(webContext());
+        object->deleteObject(webContext(), contextGL());
     }
     return true;
 }
 
 void WebGLRenderingContextBase::deleteBuffer(WebGLBuffer* buffer)
 {
     if (!deleteObject(buffer))
         return;
     removeBoundBuffer(buffer);
 }
@@ skipping 102 matching lines @@
 
 void WebGLRenderingContextBase::detachShader(ScriptState* scriptState, WebGLProgram* program, WebGLShader* shader)
 {
     if (isContextLost() || !validateWebGLObject("detachShader", program) || !validateWebGLObject("detachShader", shader))
         return;
     if (!program->detachShader(shader)) {
         synthesizeGLError(GL_INVALID_OPERATION, "detachShader", "shader not attached");
         return;
     }
     contextGL()->DetachShader(objectOrZero(program), objectOrZero(shader));
-    shader->onDetached(webContext());
+    shader->onDetached(webContext(), contextGL());
     preserveObjectWrapper(scriptState, program, "shader", shader->type(), nullptr);
 }
 
 void WebGLRenderingContextBase::disable(GLenum cap)
 {
     if (isContextLost() || !validateCapability("disable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = false;
         applyStencilTest();
@@ skipping 66 matching lines @@
     webContext()->drawElements(mode, count, type, static_cast<GLintptr>(offset));
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
 {
     if (!validateDrawArrays("drawArraysInstancedANGLE"))
         return;
 
     clearIfComposited();
-    webContext()->drawArraysInstancedANGLE(mode, first, count, primcount);
+    contextGL()->DrawArraysInstancedANGLE(mode, first, count, primcount);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei primcount)
 {
     if (!validateDrawElements("drawElementsInstancedANGLE", type, offset))
         return;
 
     clearIfComposited();
-    webContext()->drawElementsInstancedANGLE(mode, count, type, static_cast<GLintptr>(offset), primcount);
+    contextGL()->DrawElementsInstancedANGLE(mode, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)), primcount);
     markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::enable(GLenum cap)
 {
     if (isContextLost() || !validateCapability("enable", cap))
         return;
     if (cap == GL_STENCIL_TEST) {
         m_stencilEnabled = true;
         applyStencilTest();
@@ skipping 1643 matching lines @@
     m_valuebufferBinding = valuebuffer;
     contextGL()->BindValuebufferCHROMIUM(target, objectOrZero(valuebuffer));
     if (valuebuffer)
         valuebuffer->setHasEverBeenBound();
 }
 
 void WebGLRenderingContextBase::subscribeValueCHROMIUM(GLenum target, GLenum subscription)
 {
     if (isContextLost())
         return;
-    webContext()->subscribeValueCHROMIUM(target, subscription);
+    contextGL()->SubscribeValueCHROMIUM(target, subscription);
 }
 
 void WebGLRenderingContextBase::populateSubscribedValuesCHROMIUM(GLenum target)
 {
     if (isContextLost())
         return;
-    webContext()->populateSubscribedValuesCHROMIUM(target);
+    contextGL()->PopulateSubscribedValuesCHROMIUM(target);
 }
 
 void WebGLRenderingContextBase::uniformValuebufferCHROMIUM(const WebGLUniformLocation* location, GLenum target, GLenum subscription)
 {
     if (isContextLost() || !location)
         return;
-    webContext()->uniformValuebufferCHROMIUM(location->location(), target, subscription);
+    contextGL()->UniformValuebufferCHROMIUM(location->location(), target, subscription);
 }
 
 GLenum WebGLRenderingContextBase::convertTexInternalFormat(GLenum internalformat, GLenum type)
 {
     // Convert to sized internal formats that are renderable with GL_CHROMIUM_color_buffer_float_rgb(a).
     if (type == GL_FLOAT && internalformat == GL_RGBA
         && extensionsUtil()->isExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgba"))
         return GL_RGBA32F_EXT;
     if (type == GL_FLOAT && internalformat == GL_RGB
         && extensionsUtil()->isExtensionEnabled("GL_CHROMIUM_color_buffer_float_rgb"))
         return GL_RGB32F_EXT;
     return internalformat;
 }
 
 void WebGLRenderingContextBase::texImage2DBase(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
 {
     // All calling functions check isContextLost, so a duplicate check is not needed here.
-    webContext()->texImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, pixels);
+    contextGL()->TexImage2D(target, level, convertTexInternalFormat(internalformat, type), width, height, border, format, type, pixels);
 }
 
 void WebGLRenderingContextBase::texImage2DImpl(GLenum target, GLint level, GLint internalformat, 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 197 matching lines @@
         possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat, type, level);
     }
 
     // if direct copy is not possible, create a temporary texture and then copy from canvas to temporary texture to target texture.
     if (!possibleDirectCopy) {
         targetLevel = 0;
         targetInternalformat = GL_RGBA;
         targetType = GL_UNSIGNED_BYTE;
         targetTexture = webContext()->createTexture();
         contextGL()->BindTexture(GL_TEXTURE_2D, targetTexture);
-        webContext()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        webContext()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        webContext()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        webContext()->texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        webContext()->texImage2D(GL_TEXTURE_2D, 0, targetInternalformat, canvas->width(),
+        contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        contextGL()->TexImage2D(GL_TEXTURE_2D, 0, targetInternalformat, canvas->width(),
             canvas->height(), 0, GL_RGBA, targetType, 0);
     }
 
     if (!canvas->is3D()) {
         ImageBuffer* buffer = canvas->buffer();
         if (!buffer->copyToPlatformTexture(webContext(), contextGL(), targetTexture, targetInternalformat, targetType,
             targetLevel, m_unpackPremultiplyAlpha, m_unpackFlipY)) {
             ASSERT_NOT_REACHED();
         }
     } else {
@@ skipping 182 matching lines @@
         if (!isWebGL2OrHigher()) {
             synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter name");
             return;
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "texParameter", "invalid parameter name");
         return;
     }
     if (isFloat) {
-        webContext()->texParameterf(target, pname, paramf);
+        contextGL()->TexParameterf(target, pname, paramf);
     } else {
-        webContext()->texParameteri(target, pname, parami);
+        contextGL()->TexParameteri(target, pname, parami);
     }
 }
 
 void WebGLRenderingContextBase::texParameterf(GLenum target, GLenum pname, GLfloat param)
 {
     texParameter(target, pname, param, 0, true);
 }
 
 void WebGLRenderingContextBase::texParameteri(GLenum target, GLenum pname, GLint param)
 {
@@ skipping 21 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, "texSubImage2D", "bad image data");
             return;
         }
     }
 
     resetUnpackParameters();
-    webContext()->texSubImage2D(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData);
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData);
     restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     if (!validateTexture2DBinding("texSubImage2D", target))
         return;
     if (!validateTexFunc("texSubImage2D", TexSubImage, SourceArrayBufferView, target, level, 0, width, height, 1, 0, format, type, xoffset, yoffset, 0))
         return;
     if (!validateTexFuncData("texSubImage2D", Tex2D, level, width, height, 1, format, type, pixels, NullNotAllowed))
         return;
     void* data = pixels->baseAddress();
     Vector<uint8_t> tempData;
     bool changeUnpackAlignment = false;
     if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
         if (!WebGLImageConversion::extractTextureData(width, height, format, type,
             m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
             return;
         data = tempData.data();
         changeUnpackAlignment = true;
     }
     if (changeUnpackAlignment)
         resetUnpackParameters();
-    webContext()->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
     if (changeUnpackAlignment)
         restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, ImageData* pixels)
 {
     if (isContextLost())
         return;
     if (!pixels) {
@@ skipping 18 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, "texSubImage2D", "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    webContext()->texSubImage2D(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data());
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data());
     restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
     if (isContextLost())
         return;
     if (!validateHTMLImageElement("texSubImage2D", image, exceptionState))
         return;
@@ skipping 84 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, "texSubImage2D", "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    webContext()->texSubImage2D(target, level, xoffset, yoffset, bitmap->width(), bitmap->height(), format, type, needConversion ? data.data() : pixelData.get());
+    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, bitmap->width(), bitmap->height(), format, type, needConversion ? data.data() : pixelData.get());
     restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GLfloat x)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1f", "location not for current program");
         return;
     }
 
-    webContext()->uniform1f(location->location(), x);
+    contextGL()->Uniform1f(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, const FlexibleFloat32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Float32Array>("uniform1fv", location, v, 1))
         return;
 
-    webContext()->uniform1fv(location->location(), v.length(), v.dataMaybeOnStack());
+    contextGL()->Uniform1fv(location->location(), v.length(), v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform1fv(const WebGLUniformLocation* location, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1fv", location, v.data(), v.size(), 1))
         return;
 
-    webContext()->uniform1fv(location->location(), v.size(), v.data());
+    contextGL()->Uniform1fv(location->location(), v.size(), v.data());
 }
 
 void WebGLRenderingContextBase::uniform1i(const WebGLUniformLocation* location, GLint x)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1i", "location not for current program");
         return;
     }
 
-    webContext()->uniform1i(location->location(), x);
+    contextGL()->Uniform1i(location->location(), x);
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, const FlexibleInt32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Int32Array>("uniform1iv", location, v, 1))
         return;
 
-    webContext()->uniform1iv(location->location(), v.length(), v.dataMaybeOnStack());
+    contextGL()->Uniform1iv(location->location(), v.length(), v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform1iv(const WebGLUniformLocation* location, Vector<GLint>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform1iv", location, v.data(), v.size(), 1))
         return;
 
-    webContext()->uniform1iv(location->location(), v.size(), v.data());
+    contextGL()->Uniform1iv(location->location(), v.size(), v.data());
 }
 
 void WebGLRenderingContextBase::uniform2f(const WebGLUniformLocation* location, GLfloat x, GLfloat y)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform2f", "location not for current program");
         return;
     }
 
-    webContext()->uniform2f(location->location(), x, y);
+    contextGL()->Uniform2f(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, const FlexibleFloat32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Float32Array>("uniform2fv", location, v, 2))
         return;
 
-    webContext()->uniform2fv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
+    contextGL()->Uniform2fv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform2fv(const WebGLUniformLocation* location, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2fv", location, v.data(), v.size(), 2))
         return;
 
-    webContext()->uniform2fv(location->location(), v.size() >> 1, v.data());
+    contextGL()->Uniform2fv(location->location(), v.size() >> 1, v.data());
 }
 
 void WebGLRenderingContextBase::uniform2i(const WebGLUniformLocation* location, GLint x, GLint y)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform2i", "location not for current program");
         return;
     }
 
-    webContext()->uniform2i(location->location(), x, y);
+    contextGL()->Uniform2i(location->location(), x, y);
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, const FlexibleInt32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Int32Array>("uniform2iv", location, v, 2))
         return;
 
-    webContext()->uniform2iv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
+    contextGL()->Uniform2iv(location->location(), v.length() >> 1, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform2iv(const WebGLUniformLocation* location, Vector<GLint>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform2iv", location, v.data(), v.size(), 2))
         return;
 
-    webContext()->uniform2iv(location->location(), v.size() >> 1, v.data());
+    contextGL()->Uniform2iv(location->location(), v.size() >> 1, v.data());
 }
 
 void WebGLRenderingContextBase::uniform3f(const WebGLUniformLocation* location, GLfloat x, GLfloat y, GLfloat z)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform3f", "location not for current program");
         return;
     }
 
-    webContext()->uniform3f(location->location(), x, y, z);
+    contextGL()->Uniform3f(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, const FlexibleFloat32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Float32Array>("uniform3fv", location, v, 3))
         return;
 
-    webContext()->uniform3fv(location->location(), v.length() / 3, v.dataMaybeOnStack());
+    contextGL()->Uniform3fv(location->location(), v.length() / 3, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform3fv(const WebGLUniformLocation* location, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3fv", location, v.data(), v.size(), 3))
         return;
 
-    webContext()->uniform3fv(location->location(), v.size() / 3, v.data());
+    contextGL()->Uniform3fv(location->location(), v.size() / 3, v.data());
 }
 
 void WebGLRenderingContextBase::uniform3i(const WebGLUniformLocation* location, GLint x, GLint y, GLint z)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform3i", "location not for current program");
         return;
     }
 
-    webContext()->uniform3i(location->location(), x, y, z);
+    contextGL()->Uniform3i(location->location(), x, y, z);
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, const FlexibleInt32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Int32Array>("uniform3iv", location, v, 3))
         return;
 
-    webContext()->uniform3iv(location->location(), v.length() / 3, v.dataMaybeOnStack());
+    contextGL()->Uniform3iv(location->location(), v.length() / 3, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform3iv(const WebGLUniformLocation* location, Vector<GLint>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform3iv", location, v.data(), v.size(), 3))
         return;
 
-    webContext()->uniform3iv(location->location(), v.size() / 3, v.data());
+    contextGL()->Uniform3iv(location->location(), v.size() / 3, v.data());
 }
 
 void WebGLRenderingContextBase::uniform4f(const WebGLUniformLocation* location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform4f", "location not for current program");
         return;
     }
 
-    webContext()->uniform4f(location->location(), x, y, z, w);
+    contextGL()->Uniform4f(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, const FlexibleFloat32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Float32Array>("uniform4fv", location, v, 4))
         return;
 
-    webContext()->uniform4fv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
+    contextGL()->Uniform4fv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform4fv(const WebGLUniformLocation* location, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4fv", location, v.data(), v.size(), 4))
         return;
 
-    webContext()->uniform4fv(location->location(), v.size() >> 2, v.data());
+    contextGL()->Uniform4fv(location->location(), v.size() >> 2, v.data());
 }
 
 void WebGLRenderingContextBase::uniform4i(const WebGLUniformLocation* location, GLint x, GLint y, GLint z, GLint w)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform4i", "location not for current program");
         return;
     }
 
-    webContext()->uniform4i(location->location(), x, y, z, w);
+    contextGL()->Uniform4i(location->location(), x, y, z, w);
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, const FlexibleInt32ArrayView& v)
 {
     if (isContextLost() || !validateUniformParameters<WTF::Int32Array>("uniform4iv", location, v, 4))
         return;
 
-    webContext()->uniform4iv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
+    contextGL()->Uniform4iv(location->location(), v.length() >> 2, v.dataMaybeOnStack());
 }
 
 void WebGLRenderingContextBase::uniform4iv(const WebGLUniformLocation* location, Vector<GLint>& v)
 {
     if (isContextLost() || !validateUniformParameters("uniform4iv", location, v.data(), v.size(), 4))
         return;
 
-    webContext()->uniform4iv(location->location(), v.size() >> 2, v.data());
+    contextGL()->Uniform4iv(location->location(), v.size() >> 2, v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v, 4))
         return;
-    webContext()->uniformMatrix2fv(location->location(), v->length() >> 2, transpose, v->data());
+    contextGL()->UniformMatrix2fv(location->location(), v->length() >> 2, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix2fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix2fv", location, transpose, v.data(), v.size(), 4))
         return;
-    webContext()->uniformMatrix2fv(location->location(), v.size() >> 2, transpose, v.data());
+    contextGL()->UniformMatrix2fv(location->location(), v.size() >> 2, transpose, v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v, 9))
         return;
-    webContext()->uniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
+    contextGL()->UniformMatrix3fv(location->location(), v->length() / 9, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix3fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix3fv", location, transpose, v.data(), v.size(), 9))
         return;
-    webContext()->uniformMatrix3fv(location->location(), v.size() / 9, transpose, v.data());
+    contextGL()->UniformMatrix3fv(location->location(), v.size() / 9, transpose, v.data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, DOMFloat32Array* v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v, 16))
         return;
-    webContext()->uniformMatrix4fv(location->location(), v->length() >> 4, transpose, v->data());
+    contextGL()->UniformMatrix4fv(location->location(), v->length() >> 4, transpose, v->data());
 }
 
 void WebGLRenderingContextBase::uniformMatrix4fv(const WebGLUniformLocation* location, GLboolean transpose, Vector<GLfloat>& v)
 {
     if (isContextLost() || !validateUniformMatrixParameters("uniformMatrix4fv", location, transpose, v.data(), v.size(), 16))
         return;
-    webContext()->uniformMatrix4fv(location->location(), v.size() >> 4, transpose, v.data());
+    contextGL()->UniformMatrix4fv(location->location(), v.size() >> 4, transpose, v.data());
 }
 
 void WebGLRenderingContextBase::useProgram(ScriptState* scriptState, WebGLProgram* program)
 {
     bool deleted;
     if (!checkObjectToBeBound("useProgram", program, deleted))
         return;
     if (deleted)
         program = 0;
     if (program && !program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "program not valid");
         return;
     }
 
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "useProgram", "transform feedback is active and not paused");
         return;
     }
 
     if (m_currentProgram != program) {
         if (m_currentProgram)
-            m_currentProgram->onDetached(webContext());
+            m_currentProgram->onDetached(webContext(), contextGL());
         m_currentProgram = program;
-        webContext()->useProgram(objectOrZero(program));
+        contextGL()->UseProgram(objectOrZero(program));
         if (program)
             program->onAttached();
         preserveObjectWrapper(scriptState, this, "program", 0, program);
     }
 }
 
 void WebGLRenderingContextBase::validateProgram(WebGLProgram* program)
 {
     if (isContextLost() || !validateWebGLObject("validateProgram", program))
         return;
-    webContext()->validateProgram(objectOrZero(program));
+    contextGL()->ValidateProgram(objectOrZero(program));
 }
 
 void WebGLRenderingContextBase::setVertexAttribType(GLuint index, VertexAttribValueType type)
 {
     if (index < m_maxVertexAttribs)
         m_vertexAttribType[index] = type;
 }
 
 void WebGLRenderingContextBase::vertexAttrib1f(GLuint index, GLfloat v0)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttrib1f(index, v0);
+    contextGL()->VertexAttrib1f(index, v0);
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, const DOMFloat32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 1) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib1fv(index, v->data());
+    contextGL()->VertexAttrib1fv(index, v->data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib1fv(GLuint index, const Vector<GLfloat>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 1) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib1fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib1fv(index, v.data());
+    contextGL()->VertexAttrib1fv(index, v.data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttrib2f(index, v0, v1);
+    contextGL()->VertexAttrib2f(index, v0, v1);
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index, const DOMFloat32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 2) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib2fv(index, v->data());
+    contextGL()->VertexAttrib2fv(index, v->data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib2fv(GLuint index, const Vector<GLfloat>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 2) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib2fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib2fv(index, v.data());
+    contextGL()->VertexAttrib2fv(index, v.data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttrib3f(index, v0, v1, v2);
+    contextGL()->VertexAttrib3f(index, v0, v1, v2);
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index, const DOMFloat32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 3) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib3fv(index, v->data());
+    contextGL()->VertexAttrib3fv(index, v->data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib3fv(GLuint index, const Vector<GLfloat>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 3) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib3fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib3fv(index, v.data());
+    contextGL()->VertexAttrib3fv(index, v.data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
     if (isContextLost())
         return;
-    webContext()->vertexAttrib4f(index, v0, v1, v2, v3);
+    contextGL()->VertexAttrib4f(index, v0, v1, v2, v3);
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, const DOMFloat32Array* v)
 {
     if (isContextLost())
         return;
     if (!v || v->length() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib4fv(index, v->data());
+    contextGL()->VertexAttrib4fv(index, v->data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttrib4fv(GLuint index, const Vector<GLfloat>& v)
 {
     if (isContextLost())
         return;
     if (v.size() < 4) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttrib4fv", "invalid array");
         return;
     }
-    webContext()->vertexAttrib4fv(index, v.data());
+    contextGL()->VertexAttrib4fv(index, v.data());
     setVertexAttribType(index, Float32ArrayType);
 }
 
 void WebGLRenderingContextBase::vertexAttribPointer(ScriptState* scriptState, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, long long offset)
 {
     if (isContextLost())
         return;
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribPointer", "index out of range");
         return;
@@ skipping 14 matching lines @@
 void WebGLRenderingContextBase::vertexAttribDivisorANGLE(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisorANGLE", "index out of range");
         return;
     }
 
-    webContext()->vertexAttribDivisorANGLE(index, divisor);
+    contextGL()->VertexAttribDivisorANGLE(index, divisor);
 }
 
 void WebGLRenderingContextBase::viewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
     if (isContextLost())
         return;
-    webContext()->viewport(x, y, width, height);
+    contextGL()->Viewport(x, y, width, height);
 }
 
 // Added to provide a unified interface with CanvasRenderingContext2D. Prefer calling forceLostContext instead.
 void WebGLRenderingContextBase::loseContext(LostContextMode mode)
 {
     forceLostContext(mode, Manual);
 }
 
 void WebGLRenderingContextBase::forceLostContext(LostContextMode mode, AutoRecoveryMethod autoRecoveryMethod)
 {
@@ skipping 1303 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink