Make ShareGroup thread safe

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
 #include <map>
 #include <set>
 #include <queue>
 #include <GLES2/gl2ext.h>
 #include "../client/mapped_memory.h"
 #include "../client/program_info_manager.h"
 #include "../client/query_tracker.h"
-#include "../client/share_group.h"
 #include "../client/transfer_buffer.h"
 #include "../common/gles2_cmd_utils.h"
-#include "../common/id_allocator.h"
 #include "../common/trace_event.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
 #if defined(GPU_CLIENT_DEBUG)
 #include "ui/gfx/gl/gl_switches.h"
 #include "base/command_line.h"
 #endif
 
 namespace gpu {
 namespace gles2 {
 
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 static GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
-// An id handler for non-shared ids.
-class NonSharedIdHandler : public IdHandlerInterface {
- public:
-  NonSharedIdHandler() { }
-  virtual ~NonSharedIdHandler() { }
-
-  // Overridden from IdHandlerInterface.
-  virtual void MakeIds(GLuint id_offset, GLsizei n, GLuint* ids) {
-    if (id_offset == 0) {
-      for (GLsizei ii = 0; ii < n; ++ii) {
-        ids[ii] = id_allocator_.AllocateID();
-      }
-    } else {
-      for (GLsizei ii = 0; ii < n; ++ii) {
-        ids[ii] = id_allocator_.AllocateIDAtOrAbove(id_offset);
-        id_offset = ids[ii] + 1;
-      }
-    }
-  }
-
-  // Overridden from IdHandlerInterface.
-  virtual bool FreeIds(GLsizei n, const GLuint* ids) {
-    for (GLsizei ii = 0; ii < n; ++ii) {
-      id_allocator_.FreeID(ids[ii]);
-    }
-    return true;
-  }
-
-  // Overridden from IdHandlerInterface.
-  virtual bool MarkAsUsedForBind(GLuint id) {
-    return id == 0 ? true : id_allocator_.MarkAsUsed(id);
-  }
- private:
-  IdAllocator id_allocator_;
-};
-
-// An id handler for non-shared ids that are never reused.
-class NonSharedNonReusedIdHandler : public IdHandlerInterface {
- public:
-  NonSharedNonReusedIdHandler() : last_id_(0) { }
-  virtual ~NonSharedNonReusedIdHandler() { }
-
-  // Overridden from IdHandlerInterface.
-  virtual void MakeIds(GLuint id_offset, GLsizei n, GLuint* ids) {
-    for (GLsizei ii = 0; ii < n; ++ii) {
-      ids[ii] = ++last_id_ + id_offset;
-    }
-  }
-
-  // Overridden from IdHandlerInterface.
-  virtual bool FreeIds(GLsizei /* n */, const GLuint* /* ids */) {
-    // Ids are never freed.
-    return true;
-  }
-
-  // Overridden from IdHandlerInterface.
-  virtual bool MarkAsUsedForBind(GLuint /* id */) {
-    // This is only used for Shaders and Programs which have no bind.
-    return false;
-  }
-
- private:
-  GLuint last_id_;
-};
-
-// An id handler for shared ids.
-class SharedIdHandler : public IdHandlerInterface {
- public:
-  SharedIdHandler(
-    GLES2Implementation* gles2,
-    id_namespaces::IdNamespaces id_namespace)
-      : gles2_(gles2),
-        id_namespace_(id_namespace) {
-  }
-
-  virtual ~SharedIdHandler() { }
-
-  virtual void MakeIds(GLuint id_offset, GLsizei n, GLuint* ids) {
-    gles2_->GenSharedIdsCHROMIUM(id_namespace_, id_offset, n, ids);
-  }
-
-  virtual bool FreeIds(GLsizei n, const GLuint* ids) {
-    gles2_->DeleteSharedIdsCHROMIUM(id_namespace_, n, ids);
-    // We need to ensure that the delete call is evaluated on the service side
-    // before any other contexts issue commands using these client ids.
-    gles2_->helper()->CommandBufferHelper::Flush();
-    return true;
-  }
-
-  virtual bool MarkAsUsedForBind(GLuint /* id */) {
-    // This has no meaning for shared resources.
-    return true;
-  }
-
- private:
-  GLES2Implementation* gles2_;
-  id_namespaces::IdNamespaces id_namespace_;
-};
-
-// An id handler for shared ids that requires ids are made before using and
-// that only the context that created the id can delete it.
-// Assumes the service will enforce that non made ids generate an error.
-class StrictSharedIdHandler : public IdHandlerInterface {
- public:
-  StrictSharedIdHandler(
-    GLES2Implementation* gles2,
-    id_namespaces::IdNamespaces id_namespace)
-      : gles2_(gles2),
-        id_namespace_(id_namespace) {
-  }
-
-  virtual ~StrictSharedIdHandler() {
-    Destroy();
-  }
-
-  virtual void MakeIds(GLuint id_offset, GLsizei n, GLuint* ids) {
-    for (GLsizei ii = 0; ii < n; ++ii) {
-      ids[ii] = GetId(id_offset);
-    }
-  }
-
-  virtual bool FreeIds(GLsizei n, const GLuint* ids) {
-    // OpenGL sematics. If any id is bad none of them get freed.
-    for (GLsizei ii = 0; ii < n; ++ii) {
-      GLuint id = ids[ii];
-      if (id != 0) {
-        ResourceIdSet::iterator it = used_ids_.find(id);
-        if (it == used_ids_.end()) {
-          return false;
-        }
-      }
-    }
-    for (GLsizei ii = 0; ii < n; ++ii) {
-      GLuint id = ids[ii];
-      if (id != 0) {
-        ResourceIdSet::iterator it = used_ids_.find(id);
-        if (it != used_ids_.end()) {
-          used_ids_.erase(it);
-          free_ids_.push(id);
-        }
-      }
-    }
-    return true;
-  }
-
-  virtual bool MarkAsUsedForBind(GLuint /* id */) {
-    // This has no meaning for shared resources.
-    return true;
-  }
-
- private:
-  static const GLsizei kNumIdsToGet = 2048;
-  typedef std::queue<GLuint> ResourceIdQueue;
-  typedef std::set<GLuint> ResourceIdSet;
-
-  void Destroy() {
-    // Free all the ids not being used.
-    while (!free_ids_.empty()) {
-      GLuint ids[kNumIdsToGet];
-      int count = 0;
-      while (count < kNumIdsToGet && !free_ids_.empty()) {
-        ids[count++] = free_ids_.front();
-        free_ids_.pop();
-      }
-      gles2_->DeleteSharedIdsCHROMIUM(id_namespace_, count, ids);
-    }
-  }
-
-  GLuint GetId(GLuint id_offset) {
-    if (free_ids_.empty()) {
-      GLuint ids[kNumIdsToGet];
-      gles2_->GenSharedIdsCHROMIUM(id_namespace_, id_offset, kNumIdsToGet, ids);
-      for (GLsizei ii = 0; ii < kNumIdsToGet; ++ii) {
-        free_ids_.push(ids[ii]);
-      }
-    }
-    GLuint id = free_ids_.front();
-    free_ids_.pop();
-    used_ids_.insert(id);
-    return id;
-  }
-
-  GLES2Implementation* gles2_;
-  id_namespaces::IdNamespaces id_namespace_;
-  ResourceIdSet used_ids_;
-  ResourceIdQueue free_ids_;
-};
-
-#ifndef _MSC_VER
-const GLsizei StrictSharedIdHandler::kNumIdsToGet;
-#endif
-
 static GLsizei RoundUpToMultipleOf4(GLsizei size) {
   return (size + 3) & ~3;
 }
 
 // This class tracks VertexAttribPointers and helps emulate client side buffers.
 //
 // The way client side buffers work is we shadow all the Vertex Attribs so we
 // know which ones are pointing to client side buffers.
 //
 // At Draw time, for any attribs pointing to client side buffers we copy them
@@ skipping 311 matching lines @@
   scoped_array<int8> collection_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSideBufferHelper);
 };
 
 #if !defined(_MSC_VER)
 const size_t GLES2Implementation::kMaxSizeOfSimpleResult;
 const unsigned int GLES2Implementation::kStartingOffset;
 #endif
 
