Remove methods from WebGraphicsContext3D that wrap type casts.

gpu/blink/webgraphicscontext3d_impl.cc

 // Copyright (c) 2012 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 "gpu/blink/webgraphicscontext3d_impl.h"
 
 #include <stdint.h>
 
 #include "base/atomicops.h"
 #include "base/lazy_instance.h"
@@ skipping 20 matching lines @@
 using blink::WGC3Denum;
 using blink::WGC3Dfloat;
 using blink::WGC3Dint;
 using blink::WGC3Dintptr;
 using blink::WGC3Dsizei;
 using blink::WGC3Dsizeiptr;
 using blink::WGC3Dint64;
 using blink::WGC3Duint64;
 using blink::WGC3Duint;
 using blink::WebGLId;
-using blink::WGC3Dsync;
 
 namespace gpu_blink {
 
 class WebGraphicsContext3DErrorMessageCallback
     : public ::gpu::gles2::GLES2ImplementationErrorMessageCallback {
  public:
   WebGraphicsContext3DErrorMessageCallback(
       WebGraphicsContext3DImpl* context)
       : graphics_context_(context) {
   }
@@ skipping 146 matching lines @@
     synthetic_errors_.push_back(error);
   }
 }
 
 blink::WebString WebGraphicsContext3DImpl::
     getRequestableExtensionsCHROMIUM() {
   return blink::WebString::fromUTF8(
       gl_->GetRequestableExtensionsCHROMIUM());
 }
 
