Move simple methods [F-S] 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 135 matching lines @@
     m_boundCopyWriteBuffer = nullptr;
     m_boundPixelPackBuffer = nullptr;
     m_boundPixelUnpackBuffer = nullptr;
     m_boundTransformFeedbackBuffer = nullptr;
     m_boundUniformBuffer = nullptr;
 
     m_currentBooleanOcclusionQuery = nullptr;
     m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
 
     GLint numCombinedTextureImageUnits = 0;
-    webContext()->getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
+    contextGL()->GetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numCombinedTextureImageUnits);
     m_samplerUnits.clear();
     m_samplerUnits.resize(numCombinedTextureImageUnits);
 
     m_maxTransformFeedbackSeparateAttribs = 0;
-    webContext()->getIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &m_maxTransformFeedbackSeparateAttribs);
+    contextGL()->GetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &m_maxTransformFeedbackSeparateAttribs);
     m_boundIndexedTransformFeedbackBuffers.clear();
     m_boundIndexedTransformFeedbackBuffers.resize(m_maxTransformFeedbackSeparateAttribs);
 
     GLint maxUniformBufferBindings = 0;
-    webContext()->getIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
+    contextGL()->GetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
     m_boundIndexedUniformBuffers.clear();
     m_boundIndexedUniformBuffers.resize(maxUniformBufferBindings);
     m_maxBoundUniformBufferIndex = 0;
 
     m_packRowLength = 0;
     m_packSkipPixels = 0;
     m_packSkipRows = 0;
     m_unpackRowLength = 0;
     m_unpackImageHeight = 0;
     m_unpackSkipPixels = 0;
@@ skipping 408 matching lines @@
     case GL_UNPACK_SKIP_ROWS:
         m_unpackSkipRows = param;
         break;
     case GL_UNPACK_SKIP_IMAGES:
         m_unpackSkipImages = param;
         break;
     default:
         WebGLRenderingContextBase::pixelStorei(pname, param);
         return;
     }
-    webContext()->pixelStorei(pname, param);
+    contextGL()->PixelStorei(pname, param);
 }
 
 void WebGL2RenderingContextBase::readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
     if (isContextLost())
         return;
     if (m_boundPixelPackBuffer.get()) {
         synthesizeGLError(GL_INVALID_OPERATION, "readPixels", "PIXEL_PACK buffer should not be bound");
         return;
     }
@@ skipping 29 matching lines @@
     long long size = buffer->getSize() - offset;
     // If size is negative, or size is not large enough to store pixels, those cases
     // are handled by validateReadPixelsFuncParameters to generate INVALID_OPERATION.
     if (!validateReadPixelsFuncParameters(width, height, format, type, nullptr, size))
         return;
 
     clearIfComposited();
 
     {
         ScopedDrawingBufferBinder binder(drawingBuffer(), framebuffer);
-        webContext()->readPixels(x, y, width, height, format, type, reinterpret_cast<void*>(offset));
+        contextGL()->ReadPixels(x, y, width, height, format, type, reinterpret_cast<void*>(offset));
     }
 }
 
 void WebGL2RenderingContextBase::renderbufferStorageImpl(
     GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height,
     const char* functionName)
 {
     switch (internalformat) {
     case GL_R8UI:
     case GL_R8I:
@@ skipping 28 matching lines @@
     case GL_RGB5_A1:
     case GL_RGBA4:
     case GL_RGB10_A2:
     case GL_DEPTH_COMPONENT16:
     case GL_DEPTH_COMPONENT24:
     case GL_DEPTH_COMPONENT32F:
     case GL_DEPTH24_STENCIL8:
     case GL_DEPTH32F_STENCIL8:
     case GL_STENCIL_INDEX8:
         if (!samples) {
-            webContext()->renderbufferStorage(target, internalformat, width, height);
+            contextGL()->RenderbufferStorage(target, internalformat, width, height);
         } else {
             GLint maxNumberOfSamples = 0;
             webContext()->getInternalformativ(target, internalformat, GL_SAMPLES, 1, &maxNumberOfSamples);
             if (samples > maxNumberOfSamples) {
                 synthesizeGLError(GL_INVALID_OPERATION, functionName, "samples out of range");
                 return;
             }
             contextGL()->RenderbufferStorageMultisampleCHROMIUM(
                 target, samples, internalformat, width, height);
         }
         break;
     case GL_DEPTH_STENCIL:
         // To be WebGL 1 backward compatible.
         if (samples > 0) {
             synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid internalformat");
             return;
         }
-        webContext()->renderbufferStorage(target, GL_DEPTH24_STENCIL8, width, height);
+        contextGL()->RenderbufferStorage(target, GL_DEPTH24_STENCIL8, width, height);
         break;
     case GL_R16F:
     case GL_RG16F:
     case GL_RGBA16F:
     case GL_R32F:
     case GL_RG32F:
     case GL_RGBA32F:
     case GL_R11F_G11F_B10F:
         if (!extensionEnabled(EXTColorBufferFloatName)) {
             synthesizeGLError(GL_INVALID_ENUM, functionName, "EXT_color_buffer_float not enabled");
             return;
         }
         if (samples) {
             synthesizeGLError(GL_INVALID_VALUE, functionName, "multisampled float buffers not supported");
             return;
         }
-        webContext()->renderbufferStorage(target, internalformat, width, height);
+        contextGL()->RenderbufferStorage(target, internalformat, width, height);
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid internalformat");
         return;
     }
     m_renderbufferBinding->setInternalFormat(internalformat);
     m_renderbufferBinding->setSize(width, height);
 }
 
 void WebGL2RenderingContextBase::renderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
