Remove methods from WebGraphicsContext3D that wrap type casts.

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 15 matching lines @@
 #include "modules/webgl/WebGLVertexArrayObject.h"
 #include "platform/CheckedInt.h"
 #include "platform/NotImplemented.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 
 namespace blink {
 
 namespace {
 
-WGC3Dsync syncObjectOrZero(const WebGLSync* object)
+GLsync syncObjectOrZero(const WebGLSync* object)
 {
-    return object ? object->object() : 0;
+    return object ? reinterpret_cast<GLsync>(object->object()) : nullptr;

[piman, 2016/03/19 01:28:35]

nit: no need for the reinterpret_cast

[danakj, 2016/03/21 22:02:38]

Done.

 }
 
 } // namespace
 
 // These enums are from manual pages for glTexStorage2D/glTexStorage3D.
 const GLenum kSupportedInternalFormatsStorage[] = {
     GL_R8,
     GL_R8_SNORM,
     GL_R16F,
     GL_R32F,
@@ skipping 197 matching lines @@
     memcpy(returnedData->data(), mappedData, returnedData->byteLength());
 
     webContext()->unmapBuffer(target);
 }
 
 void WebGL2RenderingContextBase::blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
     if (isContextLost())
         return;
 
-    webContext()->blitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    contextGL()->BlitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 bool WebGL2RenderingContextBase::validateTexFuncLayer(const char* functionName, GLenum texTarget, GLint layer)
 {
     if (layer < 0) {
         synthesizeGLError(GL_INVALID_VALUE, functionName, "layer out of range");
         return false;
     }
     switch (texTarget) {
     case GL_TEXTURE_3D:
@@ skipping 1232 matching lines @@
         return;
     }
     if (!validateValueFitNonNegInt32("vertexAttribIPointer", "offset", offset))
         return;
     if (!m_boundArrayBuffer) {
         synthesizeGLError(GL_INVALID_OPERATION, "vertexAttribIPointer", "no bound ARRAY_BUFFER");
         return;
     }
 
     m_boundVertexArrayObject->setArrayBufferForAttrib(index, m_boundArrayBuffer);
-    webContext()->vertexAttribIPointer(index, size, type, stride, static_cast<GLintptr>(offset));
+    contextGL()->VertexAttribIPointer(index, size, type, stride, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
 }
 
 /* Writing to the drawing buffer */
 void WebGL2RenderingContextBase::vertexAttribDivisor(GLuint index, GLuint divisor)
 {
     if (isContextLost())
         return;
 
     if (index >= m_maxVertexAttribs) {
         synthesizeGLError(GL_INVALID_VALUE, "vertexAttribDivisor", "index out of range");
@@ skipping 32 matching lines @@
 {
     if (!validateDrawElements("drawRangeElements", type, offset))
         return;
 
     if (transformFeedbackActive() && !transformFeedbackPaused()) {
         synthesizeGLError(GL_INVALID_OPERATION, "drawRangeElements", "transform feedback is active and not paused");
         return;
     }
 
     clearIfComposited();
-    webContext()->drawRangeElements(mode, start, end, count, type, static_cast<GLintptr>(offset));
+    contextGL()->DrawRangeElements(mode, start, end, count, type, reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
     markContextChanged(CanvasChanged);
 }
 
 void WebGL2RenderingContextBase::drawBuffers(const Vector<GLenum>& buffers)
 {
     if (isContextLost())
         return;
 
     GLsizei n = buffers.size();
     const GLenum* bufs = buffers.data();
@@ skipping 496 matching lines @@
     WebGLSync* o = WebGLFenceSync::create(this, condition, flags);
     addSharedObject(o);
     return o;
 }
 
 GLboolean WebGL2RenderingContextBase::isSync(WebGLSync* sync)
 {
     if (isContextLost() || !sync)
         return 0;
 
-    return webContext()->isSync(sync->object());
+    return contextGL()->IsSync(sync->object());
 }
 
 void WebGL2RenderingContextBase::deleteSync(WebGLSync* sync)
 {
     deleteObject(sync);
 }
 
 GLenum WebGL2RenderingContextBase::clientWaitSync(WebGLSync* sync, GLbitfield flags, GLint64 timeout)
 {
     if (isContextLost() || !validateWebGLObject("clientWaitSync", sync))
         return GL_WAIT_FAILED;
 
     if (timeout < -1) {
         synthesizeGLError(GL_INVALID_VALUE, "clientWaitSync", "timeout < -1");
         return GL_WAIT_FAILED;
     }
 
     GLuint64 timeout64 = timeout == -1 ? GL_TIMEOUT_IGNORED : static_cast<GLuint64>(timeout);
-    return webContext()->clientWaitSync(syncObjectOrZero(sync), flags, timeout64);
+    return contextGL()->ClientWaitSync(syncObjectOrZero(sync), flags, timeout64);
 }
 
 void WebGL2RenderingContextBase::waitSync(WebGLSync* sync, GLbitfield flags, GLint64 timeout)
 {
     if (isContextLost() || !validateWebGLObject("waitSync", sync))
         return;
 
     if (timeout < -1) {
         synthesizeGLError(GL_INVALID_VALUE, "waitSync", "timeout < -1");
         return;
     }
 
     GLuint64 timeout64 = timeout == -1 ? GL_TIMEOUT_IGNORED : static_cast<GLuint64>(timeout);
-    webContext()->waitSync(syncObjectOrZero(sync), flags, timeout64);
+    contextGL()->WaitSync(syncObjectOrZero(sync), flags, timeout64);
 }
 
 ScriptValue WebGL2RenderingContextBase::getSyncParameter(ScriptState* scriptState, WebGLSync* sync, GLenum pname)
 {
     if (isContextLost() || !validateWebGLObject("getSyncParameter", sync))
         return ScriptValue::createNull(scriptState);
 
     switch (pname) {
     case GL_OBJECT_TYPE:
     case GL_SYNC_STATUS:
     case GL_SYNC_CONDITION:
     case GL_SYNC_FLAGS:
         {
             GLint value = 0;
             GLsizei length = -1;
-            webContext()->getSynciv(syncObjectOrZero(sync), pname, 1, &length, &value);
+            contextGL()->GetSynciv(syncObjectOrZero(sync), pname, 1, &length, &value);
             return WebGLAny(scriptState, static_cast<unsigned>(value));
         }
     default:
         synthesizeGLError(GL_INVALID_ENUM, "getSyncParameter", "invalid parameter name");
         return ScriptValue::createNull(scriptState);
     }
 }
 
 WebGLTransformFeedback* WebGL2RenderingContextBase::createTransformFeedback()
 {
@@ skipping 1453 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