Changes the code to use separate ids namspaces...

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // 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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <vector>
 #include <string>
 #include <map>
 
 #include "app/gfx/gl/gl_context.h"
 #include "base/callback.h"
 #include "base/linked_ptr.h"
 #include "base/scoped_ptr.h"
 #include "base/weak_ptr.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
-#include "gpu/command_buffer/service/id_manager.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 
 // TODO(alokp): Remove GLES2_GPU_SERVICE_TRANSLATE_SHADER guard
 // as soon as translator is ready.
 //#define GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
 #include "third_party/angleproject/include/GLSLANG/ShaderLang.h"
@@ skipping 336 matching lines @@
   virtual const char* GetCommandName(unsigned int command_id) const;
 
   // Overridden from GLES2Decoder.
   virtual bool Initialize(gfx::GLContext* context,
                           const gfx::Size& size,
                           GLES2Decoder* parent,
                           uint32 parent_client_texture_id);
   virtual void Destroy();
   virtual void ResizeOffscreenFrameBuffer(const gfx::Size& size);
   virtual bool MakeCurrent();
-  virtual uint32 GetServiceIdForTesting(uint32 client_id);
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_; }
 
   virtual void SetSwapBuffersCallback(Callback0::Type* callback);
 
  private:
   friend class ScopedGLErrorSuppressor;
   friend class ScopedTexture2DBinder;
   friend class ScopedFrameBufferBinder;
   friend class ScopedRenderBufferBinder;
   friend class ScopedDefaultGLContext;
   friend class RenderBuffer;
   friend class FrameBuffer;
 
   // State associated with each texture unit.
   struct TextureUnit {
     TextureUnit() : bind_target(GL_TEXTURE_2D) { }
 
     // The last target that was bound to this texture unit.
     GLenum bind_target;
 
     // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_2d;
 
     // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
     // glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_cube_map;
   };
 
-  friend void GLGenTexturesHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLDeleteTexturesHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLGenBuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLDeleteBuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLGenFramebuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLDeleteFramebuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLGenRenderbuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
-  friend void GLDeleteRenderbuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids);
+  // Helpers for the glGen and glDelete functions.
+  bool GenTexturesHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteTexturesHelper(GLsizei n, const GLuint* client_ids);
+  bool GenBuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteBuffersHelper(GLsizei n, const GLuint* client_ids);
+  bool GenFramebuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteFramebuffersHelper(GLsizei n, const GLuint* client_ids);
+  bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
 
   // TODO(gman): Cache these pointers?
-  IdManager* id_manager() {
-    return group_->id_manager();
-  }
-
   BufferManager* buffer_manager() {
     return group_->buffer_manager();
   }
 
   RenderbufferManager* renderbuffer_manager() {
     return group_->renderbuffer_manager();
   }
 
   FramebufferManager* framebuffer_manager() {
     return group_->framebuffer_manager();
   }
 
   ProgramManager* program_manager() {
     return group_->program_manager();
   }
 
   ShaderManager* shader_manager() {
     return group_->shader_manager();
   }
 
   TextureManager* texture_manager() {
     return group_->texture_manager();
   }
 
   bool UpdateOffscreenFrameBufferSize();
 
-  // Template to help call glGenXXX functions.
-  template <void gl_gen_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
-  bool GenGLObjects(GLsizei n, const GLuint* client_ids) {
-    DCHECK_GE(n, 0);
-    if (!ValidateIdsAreUnused(n, client_ids)) {
-      return false;
-    }
-    scoped_array<GLuint>temp(new GLuint[n]);
-    gl_gen_function(this, n, temp.get());
-    return RegisterObjects(n, client_ids, temp.get());
-  }
-
-  // Template to help call glDeleteXXX functions.
-  template <void gl_delete_function(GLES2DecoderImpl*, GLsizei, GLuint*)>
-  bool DeleteGLObjects(GLsizei n, const GLuint* client_ids) {
-    DCHECK_GE(n, 0);
-    scoped_array<GLuint>temp(new GLuint[n]);
-    UnregisterObjects(n, client_ids, temp.get());
-    gl_delete_function(this, n, temp.get());
-    return true;
-  }
-
-  // Check that the given ids are not used.
-  bool ValidateIdsAreUnused(GLsizei n, const GLuint* client_ids);
-
-  // Register client ids with generated service ids.
-  bool RegisterObjects(
-      GLsizei n, const GLuint* client_ids, const GLuint* service_ids);
-
-  // Unregisters client ids with service ids.
-  void UnregisterObjects(
-    GLsizei n, const GLuint* client_ids, GLuint* service_ids);
-
   // Creates a TextureInfo for the given texture.
