Changes the code to use separate ids namspaces...

gpu/command_buffer/service/gles2_cmd_decoder_autogen.h

 // Copyright (c) 2009 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.
 
 // This file is auto-generated. DO NOT EDIT!
 
 // It is included by gles2_cmd_decoder.cc
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_
 
 error::Error GLES2DecoderImpl::HandleActiveTexture(
     uint32 immediate_data_size, const gles2::ActiveTexture& c) {
   GLenum texture = static_cast<GLenum>(c.texture);
   DoActiveTexture(texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAttachShader(
     uint32 immediate_data_size, const gles2::AttachShader& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  glAttachShader(program, shader);
+  GLuint program = c.program;
+  GLuint shader = c.shader;
+  DoAttachShader(program, shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindBuffer(
     uint32 immediate_data_size, const gles2::BindBuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint buffer = c.buffer;
   if (!ValidateGLenumBufferTarget(target)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
@@ skipping 216 matching lines @@
   GLboolean red = static_cast<GLboolean>(c.red);
   GLboolean green = static_cast<GLboolean>(c.green);
   GLboolean blue = static_cast<GLboolean>(c.blue);
   GLboolean alpha = static_cast<GLboolean>(c.alpha);
   glColorMask(red, green, blue, alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompileShader(
     uint32 immediate_data_size, const gles2::CompileShader& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint shader = c.shader;
   DoCompileShader(shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2D(
     uint32 immediate_data_size, const gles2::CompressedTexSubImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
@@ skipping 114 matching lines @@
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateProgram(
     uint32 immediate_data_size, const gles2::CreateProgram& c) {
   uint32 client_id = c.client_id;
-  CreateProgramHelper(client_id);
+  if (!CreateProgramHelper(client_id)) {
+    return error::kInvalidArguments;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateShader(
     uint32 immediate_data_size, const gles2::CreateShader& c) {
   GLenum type = static_cast<GLenum>(c.type);
   if (!ValidateGLenumShaderType(type)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   uint32 client_id = c.client_id;
-  CreateShaderHelper(type, client_id);
+  if (!CreateShaderHelper(type, client_id)) {
+    return error::kInvalidArguments;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCullFace(
     uint32 immediate_data_size, const gles2::CullFace& c) {
   GLenum mode = static_cast<GLenum>(c.mode);
   if (!ValidateGLenumFaceType(mode)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
@@ skipping 10 matching lines @@
   }
   const GLuint* buffers = GetSharedMemoryAs<const GLuint*>(
       c.buffers_shm_id, c.buffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers);
+  DeleteBuffersHelper(n, buffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteBuffersImmediate(
     uint32 immediate_data_size, const gles2::DeleteBuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* buffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteBuffersHelper>(n, buffers);
+  DeleteBuffersHelper(n, buffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteFramebuffers(
     uint32 immediate_data_size, const gles2::DeleteFramebuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* framebuffers = GetSharedMemoryAs<const GLuint*>(
       c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers);
+  DeleteFramebuffersHelper(n, framebuffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteFramebuffersImmediate(
     uint32 immediate_data_size, const gles2::DeleteFramebuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* framebuffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteFramebuffersHelper>(n, framebuffers);
+  DeleteFramebuffersHelper(n, framebuffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffers(
     uint32 immediate_data_size, const gles2::DeleteRenderbuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* renderbuffers = GetSharedMemoryAs<const GLuint*>(
       c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers);
+  DeleteRenderbuffersHelper(n, renderbuffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteRenderbuffersImmediate(
     uint32 immediate_data_size, const gles2::DeleteRenderbuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* renderbuffers = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteRenderbuffersHelper>(n, renderbuffers);
+  DeleteRenderbuffersHelper(n, renderbuffers);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteTextures(
     uint32 immediate_data_size, const gles2::DeleteTextures& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* textures = GetSharedMemoryAs<const GLuint*>(
       c.textures_shm_id, c.textures_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteTexturesHelper>(n, textures);
+  DeleteTexturesHelper(n, textures);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteTexturesImmediate(
     uint32 immediate_data_size, const gles2::DeleteTexturesImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* textures = GetImmediateDataAs<const GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
-  DeleteGLObjects<GLDeleteTexturesHelper>(n, textures);
+  DeleteTexturesHelper(n, textures);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDepthFunc(
     uint32 immediate_data_size, const gles2::DepthFunc& c) {
   GLenum func = static_cast<GLenum>(c.func);
   if (!ValidateGLenumCmpFunction(func)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
@@ skipping 11 matching lines @@
 error::Error GLES2DecoderImpl::HandleDepthRangef(
     uint32 immediate_data_size, const gles2::DepthRangef& c) {
   GLclampf zNear = static_cast<GLclampf>(c.zNear);
   GLclampf zFar = static_cast<GLclampf>(c.zFar);
   glDepthRange(zNear, zFar);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDetachShader(
     uint32 immediate_data_size, const gles2::DetachShader& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  glDetachShader(program, shader);
+  GLuint program = c.program;
+  GLuint shader = c.shader;
+  DoDetachShader(program, shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDisable(
     uint32 immediate_data_size, const gles2::Disable& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   if (!ValidateGLenumCapability(cap)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
@@ skipping 53 matching lines @@
     uint32 immediate_data_size, const gles2::Flush& c) {
   glFlush();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFramebufferRenderbuffer(
     uint32 immediate_data_size, const gles2::FramebufferRenderbuffer& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum renderbuffertarget = static_cast<GLenum>(c.renderbuffertarget);
-  GLuint renderbuffer;
-  if (!id_manager()->GetServiceId(c.renderbuffer, &renderbuffer)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint renderbuffer = c.renderbuffer;
   if (!ValidateGLenumFrameBufferTarget(target)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   if (!ValidateGLenumAttachment(attachment)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   if (!ValidateGLenumRenderBufferTarget(renderbuffertarget)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   DoFramebufferRenderbuffer(
       target, attachment, renderbuffertarget, renderbuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleFramebufferTexture2D(
     uint32 immediate_data_size, const gles2::FramebufferTexture2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum attachment = static_cast<GLenum>(c.attachment);
   GLenum textarget = static_cast<GLenum>(c.textarget);
-  GLuint texture;
-  if (!id_manager()->GetServiceId(c.texture, &texture)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint texture = c.texture;
   GLint level = static_cast<GLint>(c.level);
   if (!ValidateGLenumFrameBufferTarget(target)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   if (!ValidateGLenumAttachment(attachment)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   if (!ValidateGLenumTextureTarget(textarget)) {
@@ skipping 24 matching lines @@
   }
   GLuint* buffers = GetSharedMemoryAs<GLuint*>(
       c.buffers_shm_id, c.buffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenBuffersHelper>(n, buffers)) {
+  if (!GenBuffersHelper(n, buffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenBuffersImmediate(
     uint32 immediate_data_size, const gles2::GenBuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* buffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (buffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenBuffersHelper>(n, buffers)) {
+  if (!GenBuffersHelper(n, buffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenerateMipmap(
     uint32 immediate_data_size, const gles2::GenerateMipmap& c) {
   GLenum target = static_cast<GLenum>(c.target);
   if (!ValidateGLenumTextureBindTarget(target)) {
     SetGLError(GL_INVALID_ENUM);
@@ skipping 12 matching lines @@
   }
   GLuint* framebuffers = GetSharedMemoryAs<GLuint*>(
       c.framebuffers_shm_id, c.framebuffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers)) {
+  if (!GenFramebuffersHelper(n, framebuffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenFramebuffersImmediate(
     uint32 immediate_data_size, const gles2::GenFramebuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* framebuffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (framebuffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenFramebuffersHelper>(n, framebuffers)) {
+  if (!GenFramebuffersHelper(n, framebuffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenRenderbuffers(
     uint32 immediate_data_size, const gles2::GenRenderbuffers& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* renderbuffers = GetSharedMemoryAs<GLuint*>(
       c.renderbuffers_shm_id, c.renderbuffers_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers)) {
+  if (!GenRenderbuffersHelper(n, renderbuffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenRenderbuffersImmediate(
     uint32 immediate_data_size, const gles2::GenRenderbuffersImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* renderbuffers = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (renderbuffers == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenRenderbuffersHelper>(n, renderbuffers)) {
+  if (!GenRenderbuffersHelper(n, renderbuffers)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenTextures(
     uint32 immediate_data_size, const gles2::GenTextures& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* textures = GetSharedMemoryAs<GLuint*>(
       c.textures_shm_id, c.textures_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenTexturesHelper>(n, textures)) {
+  if (!GenTexturesHelper(n, textures)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGenTexturesImmediate(
     uint32 immediate_data_size, const gles2::GenTexturesImmediate& c) {
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* textures = GetImmediateDataAs<GLuint*>(
       c, data_size, immediate_data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (textures == NULL) {
     return error::kOutOfBounds;
   }
-  if (!GenGLObjects<GLGenTexturesHelper>(n, textures)) {
+  if (!GenTexturesHelper(n, textures)) {
     return error::kInvalidArguments;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetBooleanv(
     uint32 immediate_data_size, const gles2::GetBooleanv& c) {
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetBooleanv::Result Result;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
@@ skipping 185 matching lines @@
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     SetGLError(error);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramiv(
     uint32 immediate_data_size, const gles2::GetProgramiv& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint program = c.program;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetProgramiv::Result Result;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   if (num_values == 0) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint* params = result ? result->GetData() : NULL;
@@ skipping 12 matching lines @@
   DoGetProgramiv(program, pname, params);
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     SetGLError(error);
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
-    uint32 immediate_data_size, const gles2::GetProgramInfoLog& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
-  GLint len = 0;
-  glGetProgramiv(program, GL_INFO_LOG_LENGTH, &len);
-  Bucket* bucket = CreateBucket(bucket_id);
-  bucket->SetSize(len + 1);
-  glGetProgramInfoLog(
-      program, len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGetRenderbufferParameteriv(
     uint32 immediate_data_size, const gles2::GetRenderbufferParameteriv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetRenderbufferParameteriv::Result Result;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   if (num_values == 0) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
@@ skipping 21 matching lines @@
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     SetGLError(error);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderiv(
     uint32 immediate_data_size, const gles2::GetShaderiv& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint shader = c.shader;
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetShaderiv::Result Result;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   if (num_values == 0) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   Result* result = GetSharedMemoryAs<Result*>(
       c.params_shm_id, c.params_shm_offset, Result::ComputeSize(num_values));
   GLint* params = result ? result->GetData() : NULL;
@@ skipping 12 matching lines @@
   DoGetShaderiv(shader, pname, params);
   GLenum error = glGetError();
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     SetGLError(error);
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
-    uint32 immediate_data_size, const gles2::GetShaderInfoLog& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
-  GLint len = 0;
-  glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
-  Bucket* bucket = CreateBucket(bucket_id);
-  bucket->SetSize(len + 1);
-  glGetShaderInfoLog(
-      shader, len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
-  return error::kNoError;
-}
-
-error::Error GLES2DecoderImpl::HandleGetShaderSource(
-    uint32 immediate_data_size, const gles2::GetShaderSource& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
-  GLint len = 0;
-  DoGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &len);
-  Bucket* bucket = CreateBucket(bucket_id);
-  bucket->SetSize(len + 1);
-  DoGetShaderSource(
-      shader, len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderImpl::HandleGetTexParameterfv(
     uint32 immediate_data_size, const gles2::GetTexParameterfv& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef GetTexParameterfv::Result Result;
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
   if (num_values == 0) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
@@ skipping 146 matching lines @@
   if (!ValidateGLenumHintMode(mode)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   glHint(target, mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsBuffer(
     uint32 immediate_data_size, const gles2::IsBuffer& c) {
-  GLuint buffer;
-  if (!id_manager()->GetServiceId(c.buffer, &buffer)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint buffer = c.buffer;
   typedef IsBuffer::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsBuffer(buffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsEnabled(
     uint32 immediate_data_size, const gles2::IsEnabled& c) {
   GLenum cap = static_cast<GLenum>(c.cap);
   typedef IsEnabled::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (!ValidateGLenumCapability(cap)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   *result_dst = glIsEnabled(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsFramebuffer(
     uint32 immediate_data_size, const gles2::IsFramebuffer& c) {
-  GLuint framebuffer = static_cast<GLuint>(c.framebuffer);
+  GLuint framebuffer = c.framebuffer;
   typedef IsFramebuffer::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsFramebuffer(framebuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsProgram(
     uint32 immediate_data_size, const gles2::IsProgram& c) {
-  GLuint program = static_cast<GLuint>(c.program);
+  GLuint program = c.program;
   typedef IsProgram::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsProgram(program);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsRenderbuffer(
     uint32 immediate_data_size, const gles2::IsRenderbuffer& c) {
-  GLuint renderbuffer = static_cast<GLuint>(c.renderbuffer);
+  GLuint renderbuffer = c.renderbuffer;
   typedef IsRenderbuffer::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsRenderbuffer(renderbuffer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsShader(
     uint32 immediate_data_size, const gles2::IsShader& c) {
-  GLuint shader = static_cast<GLuint>(c.shader);
+  GLuint shader = c.shader;
   typedef IsShader::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsShader(shader);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleIsTexture(
     uint32 immediate_data_size, const gles2::IsTexture& c) {
-  GLuint texture = static_cast<GLuint>(c.texture);
+  GLuint texture = c.texture;
   typedef IsTexture::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   *result_dst = DoIsTexture(texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleLineWidth(
     uint32 immediate_data_size, const gles2::LineWidth& c) {
   GLfloat width = static_cast<GLfloat>(c.width);
   glLineWidth(width);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleLinkProgram(
     uint32 immediate_data_size, const gles2::LinkProgram& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint program = c.program;
   DoLinkProgram(program);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePolygonOffset(
     uint32 immediate_data_size, const gles2::PolygonOffset& c) {
   GLfloat factor = static_cast<GLfloat>(c.factor);
   GLfloat units = static_cast<GLfloat>(c.units);
   glPolygonOffset(factor, units);
   return error::kNoError;
@@ skipping 981 matching lines @@
   if (value == NULL) {
     return error::kOutOfBounds;
   }
   glUniformMatrix4fv(location, count, transpose, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleUseProgram(
     uint32 immediate_data_size, const gles2::UseProgram& c) {
   GLuint program = c.program;
-  if (program != 0 && !id_manager()->GetServiceId(program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
   DoUseProgram(program);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleValidateProgram(
     uint32 immediate_data_size, const gles2::ValidateProgram& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
-  glValidateProgram(program);
+  GLuint program = c.program;
+  DoValidateProgram(program);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttrib1f(
     uint32 immediate_data_size, const gles2::VertexAttrib1f& c) {
   GLuint indx = static_cast<GLuint>(c.indx);
   GLfloat x = static_cast<GLfloat>(c.x);
   glVertexAttrib1f(indx, x);
   return error::kNoError;
 }
@@ skipping 181 matching lines @@
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   glViewport(x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetMaxValueInBuffer(
     uint32 immediate_data_size, const gles2::GetMaxValueInBuffer& c) {
-  GLuint buffer_id;
-  if (!id_manager()->GetServiceId(c.buffer_id, &buffer_id)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
+  GLuint buffer_id = c.buffer_id;
   GLsizei count = static_cast<GLsizei>(c.count);
   GLenum type = static_cast<GLenum>(c.type);
   GLuint offset = static_cast<GLuint>(c.offset);
   typedef GetMaxValueInBuffer::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   if (!ValidateGLenumIndexType(type)) {
     SetGLError(GL_INVALID_ENUM);
     return error::kNoError;
   }
   *result_dst = DoGetMaxValueInBuffer(buffer_id, count, type, offset);
   return error::kNoError;
 }
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_AUTOGEN_H_