-void WebGraphicsContext3DImpl::blitFramebufferCHROMIUM(
-    WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
-    WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
-    WGC3Dbitfield mask, WGC3Denum filter) {
-  gl_->BlitFramebufferCHROMIUM(
-      srcX0, srcY0, srcX1, srcY1,
-      dstX0, dstY0, dstX1, dstY1,
-      mask, filter);
-}
-
-void WebGraphicsContext3DImpl::drawElements(WGC3Denum mode,
-                                                         WGC3Dsizei count,
-                                                         WGC3Denum type,
-                                                         WGC3Dintptr offset) {
-  gl_->DrawElements(
-      mode, count, type,
-      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
-}
-
 bool WebGraphicsContext3DImpl::getActiveAttrib(
     WebGLId program, WGC3Duint index, ActiveInfo& info) {
   if (!program) {
     synthesizeGLError(GL_INVALID_VALUE);
     return false;
   }
   GLint max_name_length = -1;
   gl_->GetProgramiv(
       program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_name_length);
   if (max_name_length < 0)
@@ skipping 132 matching lines @@
       blink::WebString::fromUTF8(log.get(), returnedLogLength);
   return res;
 }
 
 blink::WebString WebGraphicsContext3DImpl::getString(
     WGC3Denum name) {
   return blink::WebString::fromUTF8(
       reinterpret_cast<const char*>(gl_->GetString(name)));
 }
 
-void WebGraphicsContext3DImpl::getSynciv(blink::WGC3Dsync sync,
-                                         blink::WGC3Denum pname,
-                                         blink::WGC3Dsizei bufSize,
-                                         blink::WGC3Dsizei *length,
-                                         blink::WGC3Dint *params) {
-  return gl_->GetSynciv(
-      reinterpret_cast<GLsync>(sync), pname, bufSize, length, params);
-}
-
-WGC3Dsizeiptr WebGraphicsContext3DImpl::getVertexAttribOffset(
-    WGC3Duint index, WGC3Denum pname) {
-  GLvoid* value = NULL;
-  // NOTE: If pname is ever a value that returns more then 1 element
-  // this will corrupt memory.
-  gl_->GetVertexAttribPointerv(index, pname, &value);
-  return static_cast<WGC3Dsizeiptr>(reinterpret_cast<intptr_t>(value));
-}
-
 void WebGraphicsContext3DImpl::shaderSource(
     WebGLId shader, const WGC3Dchar* string) {
   GLint length = strlen(string);
   gl_->ShaderSource(shader, 1, &string, &length);
 }
 
-void WebGraphicsContext3DImpl::vertexAttribPointer(
-    WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dboolean normalized,
-    WGC3Dsizei stride, WGC3Dintptr offset) {
-  gl_->VertexAttribPointer(
-      index, size, type, normalized, stride,
-      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
-}
-
 WebGLId WebGraphicsContext3DImpl::createBuffer() {
   GLuint o;
   gl_->GenBuffers(1, &o);
   return o;
 }
 
 WebGLId WebGraphicsContext3DImpl::createFramebuffer() {
   GLuint o = 0;
   gl_->GenFramebuffers(1, &o);
   return o;
@@ skipping 85 matching lines @@
 DELEGATE_TO_GL_2(bindTransformFeedback, BindTransformFeedback, WGC3Denum,
                  WebGLId)
 DELEGATE_TO_GL_4(clearBufferfi, ClearBufferfi, WGC3Denum, WGC3Dint, WGC3Dfloat,
                  WGC3Dint)
 DELEGATE_TO_GL_3(clearBufferfv, ClearBufferfv, WGC3Denum, WGC3Dint,
                  const WGC3Dfloat *)
 DELEGATE_TO_GL_3(clearBufferiv, ClearBufferiv, WGC3Denum, WGC3Dint,
                  const WGC3Dint *)
 DELEGATE_TO_GL_3(clearBufferuiv, ClearBufferuiv, WGC3Denum, WGC3Dint,
                  const WGC3Duint *)
-WGC3Denum WebGraphicsContext3DImpl::clientWaitSync(WGC3Dsync sync,
-                                                   WGC3Dbitfield flags,
-                                                   WGC3Duint64 timeout) {
-  return gl_->ClientWaitSync(reinterpret_cast<GLsync>(sync), flags, timeout);
-}
 DELEGATE_TO_GL_9(compressedTexImage3D, CompressedTexImage3D, WGC3Denum,
                  WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei, WGC3Dsizei,
                  WGC3Dint, WGC3Dsizei, const void *)
 DELEGATE_TO_GL_11(compressedTexSubImage3D, CompressedTexSubImage3D, WGC3Denum,
                   WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
                   WGC3Dsizei, WGC3Dsizei, WGC3Denum, WGC3Dsizei, const void *)
 DELEGATE_TO_GL_5(copyBufferSubData, CopyBufferSubData, WGC3Denum, WGC3Denum,
                  WGC3Dintptr, WGC3Dintptr, WGC3Dsizeiptr)
 DELEGATE_TO_GL_9(copyTexSubImage3D, CopyTexSubImage3D, WGC3Denum, WGC3Dint,
                  WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
                  WGC3Dsizei)
 WebGLId WebGraphicsContext3DImpl::createSampler() {
   GLuint sampler;
   gl_->GenSamplers(1, &sampler);
   return sampler;
 }
 WebGLId WebGraphicsContext3DImpl::createTransformFeedback() {
   GLuint tf;
   gl_->GenTransformFeedbacks(1, &tf);
   return tf;
 }
 void WebGraphicsContext3DImpl::deleteSampler(WebGLId sampler) {
   gl_->DeleteSamplers(1, &sampler);
 }
-void WebGraphicsContext3DImpl::deleteSync(WGC3Dsync sync) {
-  gl_->DeleteSync(reinterpret_cast<GLsync>(sync));
-}
 void WebGraphicsContext3DImpl::deleteTransformFeedback(WebGLId tf) {
   gl_->DeleteTransformFeedbacks(1, &tf);
 }
-void WebGraphicsContext3DImpl::drawRangeElements(
-    WGC3Denum mode, WGC3Duint start, WGC3Duint end, WGC3Dsizei count,
-    WGC3Denum type, WGC3Dintptr offset) {
-  gl_->DrawRangeElements(mode, start, end, count, type,
-      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
-}
 DELEGATE_TO_GL(endTransformFeedback, EndTransformFeedback)
-WGC3Dsync WebGraphicsContext3DImpl::fenceSync(WGC3Denum condition,
-                                              WGC3Dbitfield flags) {
-  return reinterpret_cast<WGC3Dsync>(gl_->FenceSync(condition, flags));
-}
 DELEGATE_TO_GL_5(getActiveUniformBlockName, GetActiveUniformBlockName,
                  WGC3Duint, WGC3Duint, WGC3Dsizei, WGC3Dsizei *, WGC3Dchar *)
 DELEGATE_TO_GL_4(getActiveUniformBlockiv, GetActiveUniformBlockiv, WGC3Duint,
                  WGC3Duint, WGC3Denum, WGC3Dint *)
 DELEGATE_TO_GL_5(getActiveUniformsiv, GetActiveUniformsiv, WGC3Duint,
                  WGC3Dsizei, const WGC3Duint *, WGC3Denum, WGC3Dint *)
 DELEGATE_TO_GL_2R(getFragDataLocation, GetFragDataLocation, WGC3Duint,
                   const WGC3Dchar *, WGC3Dint)
 DELEGATE_TO_GL_5(getInternalformativ, GetInternalformativ, WGC3Denum, WGC3Denum,
                  WGC3Denum, WGC3Dsizei, WGC3Dint *)
 DELEGATE_TO_GL_3(getSamplerParameterfv, GetSamplerParameterfv, WGC3Duint,
                  WGC3Denum, WGC3Dfloat *)
 DELEGATE_TO_GL_3(getSamplerParameteriv, GetSamplerParameteriv, WGC3Duint,
                  WGC3Denum, WGC3Dint *)
 DELEGATE_TO_GL_7(getTransformFeedbackVarying, GetTransformFeedbackVarying,
                  WGC3Duint, WGC3Duint, WGC3Dsizei, WGC3Dsizei *, WGC3Dsizei *,
                  WGC3Denum *, WGC3Dchar *)
 DELEGATE_TO_GL_2R(getUniformBlockIndex, GetUniformBlockIndex, WGC3Duint,
                   const WGC3Dchar *, WGC3Duint)
 DELEGATE_TO_GL_4(getUniformIndices, GetUniformIndices, WGC3Duint, WGC3Dsizei,
                  const WGC3Dchar *const*, WGC3Duint *)
 DELEGATE_TO_GL_3(getUniformuiv, GetUniformuiv, WGC3Duint, WGC3Dint,
                  WGC3Duint *)
 DELEGATE_TO_GL_3(invalidateFramebuffer, InvalidateFramebuffer, WGC3Denum,
                  WGC3Dsizei, const WGC3Denum *)
 DELEGATE_TO_GL_7(invalidateSubFramebuffer, InvalidateSubFramebuffer, WGC3Denum,
                  WGC3Dsizei, const WGC3Denum *, WGC3Dint, WGC3Dint, WGC3Dsizei,
                  WGC3Dsizei)
 DELEGATE_TO_GL_1R(isSampler, IsSampler, WebGLId, WGC3Dboolean)
-WGC3Dboolean WebGraphicsContext3DImpl::isSync(WGC3Dsync sync) {
-  return gl_->IsSync(reinterpret_cast<GLsync>(sync));
-}
 DELEGATE_TO_GL_1R(isTransformFeedback, IsTransformFeedback, WGC3Duint,
                   WGC3Dboolean)
 DELEGATE_TO_GL_4R(mapBufferRange, MapBufferRange, WGC3Denum, WGC3Dintptr,
                   WGC3Dsizeiptr, WGC3Dbitfield, void*);
 DELEGATE_TO_GL(pauseTransformFeedback, PauseTransformFeedback)
 //DELEGATE_TO_GL_3(programParameteri, ProgramParameteri, WGC3Duint, WGC3Denum,
 //                 WGC3Dint)
 DELEGATE_TO_GL_1(readBuffer, ReadBuffer, WGC3Denum)
 DELEGATE_TO_GL(resumeTransformFeedback, ResumeTransformFeedback)
 DELEGATE_TO_GL_3(samplerParameterf, SamplerParameterf, WGC3Duint, WGC3Denum,
                  WGC3Dfloat)
 DELEGATE_TO_GL_3(samplerParameterfv, SamplerParameterfv, WGC3Duint, WGC3Denum,
                  const WGC3Dfloat *)
 DELEGATE_TO_GL_3(samplerParameteri, SamplerParameteri, WGC3Duint, WGC3Denum,
                  WGC3Dint)
 DELEGATE_TO_GL_3(samplerParameteriv, SamplerParameteriv, WGC3Duint, WGC3Denum,
                  const WGC3Dint *)
 DELEGATE_TO_GL_4(transformFeedbackVaryings, TransformFeedbackVaryings,
                  WGC3Duint, WGC3Dsizei, const WGC3Dchar *const*, WGC3Denum)
 DELEGATE_TO_GL_1R(unmapBuffer, UnmapBuffer, WGC3Denum, WGC3Dboolean);
-void WebGraphicsContext3DImpl::vertexAttribIPointer(
-    WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dsizei stride,
-    WGC3Dintptr offset) {
-  gl_->VertexAttribIPointer(
-      index, size, type, stride,
-      reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
-}
-void WebGraphicsContext3DImpl::waitSync(WGC3Dsync sync,
-                                        WGC3Dbitfield flags,
-                                        WGC3Duint64 timeout) {
-  gl_->WaitSync(reinterpret_cast<GLsync>(sync), flags, timeout);
-}
 
 ::gpu::gles2::GLES2Interface* WebGraphicsContext3DImpl::getGLES2Interface() {
   return gl_;
 }
 
 ::gpu::gles2::GLES2ImplementationErrorMessageCallback*
     WebGraphicsContext3DImpl::getErrorMessageCallback() {
   if (!client_error_message_callback_) {
     client_error_message_callback_.reset(
         new WebGraphicsContext3DErrorMessageCallback(this));
@@ skipping 46 matching lines @@
       output_attribs->context_type = ::gpu::gles2::CONTEXT_TYPE_WEBGL2;
       break;
     default:
       NOTREACHED();
       output_attribs->context_type = ::gpu::gles2::CONTEXT_TYPE_OPENGLES2;
       break;
   }
 }
 
 }  // namespace gpu_blink