@@ skipping 17 matching lines @@
     }
     renderbufferStorageImpl(target, samples, internalformat, width, height, functionName);
     applyStencilTest();
 }
 
 void WebGL2RenderingContextBase::resetUnpackParameters()
 {
     WebGLRenderingContextBase::resetUnpackParameters();
 
     if (!m_unpackRowLength)
-        webContext()->pixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+        contextGL()->PixelStorei(GL_UNPACK_ROW_LENGTH, 0);
     if (!m_unpackImageHeight)
-        webContext()->pixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
+        contextGL()->PixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
     if (!m_unpackSkipPixels)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
     if (!m_unpackSkipRows)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_ROWS, 0);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_ROWS, 0);
     if (!m_unpackSkipImages)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_IMAGES, 0);
 }
 
 void WebGL2RenderingContextBase::restoreUnpackParameters()
 {
     WebGLRenderingContextBase::restoreUnpackParameters();
 
     if (!m_unpackRowLength)
-        webContext()->pixelStorei(GL_UNPACK_ROW_LENGTH, m_unpackRowLength);
+        contextGL()->PixelStorei(GL_UNPACK_ROW_LENGTH, m_unpackRowLength);
     if (!m_unpackImageHeight)
-        webContext()->pixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_unpackImageHeight);
+        contextGL()->PixelStorei(GL_UNPACK_IMAGE_HEIGHT, m_unpackImageHeight);
     if (!m_unpackSkipPixels)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_PIXELS, m_unpackSkipPixels);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_PIXELS, m_unpackSkipPixels);
     if (!m_unpackSkipRows)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_ROWS, m_unpackSkipRows);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_ROWS, m_unpackSkipRows);
     if (!m_unpackSkipImages)