-  TextureManager::TextureInfo* CreateTextureInfo(GLuint texture) {
-    return texture_manager()->CreateTextureInfo(texture);
+  TextureManager::TextureInfo* CreateTextureInfo(
+      GLuint client_id, GLuint service_id) {
+    return texture_manager()->CreateTextureInfo(client_id, service_id);
   }
 
   // Gets the texture info for the given texture. Returns NULL if none exists.
-  TextureManager::TextureInfo* GetTextureInfo(GLuint texture) {
+  TextureManager::TextureInfo* GetTextureInfo(GLuint client_id) {
     TextureManager::TextureInfo* info =
-        texture_manager()->GetTextureInfo(texture);
+        texture_manager()->GetTextureInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Deletes the texture info for the given texture.
-  void RemoveTextureInfo(GLuint texture) {
-    texture_manager()->RemoveTextureInfo(texture);
+  void RemoveTextureInfo(GLuint client_id) {
+    texture_manager()->RemoveTextureInfo(client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
   gfx::Size GetBoundFrameBufferSize();
 
   // Wrapper for CompressedTexImage2D commands.
   error::Error DoCompressedTexImage2D(
     GLenum target,
     GLint level,
@@ skipping 11 matching lines @@
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels,
     uint32 pixels_size);
 
   // Creates a ProgramInfo for the given program.
-  void CreateProgramInfo(GLuint program) {
-    program_manager()->CreateProgramInfo(program);
+  void CreateProgramInfo(GLuint client_id, GLuint service_id) {
+    program_manager()->CreateProgramInfo(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
-  // Programs that have no had glLinkProgram succesfully called on them will
-  // not exist.
-  ProgramManager::ProgramInfo* GetProgramInfo(GLuint program) {
+  ProgramManager::ProgramInfo* GetProgramInfo(GLuint client_id) {
     ProgramManager::ProgramInfo* info =
-        program_manager()->GetProgramInfo(program);
+        program_manager()->GetProgramInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Deletes the program info for the given program.
-  void RemoveProgramInfo(GLuint program) {
-    program_manager()->RemoveProgramInfo(program);
+  void RemoveProgramInfo(GLuint client_id) {
+    program_manager()->RemoveProgramInfo(client_id);
   }
 
   // Creates a ShaderInfo for the given shader.
-  void CreateShaderInfo(GLuint shader) {
-    shader_manager()->CreateShaderInfo(shader);
+  void CreateShaderInfo(GLuint client_id, GLuint service_id) {
+    shader_manager()->CreateShaderInfo(client_id, service_id);
   }
 
   // Gets the shader info for the given shader. Returns NULL if none exists.
-  ShaderManager::ShaderInfo* GetShaderInfo(GLuint shader) {
-    ShaderManager::ShaderInfo* info = shader_manager()->GetShaderInfo(shader);
+  ShaderManager::ShaderInfo* GetShaderInfo(GLuint client_id) {
+    ShaderManager::ShaderInfo* info =
+        shader_manager()->GetShaderInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Deletes the shader info for the given shader.
-  void RemoveShaderInfo(GLuint shader) {
-    shader_manager()->RemoveShaderInfo(shader);
+  void RemoveShaderInfo(GLuint client_id) {
+    shader_manager()->RemoveShaderInfo(client_id);
   }
 
   // Creates a buffer info for the given buffer.
-  void CreateBufferInfo(GLuint buffer) {
-    return buffer_manager()->CreateBufferInfo(buffer);
+  void CreateBufferInfo(GLuint client_id, GLuint service_id) {
+    return buffer_manager()->CreateBufferInfo(client_id, service_id);
   }
 
   // Gets the buffer info for the given buffer.
-  BufferManager::BufferInfo* GetBufferInfo(GLuint buffer) {
-    BufferManager::BufferInfo* info = buffer_manager()->GetBufferInfo(buffer);
+  BufferManager::BufferInfo* GetBufferInfo(GLuint client_id) {
+    BufferManager::BufferInfo* info =
+        buffer_manager()->GetBufferInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Removes any buffers in the VertexAtrribInfos and BufferInfos. This is used
   // on glDeleteBuffers so we can make sure the user does not try to render
   // with deleted buffers.
-  void RemoveBufferInfo(GLuint buffer_id);
+  void RemoveBufferInfo(GLuint client_id);
 
   // Creates a framebuffer info for the given framebuffer.
-  void CreateFramebufferInfo(GLuint framebuffer) {
-    return framebuffer_manager()->CreateFramebufferInfo(framebuffer);
+  void CreateFramebufferInfo(GLuint client_id, GLuint service_id) {
+    return framebuffer_manager()->CreateFramebufferInfo(client_id, service_id);
   }
 
   // Gets the framebuffer info for the given framebuffer.
   FramebufferManager::FramebufferInfo* GetFramebufferInfo(
-      GLuint framebuffer) {
+      GLuint client_id) {
     FramebufferManager::FramebufferInfo* info =
-        framebuffer_manager()->GetFramebufferInfo(framebuffer);
+        framebuffer_manager()->GetFramebufferInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Removes the framebuffer info for the given framebuffer.
-  void RemoveFramebufferInfo(GLuint framebuffer_id) {
-    framebuffer_manager()->RemoveFramebufferInfo(framebuffer_id);
+  void RemoveFramebufferInfo(GLuint client_id) {
+    framebuffer_manager()->RemoveFramebufferInfo(client_id);
   }
 
   // Creates a renderbuffer info for the given renderbuffer.
-  void CreateRenderbufferInfo(GLuint renderbuffer) {
-    return renderbuffer_manager()->CreateRenderbufferInfo(renderbuffer);
+  void CreateRenderbufferInfo(GLuint client_id, GLuint service_id) {
+    return renderbuffer_manager()->CreateRenderbufferInfo(
+        client_id, service_id);
   }
 
   // Gets the renderbuffer info for the given renderbuffer.
   RenderbufferManager::RenderbufferInfo* GetRenderbufferInfo(
-      GLuint renderbuffer) {
+      GLuint client_id) {
     RenderbufferManager::RenderbufferInfo* info =
-        renderbuffer_manager()->GetRenderbufferInfo(renderbuffer);
+        renderbuffer_manager()->GetRenderbufferInfo(client_id);
     return (info && !info->IsDeleted()) ? info : NULL;
   }
 
   // Removes the renderbuffer info for the given renderbuffer.
-  void RemoveRenderbufferInfo(GLuint renderbuffer_id) {
-    renderbuffer_manager()->RemoveRenderbufferInfo(renderbuffer_id);
+  void RemoveRenderbufferInfo(GLuint client_id) {
+    renderbuffer_manager()->RemoveRenderbufferInfo(client_id);
   }
 
   error::Error GetAttribLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str);
 
   error::Error GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str);
 
   // Helper for glShaderSource.
   error::Error ShaderSourceHelper(
-      GLuint shader, const char* data, uint32 data_size);
+      GLuint client_id, const char* data, uint32 data_size);
 
   // Helper for glGetBooleanv, glGetFloatv and glGetIntegerv
   bool GetHelper(GLenum pname, GLint* params, GLsizei* num_written);
 
   // Wrapper for glCreateProgram
-  void CreateProgramHelper(GLuint client_id);
+  bool CreateProgramHelper(GLuint client_id);
 
   // Wrapper for glCreateShader
-  void CreateShaderHelper(GLenum type, GLuint client_id);
+  bool CreateShaderHelper(GLenum type, GLuint client_id);
 
   // Wrapper for glActiveTexture
   void DoActiveTexture(GLenum texture_unit);
 
+  // Wrapper for glAttachShader
+  void DoAttachShader(GLuint client_program_id, GLint client_shader_id);
+
   // Wrapper for glBindBuffer since we need to track the current targets.
   void DoBindBuffer(GLenum target, GLuint buffer);
 
   // Wrapper for glBindFramebuffer since we need to track the current targets.
   void DoBindFramebuffer(GLenum target, GLuint framebuffer);
 
   // Wrapper for glBindRenderbuffer since we need to track the current targets.
   void DoBindRenderbuffer(GLenum target, GLuint renderbuffer);
 
   // Wrapper for glBindTexture since we need to track the current targets.
   void DoBindTexture(GLenum target, GLuint texture);
 
   // Wrapper for glBufferData.
   void DoBufferData(
     GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage);
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glCompileShader.
   void DoCompileShader(GLuint shader);
 
+  // Wrapper for glDetachShader
+  void DoDetachShader(GLuint client_program_id, GLint client_shader_id);
+
   // Wrapper for glDrawArrays.
   void DoDrawArrays(GLenum mode, GLint first, GLsizei count);
 
   // Wrapper for glDisableVertexAttribArray.
   void DoDisableVertexAttribArray(GLuint index);
 
   // Wrapper for glEnableVertexAttribArray.
   void DoEnableVertexAttribArray(GLuint index);
 
   // Wrapper for glFramebufferRenderbufffer.
@@ skipping 30 matching lines @@
   void DoGetProgramiv(
       GLuint program_id, GLenum pname, GLint* params);
 
   // Wrapper for glRenderbufferParameteriv.
   void DoGetRenderbufferParameteriv(
       GLenum target, GLenum pname, GLint* params);
 
   // Wrapper for glGetShaderiv
   void DoGetShaderiv(GLuint shader, GLenum pname, GLint* params);
 
-  // Wrapper for glGetShaderSource.
-  void DoGetShaderSource(
-      GLuint shader, GLsizei bufsize, GLsizei* length, char* dst);
-
   // Wrappers for glIsXXX functions.
   bool DoIsBuffer(GLuint client_id);
   bool DoIsFramebuffer(GLuint client_id);
   bool DoIsProgram(GLuint client_id);
   bool DoIsRenderbuffer(GLuint client_id);
   bool DoIsShader(GLuint client_id);
   bool DoIsTexture(GLuint client_id);
 
   // Wrapper for glLinkProgram
   void DoLinkProgram(GLuint program);
 
   // Wrapper for glRenderbufferStorage.
   void DoRenderbufferStorage(
-    GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+      GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 
   // Wrapper for glReleaseShaderCompiler.
   void DoReleaseShaderCompiler() { }
 
   // Wrappers for glTexParameter functions.
   void DoTexParameterf(GLenum target, GLenum pname, GLfloat param);
   void DoTexParameteri(GLenum target, GLenum pname, GLint param);
   void DoTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
   void DoTexParameteriv(GLenum target, GLenum pname, const GLint* params);
 
   // Wrappers for glUniform1i and glUniform1iv as according to the GLES2
   // spec only these 2 functions can be used to set sampler uniforms.
   void DoUniform1i(GLint location, GLint v0);
   void DoUniform1iv(GLint location, GLsizei count, const GLint *value);
 
   // Wrapper for glUseProgram
   void DoUseProgram(GLuint program);
 
+  // Wrapper for glValidateProgram.
+  void DoValidateProgram(GLuint program_client_id);
+
   // Gets the GLError through our wrapper.
   GLenum GetGLError();
 
   // Sets our wrapper for the GLError.
   void SetGLError(GLenum error);
 
   // Copies the real GL errors to the wrapper. This is so we can
   // make sure there are no native GL errors before calling some GL function
   // so that on return we know any error generated was for that specific
   // command.
@@ skipping 165 matching lines @@
   // before binding a new texture.
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, id);
 }
 
 ScopedTexture2DBinder::~ScopedTexture2DBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   GLES2DecoderImpl::TextureUnit& info = decoder_->texture_units_[0];
   GLuint last_id;
   if (info.bound_texture_2d)
-    last_id = info.bound_texture_2d->texture_id();
+    last_id = info.bound_texture_2d->service_id();
   else
     last_id = 0;
 
   glBindTexture(GL_TEXTURE_2D, last_id);
   glActiveTexture(GL_TEXTURE0 + decoder_->active_texture_unit_);
 }
 
 ScopedRenderBufferBinder::ScopedRenderBufferBinder(GLES2DecoderImpl* decoder,
                                                    GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindRenderbufferEXT(GL_RENDERBUFFER, id);
 }
 
 ScopedRenderBufferBinder::~ScopedRenderBufferBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindRenderbufferEXT(
       GL_RENDERBUFFER,
       decoder_->bound_renderbuffer_ ?
-          decoder_->bound_renderbuffer_->renderbuffer_id() : 0);
+          decoder_->bound_renderbuffer_->service_id() : 0);
 }
 
 ScopedFrameBufferBinder::ScopedFrameBufferBinder(GLES2DecoderImpl* decoder,
                                                  GLuint id)
     : decoder_(decoder) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindFramebufferEXT(GL_FRAMEBUFFER, id);
 }
 
 ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   FramebufferManager::FramebufferInfo* info =
       decoder_->bound_framebuffer_.get();
-  GLuint framebuffer_id = info ? info->framebuffer_id() : 0;
+  GLuint framebuffer_id = info ? info->service_id() : 0;
   if (framebuffer_id == 0 &&
       decoder_->offscreen_target_frame_buffer_.get()) {
     glBindFramebufferEXT(GL_FRAMEBUFFER,
                          decoder_->offscreen_target_frame_buffer_->id());
   } else {
     glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer_id);
   }
 }
 
 ScopedDefaultGLContext::ScopedDefaultGLContext(GLES2DecoderImpl* decoder)
@@ skipping 265 matching lines @@
 
     // Create the saved offscreen texture. The target frame buffer is copied
     // here when SwapBuffers is called.
     offscreen_saved_color_texture_.reset(new Texture(this));
     offscreen_saved_color_texture_->Create();
 
     // Map the ID of the saved offscreen texture into the parent so that
     // it can reference it.
     if (parent_) {
       GLuint service_id = offscreen_saved_color_texture_->id();
-      parent_->id_manager()->AddMapping(parent_client_texture_id,
-                                        service_id);
       TextureManager::TextureInfo* info =
-          parent_->CreateTextureInfo(service_id);
+          parent_->CreateTextureInfo(parent_client_texture_id, service_id);
       parent_->texture_manager()->SetInfoTarget(info, GL_TEXTURE_2D);
     }
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     pending_offscreen_size_ = size;
     if (!UpdateOffscreenFrameBufferSize()) {
       DLOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy();
       return false;
@@ skipping 18 matching lines @@
     DLOG(ERROR) << "Could not initialize GLSL translator.";
     Destroy();
     return false;
   }
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 
   return true;
 }
 
-// These commands convert from c calls to local os calls.
-void GLGenBuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glGenBuffersARB(n, ids);
-  // TODO(gman): handle error
+bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->CreateBufferInfo(ids[ii]);
+    if (GetBufferInfo(client_ids[ii])) {
+      return false;
+    }
+  }
+  scoped_array<GLuint> service_ids(new GLuint[n]);
+  glGenBuffersARB(n, service_ids.get());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    CreateBufferInfo(client_ids[ii], service_ids[ii]);
+  }
+  return true;
+}
+
+bool GLES2DecoderImpl::GenFramebuffersHelper(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    if (GetFramebufferInfo(client_ids[ii])) {
+      return false;
+    }
+  }
+  scoped_array<GLuint> service_ids(new GLuint[n]);
+  glGenFramebuffersEXT(n, service_ids.get());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    CreateFramebufferInfo(client_ids[ii], service_ids[ii]);
+  }
+  return true;
+}
+
+bool GLES2DecoderImpl::GenRenderbuffersHelper(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    if (GetRenderbufferInfo(client_ids[ii])) {
+      return false;
+    }
+  }
+  scoped_array<GLuint> service_ids(new GLuint[n]);
+  glGenRenderbuffersEXT(n, service_ids.get());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    CreateRenderbufferInfo(client_ids[ii], service_ids[ii]);
+  }
+  return true;
+}
+
+bool GLES2DecoderImpl::GenTexturesHelper(GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    if (GetTextureInfo(client_ids[ii])) {
+      return false;
+    }
+  }
+  scoped_array<GLuint> service_ids(new GLuint[n]);
+  glGenTextures(n, service_ids.get());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    CreateTextureInfo(client_ids[ii], service_ids[ii]);
+  }
+  return true;
+}
+
+void GLES2DecoderImpl::DeleteBuffersHelper(
+    GLsizei n, const GLuint* client_ids) {
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    BufferManager::BufferInfo* info = GetBufferInfo(client_ids[ii]);
+    if (info) {
+      GLuint service_id = info->service_id();
+      glDeleteBuffersARB(1, &service_id);
+      RemoveBufferInfo(client_ids[ii]);
+    }
   }
 }
 
-void GLGenFramebuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glGenFramebuffersEXT(n, ids);
-  // TODO(gman): handle error
+void GLES2DecoderImpl::DeleteFramebuffersHelper(
+    GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->CreateFramebufferInfo(ids[ii]);
+    FramebufferManager::FramebufferInfo* info =
+        GetFramebufferInfo(client_ids[ii]);
+    if (info) {
+      GLuint service_id = info->service_id();
+      glDeleteFramebuffersEXT(1, &service_id);
+      RemoveFramebufferInfo(client_ids[ii]);
+    }
   }
 }
 
-void GLGenRenderbuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glGenRenderbuffersEXT(n, ids);
-  // TODO(gman): handle error
+void GLES2DecoderImpl::DeleteRenderbuffersHelper(
+    GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->CreateRenderbufferInfo(ids[ii]);
+    RenderbufferManager::RenderbufferInfo* info =
+        GetRenderbufferInfo(client_ids[ii]);
+    if (info) {
+      GLuint service_id = info->service_id();
+      glDeleteRenderbuffersEXT(1, &service_id);
+      RemoveRenderbufferInfo(client_ids[ii]);
+    }
   }
 }
 
-void GLGenTexturesHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glGenTextures(n, ids);
-  // TODO(gman): handle error
+void GLES2DecoderImpl::DeleteTexturesHelper(
+    GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->CreateTextureInfo(ids[ii]);
-  }
-}
-
-void GLDeleteBuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glDeleteBuffersARB(n, ids);
-  // TODO(gman): handle error
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->RemoveBufferInfo(ids[ii]);
-  }
-}
-
-void GLDeleteFramebuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glDeleteFramebuffersEXT(n, ids);
-  // TODO(gman): handle error
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->RemoveFramebufferInfo(ids[ii]);
-  }
-}
-
-void GLDeleteRenderbuffersHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glDeleteRenderbuffersEXT(n, ids);
-  // TODO(gman): handle error
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->RemoveRenderbufferInfo(ids[ii]);
-  }
-}
-
-void GLDeleteTexturesHelper(
-    GLES2DecoderImpl* decoder, GLsizei n, GLuint* ids) {
-  glDeleteTextures(n, ids);
-  // TODO(gman): handle error
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    decoder->RemoveTextureInfo(ids[ii]);
+    TextureManager::TextureInfo* info = GetTextureInfo(client_ids[ii]);
+    if (info) {
+      GLuint service_id = info->service_id();
+      glDeleteTextures(1, &service_id);
+      RemoveTextureInfo(client_ids[ii]);
+    }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
 #if defined(UNIT_TEST)
   return true;
 #else
   return context_->MakeCurrent();
 #endif
 }
 