-COMPILE_ASSERT(gpu::kInvalidResource == 0,
-               INVALID_RESOURCE_NOT_0_AS_GL_EXPECTS);
-
 GLES2Implementation::SingleThreadChecker::SingleThreadChecker(
     GLES2Implementation* gles2_implementation)
     : gles2_implementation_(gles2_implementation) {
   GPU_CHECK_EQ(0, gles2_implementation_->use_count_);
   ++gles2_implementation_->use_count_;
 }
 
 GLES2Implementation::SingleThreadChecker::~SingleThreadChecker() {
   --gles2_implementation_->use_count_;
   GPU_CHECK_EQ(0, gles2_implementation_->use_count_);
@@ skipping 14 matching lines @@
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_renderbuffer_(0),
       bound_array_buffer_id_(0),
       bound_element_array_buffer_id_(0),
       client_side_array_id_(0),
       client_side_element_array_id_(0),
       error_bits_(0),
       debug_(false),
-      sharing_resources_(share_resources),
-      bind_generates_resource_(bind_generates_resource),
       use_count_(0),
       current_query_(NULL),
       error_message_callback_(NULL) {
   GPU_DCHECK(helper);
   GPU_DCHECK(transfer_buffer);
   GPU_CLIENT_LOG_CODE_BLOCK({
     debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUClientLogging);
   });
 
-  share_group_ = (share_group ? share_group : new ShareGroup());
+  share_group_ = (share_group ? share_group : new ShareGroup(
+      share_resources, bind_generates_resource));
 
   memset(&reserved_ids_, 0, sizeof(reserved_ids_));
 }
 
 bool GLES2Implementation::Initialize(
     unsigned int starting_transfer_buffer_size,
     unsigned int min_transfer_buffer_size,
     unsigned int max_transfer_buffer_size) {
   GPU_DCHECK_GE(starting_transfer_buffer_size, min_transfer_buffer_size);
   GPU_DCHECK_LE(starting_transfer_buffer_size, max_transfer_buffer_size);
   GPU_DCHECK_GE(min_transfer_buffer_size, kStartingOffset);
 
   if (!transfer_buffer_->Initialize(
       starting_transfer_buffer_size,
       kStartingOffset,
       min_transfer_buffer_size,
       max_transfer_buffer_size,
       kAlignment,
       kSizeToFlush)) {
     return false;
   }
 
   mapped_memory_.reset(new MappedMemoryManager(helper_));
   SetSharedMemoryChunkSizeMultiple(1024 * 1024 * 2);
 
-  if (sharing_resources_) {
-    if (!bind_generates_resource_) {
-      for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
-        id_handlers_[i].reset(new StrictSharedIdHandler(
-              this, static_cast<id_namespaces::IdNamespaces>(i)));
-      }
-    } else {
-      for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
-        id_handlers_[i].reset(new SharedIdHandler(
-              this, static_cast<id_namespaces::IdNamespaces>(i)));
-      }
-    }
-  } else {
-    for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
-      if (i == id_namespaces::kProgramsAndShaders)
-        id_handlers_[i].reset(new NonSharedNonReusedIdHandler);
-      else
-        id_handlers_[i].reset(new NonSharedIdHandler);
-    }
-  }
-
   static const GLenum pnames[] = {
     GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
     GL_MAX_CUBE_MAP_TEXTURE_SIZE,
     GL_MAX_FRAGMENT_UNIFORM_VECTORS,
     GL_MAX_RENDERBUFFER_SIZE,
     GL_MAX_TEXTURE_IMAGE_UNITS,
     GL_MAX_TEXTURE_SIZE,
     GL_MAX_VARYING_VECTORS,
     GL_MAX_VERTEX_ATTRIBS,
     GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,
     GL_MAX_VERTEX_UNIFORM_VECTORS,
     GL_NUM_COMPRESSED_TEXTURE_FORMATS,
     GL_NUM_SHADER_BINARY_FORMATS,
   };
 
   util_.set_num_compressed_texture_formats(
       gl_state_.num_compressed_texture_formats);
   util_.set_num_shader_binary_formats(
       gl_state_.num_shader_binary_formats);
 
   GetMultipleIntegervCHROMIUM(
       pnames, arraysize(pnames), &gl_state_.max_combined_texture_image_units,
       sizeof(gl_state_));
 
   texture_units_.reset(
       new TextureUnit[gl_state_.max_combined_texture_image_units]);
 