-        webContext()->pixelStorei(GL_UNPACK_SKIP_IMAGES, m_unpackSkipImages);
+        contextGL()->PixelStorei(GL_UNPACK_SKIP_IMAGES, m_unpackSkipImages);
 }
 
 /* Texture objects */
 bool WebGL2RenderingContextBase::validateTexStorage(const char* functionName, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, TexStorageType functionType)
 {
     if (functionType == TexStorageType2D) {
         if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP) {
             synthesizeGLError(GL_INVALID_ENUM, functionName, "invalid 2D target");
             return false;
         }
@@ skipping 897 matching lines @@
     addSharedObject(o);
     return o;
 }
 
 void WebGL2RenderingContextBase::deleteQuery(WebGLQuery* query)
 {
     if (isContextLost() || !query)
         return;
 
     if (m_currentBooleanOcclusionQuery == query) {
-        webContext()->endQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
+        contextGL()->EndQueryEXT(m_currentBooleanOcclusionQuery->getTarget());
         m_currentBooleanOcclusionQuery = nullptr;
     }
 
     if (m_currentTransformFeedbackPrimitivesWrittenQuery == query) {
-        webContext()->endQueryEXT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
+        contextGL()->EndQueryEXT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
         m_currentTransformFeedbackPrimitivesWrittenQuery = nullptr;
     }
 
     deleteObject(query);
 }
 
 GLboolean WebGL2RenderingContextBase::isQuery(WebGLQuery* query)
 {
     if (isContextLost() || !query)
         return 0;
 
-    return webContext()->isQueryEXT(query->object());
+    return contextGL()->IsQueryEXT(query->object());
 }
 
 void WebGL2RenderingContextBase::beginQuery(GLenum target, WebGLQuery* query)
 {
     bool deleted;
     if (!query) {
         synthesizeGLError(GL_INVALID_OPERATION, "beginQuery", "query object is null");
         return;
     }
 
@@ skipping 30 matching lines @@
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "beginQuery", "invalid target");
         return;
     }
 
     if (!query->getTarget())
         query->setTarget(target);
 
-    webContext()->beginQueryEXT(target, query->object());
+    contextGL()->BeginQueryEXT(target, query->object());
 }
 
 void WebGL2RenderingContextBase::endQuery(GLenum target)
 {
     if (isContextLost())
         return;
 
     switch (target) {
     case GL_ANY_SAMPLES_PASSED:
     case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
@@ skipping 16 matching lines @@
                 synthesizeGLError(GL_INVALID_OPERATION, "endQuery", "target query is not active");
                 return;
             }
         }
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "endQuery", "invalid target");
         return;
     }
 
