Remove unnecessary use of blink typedefs

cc/test/fake_web_graphics_context_3d.cc

 // Copyright 2013 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 "cc/test/fake_web_graphics_context_3d.h"
 
 #include "base/logging.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
-using blink::WGC3Dboolean;
-using blink::WGC3Denum;
-using blink::WGC3Dsizei;
-using blink::WebGLId;
 using blink::WebGraphicsContext3D;
 
 namespace cc {
 
 FakeWebGraphicsContext3D::FakeWebGraphicsContext3D() {}
 
 FakeWebGraphicsContext3D::~FakeWebGraphicsContext3D() {}
 
 bool FakeWebGraphicsContext3D::makeContextCurrent() {
   return true;
 }
 
 bool FakeWebGraphicsContext3D::isGLES2Compliant() {
   return false;
 }
 
-WebGLId FakeWebGraphicsContext3D::getPlatformTextureId() {
+GLuint FakeWebGraphicsContext3D::getPlatformTextureId() {
   return 0;
 }
 
 bool FakeWebGraphicsContext3D::isContextLost() {
   return false;
 }
 
 void* FakeWebGraphicsContext3D::mapBufferSubDataCHROMIUM(
-    WGC3Denum target,
-    blink::WGC3Dintptr offset,
-    blink::WGC3Dsizeiptr size,
-    WGC3Denum access) {
+    GLenum target,
+    GLintptr offset,
+    GLsizeiptr size,
+    GLenum access) {
   return 0;
 }
 
 void* FakeWebGraphicsContext3D::mapTexSubImage2DCHROMIUM(
-    WGC3Denum target,
-    blink::WGC3Dint level,
-    blink::WGC3Dint xoffset,
-    blink::WGC3Dint yoffset,
-    blink::WGC3Dsizei width,
-    blink::WGC3Dsizei height,
-    WGC3Denum format,
-    WGC3Denum type,
-    WGC3Denum access) {
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLenum type,
+    GLenum access) {
   return 0;
 }
 
 blink::WebString FakeWebGraphicsContext3D::getRequestableExtensionsCHROMIUM() {
   return blink::WebString();
 }
 
-WGC3Denum FakeWebGraphicsContext3D::checkFramebufferStatus(
-    WGC3Denum target) {
+GLenum FakeWebGraphicsContext3D::checkFramebufferStatus(
+    GLenum target) {
   return GL_FRAMEBUFFER_COMPLETE;
 }
 
 bool FakeWebGraphicsContext3D::getActiveAttrib(
-    WebGLId program,
-    blink::WGC3Duint index,
+    GLuint program,
+    GLuint index,
     WebGraphicsContext3D::ActiveInfo&) {
   return false;
 }
 
 bool FakeWebGraphicsContext3D::getActiveUniform(
-    WebGLId program,
-    blink::WGC3Duint index,
+    GLuint program,
+    GLuint index,
     WebGraphicsContext3D::ActiveInfo&) {
   return false;
 }
 
-blink::WGC3Dint FakeWebGraphicsContext3D::getAttribLocation(
-    WebGLId program,
-    const blink::WGC3Dchar* name) {
+GLint FakeWebGraphicsContext3D::getAttribLocation(
+    GLuint program,
+    const GLchar* name) {
   return 0;
 }
 
-WGC3Denum FakeWebGraphicsContext3D::getError() {
-  return 0;
+GLenum FakeWebGraphicsContext3D::getError() {
+  return GL_NO_ERROR;
 }
 
 void FakeWebGraphicsContext3D::getIntegerv(
-    WGC3Denum pname,
-    blink::WGC3Dint* value) {
+    GLenum pname,
+    GLint* value) {
   if (pname == GL_MAX_TEXTURE_SIZE)
     *value = 1024;
   else if (pname == GL_ACTIVE_TEXTURE)
     *value = GL_TEXTURE0;
 }
 
 void FakeWebGraphicsContext3D::getProgramiv(
-    WebGLId program,
-    WGC3Denum pname,
-    blink::WGC3Dint* value) {
+    GLuint program,
+    GLenum pname,
+    GLint* value) {
   if (pname == GL_LINK_STATUS)
     *value = 1;
 }
 
 blink::WebString FakeWebGraphicsContext3D::getProgramInfoLog(
-    WebGLId program) {
+    GLuint program) {
   return blink::WebString();
 }
 
 void FakeWebGraphicsContext3D::getShaderiv(
-    WebGLId shader,
-    WGC3Denum pname,
-    blink::WGC3Dint* value) {
+    GLuint shader,
+    GLenum pname,
+    GLint* value) {
   if (pname == GL_COMPILE_STATUS)
     *value = 1;
 }
 
 blink::WebString FakeWebGraphicsContext3D::getShaderInfoLog(
-    WebGLId shader) {
+    GLuint shader) {
   return blink::WebString();
 }
 
 void FakeWebGraphicsContext3D::getShaderPrecisionFormat(
-    blink::WGC3Denum shadertype,
-    blink::WGC3Denum precisiontype,
-    blink::WGC3Dint* range,
-    blink::WGC3Dint* precision) {
+    GLenum shadertype,
+    GLenum precisiontype,
+    GLint* range,
+    GLint* precision) {
   // Return the minimum precision requirements of the GLES specificatin.
   switch (precisiontype) {
     case GL_LOW_INT:
       range[0] = 8;
       range[1] = 8;
       *precision = 0;
       break;
     case GL_MEDIUM_INT:
       range[0] = 10;
       range[1] = 10;
@@ skipping 19 matching lines @@
       range[1] = 62;
       *precision = 16;
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 blink::WebString FakeWebGraphicsContext3D::getShaderSource(
-    WebGLId shader) {
+    GLuint shader) {
   return blink::WebString();
 }
 
-blink::WebString FakeWebGraphicsContext3D::getString(WGC3Denum name) {
+blink::WebString FakeWebGraphicsContext3D::getString(GLenum name) {
   return blink::WebString();
 }
 
-blink::WGC3Dint FakeWebGraphicsContext3D::getUniformLocation(
-    WebGLId program,
-    const blink::WGC3Dchar* name) {
+GLint FakeWebGraphicsContext3D::getUniformLocation(
+    GLuint program,
+    const GLchar* name) {
   return 0;
 }
 
-blink::WGC3Dsizeiptr FakeWebGraphicsContext3D::getVertexAttribOffset(
-    blink::WGC3Duint index,
-    WGC3Denum pname) {
+GLsizeiptr FakeWebGraphicsContext3D::getVertexAttribOffset(
+    GLuint index,
+    GLenum pname) {
   return 0;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isBuffer(
-    WebGLId buffer) {
+GLboolean FakeWebGraphicsContext3D::isBuffer(
+    GLuint buffer) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isEnabled(
-    WGC3Denum cap) {
+GLboolean FakeWebGraphicsContext3D::isEnabled(
+    GLenum cap) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isFramebuffer(
-    WebGLId framebuffer) {
+GLboolean FakeWebGraphicsContext3D::isFramebuffer(
+    GLuint framebuffer) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isProgram(
-    WebGLId program) {
+GLboolean FakeWebGraphicsContext3D::isProgram(
+    GLuint program) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isRenderbuffer(
-    WebGLId renderbuffer) {
+GLboolean FakeWebGraphicsContext3D::isRenderbuffer(
+    GLuint renderbuffer) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isShader(
-    WebGLId shader) {
+GLboolean FakeWebGraphicsContext3D::isShader(
+    GLuint shader) {
   return false;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isTexture(
-    WebGLId texture) {
+GLboolean FakeWebGraphicsContext3D::isTexture(
+    GLuint texture) {
   return false;
 }
 
-void FakeWebGraphicsContext3D::genBuffers(WGC3Dsizei count, WebGLId* ids) {
+void FakeWebGraphicsContext3D::genBuffers(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     ids[i] = 1;
 }
 
 void FakeWebGraphicsContext3D::genFramebuffers(
-    WGC3Dsizei count, WebGLId* ids) {
+    GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     ids[i] = 1;
 }
 
 void FakeWebGraphicsContext3D::genRenderbuffers(
-    WGC3Dsizei count, WebGLId* ids) {
+    GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     ids[i] = 1;
 }
 
-void FakeWebGraphicsContext3D::genTextures(WGC3Dsizei count, WebGLId* ids) {
+void FakeWebGraphicsContext3D::genTextures(GLsizei count, GLuint* ids) {
   for (int i = 0; i < count; ++i)
     ids[i] = 1;
 }
 
-void FakeWebGraphicsContext3D::deleteBuffers(WGC3Dsizei count, WebGLId* ids) {
+void FakeWebGraphicsContext3D::deleteBuffers(GLsizei count, GLuint* ids) {
 }
 
 void FakeWebGraphicsContext3D::deleteFramebuffers(
-    WGC3Dsizei count, WebGLId* ids) {
+    GLsizei count, GLuint* ids) {
 }
 
 void FakeWebGraphicsContext3D::deleteRenderbuffers(
-    WGC3Dsizei count, WebGLId* ids) {
+    GLsizei count, GLuint* ids) {
 }
 
-void FakeWebGraphicsContext3D::deleteTextures(WGC3Dsizei count, WebGLId* ids) {
+void FakeWebGraphicsContext3D::deleteTextures(GLsizei count, GLuint* ids) {
 }
 
-WebGLId FakeWebGraphicsContext3D::createBuffer() {
+GLuint FakeWebGraphicsContext3D::createBuffer() {
   return 1;
 }
 
-WebGLId FakeWebGraphicsContext3D::createFramebuffer() {
+GLuint FakeWebGraphicsContext3D::createFramebuffer() {
   return 1;
 }
 
-WebGLId FakeWebGraphicsContext3D::createRenderbuffer() {
+GLuint FakeWebGraphicsContext3D::createRenderbuffer() {
   return 1;
 }
 
-WebGLId FakeWebGraphicsContext3D::createTexture() {
+GLuint FakeWebGraphicsContext3D::createTexture() {
   return 1;
 }
 
-void FakeWebGraphicsContext3D::deleteBuffer(blink::WebGLId id) {
+void FakeWebGraphicsContext3D::deleteBuffer(GLuint id) {
 }
 
-void FakeWebGraphicsContext3D::deleteFramebuffer(blink::WebGLId id) {
+void FakeWebGraphicsContext3D::deleteFramebuffer(GLuint id) {
 }
 
-void FakeWebGraphicsContext3D::deleteRenderbuffer(blink::WebGLId id) {
+void FakeWebGraphicsContext3D::deleteRenderbuffer(GLuint id) {
 }
 
-void FakeWebGraphicsContext3D::deleteTexture(WebGLId texture_id) {
+void FakeWebGraphicsContext3D::deleteTexture(GLuint texture_id) {
 }
 
-WebGLId FakeWebGraphicsContext3D::createProgram() {
+GLuint FakeWebGraphicsContext3D::createProgram() {
   return 1;
 }
 
-WebGLId FakeWebGraphicsContext3D::createShader(WGC3Denum) {
+GLuint FakeWebGraphicsContext3D::createShader(GLenum) {
   return 1;
 }
 
-void FakeWebGraphicsContext3D::deleteProgram(blink::WebGLId id) {
+void FakeWebGraphicsContext3D::deleteProgram(GLuint id) {
 }
 
-void FakeWebGraphicsContext3D::deleteShader(blink::WebGLId id) {
+void FakeWebGraphicsContext3D::deleteShader(GLuint id) {
 }
 
-void FakeWebGraphicsContext3D::attachShader(WebGLId program, WebGLId shader) {
+void FakeWebGraphicsContext3D::attachShader(GLuint program, GLuint shader) {
 }
 
-void FakeWebGraphicsContext3D::useProgram(WebGLId program) {
+void FakeWebGraphicsContext3D::useProgram(GLuint program) {
 }
 
-void FakeWebGraphicsContext3D::bindBuffer(WGC3Denum target, WebGLId buffer) {
+void FakeWebGraphicsContext3D::bindBuffer(GLenum target, GLuint buffer) {
 }
 
 void FakeWebGraphicsContext3D::bindFramebuffer(
-    WGC3Denum target, WebGLId framebuffer) {
+    GLenum target, GLuint framebuffer) {
 }
 
 void FakeWebGraphicsContext3D::bindRenderbuffer(
-      WGC3Denum target, WebGLId renderbuffer) {
+      GLenum target, GLuint renderbuffer) {
 }
 
 void FakeWebGraphicsContext3D::bindTexture(
-    WGC3Denum target, WebGLId texture_id) {
+    GLenum target, GLuint texture_id) {
 }
 
-WebGLId FakeWebGraphicsContext3D::createQueryEXT() {
+GLuint FakeWebGraphicsContext3D::createQueryEXT() {
   return 1;
 }
 
-WGC3Dboolean FakeWebGraphicsContext3D::isQueryEXT(WebGLId query) {
+GLboolean FakeWebGraphicsContext3D::isQueryEXT(GLuint query) {
   return true;
 }
 
-void FakeWebGraphicsContext3D::endQueryEXT(blink::WGC3Denum target) {
+void FakeWebGraphicsContext3D::endQueryEXT(GLenum target) {
 }
 
 void FakeWebGraphicsContext3D::getQueryObjectuivEXT(
-    blink::WebGLId query,
-    blink::WGC3Denum pname,
-    blink::WGC3Duint* params) {
+    GLuint query,
+    GLenum pname,
+    GLuint* params) {
 }
 
 void FakeWebGraphicsContext3D::setContextLostCallback(
     WebGraphicsContext3D::WebGraphicsContextLostCallback* callback) {
 }
 
-void FakeWebGraphicsContext3D::loseContextCHROMIUM(WGC3Denum current,
-                                                   WGC3Denum other) {
+void FakeWebGraphicsContext3D::loseContextCHROMIUM(GLenum current,
+                                                   GLenum other) {
 }
 
-blink::WGC3Duint FakeWebGraphicsContext3D::createImageCHROMIUM(
-     blink::WGC3Dsizei width, blink::WGC3Dsizei height,
-     blink::WGC3Denum internalformat) {
+GLuint FakeWebGraphicsContext3D::createImageCHROMIUM(
+     GLsizei width, GLsizei height,
+     GLenum internalformat) {
   return 0;
 }
 
-void* FakeWebGraphicsContext3D::mapImageCHROMIUM(blink::WGC3Duint image_id,
-                                                 blink::WGC3Denum access) {
+void* FakeWebGraphicsContext3D::mapImageCHROMIUM(GLuint image_id,
+                                                 GLenum access) {
   return 0;
 }
 
 }  // namespace cc