-  program_info_manager_.reset(ProgramInfoManager::Create(sharing_resources_));
   query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
-  id_handlers_[id_namespaces::kBuffers]->MakeIds(
-      kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
+  GetIdHandler(id_namespaces::kBuffers)->MakeIds(
+      this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
 
   client_side_buffer_helper_.reset(new ClientSideBufferHelper(
       gl_state_.max_vertex_attribs,
       reserved_ids_[0],
       reserved_ids_[1]));
 #endif
 
   return true;
 }
 
 GLES2Implementation::~GLES2Implementation() {
   // Make sure the queries are finished otherwise we'll delete the
   // shared memory (mapped_memory_) which will free the memory used
   // by the queries. The GPU process when validating that memory is still
   // shared will fail and abort (ie, it will stop running).
   Finish();
   query_tracker_.reset();
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   DeleteBuffers(arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
-  for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
-      id_handlers_[i].reset();
-  }
+  // The share group needs to be able to use a command buffer to talk
+  // to service if it's destroyed so set one for it then release the reference.
+  // If it's destroyed it will use this GLES2Implemenation.
+  share_group_->SetGLES2ImplementationForDestruction(this);
+  share_group_ = NULL;
   // Make sure the commands make it the service.
   Finish();
 }
 
+GLuint GLES2Implementation::MakeTextureId() {
+  GLuint id;
+  GetIdHandler(id_namespaces::kTextures)->MakeIds(this, 0, 1, &id);
+  return id;
+}
+
+void GLES2Implementation::FreeTextureId(GLuint id) {
+  GetIdHandler(id_namespaces::kTextures)->FreeIds(this, 1, &id);
+}
+
+IdHandlerInterface* GLES2Implementation::GetIdHandler(int namespace_id) const {
+  return share_group_->GetIdHandler(namespace_id);
+}
+
 void* GLES2Implementation::GetResultBuffer() {
   return transfer_buffer_->GetResultBuffer();
 }
 
 int32 GLES2Implementation::GetResultShmId() {
   return transfer_buffer_->GetShmId();
 }
 
 uint32 GLES2Implementation::GetResultShmOffset() {
   return transfer_buffer_->GetResultOffset();
@@ skipping 225 matching lines @@
     case GL_MAX_VERTEX_UNIFORM_VECTORS:
       *params = gl_state_.max_vertex_uniform_vectors;
       return true;
     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
       *params = gl_state_.num_compressed_texture_formats;
       return true;
     case GL_NUM_SHADER_BINARY_FORMATS:
       *params = gl_state_.num_shader_binary_formats;
       return true;
     case GL_ARRAY_BUFFER_BINDING:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = bound_array_buffer_id_;
         return true;
       }
       return false;
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = bound_element_array_buffer_id_;
         return true;
       }
       return false;
     case GL_ACTIVE_TEXTURE:
       *params = active_texture_unit_ + GL_TEXTURE0;
       return true;
     case GL_TEXTURE_BINDING_2D:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = texture_units_[active_texture_unit_].bound_texture_2d;
         return true;
       }
       return false;
     case GL_TEXTURE_BINDING_CUBE_MAP:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = texture_units_[active_texture_unit_].bound_texture_cube_map;
         return true;
       }
       return false;
     case GL_FRAMEBUFFER_BINDING:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = bound_framebuffer_;
         return true;
       }
       return false;
     case GL_RENDERBUFFER_BINDING:
-      if (bind_generates_resource_) {
+      if (share_group_->bind_generates_resource()) {
         *params = bound_renderbuffer_;
         return true;
       }
       return false;
     default:
       return false;
   }
 }
 
 bool GLES2Implementation::GetBooleanvHelper(GLenum pname, GLboolean* params) {
@@ skipping 260 matching lines @@
   WaitForCmd();
   result->CopyResult(ptr);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
-  if (!id_handlers_[id_namespaces::kProgramsAndShaders]->FreeIds(1, &program)) {
+  if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
+      this, 1, &program)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteProgram: id not created by this context.");
     return false;
   }
-  program_info_manager_->DeleteInfo(program);
+  share_group_->program_info_manager()->DeleteInfo(program);
   helper_->DeleteProgram(program);
   return true;
 }
 
 bool GLES2Implementation::DeleteShaderHelper(GLuint shader) {
-  if (!id_handlers_[id_namespaces::kProgramsAndShaders]->FreeIds(1, &shader)) {
+  if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
+      this, 1, &shader)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteShader: id not created by this context.");
     return false;
   }
-  program_info_manager_->DeleteInfo(shader);
+  share_group_->program_info_manager()->DeleteInfo(shader);
   helper_->DeleteShader(shader);
   return true;
 }
 
 GLint GLES2Implementation::GetAttribLocationHelper(
     GLuint program, const char* name) {
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return -1;
   }
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetAttribLocationBucket(
       program, kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetAttribLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glGetAttribLocation(" << program
       << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetAttribLocation");
-  GLint loc = program_info_manager_->GetAttribLocation(this, program, name);
+  GLint loc = share_group_->program_info_manager()->GetAttribLocation(
+      this, program, name);
   GPU_CLIENT_LOG("returned " << loc);
   return loc;
 }
 
 GLint GLES2Implementation::GetUniformLocationHelper(
     GLuint program, const char* name) {
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return -1;
   }
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetUniformLocationBucket(program, kResultBucketId,
                                     GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetUniformLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glGetUniformLocation(" << program
       << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformLocation");
-  GLint loc = program_info_manager_->GetUniformLocation(this, program, name);
+  GLint loc = share_group_->program_info_manager()->GetUniformLocation(
+      this, program, name);
   GPU_CLIENT_LOG("returned " << loc);
   return loc;
 }
 
 bool GLES2Implementation::GetProgramivHelper(
     GLuint program, GLenum pname, GLint* params) {
-  return program_info_manager_->GetProgramiv(this, program, pname, params);
+  return share_group_->program_info_manager()->GetProgramiv(
+      this, program, pname, params);
 }
 
 void GLES2Implementation::LinkProgram(GLuint program) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glLinkProgram(" << program << ")");
   helper_->LinkProgram(program);
-  program_info_manager_->CreateInfo(program);
+  share_group_->program_info_manager()->CreateInfo(program);
 }
 
 void GLES2Implementation::ShaderBinary(
     GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary,
     GLsizei length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glShaderBinary(" << n << ", "
       << static_cast<const void*>(shaders) << ", "
       << GLES2Util::GetStringEnum(binaryformat) << ", "
       << static_cast<const void*>(binary) << ", "
@@ skipping 571 matching lines @@
       << program << ", " << index << ", " << bufsize << ", "
       << static_cast<const void*>(length) << ", "
       << static_cast<const void*>(size) << ", "
       << static_cast<const void*>(type) << ", "
       << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib: bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveAttrib");
-  bool success = program_info_manager_->GetActiveAttrib(
+  bool success = share_group_->program_info_manager()->GetActiveAttrib(
         this, program, index, bufsize, length, size, type, name);
   if (success) {
     if (size) {
       GPU_CLIENT_LOG("  size: " << *size);
     }
     if (type) {
       GPU_CLIENT_LOG("  type: " << GLES2Util::GetStringEnum(*type));
     }
     if (name) {
       GPU_CLIENT_LOG("  name: " << name);
@@ skipping 49 matching lines @@
       << program << ", " << index << ", " << bufsize << ", "
       << static_cast<const void*>(length) << ", "
       << static_cast<const void*>(size) << ", "
       << static_cast<const void*>(type) << ", "
       << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveUniform: bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveUniform");
-  bool success = program_info_manager_->GetActiveUniform(
+  bool success = share_group_->program_info_manager()->GetActiveUniform(
       this, program, index, bufsize, length, size, type, name);
   if (success) {
     if (size) {
       GPU_CLIENT_LOG("  size: " << *size);
     }
     if (type) {
       GPU_CLIENT_LOG("  type: " << GLES2Util::GetStringEnum(*type));
     }
     if (name) {
       GPU_CLIENT_LOG("  name: " << name);
@@ skipping 299 matching lines @@
       bound_array_buffer_id_ = buffer;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_id_ = buffer;
       break;
     default:
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  id_handlers_[id_namespaces::kBuffers]->MarkAsUsedForBind(buffer);
+  GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer);
 }
 
 void GLES2Implementation::BindFramebufferHelper(
     GLenum target, GLuint framebuffer) {
   // TODO(gman): See note #1 above.
   switch (target) {
     case GL_FRAMEBUFFER:
       bound_framebuffer_ = framebuffer;
       break;
     default:
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  id_handlers_[id_namespaces::kFramebuffers]->MarkAsUsedForBind(framebuffer);
+  GetIdHandler(id_namespaces::kFramebuffers)->MarkAsUsedForBind(framebuffer);
 }
 
 void GLES2Implementation::BindRenderbufferHelper(
     GLenum target, GLuint renderbuffer) {
   // TODO(gman): See note #1 above.
   switch (target) {
     case GL_RENDERBUFFER:
       bound_renderbuffer_ = renderbuffer;
       break;
     default:
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
-  id_handlers_[id_namespaces::kRenderbuffers]->MarkAsUsedForBind(renderbuffer);
+  GetIdHandler(id_namespaces::kRenderbuffers)->MarkAsUsedForBind(renderbuffer);
 }
 
 void GLES2Implementation::BindTextureHelper(GLenum target, GLuint texture) {
   // TODO(gman): See note #1 above.
   TextureUnit& unit = texture_units_[active_texture_unit_];
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = texture;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = texture;
       break;
     default:
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used. even though it's marked it as used here.
-  id_handlers_[id_namespaces::kTextures]->MarkAsUsedForBind(texture);
+  GetIdHandler(id_namespaces::kTextures)->MarkAsUsedForBind(texture);
 }
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 bool GLES2Implementation::IsBufferReservedId(GLuint id) {
   for (size_t ii = 0; ii < arraysize(reserved_ids_); ++ii) {
     if (id == reserved_ids_[ii]) {
       return true;
     }
   }
   return false;
 }
 #else
 bool GLES2Implementation::IsBufferReservedId(GLuint /* id */) {
   return false;
 }
 #endif
 
 void GLES2Implementation::DeleteBuffersHelper(
     GLsizei n, const GLuint* buffers) {
-  if (!id_handlers_[id_namespaces::kBuffers]->FreeIds(n, buffers)) {
+  if (!GetIdHandler(id_namespaces::kBuffers)->FreeIds(this, n, buffers)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteBuffers: id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (buffers[ii] == bound_array_buffer_id_) {
       bound_array_buffer_id_ = 0;
     }
     if (buffers[ii] == bound_element_array_buffer_id_) {
       bound_element_array_buffer_id_ = 0;
     }
   }
   helper_->DeleteBuffersImmediate(n, buffers);
 }
 
 void GLES2Implementation::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* framebuffers) {
-  if (!id_handlers_[id_namespaces::kFramebuffers]->FreeIds(n, framebuffers)) {
+  if (!GetIdHandler(id_namespaces::kFramebuffers)->FreeIds(
+      this, n, framebuffers)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteFramebuffers: id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (framebuffers[ii] == bound_framebuffer_) {
       bound_framebuffer_ = 0;
     }
   }
   helper_->DeleteFramebuffersImmediate(n, framebuffers);
 }
 
 void GLES2Implementation::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* renderbuffers) {
-  if (!id_handlers_[id_namespaces::kRenderbuffers]->FreeIds(n, renderbuffers)) {
+  if (!GetIdHandler(id_namespaces::kRenderbuffers)->FreeIds(
+      this, n, renderbuffers)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteRenderbuffers: id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (renderbuffers[ii] == bound_renderbuffer_) {
       bound_renderbuffer_ = 0;
     }
   }
   helper_->DeleteRenderbuffersImmediate(n, renderbuffers);
 }
 
 void GLES2Implementation::DeleteTexturesHelper(
     GLsizei n, const GLuint* textures) {
-  if (!id_handlers_[id_namespaces::kTextures]->FreeIds(n, textures)) {
+  if (!GetIdHandler(id_namespaces::kTextures)->FreeIds(
+      this, n, textures)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteTextures: id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     for (GLint tt = 0; tt < gl_state_.max_combined_texture_image_units; ++tt) {
       TextureUnit& unit = texture_units_[active_texture_unit_];
       if (textures[ii] == unit.bound_texture_2d) {
         unit.bound_texture_2d = 0;
@@ skipping 508 matching lines @@
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 void GLES2Implementation::DeleteQueriesEXTHelper(
     GLsizei n, const GLuint* queries) {
-  if (!id_handlers_[id_namespaces::kQueries]->FreeIds(n, queries)) {
+  if (!GetIdHandler(id_namespaces::kQueries)->FreeIds(
+      this, n, queries)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteTextures: id not created by this context.");
     return;
   }
   // When you delete a query you can't mark its memory as unused until it's
   // completed.
   // Note: If you don't do this you won't mess up the service but you will mess
   // up yourself.
 
@@ skipping 253 matching lines @@
     helper_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   }
 #else
   helper_->DrawElementsInstancedANGLE(
       mode, count, type, ToGLuint(indices), primcount);
 #endif
 }
 
 }  // namespace gles2
 }  // namespace gpu