-    webContext()->endQueryEXT(target);
+    contextGL()->EndQueryEXT(target);
 }
 
 WebGLQuery* WebGL2RenderingContextBase::getQuery(GLenum target, GLenum pname)
 {
     if (isContextLost())
         return nullptr;
 
     if (pname != GL_CURRENT_QUERY) {
         synthesizeGLError(GL_INVALID_ENUM, "getQuery", "invalid parameter name");
         return nullptr;
@@ skipping 34 matching lines @@
         return ScriptValue::createNull(scriptState);
     }
     if (query == m_currentBooleanOcclusionQuery || query == m_currentTransformFeedbackPrimitivesWrittenQuery) {
         synthesizeGLError(GL_INVALID_OPERATION, "getQueryParameter", "query is currently active");
         return ScriptValue::createNull(scriptState);
     }
 
     switch (pname) {
     case GL_QUERY_RESULT:
         {
-            query->updateCachedResult(webContext());
+            query->updateCachedResult(contextGL());
             return WebGLAny(scriptState, query->getQueryResult());
         }
     case GL_QUERY_RESULT_AVAILABLE:
         {
-            query->updateCachedResult(webContext());
+            query->updateCachedResult(contextGL());
             return WebGLAny(scriptState, query->isQueryResultAvailable());
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getQueryParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 WebGLSampler* WebGL2RenderingContextBase::createSampler()
 {
@@ skipping 386 matching lines @@
 WebGLActiveInfo* WebGL2RenderingContextBase::getTransformFeedbackVarying(WebGLProgram* program, GLuint index)
 {
     if (isContextLost() || !validateWebGLObject("getTransformFeedbackVarying", program))
         return nullptr;
 
     if (!program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, "getTransformFeedbackVarying", "program not linked");
         return nullptr;
     }
     GLint maxIndex = 0;
-    webContext()->getProgramiv(objectOrZero(program), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxIndex);
+    contextGL()->GetProgramiv(objectOrZero(program), GL_TRANSFORM_FEEDBACK_VARYINGS, &maxIndex);
     if (index >= static_cast<GLuint>(maxIndex)) {
         synthesizeGLError(GL_INVALID_VALUE, "getTransformFeedbackVarying", "invalid index");
         return nullptr;
     }
 
     GLint maxNameLength = -1;
-    webContext()->getProgramiv(objectOrZero(program), GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxNameLength);
+    contextGL()->GetProgramiv(objectOrZero(program), GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, &maxNameLength);
     if (maxNameLength <= 0) {
         return nullptr;
     }
     OwnPtr<GLchar[]> name = adoptArrayPtr(new GLchar[maxNameLength]);
     GLsizei length = 0;
     GLsizei size = 0;
     GLenum type = 0;
     webContext()->getTransformFeedbackVarying(objectOrZero(program), index, maxNameLength, &length, &size, &type, name.get());
 
     if (length == 0 || size == 0 || type == 0) {
@@ skipping 141 matching lines @@
             synthesizeGLError(GL_INVALID_VALUE, "getIndexedParameter", "index out of range");
             return ScriptValue::createNull(scriptState);
         }
         return WebGLAny(scriptState, m_boundIndexedUniformBuffers[index].get());
     case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
     case GL_TRANSFORM_FEEDBACK_BUFFER_START:
     case GL_UNIFORM_BUFFER_SIZE:
     case GL_UNIFORM_BUFFER_START:
         {
             GLint64 value = -1;
-            webContext()->getInteger64i_v(target, index, &value);
+            contextGL()->GetInteger64i_v(target, index, &value);
             return WebGLAny(scriptState, value);
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getIndexedParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 Vector<GLuint> WebGL2RenderingContextBase::getUniformIndices(WebGLProgram* program, const Vector<String>& uniformNames)
 {
@@ skipping 41 matching lines @@
         break;
     case GL_UNIFORM_IS_ROW_MAJOR:
         returnType = BoolType;
         break;
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getActiveUniforms", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 
     GLint activeUniforms = -1;
-    webContext()->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
+    contextGL()->GetProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORMS, &activeUniforms);
 
     GLuint activeUniformsUnsigned = activeUniforms;
     size_t size = uniformIndices.size();
     for (size_t i = 0; i < size; ++i) {
         if (uniformIndices[i] >= activeUniformsUnsigned) {
             synthesizeGLError(GL_INVALID_VALUE, "getActiveUniforms", "uniform index greater than ACTIVE_UNIFORMS");
             return ScriptValue::createNull(scriptState);
         }
     }
 
@@ skipping 42 matching lines @@
 }
 
 bool WebGL2RenderingContextBase::validateUniformBlockIndex(const char* functionName, WebGLProgram* program, GLuint blockIndex)
 {
     ASSERT(program);
     if (!program->linkStatus()) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName, "program not linked");
         return false;
     }
     GLint activeUniformBlocks = 0;
-    webContext()->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORM_BLOCKS, &activeUniformBlocks);
+    contextGL()->GetProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORM_BLOCKS, &activeUniformBlocks);
     if (blockIndex >= static_cast<GLuint>(activeUniformBlocks)) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "invalid uniform block index");
         return false;
     }
     return true;
 }
 
 ScriptValue WebGL2RenderingContextBase::getActiveUniformBlockParameter(ScriptState* scriptState, WebGLProgram* program, GLuint uniformBlockIndex, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniformBlockParameter", program))
@@ skipping 35 matching lines @@
 
 String WebGL2RenderingContextBase::getActiveUniformBlockName(WebGLProgram* program, GLuint uniformBlockIndex)
 {
     if (isContextLost() || !validateWebGLObject("getActiveUniformBlockName", program))
         return String();
 
     if (!validateUniformBlockIndex("getActiveUniformBlockName", program, uniformBlockIndex))
         return String();
 
     GLint maxNameLength = -1;
-    webContext()->getProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxNameLength);
+    contextGL()->GetProgramiv(objectOrZero(program), GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxNameLength);
     if (maxNameLength <= 0) {
         // This state indicates that there are no active uniform blocks
         synthesizeGLError(GL_INVALID_VALUE, "getActiveUniformBlockName", "invalid uniform block index");
         return String();
     }
     OwnPtr<GLchar[]> name = adoptArrayPtr(new GLchar[maxNameLength]);
 
     GLsizei length = 0;
     webContext()->getActiveUniformBlockName(objectOrZero(program), uniformBlockIndex, maxNameLength, &length, name.get());
 
@@ skipping 250 matching lines @@
 
     default:
         return WebGLRenderingContextBase::getParameter(scriptState, pname);
     }
 }
 
 ScriptValue WebGL2RenderingContextBase::getInt64Parameter(ScriptState* scriptState, GLenum pname)
 {
     GLint64 value = 0;
     if (!isContextLost())
-        webContext()->getInteger64v(pname, &value);
+        contextGL()->GetInteger64v(pname, &value);
     return WebGLAny(scriptState, value);
 }
 
 bool WebGL2RenderingContextBase::validateCapability(const char* functionName, GLenum cap)
 {
     switch (cap) {
     case GL_RASTERIZER_DISCARD:
         return true;
     default:
         return WebGLRenderingContextBase::validateCapability(functionName, cap);
@@ skipping 466 matching lines @@
         if (!attachmentObject->isTexture())
             break;
     case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
     case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
         {
             GLint value = 0;
-            webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
+            contextGL()->GetFramebufferAttachmentParameteriv(target, attachment, pname, &value);
             return WebGLAny(scriptState, value);
         }
     case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
         if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
             synthesizeGLError(GL_INVALID_OPERATION, kFunctionName,
                 "COMPONENT_TYPE can't be queried for DEPTH_STENCIL_ATTACHMENT");
             return ScriptValue::createNull(scriptState);
         }
     case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
         {
             GLint value = 0;
-            webContext()->getFramebufferAttachmentParameteriv(target, attachment, pname, &value);
+            contextGL()->GetFramebufferAttachmentParameteriv(target, attachment, pname, &value);
             return WebGLAny(scriptState, static_cast<unsigned>(value));
         }
     default:
         break;
     }
     synthesizeGLError(GL_INVALID_ENUM, kFunctionName, "invalid parameter name");
     return ScriptValue::createNull(scriptState);
 }
 
 DEFINE_TRACE(WebGL2RenderingContextBase)