-uint32 GLES2DecoderImpl::GetServiceIdForTesting(uint32 client_id) {
-#if defined(UNIT_TEST)
-  GLuint service_id;
-  bool result = id_manager()->GetServiceId(client_id, &service_id);
-  return result ? service_id : 0u;
-#else
-  DCHECK(false);
-  return 0u;
-#endif
-}
-
-bool GLES2DecoderImpl::ValidateIdsAreUnused(
-    GLsizei n, const GLuint* client_ids) {
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    GLuint service_id;
-    if (id_manager()->GetServiceId(client_ids[ii], &service_id)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool GLES2DecoderImpl::RegisterObjects(
-    GLsizei n, const GLuint* client_ids, const GLuint* service_ids) {
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    if (!id_manager()->AddMapping(client_ids[ii], service_ids[ii])) {
-      NOTREACHED();
-      return false;
-    }
-  }
-  return true;
-}
-
-void GLES2DecoderImpl::UnregisterObjects(
-    GLsizei n, const GLuint* client_ids, GLuint* service_ids) {
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    if (id_manager()->GetServiceId(client_ids[ii], &service_ids[ii])) {
-      id_manager()->RemoveMapping(client_ids[ii], service_ids[ii]);
-    } else {
-      service_ids[ii] = 0;
-    }
-  }
-}
-
 gfx::Size GLES2DecoderImpl::GetBoundFrameBufferSize() {
   if (bound_framebuffer_ != 0) {
     int width = 0;
     int height = 0;
 
     // Assume we have to have COLOR_ATTACHMENT0. Should we check for depth and
     // stencil.
     GLint fb_type = 0;
     glGetFramebufferAttachmentParameterivEXT(
         GL_FRAMEBUFFER,
@@ skipping 23 matching lines @@
         }
       case GL_TEXTURE:
         {
           GLint texture_id = 0;
           glGetFramebufferAttachmentParameterivEXT(
               GL_FRAMEBUFFER,
               GL_COLOR_ATTACHMENT0,
               GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
               &texture_id);
           if (texture_id != 0) {
-            TextureManager::TextureInfo* texture_info =
-                GetTextureInfo(texture_id);
-            if (texture_info) {
-              GLint level = 0;
-              GLint face = 0;
-              glGetFramebufferAttachmentParameterivEXT(
-                  GL_FRAMEBUFFER,
-                  GL_COLOR_ATTACHMENT0,
-                  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
-                  &level);
-              glGetFramebufferAttachmentParameterivEXT(
-                  GL_FRAMEBUFFER,
-                  GL_COLOR_ATTACHMENT0,
-                  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
-                  &face);
-              texture_info->GetLevelSize(
-                  face ? face : GL_TEXTURE_2D, level, &width, &height);
+            GLuint client_id = 0;
+            if (texture_manager()->GetClientId(texture_id, &client_id)) {
+              TextureManager::TextureInfo* texture_info =
+                 GetTextureInfo(client_id);
+              if (texture_info) {
+                GLint level = 0;
+                GLint face = 0;
+                glGetFramebufferAttachmentParameterivEXT(
+                    GL_FRAMEBUFFER,
+                    GL_COLOR_ATTACHMENT0,
+                    GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
+                    &level);
+                glGetFramebufferAttachmentParameterivEXT(
+                    GL_FRAMEBUFFER,
+                    GL_COLOR_ATTACHMENT0,
+                    GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
+                    &face);
+                texture_info->GetLevelSize(
+                    face ? face : GL_TEXTURE_2D, level, &width, &height);
+              }
             }
           }
           break;
         }
       default:
         // unknown so assume width and height are zero.
         break;
     }
 
     return gfx::Size(width, height);
@@ skipping 112 matching lines @@
   if (context_) {
     MakeCurrent();
 
     // Remove the saved frame buffer mapping from the parent decoder. The
     // parent pointer is a weak pointer so it will be null if the parent has
     // already been destroyed.
     if (parent_) {
       // First check the texture has been mapped into the parent. This might not
       // be the case if initialization failed midway through.
       GLuint service_id = offscreen_saved_color_texture_->id();
-      GLuint client_id;
-      if (parent_->id_manager()->GetClientId(service_id, &client_id)) {
-        parent_->texture_manager()->RemoveTextureInfo(service_id);
-        parent_->id_manager()->RemoveMapping(client_id, service_id);
+      GLuint client_id = 0;
+      if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
+        parent_->texture_manager()->RemoveTextureInfo(client_id);
       }
     }
 
     if (offscreen_target_frame_buffer_.get()) {
       offscreen_target_frame_buffer_->Destroy();
       offscreen_target_frame_buffer_.reset();
     }
 
     if (offscreen_target_color_texture_.get()) {
       offscreen_target_color_texture_->Destroy();
@@ skipping 80 matching lines @@
       }
     } else {
       result = error::kInvalidArguments;
     }
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
   }
   return result;
 }
 