@@ skipping 49 matching lines @@
     if (isContextLost() || !validateTextureBinding("getTexParameter", target))
         return ScriptValue::createNull(scriptState);
 
     switch (pname) {
     case GL_TEXTURE_WRAP_R:
     case GL_TEXTURE_COMPARE_FUNC:
     case GL_TEXTURE_COMPARE_MODE:
     case GL_TEXTURE_IMMUTABLE_LEVELS:
         {
             GLint value = 0;
-            webContext()->getTexParameteriv(target, pname, &value);
+            contextGL()->GetTexParameteriv(target, pname, &value);
             return WebGLAny(scriptState, static_cast<unsigned>(value));
         }
     case GL_TEXTURE_IMMUTABLE_FORMAT:
         {
             GLint value = 0;
-            webContext()->getTexParameteriv(target, pname, &value);
+            contextGL()->GetTexParameteriv(target, pname, &value);
             return WebGLAny(scriptState, static_cast<bool>(value));
         }
     case GL_TEXTURE_BASE_LEVEL:
     case GL_TEXTURE_MAX_LEVEL:
         {
             GLint value = 0;
-            webContext()->getTexParameteriv(target, pname, &value);
+            contextGL()->GetTexParameteriv(target, pname, &value);
             return WebGLAny(scriptState, value);
         }
     case GL_TEXTURE_MAX_LOD:
     case GL_TEXTURE_MIN_LOD:
         {
             GLfloat value = 0.f;
-            webContext()->getTexParameterfv(target, pname, &value);
+            contextGL()->GetTexParameterfv(target, pname, &value);
             return WebGLAny(scriptState, value);
         }
     default:
         return WebGLRenderingContextBase::getTexParameter(scriptState, target, pname);
     }
 }
 
 WebGLBuffer* WebGL2RenderingContextBase::validateBufferDataTarget(const char* functionName, GLenum target)
 {
     WebGLBuffer* buffer = nullptr;
@@ skipping 90 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