-void GLES2DecoderImpl::RemoveBufferInfo(GLuint buffer_id) {
-  buffer_manager()->RemoveBufferInfo(buffer_id);
-  // TODO(gman): See if we can remove the rest of this function as
-  //    buffers are now reference counted and have a "IsDeleted" function.
-  if (bound_array_buffer_ && bound_array_buffer_->buffer_id() == buffer_id) {
-    bound_array_buffer_ = NULL;
-  }
-  if (bound_element_array_buffer_ &&
-      bound_element_array_buffer_->buffer_id() == buffer_id) {
-    bound_element_array_buffer_ = NULL;
-  }
-
-  // go through VertexAttribInfo and update any info that references the buffer.
-  for (GLuint ii = 0; ii < group_->max_vertex_attribs(); ++ii) {
-    VertexAttribInfo& info = vertex_attrib_infos_[ii];
-    if (info.buffer() && info.buffer()->buffer_id() == buffer_id) {
-      info.ClearBuffer();
-    }
-  }
+void GLES2DecoderImpl::RemoveBufferInfo(GLuint client_id) {
+  buffer_manager()->RemoveBufferInfo(client_id);
 }
 
-void GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
-  // TODO(gman): verify client_id is unused.
+bool GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
+  if (GetProgramInfo(client_id)) {
+    return false;
+  }
   GLuint service_id = glCreateProgram();
-  if (service_id) {
-    id_manager()->AddMapping(client_id, service_id);
-    CreateProgramInfo(service_id);
+  if (service_id != 0) {
+    CreateProgramInfo(client_id, service_id);
   }
+  return true;
 }
 
-void GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
-  // TODO(gman): verify client_id is unused.
+bool GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
+  if (GetShaderInfo(client_id)) {
+    return false;
+  }
   GLuint service_id = glCreateShader(type);
-  if (service_id) {
-    id_manager()->AddMapping(client_id, service_id);
-    CreateShaderInfo(service_id);
+  if (service_id != 0) {
+    CreateShaderInfo(client_id, service_id);
   }
+  return true;
 }
 
 bool GLES2DecoderImpl::ValidateGLenumCompressedTextureInternalFormat(GLenum) {
   // TODO(gman): Add support for compressed texture formats.
   return false;
 }
 
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index > group_->max_texture_units()) {
     SetGLError(GL_INVALID_ENUM);
     return;
   }
   active_texture_unit_ = texture_index;
   glActiveTexture(texture_unit);
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint client_id) {
   BufferManager::BufferInfo* info = NULL;
   GLuint service_id = 0;
-  if (client_id != 0 && !id_manager()->GetServiceId(client_id, &service_id)) {
-    // It's a new id so make a buffer info for it.
-    glGenBuffersARB(1, &service_id);
-    RegisterObjects(1, &client_id, &service_id);
-    CreateBufferInfo(service_id);
+  if (client_id != 0) {
+    info = GetBufferInfo(client_id);
+    if (!info) {
+      // It's a new id so make a buffer info for it.
+      glGenBuffersARB(1, &service_id);
+      CreateBufferInfo(client_id, service_id);
+      info = GetBufferInfo(client_id);
+    }
   }
-  if (service_id) {
-    info = GetBufferInfo(service_id);
+  if (info) {
     // Check the buffer exists
     // Check that we are not trying to bind it to a different target.
-    if (!info || (info->target() != 0 && info->target() != target)) {
+    if ((info->target() != 0 && info->target() != target)) {
       SetGLError(GL_INVALID_OPERATION);
       return;
     }
     if (info->target() == 0) {
       info->set_target(target);
     }
+    service_id = info->service_id();
   }
   switch (target) {
     case GL_ARRAY_BUFFER:
       bound_array_buffer_ = info;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_ = info;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
   glBindBuffer(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindFramebuffer(GLenum target, GLuint client_id) {
   FramebufferManager::FramebufferInfo* info = NULL;
   GLuint service_id = 0;
-  if (client_id != 0 && !id_manager()->GetServiceId(client_id, &service_id)) {
-    // It's a new id so make a framebuffer info for it.
-    glGenFramebuffersEXT(1, &service_id);
-    RegisterObjects(1, &client_id, &service_id);
-    CreateFramebufferInfo(service_id);
-  }
-  if (service_id) {
-    info = GetFramebufferInfo(service_id);
-    // Check the framebuffer exists
+  if (client_id != 0) {
+    info = GetFramebufferInfo(client_id);
     if (!info) {
-      SetGLError(GL_INVALID_OPERATION);
-      return;
+      // It's a new id so make a framebuffer info for it.
+      glGenFramebuffersEXT(1, &service_id);
+      CreateFramebufferInfo(client_id, service_id);
+      info = GetFramebufferInfo(client_id);
+    } else {
+      service_id = info->service_id();
     }
   }
   bound_framebuffer_ = info;
 
   // When rendering to an offscreen frame buffer, instead of unbinding from
   // the current frame buffer, bind to the offscreen target frame buffer.
   if (info == NULL && offscreen_target_frame_buffer_.get())
     service_id = offscreen_target_frame_buffer_->id();
 
   glBindFramebufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
   RenderbufferManager::RenderbufferInfo* info = NULL;
   GLuint service_id = 0;
-  if (client_id != 0 && !id_manager()->GetServiceId(client_id, &service_id)) {
-    // It's a new id so make a renderbuffer info for it.
-    glGenRenderbuffersEXT(1, &service_id);
-    RegisterObjects(1, &client_id, &service_id);
-    CreateRenderbufferInfo(service_id);
-  }
-  if (service_id) {
-    info = GetRenderbufferInfo(service_id);
-    // Check the renderbuffer exists
+  if (client_id != 0) {
+    info = GetRenderbufferInfo(client_id);
     if (!info) {
-      SetGLError(GL_INVALID_OPERATION);
-      return;
+      // It's a new id so make a renderbuffer info for it.
+      glGenRenderbuffersEXT(1, &service_id);
+      CreateRenderbufferInfo(client_id, service_id);
+    } else {
+      service_id = info->service_id();
     }
   }
   bound_renderbuffer_ = info;
   glBindRenderbufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
+  TextureManager::TextureInfo* info = NULL;
   GLuint service_id = 0;
-  if (client_id != 0 && !id_manager()->GetServiceId(client_id, &service_id)) {
-    // It's a new id so make a texture info for it.
-    glGenTextures(1, &service_id);
-    RegisterObjects(1, &client_id, &service_id);
-    CreateTextureInfo(service_id);
+  if (client_id != 0) {
+    info = GetTextureInfo(client_id);
+    if (!info) {
+      // It's a new id so make a texture info for it.
+      glGenTextures(1, &service_id);
+      CreateTextureInfo(client_id, service_id);
+      info = GetTextureInfo(client_id);
+    }
+  } else {
+    info = texture_manager()->GetDefaultTextureInfo(target);
   }
-  TextureManager::TextureInfo* info =
-      service_id ? GetTextureInfo(service_id) :
-                   texture_manager()->GetDefaultTextureInfo(target);
+
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
-  if (!info || (info->target() != 0 && info->target() != target)) {
+  if (info->target() != 0 && info->target() != target) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   if (info->target() == 0) {
     texture_manager()->SetInfoTarget(info, target);
   }
-  glBindTexture(target, service_id);
+  glBindTexture(target, info->service_id());
   TextureUnit& unit = texture_units_[active_texture_unit_];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = info;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = info;
       break;
     default:
@@ skipping 120 matching lines @@
   ProgramManager::ProgramInfo* info = GetProgramInfo(program_id);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   info->GetProgramiv(pname, params);
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocation(
     uint32 immediate_data_size, const gles2::BindAttribLocation& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(c.program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   GLuint index = static_cast<GLuint>(c.index);
   uint32 name_size = c.data_size;
   const char* name = GetSharedMemoryAs<const char*>(
       c.name_shm_id, c.name_shm_offset, name_size);
   if (name == NULL) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
-  glBindAttribLocation(program, index, name_str.c_str());
+  glBindAttribLocation(info->service_id(), index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationImmediate(
     uint32 immediate_data_size, const gles2::BindAttribLocationImmediate& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(c.program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   GLuint index = static_cast<GLuint>(c.index);
   uint32 name_size = c.data_size;
   const char* name = GetImmediateDataAs<const char*>(
       c, name_size, immediate_data_size);
   if (name == NULL) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
-  glBindAttribLocation(program, index, name_str.c_str());
+  glBindAttribLocation(info->service_id(), index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationBucket(
     uint32 immediate_data_size, const gles2::BindAttribLocationBucket& c) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(c.program, &program)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(c.program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   GLuint index = static_cast<GLuint>(c.index);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   bucket->GetAsString(&name_str);
-  glBindAttribLocation(program, index, name_str.c_str());
+  glBindAttribLocation(info->service_id(), index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteShader(
     uint32 immediate_data_size, const gles2::DeleteShader& c) {
-  GLuint shader = c.shader;
-  GLuint service_id;
-  if (!id_manager()->GetServiceId(shader, &service_id)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
+  GLuint client_id = c.shader;
+  if (client_id) {
+    ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
+    if (info) {
+      glDeleteShader(info->service_id());
+      RemoveShaderInfo(client_id);
+    } else {
+      SetGLError(GL_INVALID_VALUE);
+    }
   }
-  RemoveShaderInfo(service_id);
-  glDeleteShader(service_id);
-  id_manager()->RemoveMapping(shader, service_id);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteProgram(
     uint32 immediate_data_size, const gles2::DeleteProgram& c) {
-  GLuint program = c.program;
-  GLuint service_id;
-  if (!id_manager()->GetServiceId(program, &service_id)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
+  GLuint client_id = c.program;
+  if (client_id) {
+    ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
+    if (info) {
+      glDeleteProgram(info->service_id());
+      RemoveProgramInfo(client_id);
+    } else {
+      SetGLError(GL_INVALID_VALUE);
+    }
   }
-  RemoveProgramInfo(service_id);
-  glDeleteProgram(service_id);
-  id_manager()->RemoveMapping(program, service_id);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoDrawArrays(
     GLenum mode, GLint first, GLsizei count) {
   if (IsDrawValid(first + count - 1)) {
     bool has_non_renderable_textures;
     SetBlackTextureForNonRenderableTextures(&has_non_renderable_textures);
     glDrawArrays(mode, first, count);
     if (has_non_renderable_textures) {
       RestoreStateForNonRenderableTextures();
     }
   }
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
-    GLuint renderbuffer) {
+    GLuint client_renderbuffer_id) {
   if (!bound_framebuffer_) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
-  glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
-                               renderbuffer);
+  GLuint service_id = 0;
+  if (client_renderbuffer_id) {
+    RenderbufferManager::RenderbufferInfo* info =
+        GetRenderbufferInfo(client_renderbuffer_id);
+    if (!info) {
+      SetGLError(GL_INVALID_OPERATION);
+      return;
+    }
+    service_id = info->service_id();
+  }
+  glFramebufferRenderbufferEXT(
+      target, attachment, renderbuffertarget, service_id);
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   if (!bound_framebuffer_) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
   return glCheckFramebufferStatusEXT(target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
-    GLenum target, GLenum attachment, GLenum textarget, GLuint texture,
-    GLint level) {
+    GLenum target, GLenum attachment, GLenum textarget,
+    GLuint client_texture_id, GLint level) {
   if (!bound_framebuffer_) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
-  glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
+  GLuint service_id = 0;
+  if (client_texture_id) {
+    TextureManager::TextureInfo* info = GetTextureInfo(client_texture_id);
+    if (!info) {
+      SetGLError(GL_INVALID_OPERATION);
+      return;
+    }
+    service_id = info->service_id();
+  }
+  glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   if (!bound_framebuffer_) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
 }
@@ skipping 16 matching lines @@
   glRenderbufferStorageEXT(target, internalformat, width, height);
 }
 
 void GLES2DecoderImpl::DoLinkProgram(GLuint program) {
   ProgramManager::ProgramInfo* info = GetProgramInfo(program);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   CopyRealGLErrorsToWrapper();
-  glLinkProgram(program);
+  glLinkProgram(info->service_id());
   GLenum error = glGetError();
   if (error != GL_NO_ERROR) {
-    RemoveProgramInfo(program);
+    info->Reset();
     SetGLError(error);
   } else {
     info->Update();
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
@@ skipping 52 matching lines @@
   if (!current_program_ || current_program_->IsDeleted()) {
     // The program does not exist.
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   current_program_->SetSamplers(location, count, value);
   glUniform1iv(location, count, value);
 }
 
 void GLES2DecoderImpl::DoUseProgram(GLuint program) {
+  GLuint service_id = 0;
   ProgramManager::ProgramInfo* info = NULL;
   if (program) {
     info = GetProgramInfo(program);
     if (!info) {
+      SetGLError(GL_INVALID_VALUE);
+      return;
+    }
+    if (!info->IsValid()) {
       // Program was not linked successfully. (ie, glLinkProgram)
       SetGLError(GL_INVALID_OPERATION);
       return;
     }
+    service_id = info->service_id();
   }
   current_program_ = info;
-  glUseProgram(program);
+  glUseProgram(service_id);
 }
 
 GLenum GLES2DecoderImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = glGetError();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
         error = GLES2Util::GLErrorBitToGLError(mask);
         break;
@@ skipping 100 matching lines @@
             uniform_info->type == GL_SAMPLER_2D ?
                 texture_unit.bound_texture_2d :
                 texture_unit.bound_texture_cube_map;
         if (!texture_info || !texture_info->CanRender()) {
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           // Get the texture info that was previously bound here.
           texture_info = texture_unit.bind_target == GL_TEXTURE_2D ?
               texture_unit.bound_texture_2d :
               texture_unit.bound_texture_cube_map;
           glBindTexture(texture_unit.bind_target,
-                        texture_info ? texture_info->texture_id() : 0);
+                        texture_info ? texture_info->service_id() : 0);
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
 }
 
 bool GLES2DecoderImpl::IsDrawValid(GLuint max_vertex_accessed) {
   if (!current_program_ || current_program_->IsDeleted()) {
@@ skipping 52 matching lines @@
       }
     }
   }
   return error::kNoError;
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBuffer(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
   BufferManager::BufferInfo* info = GetBufferInfo(buffer_id);
-  if (info->target() != GL_ELEMENT_ARRAY_BUFFER) {
+  if (!info || info->target() != GL_ELEMENT_ARRAY_BUFFER) {
+    // TODO(gman): Should this be a GL error or a command buffer error?
     SetGLError(GL_INVALID_OPERATION);
   } else {
     if (!info->GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
+      // TODO(gman): Should this be a GL error or a command buffer error?
       SetGLError(GL_INVALID_OPERATION);
     }
   }
   return max_vertex_accessed;
 }
 
 // Calls glShaderSource for the various versions of the ShaderSource command.
 // Assumes that data / data_size points to a piece of memory that is in range
 // of whatever context it came from (shared memory, immediate memory, bucket
 // memory.)
 error::Error GLES2DecoderImpl::ShaderSourceHelper(
-    GLuint shader, const char* data, uint32 data_size) {
-  ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
+    GLuint client_id, const char* data, uint32 data_size) {
+  ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
   if (!info) {
-    SetGLError(GL_INVALID_OPERATION);
+    SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   // Note: We don't actually call glShaderSource here. We wait until
   // the call to glCompileShader.
   info->Update(std::string(data, data + data_size));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSource(
     uint32 immediate_data_size, const gles2::ShaderSource& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
   uint32 data_size = c.data_size;
   const char* data = GetSharedMemoryAs<const char*>(
       c.data_shm_id, c.data_shm_offset, data_size);
   if (!data) {
     return error::kOutOfBounds;
   }
-  return ShaderSourceHelper(shader, data, data_size);
+  return ShaderSourceHelper(c.shader, data, data_size);
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSourceImmediate(
   uint32 immediate_data_size, const gles2::ShaderSourceImmediate& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
   uint32 data_size = c.data_size;
   const char* data = GetImmediateDataAs<const char*>(
       c, data_size, immediate_data_size);
   if (!data) {
     return error::kOutOfBounds;
   }
-  return ShaderSourceHelper(shader, data, data_size);
+  return ShaderSourceHelper(c.shader, data, data_size);
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSourceBucket(
   uint32 immediate_data_size, const gles2::ShaderSourceBucket& c) {
-  GLuint shader;
-  if (!id_manager()->GetServiceId(c.shader, &shader)) {
-    SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
-  }
   Bucket* bucket = GetBucket(c.data_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   return ShaderSourceHelper(
-      shader, bucket->GetDataAs<const char*>(0, bucket->size() - 1),
+      c.shader, bucket->GetDataAs<const char*>(0, bucket->size() - 1),
       bucket->size() - 1);
 }
 
-void GLES2DecoderImpl::DoCompileShader(GLuint shader) {
-  ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
+void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
+  ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
   if (!info) {
-    SetGLError(GL_INVALID_OPERATION);
+    SetGLError(GL_INVALID_VALUE);
     return;
   }
-
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const char* shader_src = info->source().c_str();
 #if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
 #if defined(GLES2_GPU_SERVICE_TRANSLATE_SHADER)
   int dbg_options = 0;
   EShLanguage language = EShLangVertex;
   TBuiltInResource resources;
   // TODO(alokp): Ask gman how to get appropriate values.
   resources.maxVertexAttribs = 8;
@@ skipping 10 matching lines @@
     // TODO(alokp): Ask gman where to set compile-status and info-log.
     // May be add member variables to ShaderManager::ShaderInfo?
     const char* info_log = ShGetInfoLog(compiler);
     ShDestruct(compiler);
     return;
   }
   shader_src = ShGetObjectCode(compiler);
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 
-  glShaderSource(shader, 1, &shader_src, NULL);
-  glCompileShader(shader);
+  glShaderSource(info->service_id(), 1, &shader_src, NULL);
+  glCompileShader(info->service_id());
 
 #if !defined(GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2)
 #ifdef GLES2_GPU_SERVICE_TRANSLATE_SHADER
   ShDestruct(compiler);
 #endif  // GLES2_GPU_SERVICE_TRANSLATE_SHADER
 #endif  // GLES2_GPU_SERVICE_BACKEND_NATIVE_GLES2
 };
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader, GLenum pname, GLint* params) {
   ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION);
     return;
   }
   if (pname == GL_SHADER_SOURCE_LENGTH) {
     *params = info->source().size();
   } else {
-    glGetShaderiv(shader, pname, params);
+    glGetShaderiv(info->service_id(), pname, params);
   }
 }
 
-void GLES2DecoderImpl::DoGetShaderSource(
-      GLuint shader, GLsizei bufsize, GLsizei* length, char* dst) {
+error::Error GLES2DecoderImpl::HandleGetShaderSource(
+    uint32 immediate_data_size, const gles2::GetShaderSource& c) {
+  GLuint shader = c.shader;
   ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
   if (!info) {
-    SetGLError(GL_INVALID_OPERATION);
-    return;
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
   }
-  // bufsize is set by the service side code and should always be positive.
-  DCHECK_GT(bufsize, 0);
-  const std::string& source = info->source();
-  GLsizei size = std::min(bufsize - 1, static_cast<GLsizei>(source.size()));
-  if (length) {
-    *length = size;
+  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  Bucket* bucket = CreateBucket(bucket_id);
+  bucket->SetFromString(info->source());
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
+    uint32 immediate_data_size, const gles2::GetProgramInfoLog& c) {
+  GLuint program = c.program;
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
+  if (!info) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
   }
-  memcpy(dst, source.c_str(), size);
-  dst[size] = '\0';
+  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  GLint len = 0;
+  glGetProgramiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
+  Bucket* bucket = CreateBucket(bucket_id);
+  bucket->SetSize(len + 1);
+  glGetProgramInfoLog(
+      info->service_id(),
+      len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
+    uint32 immediate_data_size, const gles2::GetShaderInfoLog& c) {
+  GLuint shader = c.shader;
+  ShaderManager::ShaderInfo* info = GetShaderInfo(shader);
+  if (!info) {
+    SetGLError(GL_INVALID_VALUE);
+    return error::kNoError;
+  }
+  uint32 bucket_id = static_cast<uint32>(c.bucket_id);
+  GLint len = 0;
+  glGetShaderiv(info->service_id(), GL_INFO_LOG_LENGTH, &len);
+  Bucket* bucket = CreateBucket(bucket_id);
+  bucket->SetSize(len + 1);
+  glGetShaderInfoLog(
+      info->service_id(),
+      len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));
+  return error::kNoError;
 }
 
 bool GLES2DecoderImpl::DoIsBuffer(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
-  }
-  return GetBufferInfo(service_id) != NULL;
+  return GetBufferInfo(client_id) != NULL;
 }
 
 bool GLES2DecoderImpl::DoIsFramebuffer(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
-  }
-  return GetFramebufferInfo(service_id) != NULL;
+  return GetFramebufferInfo(client_id) != NULL;
 }
 
 bool GLES2DecoderImpl::DoIsProgram(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
-  }
-  return GetProgramInfo(service_id) != NULL;
+  return GetProgramInfo(client_id) != NULL;
 }
 
 bool GLES2DecoderImpl::DoIsRenderbuffer(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
-  }
-  return GetRenderbufferInfo(service_id) != NULL;
+  return GetRenderbufferInfo(client_id) != NULL;
 }
 
 bool GLES2DecoderImpl::DoIsShader(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
-  }
-  return GetShaderInfo(service_id) != NULL;
+  return GetShaderInfo(client_id) != NULL;
 }
 
 bool GLES2DecoderImpl::DoIsTexture(GLuint client_id) {
-  GLuint service_id = 0;
-  if (!id_manager()->GetServiceId(client_id, &service_id)) {
-    return false;
+  return GetTextureInfo(client_id) != NULL;
+}
+
+void GLES2DecoderImpl::DoAttachShader(
+    GLuint program_client_id, GLint shader_client_id) {
+  ProgramManager::ProgramInfo* program_info = GetProgramInfo(program_client_id);
+  if (!program_info) {
+    SetGLError(GL_INVALID_VALUE);
+    return;
   }
-  return GetTextureInfo(service_id) != NULL;
+  ShaderManager::ShaderInfo* shader_info = GetShaderInfo(shader_client_id);
+  if (!shader_info) {
+    SetGLError(GL_INVALID_VALUE);
+    return;
+  }
+  glAttachShader(program_info->service_id(), shader_info->service_id());
+}
+
+void GLES2DecoderImpl::DoDetachShader(
+    GLuint program_client_id, GLint shader_client_id) {
+  ProgramManager::ProgramInfo* program_info = GetProgramInfo(program_client_id);
+  if (!program_info) {
+    SetGLError(GL_INVALID_VALUE);
+    return;
+  }
+  ShaderManager::ShaderInfo* shader_info = GetShaderInfo(shader_client_id);
+  if (!shader_info) {
+    SetGLError(GL_INVALID_VALUE);
+    return;
+  }
+  glDetachShader(program_info->service_id(), shader_info->service_id());
+}
+
+void GLES2DecoderImpl::DoValidateProgram(GLuint program_client_id) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program_client_id);
+  if (!info) {
+    SetGLError(GL_INVALID_VALUE);
+    return;
+  }
+  glValidateProgram(info->service_id());
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
     uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
   if (bound_array_buffer_ && !bound_array_buffer_->IsDeleted()) {
     GLuint indx = c.indx;
     GLint size = c.size;
     GLenum type = c.type;
     GLboolean normalized = c.normalized;
     GLsizei stride = c.stride;
@@ skipping 160 matching lines @@
       // Validation should have prevented us from getting here.
       DCHECK(false);
       break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::GetAttribLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(client_id, &program)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
-  if (!info) {
-    // Program was not linked successfully. (ie, glLinkProgram)
+  if (!info->IsValid()) {
     SetGLError(GL_INVALID_OPERATION);
     return error::kNoError;
   }
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Require the client to init this incase the context is lost and we are no
   // longer executing commands.
@@ skipping 38 matching lines @@
   }
   std::string name_str;
   bucket->GetAsString(&name_str);
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::GetUniformLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
-  GLuint program;
-  if (!id_manager()->GetServiceId(client_id, &program)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
-  if (!info) {
-    // Program was not linked successfully. (ie, glLinkProgram)
+  if (!info->IsValid()) {
     SetGLError(GL_INVALID_OPERATION);
     return error::kNoError;
   }
   GLint* location = GetSharedMemoryAs<GLint*>(
       location_shm_id, location_shm_offset, sizeof(GLint));
   if (!location) {
     return error::kOutOfBounds;
   }
   // Require the client to init this incase the context is lost an we are no
   // longer executing commands.
@@ skipping 363 matching lines @@
   SizedResult<GLint>* result;
   result = GetSharedMemoryAs<SizedResult<GLint>*>(
       shm_id, shm_offset, SizedResult<GLint>::ComputeSize(0));
   if (!result) {
     *error = error::kOutOfBounds;
     return false;
   }
   *result_pointer = result;
   // Set the result size to 0 so the client does not have to check for success.
   result->SetNumResults(0);
-  if (!id_manager()->GetServiceId(program, service_id)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
-    return error::kNoError;
+    return false;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfo(*service_id);
-  if (!info) {
+  if (!info->IsValid()) {
     // Program was not linked successfully. (ie, glLinkProgram)
     SetGLError(GL_INVALID_OPERATION);
     return false;
   }
+  *service_id = info->service_id();
   GLenum type;
   if (!info->GetUniformTypeByLocation(location, &type)) {
     // No such location.
     SetGLError(GL_INVALID_OPERATION);
     return false;
   }
   GLsizei size = GLES2Util::GetGLDataTypeSizeForUniforms(type);
   if (size == 0) {
     SetGLError(GL_INVALID_OPERATION);
     return false;
@@ skipping 80 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
     uint32 immediate_data_size, const gles2::GetAttachedShaders& c) {
-  GLuint service_id;
   uint32 result_size = c.result_size;
-  if (!id_manager()->GetServiceId(c.program, &service_id)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(c.program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   typedef gles2::GetAttachedShaders::Result Result;
   uint32 max_count = Result::ComputeMaxResults(result_size);
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, Result::ComputeSize(max_count));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   GLsizei count = 0;
-  glGetAttachedShaders(service_id, max_count, &count, result->GetData());
+  glGetAttachedShaders(
+      info->service_id(), max_count, &count, result->GetData());
   for (GLsizei ii = 0; ii < count; ++ii) {
-    if (!id_manager()->GetClientId(result->GetData()[ii],
-                                  &result->GetData()[ii])) {
+    if (!shader_manager()->GetClientId(result->GetData()[ii],
+                                       &result->GetData()[ii])) {
       NOTREACHED();
       return error::kGenericError;
     }
   }
   result->SetNumResults(count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniform(
     uint32 immediate_data_size, const gles2::GetActiveUniform& c) {
   GLuint program = c.program;
   GLuint index = c.index;
   uint32 name_bucket_id = c.name_bucket_id;
-  GLuint service_id;
   typedef gles2::GetActiveUniform::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
-  if (!id_manager()->GetServiceId(program, &service_id)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfo(service_id);
-  if (!info) {
+  if (!info->IsValid()) {
     // Program was not linked successfully. (ie, glLinkProgram)
-    SetGLError(GL_INVALID_OPERATION);
+    SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
       info->GetUniformInfo(index);
   if (!uniform_info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = uniform_info->size;
   result->type = uniform_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(uniform_info->name);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveAttrib(
     uint32 immediate_data_size, const gles2::GetActiveAttrib& c) {
   GLuint program = c.program;
   GLuint index = c.index;
   uint32 name_bucket_id = c.name_bucket_id;
-  GLuint service_id;
   typedef gles2::GetActiveAttrib::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
     return error::kInvalidArguments;
   }
-  if (!id_manager()->GetServiceId(program, &service_id)) {
+  ProgramManager::ProgramInfo* info = GetProgramInfo(program);
+  if (!info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfo(service_id);
-  if (!info) {
+  if (!info->IsValid()) {
     // Program was not linked successfully. (ie, glLinkProgram)
     SetGLError(GL_INVALID_OPERATION);
     return error::kNoError;
   }
   const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
       info->GetAttribInfo(index);
   if (!attrib_info) {
     SetGLError(GL_INVALID_VALUE);
     return error::kNoError;
   }
@@ skipping 28 matching lines @@
   const GLuint* shaders = GetSharedMemoryAs<const GLuint*>(
       c.shaders_shm_id, c.shaders_shm_offset, data_size);
   GLenum binaryformat = static_cast<GLenum>(c.binaryformat);
   const void* binary = GetSharedMemoryAs<const void*>(
       c.binary_shm_id, c.binary_shm_offset, length);
   if (shaders == NULL || binary == NULL) {
     return error::kOutOfBounds;
   }
   scoped_array<GLuint> service_ids(new GLuint[n]);
   for (GLsizei ii = 0; ii < n; ++ii) {
-    if (!id_manager()->GetServiceId(shaders[ii], &service_ids[ii])) {
+    ShaderManager::ShaderInfo* info = GetShaderInfo(shaders[ii]);
+    if (!info) {
       SetGLError(GL_INVALID_VALUE);
       return error::kNoError;
     }
-    // TODO(gman): Check that each shader exists.
+    service_ids[ii] = info->service_id();
   }
   // TODO(gman): call glShaderBinary
   return error::kNoError;
 #endif
 }
 
 error::Error GLES2DecoderImpl::HandleSwapBuffers(
     uint32 immediate_data_size, const gles2::SwapBuffers& c) {
   // Check a client created frame buffer is not bound. TODO(apatrick):
   // this error is overkill. It will require that the client recreate the
@@ skipping 35 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu