Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 126 matching lines @@
 }
 
 // A struct to hold info about each command.
 struct CommandInfo {
   int arg_flags;  // How to handle the arguments for this command
   int arg_count;  // How many arguments are expected for this command.
 };
 
 // A table of CommandInfo for all the commands.
 const CommandInfo g_command_info[] = {
-  #define GLES2_CMD_OP(name) {                                            \
-    name::kArgFlags,                                                      \
-    sizeof(name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */       \
+  #define GLES2_CMD_OP(name) {                                             \
+    cmds::name::kArgFlags,                                                 \
+    sizeof(cmds::name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */  \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 };
 
 // Return true if a character belongs to the ASCII subset as defined in
 // GLSL ES 1.0 spec section 3.1.
 static bool CharacterIsValidForGLES(unsigned char c) {
   // Printing characters are valid except " $ ` @ \ ' DEL.
@@ skipping 182 matching lines @@
   explicit ScopedTextureUploadTimer(GLES2DecoderImpl* decoder);
   ~ScopedTextureUploadTimer();
 
  private:
   GLES2DecoderImpl* decoder_;
   base::TimeTicks begin_time_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTextureUploadTimer);
 };
 
 // Encapsulates an OpenGL texture.
-class Texture {
+class BackTexture {
  public:
-  explicit Texture(GLES2DecoderImpl* decoder);
-  ~Texture();
+  explicit BackTexture(GLES2DecoderImpl* decoder);
+  ~BackTexture();
 
   // Create a new render texture.
   void Create();
 
   // Set the initial size and format of a render texture or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format, bool zero);
 
   // Copy the contents of the currently bound frame buffer.
   void Copy(const gfx::Size& size, GLenum format);
 
@@ skipping 16 matching lines @@
   size_t estimated_size() const {
     return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
   size_t bytes_allocated_;
   GLuint id_;
   gfx::Size size_;
-  DISALLOW_COPY_AND_ASSIGN(Texture);
+  DISALLOW_COPY_AND_ASSIGN(BackTexture);
 };
 
 // Encapsulates an OpenGL render buffer of any format.
-class RenderBuffer {
+class BackRenderbuffer {
  public:
-  explicit RenderBuffer(GLES2DecoderImpl* decoder);
-  ~RenderBuffer();
+  explicit BackRenderbuffer(GLES2DecoderImpl* decoder);
+  ~BackRenderbuffer();
 
   // Create a new render buffer.
   void Create();
 
   // Set the initial size and format of a render buffer or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format, GLsizei samples);
 
   // Destroy the render buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // Invalidate the render buffer. This can be used when a context is lost and
   // it is not possible to make it current in order to free the resource.
   void Invalidate();
 
   GLuint id() const {
     return id_;
   }
 
   size_t estimated_size() const {
     return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
   size_t bytes_allocated_;
   GLuint id_;
-  DISALLOW_COPY_AND_ASSIGN(RenderBuffer);
+  DISALLOW_COPY_AND_ASSIGN(BackRenderbuffer);
 };
 
 // Encapsulates an OpenGL frame buffer.
-class FrameBuffer {
+class BackFramebuffer {
  public:
-  explicit FrameBuffer(GLES2DecoderImpl* decoder);
-  ~FrameBuffer();
+  explicit BackFramebuffer(GLES2DecoderImpl* decoder);
+  ~BackFramebuffer();
 
   // Create a new frame buffer.
   void Create();
 
   // Attach a color render buffer to a frame buffer.
-  void AttachRenderTexture(Texture* texture);
+  void AttachRenderTexture(BackTexture* texture);
 
   // Attach a render buffer to a frame buffer. Note that this unbinds any
   // currently bound frame buffer.
-  void AttachRenderBuffer(GLenum target, RenderBuffer* render_buffer);
+  void AttachRenderBuffer(GLenum target, BackRenderbuffer* render_buffer);
 
   // Destroy the frame buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // Invalidate the frame buffer. This can be used when a context is lost and it
   // is not possible to make it current in order to free the resource.
   void Invalidate();
 
   // See glCheckFramebufferStatusEXT.
   GLenum CheckStatus();
 
   GLuint id() const {
     return id_;
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   GLuint id_;
-  DISALLOW_COPY_AND_ASSIGN(FrameBuffer);
+  DISALLOW_COPY_AND_ASSIGN(BackFramebuffer);
 };
 
 // }  // anonymous namespace.
 
 bool GLES2Decoder::GetServiceTextureId(uint32 client_texture_id,
                                        uint32* service_texture_id) {
   return false;
 }
 
 GLES2Decoder::GLES2Decoder()
@@ skipping 141 matching lines @@
   bool BoundFramebufferHasDepthAttachment();
   bool BoundFramebufferHasStencilAttachment();
 
   virtual error::ContextLostReason GetContextLostReason() OVERRIDE;
 
  private:
   friend class ScopedFrameBufferBinder;
   friend class ScopedGLErrorSuppressor;
   friend class ScopedResolvedFrameBufferBinder;
   friend class ScopedTextureUploadTimer;
-  friend class Texture;
-  friend class RenderBuffer;
-  friend class FrameBuffer;
+  friend class BackTexture;
+  friend class BackRenderbuffer;
+  friend class BackFramebuffer;
 
   // Initialize or re-initialize the shader translator.
   bool InitializeShaderTranslator();
 
   void UpdateCapabilities();
 
   // 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);
@@ skipping 60 matching lines @@
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
   }
 
-  // Creates a TextureInfo for the given texture.
-  TextureManager::TextureInfo* CreateTextureInfo(
+  // Creates a Texture for the given texture.
+  Texture* CreateTexture(
       GLuint client_id, GLuint service_id) {
-    return texture_manager()->CreateTextureInfo(client_id, service_id);
+    return texture_manager()->CreateTexture(client_id, service_id);
   }
 
   // Gets the texture info for the given texture. Returns NULL if none exists.
-  TextureManager::TextureInfo* GetTextureInfo(GLuint client_id) const {
-    TextureManager::TextureInfo* info =
-        texture_manager()->GetTextureInfo(client_id);
+  Texture* GetTexture(GLuint client_id) const {
+    Texture* info =
+        texture_manager()->GetTexture(client_id);
     return info;
   }
 
   // Deletes the texture info for the given texture.
-  void RemoveTextureInfo(GLuint client_id) {
-    texture_manager()->RemoveTextureInfo(client_id);
+  void RemoveTexture(GLuint client_id) {
+    texture_manager()->RemoveTexture(client_id);
   }
 
   // Get the size (in pixels) of the currently bound frame buffer (either FBO
   // or regular back buffer).
   gfx::Size GetBoundReadFrameBufferSize();
 
   // Get the format of the currently bound frame buffer (either FBO or regular
   // back buffer)
   GLenum GetBoundReadFrameBufferInternalFormat();
   GLenum GetBoundDrawFrameBufferInternalFormat();
@@ skipping 92 matching lines @@
       GLint yoffset,
       GLsizei width,
       GLsizei height,
       GLenum format,
       GLenum type,
       const void * data);
 
   // Extra validation for async tex(Sub)Image2D.
   bool ValidateAsyncTransfer(
       const char* function_name,
-      TextureManager::TextureInfo* info,
+      Texture* info,
       GLenum target,
       GLint level,
       const void * data);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
       GLsizei width,
       GLsizei height,
       GLuint io_surface_id,
@@ skipping 19 matching lines @@
 
   void DoBindTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
   void DoReleaseTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
-  // Creates a ProgramInfo for the given program.
-  ProgramManager::ProgramInfo* CreateProgramInfo(
+  // Creates a Program for the given program.
+  Program* CreateProgram(
       GLuint client_id, GLuint service_id) {
-    return program_manager()->CreateProgramInfo(client_id, service_id);
+    return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
-  ProgramManager::ProgramInfo* GetProgramInfo(GLuint client_id) {
-    return program_manager()->GetProgramInfo(client_id);
+  Program* GetProgram(GLuint client_id) {
+    return program_manager()->GetProgram(client_id);
   }
 
 #if defined(NDEBUG)
   void LogClientServiceMapping(
       const char* /* function_name */,
       GLuint /* client_id */,
       GLuint /* service_id */) {
   }
   template<typename T>
   void LogClientServiceForInfo(
@@ skipping 12 matching lines @@
   void LogClientServiceForInfo(
       T* info, GLuint client_id, const char* function_name) {
     if (info) {
       LogClientServiceMapping(function_name, client_id, info->service_id());
     }
   }
 #endif
 
   // Gets the program info for the given program. If it's not a program
   // generates a GL error. Returns NULL if not program.
-  ProgramManager::ProgramInfo* GetProgramInfoNotShader(
+  Program* GetProgramInfoNotShader(
       GLuint client_id, const char* function_name) {
-    ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
+    Program* info = GetProgram(client_id);
     if (!info) {
-      if (GetShaderInfo(client_id)) {
+      if (GetShader(client_id)) {
         SetGLError(
             GL_INVALID_OPERATION, function_name, "shader passed for program");
       } else {
         SetGLError(GL_INVALID_VALUE, function_name, "unknown program");
       }
     }
     LogClientServiceForInfo(info, client_id, function_name);
     return info;
   }
 
 
-  // Creates a ShaderInfo for the given shader.
-  ShaderManager::ShaderInfo* CreateShaderInfo(
+  // Creates a Shader for the given shader.
+  Shader* CreateShader(
       GLuint client_id,
       GLuint service_id,
       GLenum shader_type) {
-    return shader_manager()->CreateShaderInfo(
+    return shader_manager()->CreateShader(
         client_id, service_id, shader_type);
   }
 
   // Gets the shader info for the given shader. Returns NULL if none exists.
-  ShaderManager::ShaderInfo* GetShaderInfo(GLuint client_id) {
-    return shader_manager()->GetShaderInfo(client_id);
+  Shader* GetShader(GLuint client_id) {
+    return shader_manager()->GetShader(client_id);
   }
 
   // Gets the shader info for the given shader. If it's not a shader generates a
   // GL error. Returns NULL if not shader.
-  ShaderManager::ShaderInfo* GetShaderInfoNotProgram(
+  Shader* GetShaderInfoNotProgram(
       GLuint client_id, const char* function_name) {
-    ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
+    Shader* info = GetShader(client_id);
     if (!info) {
-      if (GetProgramInfo(client_id)) {
+      if (GetProgram(client_id)) {
         SetGLError(
             GL_INVALID_OPERATION, function_name, "program passed for shader");
       } else {
         SetGLError(
             GL_INVALID_VALUE, function_name, "unknown shader");
       }
     }
     LogClientServiceForInfo(info, client_id, function_name);
     return info;
   }
 
   // Creates a buffer info for the given buffer.
-  void CreateBufferInfo(GLuint client_id, GLuint service_id) {
-    return buffer_manager()->CreateBufferInfo(client_id, service_id);
+  void CreateBuffer(GLuint client_id, GLuint service_id) {
+    return buffer_manager()->CreateBuffer(client_id, service_id);
   }
 
   // Gets the buffer info for the given buffer.
-  BufferManager::BufferInfo* GetBufferInfo(GLuint client_id) {
-    BufferManager::BufferInfo* info =
-        buffer_manager()->GetBufferInfo(client_id);
+  BufferManager::Buffer* GetBuffer(GLuint client_id) {
+    BufferManager::Buffer* info =
+        buffer_manager()->GetBuffer(client_id);
     return info;
   }
 
   // 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 client_id);
+  void RemoveBuffer(GLuint client_id);
 
   // Creates a framebuffer info for the given framebuffer.
-  void CreateFramebufferInfo(GLuint client_id, GLuint service_id) {
-    return framebuffer_manager()->CreateFramebufferInfo(client_id, service_id);
+  void CreateFramebuffer(GLuint client_id, GLuint service_id) {
+    return framebuffer_manager()->CreateFramebuffer(client_id, service_id);
   }
 
   // Gets the framebuffer info for the given framebuffer.
-  FramebufferManager::FramebufferInfo* GetFramebufferInfo(
+  Framebuffer* GetFramebuffer(
       GLuint client_id) {
-    FramebufferManager::FramebufferInfo* info =
-        framebuffer_manager()->GetFramebufferInfo(client_id);
+    Framebuffer* info =
+        framebuffer_manager()->GetFramebuffer(client_id);
     return info;
   }
 
   // Removes the framebuffer info for the given framebuffer.
-  void RemoveFramebufferInfo(GLuint client_id) {
-    framebuffer_manager()->RemoveFramebufferInfo(client_id);
+  void RemoveFramebuffer(GLuint client_id) {
+    framebuffer_manager()->RemoveFramebuffer(client_id);
   }
 
   // Creates a renderbuffer info for the given renderbuffer.
-  void CreateRenderbufferInfo(GLuint client_id, GLuint service_id) {
-    return renderbuffer_manager()->CreateRenderbufferInfo(
+  void CreateRenderbuffer(GLuint client_id, GLuint service_id) {
+    return renderbuffer_manager()->CreateRenderbuffer(
         client_id, service_id);
   }
 
   // Gets the renderbuffer info for the given renderbuffer.
-  RenderbufferManager::RenderbufferInfo* GetRenderbufferInfo(
+  Renderbuffer* GetRenderbuffer(
       GLuint client_id) {
-    RenderbufferManager::RenderbufferInfo* info =
-        renderbuffer_manager()->GetRenderbufferInfo(client_id);
+    Renderbuffer* info =
+        renderbuffer_manager()->GetRenderbuffer(client_id);
     return info;
   }
 
   // Removes the renderbuffer info for the given renderbuffer.
-  void RemoveRenderbufferInfo(GLuint client_id) {
-    renderbuffer_manager()->RemoveRenderbufferInfo(client_id);
+  void RemoveRenderbuffer(GLuint client_id) {
+    renderbuffer_manager()->RemoveRenderbuffer(client_id);
   }
 
   // Gets the vertex attrib manager for the given vertex array.
   VertexAttribManager* GetVertexAttribManager(GLuint client_id) {
     VertexAttribManager* info =
         vertex_array_manager()->GetVertexAttribManager(client_id);
     return info;
   }
 
   // Removes the vertex attrib manager for the given vertex array.
@@ skipping 21 matching lines @@
 
   // Helper for glShaderSource.
   error::Error ShaderSourceHelper(
       GLuint client_id, const char* data, uint32 data_size);
 
   // Clear any textures used by the current program.
   bool ClearUnclearedTextures();
 
   // Clear any uncleared level in texture.
   // Returns false if there was a generated GL error.
-  bool ClearTexture(TextureManager::TextureInfo* info);
+  bool ClearTexture(Texture* info);
 
   // Clears any uncleared attachments attached to the given frame buffer.
   // Returns false if there was a generated GL error.
   void ClearUnclearedAttachments(
-      GLenum target, FramebufferManager::FramebufferInfo* info);
+      GLenum target, Framebuffer* info);
 
   // overridden from GLES2Decoder
   virtual bool ClearLevel(unsigned service_id,
                           unsigned bind_target,
                           unsigned target,
                           int level,
                           unsigned format,
                           unsigned type,
                           int width,
                           int height,
                           bool is_texture_immutable) OVERRIDE;
 
   // Restore all GL state that affects clearing.
   void RestoreClearState();
 
   // Remembers the state of some capabilities.
   // Returns: true if glEnable/glDisable should actually be called.
   bool SetCapabilityState(GLenum cap, bool enabled);
 
   // Check that the currently bound framebuffers are valid.
   // Generates GL error if not.
   bool CheckBoundFramebuffersValid(const char* func_name);
 
   // Check if a framebuffer meets our requirements.
   bool CheckFramebufferValid(
-      FramebufferManager::FramebufferInfo* framebuffer,
+      Framebuffer* framebuffer,
       GLenum target,
       const char* func_name);
 
   // Checks if the current program exists and is valid. If not generates the
   // appropriate GL error.  Returns true if the current program is in a usable
   // state.
   bool CheckCurrentProgram(const char* function_name);
 
   // Checks if the current program exists and is valid and that location is not
   // -1. If the current program is not valid generates the appropriate GL
@@ skipping 289 matching lines @@
   error::Error DoDrawArrays(
       const char* function_name,
       bool instanced, GLenum mode, GLint first, GLsizei count,
       GLsizei primcount);
   error::Error DoDrawElements(
       const char* function_name,
       bool instanced, GLenum mode, GLsizei count, GLenum type,
       int32 offset, GLsizei primcount);
 
   // Gets the buffer id for a given target.
-  BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
+  BufferManager::Buffer* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     if (target == GL_ARRAY_BUFFER) {
       return state_.bound_array_buffer;
     } else {
       return state_.vertex_attrib_manager->element_array_buffer();
     }
   }
 
   // Gets the texture id for a given target.
-  TextureManager::TextureInfo* GetTextureInfoForTarget(GLenum target) {
+  Texture* GetTextureInfoForTarget(GLenum target) {
     TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
-    TextureManager::TextureInfo* info = NULL;
+    Texture* info = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
         info = unit.bound_texture_2d;
         break;
       case GL_TEXTURE_CUBE_MAP:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
         info = unit.bound_texture_cube_map;
         break;
       case GL_TEXTURE_EXTERNAL_OES:
         info = unit.bound_texture_external_oes;
         break;
       case GL_TEXTURE_RECTANGLE_ARB:
         info = unit.bound_texture_rectangle_arb;
         break;
       default:
         NOTREACHED();
         return NULL;
     }
     return info;
   }
 
-  TextureManager::TextureInfo* GetTextureInfoForTargetUnlessDefault(
+  Texture* GetTextureInfoForTargetUnlessDefault(
       GLenum target) {
-    TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+    Texture* info = GetTextureInfoForTarget(target);
     if (!info)
       return NULL;
     if (info == texture_manager()->GetDefaultTextureInfo(target))
       return NULL;
     return info;
   }
 
   GLenum GetBindTargetForSamplerType(GLenum type) {
     DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
            type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
     switch (type) {
       case GL_SAMPLER_2D:
         return GL_TEXTURE_2D;
       case GL_SAMPLER_CUBE:
         return GL_TEXTURE_CUBE_MAP;
       case GL_SAMPLER_EXTERNAL_OES:
         return GL_TEXTURE_EXTERNAL_OES;
       case GL_SAMPLER_2D_RECT_ARB:
         return GL_TEXTURE_RECTANGLE_ARB;
     }
 
     NOTREACHED();
     return 0;
   }
 
   // Gets the framebuffer info for a particular target.
-  FramebufferManager::FramebufferInfo* GetFramebufferInfoForTarget(
+  Framebuffer* GetFramebufferInfoForTarget(
       GLenum target) {
-    FramebufferManager::FramebufferInfo* info = NULL;
+    Framebuffer* info = NULL;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER_EXT:
         info = state_.bound_draw_framebuffer;
         break;
       case GL_READ_FRAMEBUFFER_EXT:
         info = state_.bound_read_framebuffer;
         break;
       default:
         NOTREACHED();
         break;
     }
     return info;
   }
 
-  RenderbufferManager::RenderbufferInfo* GetRenderbufferInfoForTarget(
+  Renderbuffer* GetRenderbufferInfoForTarget(
       GLenum target) {
-    RenderbufferManager::RenderbufferInfo* info = NULL;
+    Renderbuffer* info = NULL;
     switch (target) {
       case GL_RENDERBUFFER:
         info = state_.bound_renderbuffer;
         break;
       default:
         NOTREACHED();
         break;
     }
     return info;
   }
@@ skipping 28 matching lines @@
   bool ValidateCompressedTexDimensions(
       const char* function_name,
       GLint level, GLsizei width, GLsizei height, GLenum format);
   bool ValidateCompressedTexFuncData(
       const char* function_name,
       GLsizei width, GLsizei height, GLenum format, size_t size);
   bool ValidateCompressedTexSubDimensions(
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height, GLenum format,
-    TextureManager::TextureInfo* texture);
+    Texture* texture);
 
   void LogMessage(const std::string& msg);
   void RenderWarning(const std::string& msg);
   void PerformanceWarning(const std::string& msg);
   const std::string& GetLogPrefix() const;
 
   const FeatureInfo::FeatureFlags& features() const {
     return feature_info_->feature_flags();
   }
 
   const FeatureInfo::Workarounds& workarounds() const {
     return feature_info_->workarounds();
   }
 
   bool ShouldDeferDraws() {
     return !offscreen_target_frame_buffer_.get() &&
            state_.bound_draw_framebuffer == NULL &&
            surface_->DeferDraws();
   }
 
   bool ShouldDeferReads() {
     return !offscreen_target_frame_buffer_.get() &&
            state_.bound_read_framebuffer == NULL &&
            surface_->DeferDraws();
   }
 
-  void ForceCompileShaderIfPending(ShaderManager::ShaderInfo* info);
+  void ForceCompileShaderIfPending(Shader* info);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
-       uint32 immediate_data_size,          \
-       const gles2::name& args);            \
+       uint32 immediate_data_size,     \
+       const cmds::name& args);        \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
-  ContextGroup::Ref group_;
+  scoped_refptr<ContextGroup> group_;
 
   // All the state for this context.
   ContextState state_;
 
   // A parent decoder can access this decoders saved offscreen frame buffer.
   // The parent pointer is reset if the parent is destroyed.
   base::WeakPtr<GLES2DecoderImpl> parent_;
 
   // Current width and height of the offscreen frame buffer.
   gfx::Size offscreen_size_;
 
   // Current GL error bits.
   uint32 error_bits_;
 
   // Util to help with GL.
   GLES2Util util_;
 
   // unpack flip y as last set by glPixelStorei
   bool unpack_flip_y_;
 
   // unpack (un)premultiply alpha as last set by glPixelStorei
   bool unpack_premultiply_alpha_;
   bool unpack_unpremultiply_alpha_;
 
   // Default vertex attribs manager, used when no VAOs are bound.
-  VertexAttribManager::Ref default_vertex_attrib_manager_;
+  scoped_refptr<VertexAttribManager> default_vertex_attrib_manager_;
 
   // The buffer we bind to attrib 0 since OpenGL requires it (ES does not).
   GLuint attrib_0_buffer_id_;
 
   // The value currently in attrib_0.
   Vec4 attrib_0_value_;
 
   // Whether or not the attrib_0 buffer holds the attrib_0_value.
   bool attrib_0_buffer_matches_value_;
 
   // The size of attrib 0.
   GLsizei attrib_0_size_;
 
   // The buffer used to simulate GL_FIXED attribs.
   GLuint fixed_attrib_buffer_id_;
 
   // The size of fiixed attrib buffer.
   GLsizei fixed_attrib_buffer_size_;
 
   // state saved for clearing so we can clear render buffers and then
   // restore to these values.
   bool clear_state_dirty_;
 
   // The offscreen frame buffer that the client renders to. With EGL, the
   // depth and stencil buffers are separate. With regular GL there is a single
   // packed depth stencil buffer in offscreen_target_depth_render_buffer_.
   // offscreen_target_stencil_render_buffer_ is unused.
-  scoped_ptr<FrameBuffer> offscreen_target_frame_buffer_;
-  scoped_ptr<Texture> offscreen_target_color_texture_;
-  scoped_ptr<RenderBuffer> offscreen_target_color_render_buffer_;
-  scoped_ptr<RenderBuffer> offscreen_target_depth_render_buffer_;
-  scoped_ptr<RenderBuffer> offscreen_target_stencil_render_buffer_;
+  scoped_ptr<BackFramebuffer> offscreen_target_frame_buffer_;
+  scoped_ptr<BackTexture> offscreen_target_color_texture_;
+  scoped_ptr<BackRenderbuffer> offscreen_target_color_render_buffer_;
+  scoped_ptr<BackRenderbuffer> offscreen_target_depth_render_buffer_;
+  scoped_ptr<BackRenderbuffer> offscreen_target_stencil_render_buffer_;
   GLenum offscreen_target_color_format_;
   GLenum offscreen_target_depth_format_;
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
   GLboolean offscreen_target_buffer_preserved_;
 
   // The copy that is saved when SwapBuffers is called.
-  scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
-  scoped_ptr<Texture> offscreen_saved_color_texture_;
-  TextureManager::TextureInfo::Ref offscreen_saved_color_texture_info_;
+  scoped_ptr<BackFramebuffer> offscreen_saved_frame_buffer_;
+  scoped_ptr<BackTexture> offscreen_saved_color_texture_;
+  scoped_refptr<Texture>
+      offscreen_saved_color_texture_info_;
 
   // The copy that is used as the destination for multi-sample resolves.
-  scoped_ptr<FrameBuffer> offscreen_resolved_frame_buffer_;
-  scoped_ptr<Texture> offscreen_resolved_color_texture_;
+  scoped_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
+  scoped_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<QueryManager> query_manager_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
 
   base::Callback<void(gfx::Size)> resize_callback_;
 
   MsgCallback msg_callback_;
   WaitSyncPointCallback wait_sync_point_callback_;
@@ skipping 23 matching lines @@
   std::string this_in_hex_;
 
   bool use_shader_translator_;
   scoped_refptr<ShaderTranslator> vertex_translator_;
   scoped_refptr<ShaderTranslator> fragment_translator_;
 
   DisallowedFeatures disallowed_features_;
 
   // Cached from ContextGroup
   const Validators* validators_;
-  FeatureInfo::Ref feature_info_;
+  scoped_refptr<FeatureInfo> feature_info_;
 
   // This indicates all the following texSubImage2D calls that are part of the
   // failed texImage2D call should be ignored.
   bool tex_image_2d_failed_;
 
   int frame_number_;
 
   bool has_robustness_extension_;
   GLenum reset_status_;
 
@@ skipping 94 matching lines @@
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,
                        decoder_->offscreen_target_frame_buffer_->id());
   GLuint targetid;
   if (internal) {
     if (!decoder_->offscreen_resolved_frame_buffer_.get()) {
       decoder_->offscreen_resolved_frame_buffer_.reset(
-          new FrameBuffer(decoder_));
+          new BackFramebuffer(decoder_));
       decoder_->offscreen_resolved_frame_buffer_->Create();
-      decoder_->offscreen_resolved_color_texture_.reset(new Texture(decoder_));
+      decoder_->offscreen_resolved_color_texture_.reset(
+          new BackTexture(decoder_));
       decoder_->offscreen_resolved_color_texture_->Create();
 
       DCHECK(decoder_->offscreen_saved_color_format_);
       decoder_->offscreen_resolved_color_texture_->AllocateStorage(
           decoder_->offscreen_size_, decoder_->offscreen_saved_color_format_,
           false);
       decoder_->offscreen_resolved_frame_buffer_->AttachRenderTexture(
           decoder_->offscreen_resolved_color_texture_.get());
       if (decoder_->offscreen_resolved_frame_buffer_->CheckStatus() !=
           GL_FRAMEBUFFER_COMPLETE) {
@@ skipping 35 matching lines @@
     : decoder_(decoder),
       begin_time_(base::TimeTicks::HighResNow()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   decoder_->texture_upload_count_++;
   decoder_->total_texture_upload_time_ +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
-Texture::Texture(GLES2DecoderImpl* decoder)
+BackTexture::BackTexture(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       memory_tracker_(decoder->memory_tracker(), MemoryTracker::kUnmanaged),
       bytes_allocated_(0),
       id_(0) {
 }
 
-Texture::~Texture() {
+BackTexture::~BackTexture() {
   // This does not destroy the render texture because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
 }
 
-void Texture::Create() {
+void BackTexture::Create() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   Destroy();
   glGenTextures(1, &id_);
   ScopedTexture2DBinder binder(decoder_, id_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   // TODO(apatrick): Attempt to diagnose crbug.com/97775. If SwapBuffers is
   // never called on an offscreen context, no data will ever be uploaded to the
   // saved offscreen color texture (it is deferred until to when SwapBuffers
   // is called). My idea is that some nvidia drivers might have a bug where
   // deleting a texture that has never been populated might cause a
   // crash.
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
   bytes_allocated_ = 16u * 16u * 4u;
   memory_tracker_.TrackMemAlloc(bytes_allocated_);
 }
 
-bool Texture::AllocateStorage(const gfx::Size& size, GLenum format, bool zero) {
+bool BackTexture::AllocateStorage(
+    const gfx::Size& size, GLenum format, bool zero) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
   uint32 image_size = 0;
   GLES2Util::ComputeImageDataSizes(
       size.width(), size.height(), format, GL_UNSIGNED_BYTE, 8, &image_size,
       NULL, NULL);
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(image_size)) {
     return false;
@@ skipping 19 matching lines @@
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     memory_tracker_.TrackMemFree(bytes_allocated_);
     bytes_allocated_ = image_size;
     memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   return success;
 }
 
-void Texture::Copy(const gfx::Size& size, GLenum format) {
+void BackTexture::Copy(const gfx::Size& size, GLenum format) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
   glCopyTexImage2D(GL_TEXTURE_2D,
                    0,  // level
                    format,
                    0, 0,
                    size.width(),
                    size.height(),
                    0);  // border
 }
 
-void Texture::Destroy() {
+void BackTexture::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteTextures(1, &id_);
     id_ = 0;
   }
   memory_tracker_.TrackMemFree(bytes_allocated_);
   bytes_allocated_ = 0;
 }
 
-void Texture::Invalidate() {
+void BackTexture::Invalidate() {
   id_ = 0;
 }
 
-RenderBuffer::RenderBuffer(GLES2DecoderImpl* decoder)
+BackRenderbuffer::BackRenderbuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       memory_tracker_(decoder->memory_tracker(), MemoryTracker::kUnmanaged),
       bytes_allocated_(0),
       id_(0) {
 }
 
-RenderBuffer::~RenderBuffer() {
+BackRenderbuffer::~BackRenderbuffer() {
   // This does not destroy the render buffer because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
 }
 
-void RenderBuffer::Create() {
+void BackRenderbuffer::Create() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   Destroy();
   glGenRenderbuffersEXT(1, &id_);
 }
 
-bool RenderBuffer::AllocateStorage(const gfx::Size& size, GLenum format,
-                                   GLsizei samples) {
+bool BackRenderbuffer::AllocateStorage(const gfx::Size& size, GLenum format,
+                                       GLsizei samples) {
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedRenderBufferBinder binder(decoder_, id_);
 
   uint32 estimated_size = 0;
   if (!RenderbufferManager::ComputeEstimatedRenderbufferSize(
       size.width(), size.height(), samples, format, &estimated_size)) {
     return false;
   }
 
   if (!memory_tracker_.EnsureGPUMemoryAvailable(estimated_size)) {
@@ skipping 22 matching lines @@
   }
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     memory_tracker_.TrackMemFree(bytes_allocated_);
     bytes_allocated_ = estimated_size;
     memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   return success;
 }
 
-void RenderBuffer::Destroy() {
+void BackRenderbuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteRenderbuffersEXT(1, &id_);
     id_ = 0;
   }
   memory_tracker_.TrackMemFree(bytes_allocated_);
   bytes_allocated_ = 0;
 }
 
-void RenderBuffer::Invalidate() {
+void BackRenderbuffer::Invalidate() {
   id_ = 0;
 }
 
-FrameBuffer::FrameBuffer(GLES2DecoderImpl* decoder)
+BackFramebuffer::BackFramebuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       id_(0) {
 }
 
-FrameBuffer::~FrameBuffer() {
+BackFramebuffer::~BackFramebuffer() {
   // This does not destroy the frame buffer because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
 }
 
-void FrameBuffer::Create() {
+void BackFramebuffer::Create() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   Destroy();
   glGenFramebuffersEXT(1, &id_);
 }
 
-void FrameBuffer::AttachRenderTexture(Texture* texture) {
+void BackFramebuffer::AttachRenderTexture(BackTexture* texture) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   GLuint attach_id = texture ? texture->id() : 0;
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
                             GL_COLOR_ATTACHMENT0,
                             GL_TEXTURE_2D,
                             attach_id,
                             0);
 }
 
-void FrameBuffer::AttachRenderBuffer(GLenum target,
-                                     RenderBuffer* render_buffer) {
+void BackFramebuffer::AttachRenderBuffer(GLenum target,
+                                         BackRenderbuffer* render_buffer) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   GLuint attach_id = render_buffer ? render_buffer->id() : 0;
   glFramebufferRenderbufferEXT(GL_FRAMEBUFFER,
                                target,
                                GL_RENDERBUFFER,
                                attach_id);
 }
 
-void FrameBuffer::Destroy() {
+void BackFramebuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteFramebuffersEXT(1, &id_);
     id_ = 0;
   }
 }
 
-void FrameBuffer::Invalidate() {
+void BackFramebuffer::Invalidate() {
   id_ = 0;
 }
 
-GLenum FrameBuffer::CheckStatus() {
+GLenum BackFramebuffer::CheckStatus() {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedFrameBufferBinder binder(decoder_, id_);
   return glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 }
 
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   return new GLES2DecoderImpl(group);
 }
 
@@ skipping 135 matching lines @@
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
 
   state_.texture_units.resize(group_->max_texture_units());
   for (uint32 tt = 0; tt < state_.texture_units.size(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // We want the last bind to be 2D.
-    TextureManager::TextureInfo* info;
+    Texture* info;
     if (features().oes_egl_image_external) {
       info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_EXTERNAL_OES);
       state_.texture_units[tt].bound_texture_external_oes = info;
       glBindTexture(GL_TEXTURE_EXTERNAL_OES, info->service_id());
     }
     if (features().arb_texture_rectangle) {
       info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_RECTANGLE_ARB);
       state_.texture_units[tt].bound_texture_rectangle_arb = info;
       glBindTexture(GL_TEXTURE_RECTANGLE_ARB, info->service_id());
     }
@@ skipping 100 matching lines @@
         offscreen_target_stencil_format_ = attrib_parser.stencil_size_ > 0 ?
             GL_STENCIL_INDEX : 0;
       }
     }
 
     offscreen_saved_color_format_ = attrib_parser.alpha_size_ > 0 ?
         GL_RGBA : GL_RGB;
 
     // Create the target frame buffer. This is the one that the client renders
     // directly to.
-    offscreen_target_frame_buffer_.reset(new FrameBuffer(this));
+    offscreen_target_frame_buffer_.reset(new BackFramebuffer(this));
     offscreen_target_frame_buffer_->Create();
     // Due to GLES2 format limitations, either the color texture (for
     // non-multisampling) or the color render buffer (for multisampling) will be
     // attached to the offscreen frame buffer.  The render buffer has more
     // limited formats available to it, but the texture can't do multisampling.
     if (IsOffscreenBufferMultisampled()) {
-      offscreen_target_color_render_buffer_.reset(new RenderBuffer(this));
+      offscreen_target_color_render_buffer_.reset(new BackRenderbuffer(this));
       offscreen_target_color_render_buffer_->Create();
     } else {
-      offscreen_target_color_texture_.reset(new Texture(this));
+      offscreen_target_color_texture_.reset(new BackTexture(this));
       offscreen_target_color_texture_->Create();
     }
-    offscreen_target_depth_render_buffer_.reset(new RenderBuffer(this));
+    offscreen_target_depth_render_buffer_.reset(new BackRenderbuffer(this));
     offscreen_target_depth_render_buffer_->Create();
-    offscreen_target_stencil_render_buffer_.reset(new RenderBuffer(this));
+    offscreen_target_stencil_render_buffer_.reset(new BackRenderbuffer(this));
     offscreen_target_stencil_render_buffer_->Create();
 
     // Create the saved offscreen texture. The target frame buffer is copied
     // here when SwapBuffers is called.
-    offscreen_saved_frame_buffer_.reset(new FrameBuffer(this));
+    offscreen_saved_frame_buffer_.reset(new BackFramebuffer(this));
     offscreen_saved_frame_buffer_->Create();
     //
-    offscreen_saved_color_texture_.reset(new Texture(this));
+    offscreen_saved_color_texture_.reset(new BackTexture(this));
     offscreen_saved_color_texture_->Create();
 
     // Allocate the render buffers at their initial size and check the status
     // of the frame buffers is okay.
     if (!ResizeOffscreenFrameBuffer(size)) {
       LOG(ERROR) << "Could not allocate offscreen buffer storage.";
       Destroy(true);
       return false;
     }
 
@@ skipping 148 matching lines @@
   if (!fragment_translator_.get()) {
     LOG(ERROR) << "Could not initialize fragment shader translator.";
     Destroy(true);
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::GenBuffersHelper(GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
-    if (GetBufferInfo(client_ids[ii])) {
+    if (GetBuffer(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]);
+    CreateBuffer(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])) {
+    if (GetFramebuffer(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]);
+    CreateFramebuffer(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])) {
+    if (GetRenderbuffer(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]);
+    CreateRenderbuffer(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])) {
+    if (GetTexture(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]);
+    CreateTexture(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* buffer = GetBufferInfo(client_ids[ii]);
+    BufferManager::Buffer* buffer = GetBuffer(client_ids[ii]);
     if (buffer && !buffer->IsDeleted()) {
       state_.vertex_attrib_manager->Unbind(buffer);
       if (state_.bound_array_buffer == buffer) {
         state_.bound_array_buffer = NULL;
       }
-      RemoveBufferInfo(client_ids[ii]);
+      RemoveBuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
 
   for (GLsizei ii = 0; ii < n; ++ii) {
-    FramebufferManager::FramebufferInfo* framebuffer =
-        GetFramebufferInfo(client_ids[ii]);
+    Framebuffer* framebuffer =
+        GetFramebuffer(client_ids[ii]);
     if (framebuffer && !framebuffer->IsDeleted()) {
       if (framebuffer == state_.bound_draw_framebuffer) {
         state_.bound_draw_framebuffer = NULL;
         clear_state_dirty_ = true;
         GLenum target = supports_separate_framebuffer_binds ?
             GL_DRAW_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       if (framebuffer == state_.bound_read_framebuffer) {
         state_.bound_read_framebuffer = NULL;
         GLenum target = supports_separate_framebuffer_binds ?
             GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       OnFboChanged();
-      RemoveFramebufferInfo(client_ids[ii]);
+      RemoveFramebuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
-    RenderbufferManager::RenderbufferInfo* renderbuffer =
-        GetRenderbufferInfo(client_ids[ii]);
+    Renderbuffer* renderbuffer =
+        GetRenderbuffer(client_ids[ii]);
     if (renderbuffer && !renderbuffer->IsDeleted()) {
       if (state_.bound_renderbuffer == renderbuffer) {
         state_.bound_renderbuffer = NULL;
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
         if (state_.bound_read_framebuffer) {
           state_.bound_read_framebuffer->UnbindRenderbuffer(
               GL_READ_FRAMEBUFFER_EXT, renderbuffer);
         }
         if (state_.bound_draw_framebuffer) {
           state_.bound_draw_framebuffer->UnbindRenderbuffer(
               GL_DRAW_FRAMEBUFFER_EXT, renderbuffer);
         }
       } else {
         if (state_.bound_draw_framebuffer) {
           state_.bound_draw_framebuffer->UnbindRenderbuffer(
               GL_FRAMEBUFFER, renderbuffer);
         }
       }
       clear_state_dirty_ = true;
-      RemoveRenderbufferInfo(client_ids[ii]);
+      RemoveRenderbuffer(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
-    TextureManager::TextureInfo* texture = GetTextureInfo(client_ids[ii]);
+    Texture* texture = GetTexture(client_ids[ii]);
     if (texture && !texture->IsDeleted()) {
       if (texture->IsAttachedToFramebuffer()) {
         clear_state_dirty_ = true;
       }
       // Unbind texture from texture units.
       for (size_t jj = 0; jj < state_.texture_units.size(); ++jj) {
         state_.texture_units[jj].Unbind(texture);
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
@@ skipping 12 matching lines @@
       }
       GLuint service_id = texture->service_id();
       if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
 #if defined(OS_MACOSX)
       if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
         ReleaseIOSurfaceForTexture(service_id);
       }
 #endif
-      RemoveTextureInfo(client_ids[ii]);
+      RemoveTexture(client_ids[ii]);
     }
   }
 }
 
 // }  // anonymous namespace
 
 bool GLES2DecoderImpl::MakeCurrent() {
   if (!context_.get() || !context_->MakeCurrent(surface_.get()))
     return false;
 
@@ skipping 28 matching lines @@
 
   return true;
 }
 
 void GLES2DecoderImpl::ReleaseCurrent() {
   if (context_.get())
     context_->ReleaseCurrent(surface_.get());
 }
 
 void GLES2DecoderImpl::RestoreCurrentRenderbufferBindings() {
-  RenderbufferManager::RenderbufferInfo* renderbuffer =
+  Renderbuffer* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   glBindRenderbufferEXT(
       GL_RENDERBUFFER, renderbuffer ? renderbuffer->service_id() : 0);
 }
 
 static void RebindCurrentFramebuffer(
     GLenum target,
-    FramebufferManager::FramebufferInfo* info,
+    Framebuffer* info,
     GLuint back_buffer_service_id) {
   GLuint framebuffer_id = info ? info->service_id() : 0;
 
   if (framebuffer_id == 0) {
     framebuffer_id = back_buffer_service_id;
   }
 
   glBindFramebufferEXT(target, framebuffer_id);
 }
 
@@ skipping 25 matching lines @@
     last_id = info.bound_texture_2d->service_id();
   } else {
     last_id = 0;
   }
 
   glBindTexture(GL_TEXTURE_2D, last_id);
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
-    FramebufferManager::FramebufferInfo* framebuffer,
+    Framebuffer* framebuffer,
     GLenum target, const char* func_name) {
   if (!framebuffer) {
     if (backbuffer_needs_clear_bits_) {
       glClearColor(0, 0, 0, (GLES2Util::GetChannelsForFormat(
           offscreen_target_color_format_) & 0x0008) != 0 ? 0 : 1);
       glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
       glClearStencil(0);
       glStencilMask(-1);
       glClearDepth(1.0f);
       glDepthMask(true);
@@ skipping 55 matching lines @@
   }
   return CheckFramebufferValid(
              state_.bound_draw_framebuffer,
              GL_DRAW_FRAMEBUFFER_EXT, func_name) &&
          CheckFramebufferValid(
              state_.bound_read_framebuffer,
              GL_READ_FRAMEBUFFER_EXT, func_name);
 }
 
 gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   if (framebuffer != NULL) {
-    const FramebufferManager::FramebufferInfo::Attachment* attachment =
+    const Framebuffer::Attachment* attachment =
         framebuffer->GetAttachment(GL_COLOR_ATTACHMENT0);
     if (attachment) {
       return gfx::Size(attachment->width(), attachment->height());
     }
     return gfx::Size(0, 0);
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_size_;
   } else {
     return surface_->GetSize();
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundReadFrameBufferInternalFormat() {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   if (framebuffer != NULL) {
     return framebuffer->GetColorAttachmentFormat();
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_color_format_;
   } else {
     return back_buffer_color_format_;
   }
 }
 
 GLenum GLES2DecoderImpl::GetBoundDrawFrameBufferInternalFormat() {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
   if (framebuffer != NULL) {
     return framebuffer->GetColorAttachmentFormat();
   } else if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_color_format_;
   } else {
     return back_buffer_color_format_;
   }
 }
 
@@ skipping 59 matching lines @@
   return async_pixel_transfer_delegate_.get();
 }
 
 void GLES2DecoderImpl::SetAsyncPixelTransferDelegate(
     gfx::AsyncPixelTransferDelegate* delegate) {
   async_pixel_transfer_delegate_ = make_scoped_ptr(delegate);
 }
 
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
-  TextureManager::TextureInfo* texture =
-      texture_manager()->GetTextureInfo(client_texture_id);
+  Texture* texture =
+      texture_manager()->GetTexture(client_texture_id);
   if (texture) {
     *service_texture_id = texture->service_id();
     return true;
   }
   return false;
 }
 
 uint32 GLES2DecoderImpl::GetTextureUploadCount() {
   return texture_upload_count_ +
       async_pixel_transfer_delegate_->GetTextureUploadCount();
@@ skipping 150 matching lines @@
         parent_->children_.begin(),
         parent_->children_.end(),
         this);
     DCHECK(it != parent_->children_.end());
     parent_->children_.erase(it);
     // 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 = 0;
     if (parent_->texture_manager()->GetClientId(service_id, &client_id)) {
-      parent_->texture_manager()->RemoveTextureInfo(client_id);
+      parent_->texture_manager()->RemoveTexture(client_id);
     }
   }
 
   GLES2DecoderImpl* new_parent_impl = static_cast<GLES2DecoderImpl*>(
       new_parent);
   if (new_parent_impl) {
 #ifndef NDEBUG
     ChildList::iterator it = std::find(
         new_parent_impl->children_.begin(),
         new_parent_impl->children_.end(),
         this);
     DCHECK(it == new_parent_impl->children_.end());
 #endif
     new_parent_impl->children_.push_back(this);
     // Map the ID of the saved offscreen texture into the parent so that
     // it can reference it.
     GLuint service_id = offscreen_saved_color_texture_->id();
 
     // Replace texture info when ID is already in use by parent.
-    if (new_parent_impl->texture_manager()->GetTextureInfo(
+    if (new_parent_impl->texture_manager()->GetTexture(
         new_parent_texture_id))
-      new_parent_impl->texture_manager()->RemoveTextureInfo(
+      new_parent_impl->texture_manager()->RemoveTexture(
           new_parent_texture_id);
 
     offscreen_saved_color_texture_info_ =
-        new_parent_impl->CreateTextureInfo(new_parent_texture_id, service_id);
+        new_parent_impl->CreateTexture(new_parent_texture_id, service_id);
     offscreen_saved_color_texture_info_->SetNotOwned();
     new_parent_impl->texture_manager()->
        SetInfoTarget(offscreen_saved_color_texture_info_, GL_TEXTURE_2D);
 
     parent_ = base::AsWeakPtr<GLES2DecoderImpl>(new_parent_impl);
 
     UpdateParentTextureInfo();
   } else {
     parent_.reset();
     offscreen_saved_color_texture_info_ = NULL;
@@ skipping 140 matching lines @@
     offscreen_resolved_frame_buffer_->Destroy();
   if (offscreen_resolved_color_texture_.get())
     offscreen_resolved_color_texture_->Destroy();
   offscreen_resolved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
 
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleResizeCHROMIUM(
-    uint32 immediate_data_size, const gles2::ResizeCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::ResizeCHROMIUM& c) {
   if (!offscreen_target_frame_buffer_.get() && surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
 
   GLuint width = static_cast<GLuint>(c.width);
   GLuint height = static_cast<GLuint>(c.height);
   TRACE_EVENT2("gpu", "glResizeChromium", "width", width, "height", height);
 
   width = std::max(1U, width);
   height = std::max(1U, height);
 
@@ skipping 49 matching lines @@
   unsigned int command_index = command - kStartPoint - 1;
   if (command_index < arraysize(g_command_info)) {
     const CommandInfo& info = g_command_info[command_index];
     unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
         (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
       uint32 immediate_data_size =
           (arg_count - info_arg_count) * sizeof(CommandBufferEntry);  // NOLINT
       switch (command) {
         #define GLES2_CMD_OP(name)                                 \
-          case name::kCmdId:                                       \
+          case cmds::name::kCmdId:                                 \
             result = Handle ## name(                               \
                 immediate_data_size,                               \
-                *static_cast<const name*>(cmd_data));              \
+                *static_cast<const gles2::cmds::name*>(cmd_data)); \
             break;                                                 \
 
         GLES2_COMMAND_LIST(GLES2_CMD_OP)
         #undef GLES2_CMD_OP
       }
       if (debug()) {
         GLenum error;
         while ((error = glGetError()) != GL_NO_ERROR) {
           LOG(ERROR) << "[" << GetLogPrefix() << "] "
                      << "GL ERROR: " << GLES2Util::GetStringEnum(error) << " : "
                      << GetCommandName(command);
           SetGLError(error, "DoCommand", "GL error from driver");
         }
       }
     } else {
       result = error::kInvalidArguments;
     }
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
   }
   if (result == error::kNoError && current_decoder_error_ != error::kNoError) {
       result = current_decoder_error_;
       current_decoder_error_ = error::kNoError;
   }
   return result;
 }
 
-void GLES2DecoderImpl::RemoveBufferInfo(GLuint client_id) {
-  buffer_manager()->RemoveBufferInfo(client_id);
+void GLES2DecoderImpl::RemoveBuffer(GLuint client_id) {
+  buffer_manager()->RemoveBuffer(client_id);
 }
 
 bool GLES2DecoderImpl::CreateProgramHelper(GLuint client_id) {
-  if (GetProgramInfo(client_id)) {
+  if (GetProgram(client_id)) {
     return false;
   }
   GLuint service_id = glCreateProgram();
   if (service_id != 0) {
-    CreateProgramInfo(client_id, service_id);
+    CreateProgram(client_id, service_id);
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CreateShaderHelper(GLenum type, GLuint client_id) {
-  if (GetShaderInfo(client_id)) {
+  if (GetShader(client_id)) {
     return false;
   }
   GLuint service_id = glCreateShader(type);
   if (service_id != 0) {
-    CreateShaderInfo(client_id, service_id, type);
+    CreateShader(client_id, service_id, type);
   }
   return true;
 }
 
 void GLES2DecoderImpl::DoFinish() {
   glFinish();
   ProcessPendingQueries();
 }
 
 void GLES2DecoderImpl::DoFlush() {
   glFlush();
   ProcessPendingQueries();
 }
 
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index >= state_.texture_units.size()) {
     SetGLErrorInvalidEnum(
         "glActiveTexture", texture_unit, "texture_unit");
     return;
   }
   state_.active_texture_unit = texture_index;
   glActiveTexture(texture_unit);
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint client_id) {
-  BufferManager::BufferInfo* info = NULL;
+  BufferManager::Buffer* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetBufferInfo(client_id);
+    info = GetBuffer(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
         LOG(ERROR) << "glBindBuffer: id not generated by glGenBuffers";
         current_decoder_error_ = error::kGenericError;
         return;
       }
 
       // 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);
+      CreateBuffer(client_id, service_id);
+      info = GetBuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kBuffers);
       id_allocator->MarkAsUsed(client_id);
     }
   }
   LogClientServiceForInfo(info, client_id, "glBindBuffer");
   if (info) {
     if (!buffer_manager()->SetTarget(info, target)) {
       SetGLError(GL_INVALID_OPERATION,
                  "glBindBuffer", "buffer bound to more than 1 target");
@@ skipping 14 matching lines @@
   }
   glBindBuffer(target, service_id);
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasColorAttachmentWithAlpha() {
   return (GLES2Util::GetChannelsForFormat(
       GetBoundDrawFrameBufferInternalFormat()) & 0x0008) != 0;
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasDepthAttachment() {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
   if (framebuffer) {
     return framebuffer->HasDepthAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_depth_format_ != 0;
   }
   return back_buffer_has_depth_;
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasStencilAttachment() {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
   if (framebuffer) {
     return framebuffer->HasStencilAttachment();
   }
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_stencil_format_ != 0 ||
            offscreen_target_depth_format_ == GL_DEPTH24_STENCIL8;
   }
   return back_buffer_has_stencil_;
 }
@@ skipping 48 matching lines @@
         GetBackbufferServiceId();
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER, service_id);
   }
   OnFboChanged();
 
 }
 
 void GLES2DecoderImpl::RestoreTextureState(unsigned service_id) const {
   GLuint client_id = 0;
   if (texture_manager()->GetClientId(service_id, &client_id)) {
-    TextureManager::TextureInfo* texture = GetTextureInfo(client_id);
+    Texture* texture = GetTexture(client_id);
     glBindTexture(GL_TEXTURE_2D, service_id);
     glTexParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, texture->wrap_s());
     glTexParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, texture->wrap_t());
     glTexParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texture->min_filter());
     glTexParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texture->mag_filter());
     RestoreTextureUnitBindings(state_.active_texture_unit);
   }
 }
 
 void GLES2DecoderImpl::OnFboChanged() const {
   if (workarounds().restore_scissor_on_fbo_change)
     glScissor(state_.scissor_x, state_.scissor_y,
               state_.scissor_width, state_.scissor_height);
 }
 
 void GLES2DecoderImpl::DoBindFramebuffer(GLenum target, GLuint client_id) {
-  FramebufferManager::FramebufferInfo* info = NULL;
+  Framebuffer* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetFramebufferInfo(client_id);
+    info = GetFramebuffer(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
          LOG(ERROR)
              << "glBindFramebuffer: id not generated by glGenFramebuffers";
          current_decoder_error_ = error::kGenericError;
          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);
+      CreateFramebuffer(client_id, service_id);
+      info = GetFramebuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   }
   LogClientServiceForInfo(info, client_id, "glBindFramebuffer");
 
@@ skipping 10 matching lines @@
   // backbuffer.
   if (info == NULL) {
     service_id = GetBackbufferServiceId();
   }
 
   glBindFramebufferEXT(target, service_id);
   OnFboChanged();
 }
 
 void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_id) {
-  RenderbufferManager::RenderbufferInfo* info = NULL;
+  Renderbuffer* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetRenderbufferInfo(client_id);
+    info = GetRenderbuffer(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
         LOG(ERROR)
             << "glBindRenderbuffer: id not generated by glGenRenderbuffers";
         current_decoder_error_ = error::kGenericError;
         return;
       }
 
       // It's a new id so make a renderbuffer info for it.
       glGenRenderbuffersEXT(1, &service_id);
-      CreateRenderbufferInfo(client_id, service_id);
-      info = GetRenderbufferInfo(client_id);
+      CreateRenderbuffer(client_id, service_id);
+      info = GetRenderbuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kRenderbuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   }
   LogClientServiceForInfo(info, client_id, "glBindRenerbuffer");
   state_.bound_renderbuffer = info;
   glBindRenderbufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
-  TextureManager::TextureInfo* info = NULL;
+  Texture* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetTextureInfo(client_id);
+    info = GetTexture(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
          LOG(ERROR) << "glBindTexture: id not generated by glGenTextures";
          current_decoder_error_ = error::kGenericError;
          return;
       }
 
       // It's a new id so make a texture info for it.
       glGenTextures(1, &service_id);
       DCHECK_NE(0u, service_id);
-      CreateTextureInfo(client_id, service_id);
-      info = GetTextureInfo(client_id);
+      CreateTexture(client_id, service_id);
+      info = GetTexture(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kTextures);
       id_allocator->MarkAsUsed(client_id);
     }
   } else {
     info = texture_manager()->GetDefaultTextureInfo(target);
   }
 
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
@@ skipping 49 matching lines @@
     }
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glDisableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoDiscardFramebufferEXT(GLenum target,
                                                GLsizei numAttachments,
                                                const GLenum* attachments) {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
 
   // Validates the attachments. If one of them fails
   // the whole command fails.
   for (GLsizei i = 0; i < numAttachments; ++i) {
     if ((framebuffer &&
         !validators_->attachment.IsValid(attachments[i])) ||
        (!framebuffer &&
         !validators_->backbuffer_attachment.IsValid(attachments[i]))) {
       SetGLErrorInvalidEnum("glDiscardFramebufferEXT",
@@ skipping 33 matching lines @@
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glEnableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info ||
       !texture_manager()->CanGenerateMipmaps(info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glGenerateMipmaps", "Can not generate mips");
     return;
   }
 
   if (target == GL_TEXTURE_CUBE_MAP) {
     for (int i = 0; i < 6; ++i) {
       GLenum face = GL_TEXTURE_CUBE_MAP_POSITIVE_X + i;
@@ skipping 183 matching lines @@
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_FRAMEBUFFER_BINDING:
     // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
-        FramebufferManager::FramebufferInfo* framebuffer =
+        Framebuffer* framebuffer =
             GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
         if (framebuffer) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
               framebuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_READ_FRAMEBUFFER_BINDING_EXT:
       *num_written = 1;
       if (params) {
-        FramebufferManager::FramebufferInfo* framebuffer =
+        Framebuffer* framebuffer =
             GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
         if (framebuffer) {
           GLuint client_id = 0;
           framebuffer_manager()->GetClientId(
               framebuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_RENDERBUFFER_BINDING:
       *num_written = 1;
       if (params) {
-        RenderbufferManager::RenderbufferInfo* renderbuffer =
+        Renderbuffer* renderbuffer =
             GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
         if (renderbuffer) {
           GLuint client_id = 0;
           renderbuffer_manager()->GetClientId(
               renderbuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
@@ skipping 148 matching lines @@
   DCHECK(params);
   GLsizei num_written;
   if (!state_.GetStateAsGLint(pname, params, &num_written) &&
       !GetHelper(pname, params, &num_written)) {
     glGetIntegerv(pname, params);
   }
 }
 
 void GLES2DecoderImpl::DoGetProgramiv(
     GLuint program_id, GLenum pname, GLint* params) {
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program_id, "glGetProgramiv");
   if (!info) {
     return;
   }
   info->GetProgramiv(pname, params);
 }
 
 void GLES2DecoderImpl::DoBindAttribLocation(
     GLuint program, GLuint index, const char* name) {
   if (!StringIsValidForGLES(name)) {
     SetGLError(GL_INVALID_VALUE, "glBindAttribLocation", "Invalid character");
     return;
   }
   if (ProgramManager::IsInvalidPrefix(name, strlen(name))) {
     SetGLError(GL_INVALID_OPERATION, "glBindAttribLocation", "reserved prefix");
     return;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE, "glBindAttribLocation", "index out of range");
     return;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glBindAttribLocation");
   if (!info) {
     return;
   }
   info->SetAttribLocationBinding(name, static_cast<GLint>(index));
   glBindAttribLocation(info->service_id(), index, name);
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocation(
-    uint32 immediate_data_size, const gles2::BindAttribLocation& c) {
+    uint32 immediate_data_size, const cmds::BindAttribLocation& c) {
   GLuint program = static_cast<GLuint>(c.program);
   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);
   DoBindAttribLocation(program, index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationImmediate(
-    uint32 immediate_data_size, const gles2::BindAttribLocationImmediate& c) {
+    uint32 immediate_data_size, const cmds::BindAttribLocationImmediate& c) {
   GLuint program = static_cast<GLuint>(c.program);
   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);
   DoBindAttribLocation(program, index, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationBucket(
-    uint32 immediate_data_size, const gles2::BindAttribLocationBucket& c) {
+    uint32 immediate_data_size, const cmds::BindAttribLocationBucket& c) {
   GLuint program = static_cast<GLuint>(c.program);
   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;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
@@ skipping 13 matching lines @@
                "glBindUniformLocationCHROMIUM", "reserved prefix");
     return;
   }
   if (location < 0 || static_cast<uint32>(location) >=
       (group_->max_fragment_uniform_vectors() +
        group_->max_vertex_uniform_vectors()) * 4) {
     SetGLError(GL_INVALID_VALUE,
                "glBindUniformLocationCHROMIUM", "location out of range");
     return;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glBindUniformLocationCHROMIUM");
   if (!info) {
     return;
   }
   if (!info->SetUniformLocationBinding(name, location)) {
     SetGLError(GL_INVALID_VALUE,
                "glBindUniformLocationCHROMIUM", "location out of range");
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUM(
-    uint32 immediate_data_size, const gles2::BindUniformLocationCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::BindUniformLocationCHROMIUM& c) {
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   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);
   DoBindUniformLocationCHROMIUM(program, location, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUMImmediate(
     uint32 immediate_data_size,
-    const gles2::BindUniformLocationCHROMIUMImmediate& c) {
+    const cmds::BindUniformLocationCHROMIUMImmediate& c) {
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   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);
   DoBindUniformLocationCHROMIUM(program, location, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUMBucket(
     uint32 immediate_data_size,
-    const gles2::BindUniformLocationCHROMIUMBucket& c) {
+    const cmds::BindUniformLocationCHROMIUMBucket& c) {
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindUniformLocationCHROMIUM(program, location, name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteShader(
-    uint32 immediate_data_size, const gles2::DeleteShader& c) {
+    uint32 immediate_data_size, const cmds::DeleteShader& c) {
   GLuint client_id = c.shader;
   if (client_id) {
-    ShaderManager::ShaderInfo* info = GetShaderInfo(client_id);
+    Shader* info = GetShader(client_id);
     if (info) {
       if (!info->IsDeleted()) {
         glDeleteShader(info->service_id());
         shader_manager()->MarkAsDeleted(info);
       }
     } else {
       SetGLError(GL_INVALID_VALUE, "glDeleteShader", "unknown shader");
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteProgram(
-    uint32 immediate_data_size, const gles2::DeleteProgram& c) {
+    uint32 immediate_data_size, const cmds::DeleteProgram& c) {
   GLuint client_id = c.program;
   if (client_id) {
-    ProgramManager::ProgramInfo* info = GetProgramInfo(client_id);
+    Program* info = GetProgram(client_id);
     if (info) {
       if (!info->IsDeleted()) {
         program_manager()->MarkAsDeleted(shader_manager(), info);
       }
     } else {
       SetGLError(GL_INVALID_VALUE, "glDeleteProgram", "unknown program");
     }
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoDeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   IdAllocatorInterface* id_allocator = group_->GetIdAllocator(namespace_id);
   for (GLsizei ii = 0; ii < n; ++ii) {
     id_allocator->FreeID(ids[ii]);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleDeleteSharedIdsCHROMIUM(
-    uint32 immediate_data_size, const gles2::DeleteSharedIdsCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::DeleteSharedIdsCHROMIUM& c) {
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   const GLuint* ids = GetSharedMemoryAs<const GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE, "DeleteSharedIdsCHROMIUM", "n < 0");
@@ skipping 15 matching lines @@
     }
   } else {
     for (GLsizei ii = 0; ii < n; ++ii) {
       ids[ii] = id_allocator->AllocateIDAtOrAbove(id_offset);
       id_offset = ids[ii] + 1;
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleGenSharedIdsCHROMIUM(
-    uint32 immediate_data_size, const gles2::GenSharedIdsCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::GenSharedIdsCHROMIUM& c) {
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLuint id_offset = static_cast<GLuint>(c.id_offset);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* ids = GetSharedMemoryAs<GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
@@ skipping 17 matching lines @@
       }
       SetGLError(
           GL_INVALID_VALUE, "RegisterSharedIdsCHROMIUM",
           "attempt to register id that already exists");
       return;
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleRegisterSharedIdsCHROMIUM(
-    uint32 immediate_data_size, const gles2::RegisterSharedIdsCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::RegisterSharedIdsCHROMIUM& c) {
   GLuint namespace_id = static_cast<GLuint>(c.namespace_id);
   GLsizei n = static_cast<GLsizei>(c.n);
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   GLuint* ids = GetSharedMemoryAs<GLuint*>(
       c.ids_shm_id, c.ids_shm_offset, data_size);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE, "RegisterSharedIdsCHROMIUM", "n < 0");
@@ skipping 15 matching lines @@
         "green", state_.color_clear_green);
     ApplyDirtyState();
     glClear(mask);
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoFramebufferRenderbuffer(
     GLenum target, GLenum attachment, GLenum renderbuffertarget,
     GLuint client_renderbuffer_id) {
-  FramebufferManager::FramebufferInfo* framebuffer_info =
+  Framebuffer* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferRenderbuffer", "no framebuffer bound");
     return;
   }
   GLuint service_id = 0;
-  RenderbufferManager::RenderbufferInfo* info = NULL;
+  Renderbuffer* info = NULL;
   if (client_renderbuffer_id) {
-    info = GetRenderbufferInfo(client_renderbuffer_id);
+    info = GetRenderbuffer(client_renderbuffer_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferRenderbuffer", "unknown renderbuffer");
       return;
     }
     service_id = info->service_id();
   }
   CopyRealGLErrorsToWrapper();
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, service_id);
@@ skipping 39 matching lines @@
 }
 
 void GLES2DecoderImpl::DoSampleCoverage(GLclampf value, GLboolean invert) {
   state_.sample_coverage_value = std::min(1.0f, std::max(0.0f, value));
   state_.sample_coverage_invert = (invert != 0);
   glSampleCoverage(state_.sample_coverage_value, invert);
 }
 
 // Assumes framebuffer is complete.
 void GLES2DecoderImpl::ClearUnclearedAttachments(
-    GLenum target, FramebufferManager::FramebufferInfo* info) {
+    GLenum target, Framebuffer* info) {
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // bind this to the DRAW point, clear then bind back to READ
     // TODO(gman): I don't think there is any guarantee that an FBO that
     //   is complete on the READ attachment will be complete as a DRAW
     //   attachment.
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, info->service_id());
   }
   GLbitfield clear_bits = 0;
   if (info->HasUnclearedAttachment(GL_COLOR_ATTACHMENT0)) {
@@ skipping 22 matching lines @@
   glDisable(GL_SCISSOR_TEST);
   glClear(clear_bits);
 
   framebuffer_manager()->MarkAttachmentsAsCleared(
       info, renderbuffer_manager(), texture_manager());
 
   RestoreClearState();
 
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, info->service_id());
-    FramebufferManager::FramebufferInfo* framebuffer =
+    Framebuffer* framebuffer =
         GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
     GLuint service_id =
         framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, service_id);
   }
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
   clear_state_dirty_ = true;
   glClearColor(
       state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
       state_.color_clear_alpha);
   glClearStencil(state_.stencil_clear);
   glClearDepth(state_.depth_clear);
   if (state_.enable_flags.scissor_test) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
-  FramebufferManager::FramebufferInfo* framebuffer =
+  Framebuffer* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
   GLenum completeness = framebuffer->IsPossiblyComplete();
   if (completeness != GL_FRAMEBUFFER_COMPLETE) {
     return completeness;
   }
   return framebuffer->GetStatus(texture_manager(), target);
 }
 
 void GLES2DecoderImpl::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
-  FramebufferManager::FramebufferInfo* framebuffer_info =
+  Framebuffer* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferTexture2D", "no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
-  TextureManager::TextureInfo* info = NULL;
+  Texture* info = NULL;
   if (client_texture_id) {
-    info = GetTextureInfo(client_texture_id);
+    info = GetTexture(client_texture_id);
     if (!info) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferTexture2D", "unknown texture");
       return;
     }
     service_id = info->service_id();
   }
 
   if (!texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     SetGLError(GL_INVALID_VALUE,
                "glFramebufferTexture2D", "level out of range");
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachTexture(attachment, info, textarget, level);
   }
   if (framebuffer_info == state_.bound_draw_framebuffer) {
     clear_state_dirty_ = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
-  FramebufferManager::FramebufferInfo* framebuffer_info =
+  Framebuffer* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferAttachmentParameteriv", "no framebuffer bound");
     return;
   }
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
   if (pname == GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
     GLint type = 0;
     GLuint client_id = 0;
@@ skipping 10 matching lines @@
       }
       default:
         break;
     }
     *params = client_id;
   }
 }
 
 void GLES2DecoderImpl::DoGetRenderbufferParameteriv(
     GLenum target, GLenum pname, GLint* params) {
-  RenderbufferManager::RenderbufferInfo* renderbuffer =
+  Renderbuffer* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
                "glGetRenderbufferParameteriv", "no renderbuffer bound");
     return;
   }
   switch (pname) {
     case GL_RENDERBUFFER_INTERNAL_FORMAT:
       *params = renderbuffer->internal_format();
       break;
@@ skipping 32 matching lines @@
 
 void GLES2DecoderImpl::DoRenderbufferStorageMultisample(
     GLenum target, GLsizei samples, GLenum internalformat,
     GLsizei width, GLsizei height) {
   if (!features().chromium_framebuffer_multisample) {
     SetGLError(GL_INVALID_OPERATION,
                "glRenderbufferStorageMultisampleEXT", "function not available");
     return;
   }
 
-  RenderbufferManager::RenderbufferInfo* renderbuffer =
+  Renderbuffer* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
                "glRenderbufferStorageMultisampleEXT", "no renderbuffer bound");
     return;
   }
 
   if (samples > renderbuffer_manager()->max_samples()) {
     SetGLError(GL_INVALID_VALUE,
                "glRenderbufferStorageMultisampleEXT", "samples too large");
@@ skipping 36 matching lines @@
     // TODO(gman): If renderbuffers tracked which framebuffers they were
     // attached to we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
     renderbuffer_manager()->SetInfo(
         renderbuffer, samples, internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoRenderbufferStorage(
   GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
-  RenderbufferManager::RenderbufferInfo* renderbuffer =
+  Renderbuffer* renderbuffer =
       GetRenderbufferInfoForTarget(GL_RENDERBUFFER);
   if (!renderbuffer) {
     SetGLError(GL_INVALID_OPERATION,
                "glRenderbufferStorage", "no renderbuffer bound");
     return;
   }
 
   if (width > renderbuffer_manager()->max_renderbuffer_size() ||
       height > renderbuffer_manager()->max_renderbuffer_size()) {
     SetGLError(GL_INVALID_VALUE,
@@ skipping 24 matching lines @@
     // TODO(gman): If tetxures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
     renderbuffer_manager()->SetInfo(
         renderbuffer, 1, internalformat, width, height);
   }
 }
 
 void GLES2DecoderImpl::DoLinkProgram(GLuint program) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoLinkProgram");
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glLinkProgram");
   if (!info) {
     return;
   }
 
   LogClientServiceForInfo(info, program, "glLinkProgram");
   ShaderTranslator* vertex_translator = NULL;
   ShaderTranslator* fragment_translator = NULL;
   if (use_shader_translator_) {
     vertex_translator = vertex_translator_;
     fragment_translator = fragment_translator_;
   }
   if (info->Link(shader_manager(),
                  vertex_translator,
                  fragment_translator,
                  feature_info_)) {
     if (info == state_.current_program.get()) {
       if (workarounds().use_current_program_after_successful_link) {
         glUseProgram(info->service_id());
       }
       program_manager()->ClearUniforms(info);
     }
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
     return;
   }
 
   GLenum error = texture_manager()->SetParameter(
       info, pname, static_cast<GLint>(param));
   if (error != GL_NO_ERROR) {
     SetGLErrorInvalidParam(
         error, "glTexParameterf", pname, static_cast<GLint>(param));
     return;
   }
   glTexParameterf(target, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   GLenum error =  texture_manager()->SetParameter(info, pname, param);
   if (error != GL_NO_ERROR) {
     SetGLErrorInvalidParam(error, "glTexParameteri", pname, param);
     return;
   }
   // Texture tracking pools exist only for the command decoder, so
   // do not pass them on to the native GL implementation.
   if (pname == GL_TEXTURE_POOL_CHROMIUM) {
     return;
   }
   glTexParameteri(target, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterfv", "unknown texture");
     return;
   }
 
   GLenum error =texture_manager()->SetParameter(
       info, pname, static_cast<GLint>(params[0]));
   if (error != GL_NO_ERROR) {
     SetGLErrorInvalidParam(
         error, "glTexParameterfv", pname, static_cast<GLint>(params[0]));
     return;
   }
   glTexParameterfv(target, pname, params);
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   GLenum error = texture_manager()->SetParameter(info, pname, *params);
   if (error != GL_NO_ERROR) {
     SetGLErrorInvalidParam(error, "glTexParameteriv", pname, *params);
     return;
   }
@@ skipping 141 matching lines @@
     const GLES2DecoderImpl::BaseUniformInfo& base_info,
     GLint* real_location, GLenum* type, GLsizei* count) {
   DCHECK(type);
   DCHECK(count);
   DCHECK(real_location);
 
   if (!CheckCurrentProgramForUniform(fake_location, function_name)) {
     return false;
   }
   GLint array_index = -1;
-  const ProgramManager::ProgramInfo::UniformInfo* info =
+  const Program::UniformInfo* info =
       state_.current_program->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION, function_name, "unknown location");
     return false;
   }
   bool okay = false;
   for (size_t ii = 0; ii < base_info.num_valid_types; ++ii) {
     if (base_info.valid_types[ii] == info->type) {
       okay = true;
@@ skipping 208 matching lines @@
   if (!PrepForSetUniformByLocation(
       fake_location, "glUniformMatrix4fv",  valid_float_mat4_base_info,
       &real_location, &type, &count)) {
     return;
   }
   glUniformMatrix4fv(real_location, count, transpose, value);
 }
 
 void GLES2DecoderImpl::DoUseProgram(GLuint program) {
   GLuint service_id = 0;
-  ProgramManager::ProgramInfo* info = NULL;
+  Program* info = NULL;
   if (program) {
     info = GetProgramInfoNotShader(program, "glUseProgram");
     if (!info) {
       return;
     }
     if (!info->IsValid()) {
       // Program was not linked successfully. (ie, glLinkProgram)
       SetGLError(GL_INVALID_OPERATION, "glUseProgram", "program not linked");
       return;
     }
@@ skipping 105 matching lines @@
 
 void GLES2DecoderImpl::RenderWarning(const std::string& msg) {
   LogMessage(std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(const std::string& msg) {
   LogMessage(std::string("PERFORMANCE WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::ForceCompileShaderIfPending(
-    ShaderManager::ShaderInfo* info) {
+    Shader* info) {
   if (info->compilation_status() ==
-      ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE) {
+      Shader::PENDING_DEFERRED_COMPILE) {
     ShaderTranslator* translator = NULL;
     if (use_shader_translator_) {
       translator = info->shader_type() == GL_VERTEX_SHADER ?
           vertex_translator_.get() : fragment_translator_.get();
     }
     // We know there will be no errors, because we only defer compilation on
     // shaders that were previously compiled successfully.
     program_manager()->ForceCompileShader(info->deferred_compilation_source(),
                                           info,
                                           translator,
@@ skipping 18 matching lines @@
   }
 }
 
 bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
   DCHECK(state_.current_program);
   // Only check if there are some unrenderable textures.
   if (!texture_manager()->HaveUnrenderableTextures()) {
     return false;
   }
   bool textures_set = false;
-  const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
+  const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
-    const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+    const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-        TextureManager::TextureInfo* texture_info =
+        Texture* texture_info =
             texture_unit.GetInfoForSamplerType(uniform_info->type);
         if (!texture_info || !texture_manager()->CanRender(texture_info)) {
           textures_set = true;
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           glBindTexture(
               GetBindTargetForSamplerType(uniform_info->type),
               texture_manager()->black_texture_id(uniform_info->type));
           RenderWarning(
               std::string("texture bound to texture unit ") +
               base::IntToString(texture_unit_index) +
               " is not renderable. It maybe non-power-of-2 and have "
               " incompatible texture filtering or is not "
               "'texture complete'");
         }
       }
       // else: should this be an error?
     }
   }
   return textures_set;
 }
 
 void GLES2DecoderImpl::RestoreStateForNonRenderableTextures() {
   DCHECK(state_.current_program);
-  const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
+  const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
-    const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+    const Program::UniformInfo* uniform_info =
         state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < state_.texture_units.size()) {
         TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-        TextureManager::TextureInfo* texture_info =
+        Texture* texture_info =
             uniform_info->type == GL_SAMPLER_2D ?
                 texture_unit.bound_texture_2d :
                 texture_unit.bound_texture_cube_map;
         if (!texture_info || !texture_manager()->CanRender(texture_info)) {
           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->service_id() : 0);
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
   glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::ClearUnclearedTextures() {
   // Only check if there are some uncleared textures.
   if (!texture_manager()->HaveUnsafeTextures()) {
     return true;
   }
 
   // 1: Check all textures we are about to render with.
   if (state_.current_program) {
-    const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
+    const Program::SamplerIndices& sampler_indices =
        state_.current_program->sampler_indices();
     for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
-      const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+      const Program::UniformInfo* uniform_info =
           state_.current_program->GetUniformInfo(sampler_indices[ii]);
       DCHECK(uniform_info);
       for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
         GLuint texture_unit_index = uniform_info->texture_units[jj];
         if (texture_unit_index < state_.texture_units.size()) {
           TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
-          TextureManager::TextureInfo* texture_info =
+          Texture* texture_info =
               texture_unit.GetInfoForSamplerType(uniform_info->type);
           if (texture_info && !texture_info->SafeToRenderFrom()) {
             if (!texture_manager()->ClearRenderableLevels(this, texture_info)) {
               return false;
             }
           }
         }
       }
     }
   }
@@ skipping 16 matching lines @@
   // true if any enabled, used divisor is zero
   bool divisor0 = false;
   // Validate all attribs currently enabled. If they are used by the current
   // program then check that they have enough elements to handle the draw call.
   // If they are not used by the current program check that they have a buffer
   // assigned.
   const VertexAttribManager::VertexAttribInfoList& infos =
       state_.vertex_attrib_manager->GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
-    const VertexAttribManager::VertexAttribInfo* info = *it;
-    const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
+    const VertexAttrib* info = *it;
+    const Program::VertexAttrib* attrib_info =
         state_.current_program->GetAttribInfoByLocation(info->index());
     if (attrib_info) {
       divisor0 |= (info->divisor() == 0);
       GLuint count = info->MaxVertexAccessed(primcount, max_vertex_accessed);
       // This attrib is used in the current program.
       if (!info->CanAccess(count)) {
         SetGLError(
             GL_INVALID_OPERATION, function_name,
             (std::string(
                  "attempt to access out of range vertices in attribute ") +
@@ skipping 26 matching lines @@
 }
 
 bool GLES2DecoderImpl::SimulateAttrib0(
     const char* function_name, GLuint max_vertex_accessed, bool* simulated) {
   DCHECK(simulated);
   *simulated = false;
 
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
-  const VertexAttribManager::VertexAttribInfo* info =
-      state_.vertex_attrib_manager->GetVertexAttribInfo(0);
+  const VertexAttrib* info =
+      state_.vertex_attrib_manager->GetVertexAttrib(0);
   // If it's enabled or it's not used then we don't need to do anything.
   bool attrib_0_used =
       state_.current_program->GetAttribInfoByLocation(0) != NULL;
   if (info->enabled() && attrib_0_used) {
     return true;
   }
 
   // Make a buffer with a single repeated vec4 value enough to
   // simulate the constant value that is supposed to be here.
   // This is required to emulate GLES2 on GL.
@@ skipping 41 matching lines @@
   glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
 
   if (info->divisor())
     glVertexAttribDivisorANGLE(0, 0);
 
   *simulated = true;
   return true;
 }
 
 void GLES2DecoderImpl::RestoreStateForAttrib(GLuint attrib) {
-  const VertexAttribManager::VertexAttribInfo* info =
-      state_.vertex_attrib_manager->GetVertexAttribInfo(attrib);
+  const VertexAttrib* info =
+      state_.vertex_attrib_manager->GetVertexAttrib(attrib);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
-  BufferManager::BufferInfo* buffer_info = info->buffer();
+  BufferManager::Buffer* buffer_info = info->buffer();
   glBindBuffer(GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
   glVertexAttribPointer(
       attrib, info->size(), info->type(), info->normalized(), info->gl_stride(),
       ptr);
   if (info->divisor())
     glVertexAttribDivisorANGLE(attrib, info->divisor());
   glBindBuffer(
       GL_ARRAY_BUFFER,
       state_.bound_array_buffer ? state_.bound_array_buffer->service_id() : 0);
 
@@ skipping 29 matching lines @@
   // twice in 2 different attribs, find the overlapping parts and therefore
   // duplicate the minimum amount of data but this whole code path is not meant
   // to be used normally. It's just here to pass that OpenGL ES 2.0 conformance
   // tests so we just add to the buffer attrib used.
 
   GLuint elements_needed = 0;
   const VertexAttribManager::VertexAttribInfoList& infos =
       state_.vertex_attrib_manager->GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
-    const VertexAttribManager::VertexAttribInfo* info = *it;
-    const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
+    const VertexAttrib* info = *it;
+    const Program::VertexAttrib* attrib_info =
         state_.current_program->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
@@ skipping 26 matching lines @@
       SetGLError(
           GL_OUT_OF_MEMORY, function_name, "simulating GL_FIXED attribs");
       return false;
     }
   }
 
   // Copy the elements and convert to float
   GLintptr offset = 0;
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
            infos.begin(); it != infos.end(); ++it) {
-    const VertexAttribManager::VertexAttribInfo* info = *it;
-    const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
+    const VertexAttrib* info = *it;
+    const Program::VertexAttrib* attrib_info =
         state_.current_program->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
@@ skipping 94 matching lines @@
       }
     }
     if (simulated_attrib_0) {
       RestoreStateForAttrib(0);
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(
-    uint32 immediate_data_size, const gles2::DrawArrays& c) {
+    uint32 immediate_data_size, const cmds::DrawArrays& c) {
   return DoDrawArrays("glDrawArrays",
                       false,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       0);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
-    uint32 immediate_data_size, const gles2::DrawArraysInstancedANGLE& c) {
+    uint32 immediate_data_size, const cmds::DrawArraysInstancedANGLE& c) {
   if (!features().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawArraysInstancedANGLE", "function not available");
     return error::kNoError;
   }
   return DoDrawArrays("glDrawArraysIntancedANGLE",
                       true,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
@@ skipping 84 matching lines @@
       }
     }
     if (simulated_attrib_0) {
       RestoreStateForAttrib(0);
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElements(
-    uint32 immediate_data_size, const gles2::DrawElements& c) {
+    uint32 immediate_data_size, const cmds::DrawElements& c) {
   return DoDrawElements("glDrawElements",
                         false,
                         static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32>(c.index_offset),
                         0);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
-    uint32 immediate_data_size, const gles2::DrawElementsInstancedANGLE& c) {
+    uint32 immediate_data_size, const cmds::DrawElementsInstancedANGLE& c) {
   if (!features().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
                "glDrawElementsInstancedANGLE", "function not available");
     return error::kNoError;
   }
   return DoDrawElements("glDrawElementsInstancedANGLE",
                         true,
                         static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32>(c.index_offset),
                         static_cast<GLsizei>(c.primcount));
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GLuint max_vertex_accessed = 0;
-  BufferManager::BufferInfo* info = GetBufferInfo(buffer_id);
+  BufferManager::Buffer* info = GetBuffer(buffer_id);
   if (!info) {
     // TODO(gman): Should this be a GL error or a command buffer error?
     SetGLError(GL_INVALID_VALUE,
                "GetMaxValueInBufferCHROMIUM", "unknown buffer");
   } 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,
           "GetMaxValueInBufferCHROMIUM", "range out of bounds for buffer");
     }
   }
   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 client_id, const char* data, uint32 data_size) {
   std::string str(data, data + data_size);
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       client_id, "glShaderSource");
   if (!info) {
     return error::kNoError;
   }
   // Note: We don't actually call glShaderSource here. We wait until
   // the call to glCompileShader.
   info->UpdateSource(str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSource(
-    uint32 immediate_data_size, const gles2::ShaderSource& c) {
+    uint32 immediate_data_size, const cmds::ShaderSource& c) {
   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(c.shader, data, data_size);
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSourceImmediate(
-  uint32 immediate_data_size, const gles2::ShaderSourceImmediate& c) {
+  uint32 immediate_data_size, const cmds::ShaderSourceImmediate& c) {
   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(c.shader, data, data_size);
 }
 
 error::Error GLES2DecoderImpl::HandleShaderSourceBucket(
-  uint32 immediate_data_size, const gles2::ShaderSourceBucket& c) {
+  uint32 immediate_data_size, const cmds::ShaderSourceBucket& c) {
   Bucket* bucket = GetBucket(c.data_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   return ShaderSourceHelper(
       c.shader, bucket->GetDataAs<const char*>(0, bucket->size() - 1),
       bucket->size() - 1);
 }
 
 void GLES2DecoderImpl::DoCompileShader(GLuint client_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCompileShader");
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       client_id, "glCompileShader");
   if (!info) {
     return;
   }
   ShaderTranslator* translator = NULL;
   if (use_shader_translator_) {
     translator = info->shader_type() == GL_VERTEX_SHADER ?
         vertex_translator_.get() : fragment_translator_.get();
   }
 
   program_manager()->DoCompileShader(info, translator, feature_info_);
 };
 
 void GLES2DecoderImpl::DoGetShaderiv(
     GLuint shader, GLenum pname, GLint* params) {
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       shader, "glGetShaderiv");
   if (!info) {
     return;
   }
   switch (pname) {
     case GL_SHADER_SOURCE_LENGTH:
       *params = info->source() ? info->source()->size() + 1 : 0;
       return;
     case GL_COMPILE_STATUS:
       *params = compile_shader_always_succeeds_ ? true : info->IsValid();
       return;
     case GL_INFO_LOG_LENGTH:
       *params = info->log_info() ? info->log_info()->size() + 1 : 0;
       return;
     case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
       ForceCompileShaderIfPending(info);
       *params = info->translated_source() ?
           info->translated_source()->size() + 1 : 0;
       return;
     default:
       break;
   }
   glGetShaderiv(info->service_id(), pname, params);
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderSource(
-    uint32 immediate_data_size, const gles2::GetShaderSource& c) {
+    uint32 immediate_data_size, const cmds::GetShaderSource& c) {
   GLuint shader = c.shader;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       shader, "glGetShaderSource");
   if (!info || !info->source()) {
     bucket->SetSize(0);
     return error::kNoError;
   }
   bucket->SetFromString(info->source()->c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
     uint32 immediate_data_size,
-    const gles2::GetTranslatedShaderSourceANGLE& c) {
+    const cmds::GetTranslatedShaderSourceANGLE& c) {
   GLuint shader = c.shader;
 
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       shader, "glTranslatedGetShaderSourceANGLE");
   if (!info) {
     bucket->SetSize(0);
     return error::kNoError;
   }
   ForceCompileShaderIfPending(info);
 
   bucket->SetFromString(info->translated_source() ?
       info->translated_source()->c_str() : NULL);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
-    uint32 immediate_data_size, const gles2::GetProgramInfoLog& c) {
+    uint32 immediate_data_size, const cmds::GetProgramInfoLog& c) {
   GLuint program = c.program;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glGetProgramInfoLog");
   if (!info || !info->log_info()) {
     bucket->SetFromString("");
     return error::kNoError;
   }
   bucket->SetFromString(info->log_info()->c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
-    uint32 immediate_data_size, const gles2::GetShaderInfoLog& c) {
+    uint32 immediate_data_size, const cmds::GetShaderInfoLog& c) {
   GLuint shader = c.shader;
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
-  ShaderManager::ShaderInfo* info = GetShaderInfoNotProgram(
+  Shader* info = GetShaderInfoNotProgram(
       shader, "glGetShaderInfoLog");
   if (!info || !info->log_info()) {
     bucket->SetFromString("");
     return error::kNoError;
   }
   bucket->SetFromString(info->log_info()->c_str());
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
   return state_.GetEnabled(cap);
 }
 
 bool GLES2DecoderImpl::DoIsBuffer(GLuint client_id) {
-  const BufferManager::BufferInfo* buffer = GetBufferInfo(client_id);
+  const BufferManager::Buffer* buffer = GetBuffer(client_id);
   return buffer && buffer->IsValid() && !buffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsFramebuffer(GLuint client_id) {
-  const FramebufferManager::FramebufferInfo* framebuffer =
-      GetFramebufferInfo(client_id);
+  const Framebuffer* framebuffer =
+      GetFramebuffer(client_id);
   return framebuffer && framebuffer->IsValid() && !framebuffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsProgram(GLuint client_id) {
   // IsProgram is true for programs as soon as they are created, until they are
   // deleted and no longer in use.
-  const ProgramManager::ProgramInfo* program = GetProgramInfo(client_id);
+  const Program* program = GetProgram(client_id);
   return program != NULL && !program->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsRenderbuffer(GLuint client_id) {
-  const RenderbufferManager::RenderbufferInfo* renderbuffer =
-      GetRenderbufferInfo(client_id);
+  const Renderbuffer* renderbuffer =
+      GetRenderbuffer(client_id);
   return renderbuffer && renderbuffer->IsValid() && !renderbuffer->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsShader(GLuint client_id) {
   // IsShader is true for shaders as soon as they are created, until they
   // are deleted and not attached to any programs.
-  const ShaderManager::ShaderInfo* shader = GetShaderInfo(client_id);
+  const Shader* shader = GetShader(client_id);
   return shader != NULL && !shader->IsDeleted();
 }
 
 bool GLES2DecoderImpl::DoIsTexture(GLuint client_id) {
-  const TextureManager::TextureInfo* texture = GetTextureInfo(client_id);
+  const Texture* texture = GetTexture(client_id);
   return texture && texture->IsValid() && !texture->IsDeleted();
 }
 
 void GLES2DecoderImpl::DoAttachShader(
     GLuint program_client_id, GLint shader_client_id) {
-  ProgramManager::ProgramInfo* program_info = GetProgramInfoNotShader(
+  Program* program_info = GetProgramInfoNotShader(
       program_client_id, "glAttachShader");
   if (!program_info) {
     return;
   }
-  ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
+  Shader* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glAttachShader");
   if (!shader_info) {
     return;
   }
   if (!program_info->AttachShader(shader_manager(), shader_info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glAttachShader", "can not attach more than"
                " one shader of the same type.");
     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 = GetProgramInfoNotShader(
+  Program* program_info = GetProgramInfoNotShader(
       program_client_id, "glDetachShader");
   if (!program_info) {
     return;
   }
-  ShaderManager::ShaderInfo* shader_info = GetShaderInfoNotProgram(
+  Shader* shader_info = GetShaderInfoNotProgram(
       shader_client_id, "glDetachShader");
   if (!shader_info) {
     return;
   }
   if (!program_info->DetachShader(shader_manager(), shader_info)) {
     SetGLError(GL_INVALID_OPERATION,
                "glDetachShader", "shader not attached to program");
     return;
   }
   glDetachShader(program_info->service_id(), shader_info->service_id());
 }
 
 void GLES2DecoderImpl::DoValidateProgram(GLuint program_client_id) {
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program_client_id, "glValidateProgram");
   if (!info) {
     return;
   }
   info->Validate();
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
-  VertexAttribManager::VertexAttribInfo* info =
-      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
+  VertexAttrib* info =
+      state_.vertex_attrib_manager->GetVertexAttrib(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glGetVertexAttribfv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
-        BufferManager::BufferInfo* buffer = info->buffer();
+        BufferManager::Buffer* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
           *params = static_cast<GLfloat>(client_id);
         }
         break;
       }
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
       *params = static_cast<GLfloat>(info->enabled());
       break;
@@ skipping 21 matching lines @@
       *params = static_cast<GLfloat>(info->divisor());
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
-  VertexAttribManager::VertexAttribInfo* info =
-      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
+  VertexAttrib* info =
+      state_.vertex_attrib_manager->GetVertexAttrib(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glGetVertexAttribiv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
-        BufferManager::BufferInfo* buffer = info->buffer();
+        BufferManager::Buffer* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
           *params = client_id;
         }
         break;
       }
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
       *params = info->enabled();
       break;
@@ skipping 91 matching lines @@
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index, const GLfloat* v) {
   if (SetVertexAttribValue("glVertexAttrib4fv", index, v)) {
     glVertexAttrib4fv(index, v);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
-    uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
+    uint32 immediate_data_size, const cmds::VertexAttribPointer& c) {
 
   if (!state_.bound_array_buffer || state_.bound_array_buffer->IsDeleted()) {
     if (state_.vertex_attrib_manager == default_vertex_attrib_manager_) {
       SetGLError(GL_INVALID_VALUE,
                 "glVertexAttribPointer", "no array buffer bound");
       return error::kNoError;
     } else if (c.offset != 0) {
       SetGLError(GL_INVALID_VALUE,
                 "glVertexAttribPointer", "client side arrays are not allowed");
       return error::kNoError;
@@ skipping 65 matching lines @@
 void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
                                   GLsizei height) {
   state_.viewport_x = x;
   state_.viewport_y = y;
   state_.viewport_width = std::min(width, viewport_max_width_);
   state_.viewport_height = std::min(height, viewport_max_height_);
   glViewport(x, y, width, height);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
-    uint32 immediate_data_size, const gles2::VertexAttribDivisorANGLE& c) {
+    uint32 immediate_data_size, const cmds::VertexAttribDivisorANGLE& c) {
   if (!features().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
                "glVertexAttribDivisorANGLE", "function not available");
   }
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glVertexAttribDivisorANGLE", "index out of range");
     return error::kNoError;
   }
 
   state_.vertex_attrib_manager->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(
-    uint32 immediate_data_size, const gles2::ReadPixels& c) {
+    uint32 immediate_data_size, const cmds::ReadPixels& c) {
   if (ShouldDeferReads())
     return error::kDeferCommandUntilLater;
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
-  typedef gles2::ReadPixels::Result Result;
+  typedef cmds::ReadPixels::Result Result;
   uint32 pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.pack_alignment, &pixels_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
@@ skipping 120 matching lines @@
         default:
           break;
       }
     }
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePixelStorei(
-    uint32 immediate_data_size, const gles2::PixelStorei& c) {
+    uint32 immediate_data_size, const cmds::PixelStorei& c) {
   GLenum pname = c.pname;
   GLenum param = c.param;
   if (!validators_->pixel_store.IsValid(pname)) {
     SetGLErrorInvalidEnum("glPixelStorei", pname, "pname");
     return error::kNoError;
   }
   switch (pname) {
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
         if (!validators_->pixel_store_alignment.IsValid(param)) {
@@ skipping 27 matching lines @@
         break;
     default:
         // Validation should have prevented us from getting here.
         NOTREACHED();
         break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
-    uint32 immediate_data_size, const gles2::PostSubBufferCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::PostSubBufferCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandlePostSubBufferCHROMIUM");
   if (!surface_->HasExtension("GL_CHROMIUM_post_sub_buffer")) {
     SetGLError(GL_INVALID_OPERATION,
                "glPostSubBufferCHROMIUM", "command not supported by surface");
     return error::kNoError;
   }
   if (surface_->PostSubBuffer(c.x, c.y, c.width, c.height)) {
     return error::kNoError;
   } else {
     LOG(ERROR) << "Context lost because PostSubBuffer failed.";
     return error::kLostContext;
   }
 }
 
 error::Error GLES2DecoderImpl::GetAttribLocationHelper(
     GLuint client_id, uint32 location_shm_id, uint32 location_shm_offset,
     const std::string& name_str) {
   if (!StringIsValidForGLES(name_str.c_str())) {
     SetGLError(GL_INVALID_VALUE, "glGetAttribLocation", "Invalid character");
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       client_id, "glGetAttribLocation");
   if (!info) {
     return error::kNoError;
   }
   if (!info->IsValid()) {
     SetGLError(
         GL_INVALID_OPERATION, "glGetAttribLocation", "program not linked");
     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.
   if (*location != -1) {
     return error::kGenericError;
   }
   *location = info->GetAttribLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocation(
-    uint32 immediate_data_size, const gles2::GetAttribLocation& c) {
+    uint32 immediate_data_size, const cmds::GetAttribLocation& c) {
   uint32 name_size = c.data_size;
   const char* name = GetSharedMemoryAs<const char*>(
       c.name_shm_id, c.name_shm_offset, name_size);
   if (!name) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocationImmediate(
-    uint32 immediate_data_size, const gles2::GetAttribLocationImmediate& c) {
+    uint32 immediate_data_size, const cmds::GetAttribLocationImmediate& c) {
   uint32 name_size = c.data_size;
   const char* name = GetImmediateDataAs<const char*>(
       c, name_size, immediate_data_size);
   if (!name) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocationBucket(
-    uint32 immediate_data_size, const gles2::GetAttribLocationBucket& c) {
+    uint32 immediate_data_size, const cmds::GetAttribLocationBucket& c) {
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   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) {
   if (!StringIsValidForGLES(name_str.c_str())) {
     SetGLError(GL_INVALID_VALUE, "glGetUniformLocation", "Invalid character");
     return error::kNoError;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       client_id, "glUniformLocation");
   if (!info) {
     return error::kNoError;
   }
   if (!info->IsValid()) {
     SetGLError(
         GL_INVALID_OPERATION, "glGetUniformLocation", "program not linked");
     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.
   if (*location != -1) {
     return error::kGenericError;
   }
   *location = info->GetUniformFakeLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocation(
-    uint32 immediate_data_size, const gles2::GetUniformLocation& c) {
+    uint32 immediate_data_size, const cmds::GetUniformLocation& c) {
   uint32 name_size = c.data_size;
   const char* name = GetSharedMemoryAs<const char*>(
       c.name_shm_id, c.name_shm_offset, name_size);
   if (!name) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocationImmediate(
-    uint32 immediate_data_size, const gles2::GetUniformLocationImmediate& c) {
+    uint32 immediate_data_size, const cmds::GetUniformLocationImmediate& c) {
   uint32 name_size = c.data_size;
   const char* name = GetImmediateDataAs<const char*>(
       c, name_size, immediate_data_size);
   if (!name) {
     return error::kOutOfBounds;
   }
   String name_str(name, name_size);
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocationBucket(
-    uint32 immediate_data_size, const gles2::GetUniformLocationBucket& c) {
+    uint32 immediate_data_size, const cmds::GetUniformLocationBucket& c) {
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetString(
-    uint32 immediate_data_size, const gles2::GetString& c) {
+    uint32 immediate_data_size, const cmds::GetString& c) {
   GLenum name = static_cast<GLenum>(c.name);
   if (!validators_->string_type.IsValid(name)) {
     SetGLErrorInvalidEnum("glGetString", name, "name");
     return error::kNoError;
   }
   const char* gl_str = reinterpret_cast<const char*>(glGetString(name));
   const char* str = NULL;
   std::string extensions;
   switch (name) {
     case GL_VERSION:
@@ skipping 46 matching lines @@
     return;
   }
   if (!validators_->buffer_usage.IsValid(usage)) {
     SetGLErrorInvalidEnum("glBufferData", usage, "usage");
     return;
   }
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
-  BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
+  BufferManager::Buffer* info = GetBufferInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "unknown buffer");
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(size)) {
     SetGLError(GL_OUT_OF_MEMORY, "glBufferData", "out of memory");
     return;
   }
 
@@ skipping 10 matching lines @@
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     buffer_manager()->SetInfo(info, size, usage);
     info->SetRange(0, size, data);
   } else {
     buffer_manager()->SetInfo(info, 0, usage);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBufferData(
-    uint32 immediate_data_size, const gles2::BufferData& c) {
+    uint32 immediate_data_size, const cmds::BufferData& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   DoBufferData(target, size, data, usage);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBufferDataImmediate(
-    uint32 immediate_data_size, const gles2::BufferDataImmediate& c) {
+    uint32 immediate_data_size, const cmds::BufferDataImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   const void* data = GetImmediateDataAs<const void*>(
       c, size, immediate_data_size);
   if (!data) {
     return error::kOutOfBounds;
   }
   GLenum usage = static_cast<GLenum>(c.usage);
   DoBufferData(target, size, data, usage);
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoBufferSubData(
   GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {
-  BufferManager::BufferInfo* info = GetBufferInfoForTarget(target);
+  BufferManager::Buffer* info = GetBufferInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData", "unknown buffer");
     return;
   }
   if (!info->SetRange(offset, size, data)) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
     return;
   }
   glBufferSubData(target, offset, size, data);
 }
@@ skipping 30 matching lines @@
     glClearStencil(0);
     glStencilMask(-1);
     glClearDepth(1.0f);
     glDepthMask(true);
     glDisable(GL_SCISSOR_TEST);
     glClear(GL_DEPTH_BUFFER_BIT | (have_stencil ? GL_STENCIL_BUFFER_BIT : 0));
 
     RestoreClearState();
 
     glDeleteFramebuffersEXT(1, &fb);
-    FramebufferManager::FramebufferInfo* framebuffer =
+    Framebuffer* framebuffer =
         GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
     GLuint fb_service_id =
         framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb_service_id);
     return true;
   }
 
   static const uint32 kMaxZeroSize = 1024 * 1024 * 4;
 
   uint32 size;
@@ skipping 34 matching lines @@
   while (y < height) {
     GLint h = y + tile_height > height ? height - y : tile_height;
     if (is_texture_immutable || h != height) {
       glTexSubImage2D(target, level, 0, y, width, h, format, type, zero.get());
     } else {
       WrappedTexImage2D(
           target, level, format, width, h, 0, format, type, zero.get());
     }
     y += tile_height;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(bind_target);
+  Texture* info = GetTextureInfoForTarget(bind_target);
   glBindTexture(bind_target, info ? info->service_id() : 0);
   return true;
 }
 
 namespace {
 
 const int kS3TCBlockWidth = 4;
 const int kS3TCBlockHeight = 4;
 const int kS3TCDXT1BlockSize = 8;
 const int kS3TCDXT3AndDXT5BlockSize = 16;
@@ skipping 83 matching lines @@
       return true;
     default:
       return false;
   }
 }
 
 bool GLES2DecoderImpl::ValidateCompressedTexSubDimensions(
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height, GLenum format,
-    TextureManager::TextureInfo* texture) {
+    Texture* texture) {
   if (xoffset < 0 || yoffset < 0) {
     SetGLError(
         GL_INVALID_VALUE, function_name, "xoffset or yoffset < 0");
     return false;
   }
 
   switch (format) {
     case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
     case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
     case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
@@ skipping 48 matching lines @@
     SetGLErrorInvalidEnum(
         "glCompressedTexImage2D", internal_format, "internal_format");
     return error::kNoError;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D", "dimensions out of range");
     return error::kNoError;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D", "unknown texture target");
     return error::kNoError;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCompressedTexImage2D", "texture is immutable");
     return error::kNoError;
   }
@@ skipping 29 matching lines @@
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
         info, target, level, internal_format, width, height, 1, border, 0, 0,
         true);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
-    uint32 immediate_data_size, const gles2::CompressedTexImage2D& c) {
+    uint32 immediate_data_size, const cmds::CompressedTexImage2D& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   uint32 data_shm_id = static_cast<uint32>(c.data_shm_id);
   uint32 data_shm_offset = static_cast<uint32>(c.data_shm_offset);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(
         data_shm_id, data_shm_offset, image_size);
     if (!data) {
       return error::kOutOfBounds;
     }
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2DImmediate(
-    uint32 immediate_data_size, const gles2::CompressedTexImage2DImmediate& c) {
+    uint32 immediate_data_size, const cmds::CompressedTexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLsizei image_size = static_cast<GLsizei>(c.imageSize);
   const void* data = GetImmediateDataAs<const void*>(
       c, image_size, immediate_data_size);
   if (!data) {
     return error::kOutOfBounds;
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2DBucket(
-    uint32 immediate_data_size, const gles2::CompressedTexImage2DBucket& c) {
+    uint32 immediate_data_size, const cmds::CompressedTexImage2DBucket& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLenum internal_format = static_cast<GLenum>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   uint32 data_size = bucket->size();
   GLsizei imageSize = data_size;
   const void* data = bucket->GetData(0, data_size);
   if (!data) {
     return error::kInvalidArguments;
   }
   return DoCompressedTexImage2D(
       target, level, internal_format, width, height, border,
       imageSize, data);
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexSubImage2DBucket(
     uint32 immediate_data_size,
-    const gles2::CompressedTexSubImage2DBucket& c) {
+    const cmds::CompressedTexSubImage2DBucket& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
@@ skipping 93 matching lines @@
     SetGLError(GL_INVALID_VALUE, function_name, "dimensions out of range");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0 && pixels) {
     SetGLError(
         GL_INVALID_OPERATION,
         function_name, "can not supply data for depth or stencil textures");
     return false;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "unknown texture for target");
     return false;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "texture is immutable");
     return false;
   }
@@ skipping 14 matching lines @@
   if (!ValidateTexImage2D("glTexImage2D", target, level, internal_format,
       width, height, border, format, type, pixels, pixels_size)) {
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(pixels_size)) {
     SetGLError(GL_OUT_OF_MEMORY, "glTexImage2D", "out of memory");
     return;
   }
 
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   GLenum tex_type = 0;
   GLenum tex_format = 0;
   bool level_is_same =
       info->GetLevelSize(target, level, &tex_width, &tex_height) &&
       info->GetLevelType(target, level, &tex_type, &tex_format) &&
       width == tex_width && height == tex_height &&
       type == tex_type && format == tex_format;
 
@@ skipping 30 matching lines @@
     texture_manager()->SetLevelInfo(
         info,
         target, level, internal_format, width, height, 1, border, format, type,
         pixels != NULL);
     tex_image_2d_failed_ = false;
   }
   return;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(
-    uint32 immediate_data_size, const gles2::TexImage2D& c) {
+    uint32 immediate_data_size, const cmds::TexImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexImage2D");
   tex_image_2d_failed_ = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
@@ skipping 14 matching lines @@
     }
   }
 
   DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, pixels_size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2DImmediate(
-    uint32 immediate_data_size, const gles2::TexImage2DImmediate& c) {
+    uint32 immediate_data_size, const cmds::TexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 size;
   if (!GLES2Util::ComputeImageDataSizes(
@@ skipping 15 matching lines @@
 void GLES2DecoderImpl::DoCompressedTexSubImage2D(
   GLenum target,
   GLint level,
   GLint xoffset,
   GLint yoffset,
   GLsizei width,
   GLsizei height,
   GLenum format,
   GLsizei image_size,
   const void * data) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCompressedTexSubImage2D", "unknown texture for target");
     return;
   }
   GLenum type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION,
@@ skipping 50 matching lines @@
 void GLES2DecoderImpl::DoCopyTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
   DCHECK(!ShouldDeferReads());
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "unknown texture for target");
     return;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "texture is immutable");
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
@@ skipping 95 matching lines @@
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
   DCHECK(!ShouldDeferReads());
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexSubImage2D", "unknown texture for target");
     return;
   }
   GLenum type = 0;
   GLenum format = 0;
   if (!info->GetLevelType(target, level, &type, &format) ||
       !info->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
@@ skipping 101 matching lines @@
     return false;
   }
   if (!validators_->texture_format.IsValid(format)) {
     SetGLErrorInvalidEnum(function_name, format, "format");
     return false;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLErrorInvalidEnum(function_name, type, "type");
     return false;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "unknown texture for target");
     return false;
   }
   GLenum current_type = 0;
   GLenum internal_format = 0;
   if (!info->GetLevelType(target, level, &current_type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION, function_name, "level does not exist.");
@@ skipping 41 matching lines @@
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type,
     const void * data) {
   error::Error error = error::kNoError;
   if (!ValidateTexSubImage2D(&error, "glTexSubImage2D", target, level,
       xoffset, yoffset, width, height, format, type, data)) {
     return error;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
   bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
   DCHECK(ok);
   if (xoffset != 0 || yoffset != 0 ||
       width != tex_width || height != tex_height) {
     if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
       SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
       return error::kNoError;
     }
@@ skipping 12 matching lines @@
   } else {
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
   texture_manager()->SetLevelCleared(info, target, level, true);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
-    uint32 immediate_data_size, const gles2::TexSubImage2D& c) {
+    uint32 immediate_data_size, const cmds::TexSubImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexSubImage2D");
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   return DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2DImmediate(
-    uint32 immediate_data_size, const gles2::TexSubImage2DImmediate& c) {
+    uint32 immediate_data_size, const cmds::TexSubImage2DImmediate& c) {
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && tex_image_2d_failed_)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   return DoTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
-    uint32 immediate_data_size, const gles2::GetVertexAttribPointerv& c) {
+    uint32 immediate_data_size, const cmds::GetVertexAttribPointerv& c) {
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
-  typedef gles2::GetVertexAttribPointerv::Result Result;
+  typedef cmds::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
     return error::kInvalidArguments;
   }
   if (!validators_->vertex_pointer.IsValid(pname)) {
     SetGLErrorInvalidEnum("glGetVertexAttribPointerv", pname, "pname");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetVertexAttribPointerv", "index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
   *result->GetData() =
-      state_.vertex_attrib_manager->GetVertexAttribInfo(index)->offset();
+      state_.vertex_attrib_manager->GetVertexAttrib(index)->offset();
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GetUniformSetup(
     GLuint program, GLint fake_location,
     uint32 shm_id, uint32 shm_offset,
     error::Error* error, GLint* real_location,
     GLuint* service_id, void** result_pointer, GLenum* result_type) {
   DCHECK(error);
   DCHECK(service_id);
   DCHECK(result_pointer);
   DCHECK(result_type);
   DCHECK(real_location);
   *error = error::kNoError;
   // Make sure we have enough room for the result on failure.
   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);
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glGetUniform");
   if (!info) {
     return false;
   }
   if (!info->IsValid()) {
     // Program was not linked successfully. (ie, glLinkProgram)
     SetGLError(GL_INVALID_OPERATION, "glGetUniform", "program not linked");
     return false;
   }
   *service_id = info->service_id();
   GLint array_index = -1;
-  const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+  const Program::UniformInfo* uniform_info =
       info->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!uniform_info) {
     // No such location.
     SetGLError(GL_INVALID_OPERATION, "glGetUniform", "unknown location");
     return false;
   }
   GLenum type = uniform_info->type;
   GLsizei size = GLES2Util::GetGLDataTypeSizeForUniforms(type);
   if (size == 0) {
     SetGLError(GL_INVALID_OPERATION, "glGetUniform", "unknown type");
     return false;
   }
   result = GetSharedMemoryAs<SizedResult<GLint>*>(
       shm_id, shm_offset, SizedResult<GLint>::ComputeSizeFromBytes(size));
   if (!result) {
     *error = error::kOutOfBounds;
     return false;
   }
   result->size = size;
   *result_type = type;
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformiv(
-    uint32 immediate_data_size, const gles2::GetUniformiv& c) {
+    uint32 immediate_data_size, const cmds::GetUniformiv& c) {
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLenum result_type;
   GLint real_location = -1;
   Error error;
   void* result;
   if (GetUniformSetup(
       program, fake_location, c.params_shm_id, c.params_shm_offset,
       &error, &real_location, &service_id, &result, &result_type)) {
     glGetUniformiv(
         service_id, real_location,
-        static_cast<gles2::GetUniformiv::Result*>(result)->GetData());
+        static_cast<cmds::GetUniformiv::Result*>(result)->GetData());
   }
   return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformfv(
-    uint32 immediate_data_size, const gles2::GetUniformfv& c) {
+    uint32 immediate_data_size, const cmds::GetUniformfv& c) {
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLint real_location = -1;
   Error error;
-  typedef gles2::GetUniformfv::Result Result;
+  typedef cmds::GetUniformfv::Result Result;
   Result* result;
   GLenum result_type;
   if (GetUniformSetup(
       program, fake_location, c.params_shm_id, c.params_shm_offset,
       &error, &real_location, &service_id,
       reinterpret_cast<void**>(&result), &result_type)) {
     if (result_type == GL_BOOL || result_type == GL_BOOL_VEC2 ||
         result_type == GL_BOOL_VEC3 || result_type == GL_BOOL_VEC4) {
       GLsizei num_values = result->GetNumResults();
       scoped_array<GLint> temp(new GLint[num_values]);
       glGetUniformiv(service_id, real_location, temp.get());
       GLfloat* dst = result->GetData();
       for (GLsizei ii = 0; ii < num_values; ++ii) {
         dst[ii] = (temp[ii] != 0);
       }
     } else {
       glGetUniformfv(service_id, real_location, result->GetData());
     }
   }
   return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
-    uint32 immediate_data_size, const gles2::GetShaderPrecisionFormat& c) {
+    uint32 immediate_data_size, const cmds::GetShaderPrecisionFormat& c) {
   GLenum shader_type = static_cast<GLenum>(c.shadertype);
   GLenum precision_type = static_cast<GLenum>(c.precisiontype);
-  typedef gles2::GetShaderPrecisionFormat::Result Result;
+  typedef cmds::GetShaderPrecisionFormat::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 (!validators_->shader_type.IsValid(shader_type)) {
@@ skipping 26 matching lines @@
       result->precision = 23;
       break;
     default:
       NOTREACHED();
       break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
-    uint32 immediate_data_size, const gles2::GetAttachedShaders& c) {
+    uint32 immediate_data_size, const cmds::GetAttachedShaders& c) {
   uint32 result_size = c.result_size;
   GLuint program = static_cast<GLuint>(c.program);
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glGetAttachedShaders");
   if (!info) {
     return error::kNoError;
   }
-  typedef gles2::GetAttachedShaders::Result Result;
+  typedef cmds::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(
       info->service_id(), max_count, &count, result->GetData());
   for (GLsizei ii = 0; ii < count; ++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) {
+    uint32 immediate_data_size, const cmds::GetActiveUniform& c) {
   GLuint program = c.program;
   GLuint index = c.index;
   uint32 name_bucket_id = c.name_bucket_id;
-  typedef gles2::GetActiveUniform::Result Result;
+  typedef cmds::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;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glGetActiveUniform");
   if (!info) {
     return error::kNoError;
   }
-  const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
+  const Program::UniformInfo* uniform_info =
       info->GetUniformInfo(index);
   if (!uniform_info) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveUniform", "index out of range");
     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.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveAttrib(
-    uint32 immediate_data_size, const gles2::GetActiveAttrib& c) {
+    uint32 immediate_data_size, const cmds::GetActiveAttrib& c) {
   GLuint program = c.program;
   GLuint index = c.index;
   uint32 name_bucket_id = c.name_bucket_id;
-  typedef gles2::GetActiveAttrib::Result Result;
+  typedef cmds::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;
   }
-  ProgramManager::ProgramInfo* info = GetProgramInfoNotShader(
+  Program* info = GetProgramInfoNotShader(
       program, "glGetActiveAttrib");
   if (!info) {
     return error::kNoError;
   }
-  const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
+  const Program::VertexAttrib* attrib_info =
       info->GetAttribInfo(index);
   if (!attrib_info) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib", "index out of range");
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = attrib_info->size;
   result->type = attrib_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(attrib_info->name.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleShaderBinary(
-    uint32 immediate_data_size, const gles2::ShaderBinary& c) {
+    uint32 immediate_data_size, const cmds::ShaderBinary& c) {
 #if 1  // No binary shader support.
   SetGLError(GL_INVALID_OPERATION, "glShaderBinary", "not supported");
   return error::kNoError;
 #else
   GLsizei n = static_cast<GLsizei>(c.n);
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary", "n < 0");
     return error::kNoError;
   }
   GLsizei length = static_cast<GLsizei>(c.length);
   if (length < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary", "length < 0");
     return error::kNoError;
   }
   uint32 data_size;
   if (!SafeMultiplyUint32(n, sizeof(GLuint), &data_size)) {
     return error::kOutOfBounds;
   }
   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) {
-    ShaderManager::ShaderInfo* info = GetShaderInfo(shaders[ii]);
+    Shader* info = GetShader(shaders[ii]);
     if (!info) {
       SetGLError(GL_INVALID_VALUE, "glShaderBinary", "unknown shader");
       return error::kNoError;
     }
     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) {
+    uint32 immediate_data_size, const cmds::SwapBuffers& c) {
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
 
   int this_frame_number = frame_number_++;
   // TRACE_EVENT for gpu tests:
   TRACE_EVENT_INSTANT2("test_gpu", "SwapBuffersLatency",
                        "GLImpl", static_cast<int>(gfx::GetGLImplementation()),
                        "width", (is_offscreen ? offscreen_size_.width() :
                                  surface_->GetSize().width()));
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleSwapBuffers",
                "offscreen", is_offscreen,
@@ skipping 85 matching lines @@
     if (!surface_->SwapBuffers()) {
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       return error::kLostContext;
     }
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
-    uint32 immediate_data_size, const gles2::EnableFeatureCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::EnableFeatureCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
-  typedef gles2::EnableFeatureCHROMIUM::Result Result;
+  typedef cmds::EnableFeatureCHROMIUM::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 != 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
@@ skipping 22 matching lines @@
   } else {
     return error::kNoError;
   }
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32 immediate_data_size,
-    const gles2::GetRequestableExtensionsCHROMIUM& c) {
+    const cmds::GetRequestableExtensionsCHROMIUM& c) {
   Bucket* bucket = CreateBucket(c.bucket_id);
-  FeatureInfo::Ref info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> info(new FeatureInfo());
   info->Initialize(disallowed_features_, NULL);
   bucket->SetFromString(info->extensions().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
-    uint32 immediate_data_size, const gles2::RequestExtensionCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::RequestExtensionCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
   }
 
   bool desire_webgl_glsl_validation =
@@ skipping 10 matching lines @@
     derivatives_explicitly_enabled_ = desire_standard_derivatives;
     InitializeShaderTranslator();
   }
 
   UpdateCapabilities();
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetMultipleIntegervCHROMIUM(
-    uint32 immediate_data_size, const gles2::GetMultipleIntegervCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::GetMultipleIntegervCHROMIUM& c) {
   GLuint count = c.count;
   uint32 pnames_size;
   if (!SafeMultiplyUint32(count, sizeof(GLenum), &pnames_size)) {
     return error::kOutOfBounds;
   }
   const GLenum* pnames = GetSharedMemoryAs<const GLenum*>(
       c.pnames_shm_id, c.pnames_shm_offset, pnames_size);
   if (pnames == NULL) {
     return error::kOutOfBounds;
   }
@@ skipping 56 matching lines @@
 
   // Just to verify. Should this be a DCHECK?
   if (static_cast<uint32>(results - start) != num_results) {
     return error::kOutOfBounds;
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoCHROMIUM(
-    uint32 immediate_data_size, const gles2::GetProgramInfoCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::GetProgramInfoCHROMIUM& c) {
   GLuint program = static_cast<GLuint>(c.program);
   uint32 bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(ProgramInfoHeader));  // in case we fail.
-  ProgramManager::ProgramInfo* info = NULL;
-  info = GetProgramInfo(program);
+  Program* info = NULL;
+  info = GetProgram(program);
   if (!info || !info->IsValid()) {
     return error::kNoError;
   }
-  info->GetProgramInfo(program_manager(), bucket);
+  info->GetProgram(program_manager(), bucket);
   return error::kNoError;
 }
 
 error::ContextLostReason GLES2DecoderImpl::GetContextLostReason() {
   switch (reset_status_) {
     case GL_NO_ERROR:
       // TODO(kbr): improve the precision of the error code in this case.
       // Consider delegating to context for error code if MakeCurrent fails.
       return error::kUnknown;
     case GL_GUILTY_CONTEXT_RESET_ARB:
@@ skipping 45 matching lines @@
 
   // Loses any child contexts.
   for (ChildList::iterator it = children_.begin();
        it != children_.end();
        ++it) {
     (*it)->LoseContext(reset_status);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleLoseContextCHROMIUM(
-    uint32 immediate_data_size, const gles2::LoseContextCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::LoseContextCHROMIUM& c) {
   GLenum current = static_cast<GLenum>(c.current);
   GLenum other = static_cast<GLenum>(c.other);
   if (!validators_->reset_status.IsValid(current)) {
     SetGLErrorInvalidEnum("glLoseContextCHROMIUM", current, "current");
   }
   if (!validators_->reset_status.IsValid(other)) {
     SetGLErrorInvalidEnum("glLoseContextCHROMIUM", other, "other");
   }
   group_->LoseContexts(other);
   reset_status_ = current;
   current_decoder_error_ = error::kLostContext;
   return error::kLostContext;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitSyncPointCHROMIUM(
-    uint32 immediate_data_size, const gles2::WaitSyncPointCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::WaitSyncPointCHROMIUM& c) {
   if (wait_sync_point_callback_.is_null())
     return error::kNoError;
 
   return wait_sync_point_callback_.Run(c.sync_point) ?
       error::kNoError : error::kDeferCommandUntilLater;
 }
 
 bool GLES2DecoderImpl::GenQueriesEXTHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
@@ skipping 23 matching lines @@
   if (query_manager_.get() == NULL) {
     return false;
   }
   if (!query_manager_->ProcessPendingQueries()) {
     current_decoder_error_ = error::kOutOfBounds;
   }
   return query_manager_->HavePendingQueries();
 }
 
 error::Error GLES2DecoderImpl::HandleBeginQueryEXT(
-    uint32 immediate_data_size, const gles2::BeginQueryEXT& c) {
+    uint32 immediate_data_size, const cmds::BeginQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
   int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
   uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
 
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
     case GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM:
       break;
@@ skipping 51 matching lines @@
 
   if (!query_manager_->BeginQuery(query)) {
     return error::kOutOfBounds;
   }
 
   state_.current_query = query;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEndQueryEXT(
-    uint32 immediate_data_size, const gles2::EndQueryEXT& c) {
+    uint32 immediate_data_size, const cmds::EndQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 submit_count = static_cast<GLuint>(c.submit_count);
 
   if (!state_.current_query) {
     SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "No active query");
     return error::kNoError;
   }
   if (state_.current_query->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glEndQueryEXT", "target does not match active query");
@@ skipping 82 matching lines @@
 }
 
 // Used when OES_vertex_array_object isn't natively supported
 void GLES2DecoderImpl::EmulateVertexArrayState() {
   // Setup the Vertex attribute state
   for (uint32 vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
     RestoreStateForAttrib(vv);
   }
 
   // Setup the element buffer
-  BufferManager::BufferInfo* element_array_buffer =
+  BufferManager::Buffer* element_array_buffer =
       state_.vertex_attrib_manager->element_array_buffer();
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
       element_array_buffer ? element_array_buffer->service_id() : 0);
 }
 
 bool GLES2DecoderImpl::DoIsVertexArrayOES(GLuint client_id) {
   const VertexAttribManager* vao =
       GetVertexAttribManager(client_id);
   return vao && vao->IsValid() && !vao->IsDeleted();
 }
 
 error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(
     uint32 immediate_data_size,
-    const gles2::CreateStreamTextureCHROMIUM& c) {
+    const cmds::CreateStreamTextureCHROMIUM& c) {
   if (!features().chromium_stream_texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glOpenStreamTextureCHROMIUM", ""
                "not supported.");
     return error::kNoError;
   }
 
   uint32 client_id = c.client_id;
-  typedef gles2::CreateStreamTextureCHROMIUM::Result Result;
+  typedef cmds::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
 
   if (!result)
     return error::kOutOfBounds;
   *result = GL_ZERO;
-  TextureManager::TextureInfo* info =
-      texture_manager()->GetTextureInfo(client_id);
+  Texture* info =
+      texture_manager()->GetTexture(client_id);
   if (!info) {
     SetGLError(GL_INVALID_VALUE,
                "glCreateStreamTextureCHROMIUM", ""
                "bad texture id.");
     return error::kNoError;
   }
 
   if (info->IsStreamTexture()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCreateStreamTextureCHROMIUM", ""
@@ skipping 21 matching lines @@
                "glCreateStreamTextureCHROMIUM", ""
                "failed to create platform texture.");
   }
 
   *result = object_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
-    const gles2::DestroyStreamTextureCHROMIUM& c) {
+    const cmds::DestroyStreamTextureCHROMIUM& c) {
   GLuint client_id = c.texture;
-  TextureManager::TextureInfo* info =
-      texture_manager()->GetTextureInfo(client_id);
+  Texture* info =
+      texture_manager()->GetTexture(client_id);
   if (info && info->IsStreamTexture()) {
     if (!stream_texture_manager_)
       return error::kInvalidArguments;
 
     stream_texture_manager_->DestroyStreamTexture(info->service_id());
     info->SetStreamTexture(false);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
@@ skipping 39 matching lines @@
     // know what's going on.
     SetGLError(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM",
         "requires TEXTURE_RECTANGLE_ARB target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  TextureManager::TextureInfo* info = GetTextureInfoForTargetUnlessDefault(
+  Texture* info = GetTextureInfoForTargetUnlessDefault(
       target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexImageIOSurface2DCHROMIUM", "no rectangle texture bound");
     return;
   }
 
   // Look up the new IOSurface. Note that because of asynchrony
   // between processes this might fail; during live resizing the
   // plugin process might allocate and release an IOSurface before
@@ skipping 86 matching lines @@
     case GL_BGRA8_EXT:
       return GL_BGRA_EXT;
     default:
       return GL_NONE;
   }
 }
 
 void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     GLenum target, GLuint source_id, GLuint dest_id, GLint level,
     GLenum internal_format) {
-  TextureManager::TextureInfo* dest_info = GetTextureInfo(dest_id);
-  TextureManager::TextureInfo* source_info = GetTextureInfo(source_id);
+  Texture* dest_info = GetTexture(dest_id);
+  Texture* source_info = GetTexture(source_id);
 
   if (!source_info || !dest_info) {
     SetGLError(GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "unknown texture id");
     return;
   }
 
   if (GL_TEXTURE_2D != target) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTextureCHROMIUM", "invalid texture target");
     return;
@@ skipping 149 matching lines @@
     GLenum internal_format,
     GLsizei width,
     GLsizei height) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoTexStorage2DEXT");
   if (!texture_manager()->ValidForTarget(target, 0, width, height, 1) ||
       TextureManager::ComputeMipMapCount(width, height, 1) < levels) {
     SetGLError(
         GL_INVALID_VALUE, "glTexStorage2DEXT", "dimensions out of range");
     return;
   }
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexStorage2DEXT", "unknown texture for target");
     return;
   }
   if (info->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
   }
   if (info->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
@@ skipping 39 matching lines @@
           info, target, ii, format, level_width, level_height, 1, 0, format,
           type, false);
       level_width = std::max(1, level_width >> 1);
       level_height = std::max(1, level_height >> 1);
     }
     info->SetImmutable(true);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
-    uint32 immediate_data_size, const gles2::GenMailboxCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::GenMailboxCHROMIUM& c) {
   MailboxName name;
   mailbox_manager()->GenerateMailboxName(&name);
   uint32 bucket_id = static_cast<uint32>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
 
   bucket->SetSize(GL_MAILBOX_SIZE_CHROMIUM);
   bucket->SetData(&name, 0, GL_MAILBOX_SIZE_CHROMIUM);
 
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   TextureDefinition* definition = texture_manager()->Save(info);
   if (!definition) {
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "invalid texture");
@@ skipping 10 matching lines @@
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
   glBindTexture(info->target(), info->service_id());
 }
 
 void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   scoped_ptr<TextureDefinition> definition(
       group_->mailbox_manager()->ConsumeTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox)));
@@ skipping 40 matching lines @@
   if (target != GL_TEXTURE_2D) {
     // This might be supported in the future.
     SetGLError(
         GL_INVALID_OPERATION,
         "glBindTexImage2DCHROMIUM", "requires TEXTURE_2D target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  TextureManager::TextureInfo* info = GetTextureInfoForTargetUnlessDefault(
+  Texture* info = GetTextureInfoForTargetUnlessDefault(
       target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
   if (!gl_image) {
     SetGLError(GL_INVALID_OPERATION,
@@ skipping 22 matching lines @@
   if (target != GL_TEXTURE_2D) {
     // This might be supported in the future.
     SetGLError(
         GL_INVALID_OPERATION,
         "glReleaseTexImage2DCHROMIUM", "requires TEXTURE_2D target");
     return;
   }
 
   // Default target might be conceptually valid, but disallow it to avoid
   // accidents.
-  TextureManager::TextureInfo* info = GetTextureInfoForTargetUnlessDefault(
+  Texture* info = GetTextureInfoForTargetUnlessDefault(
       target);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION,
                "glReleaseTexImage2DCHROMIUM", "no texture bound");
     return;
   }
 
   gfx::GLImage* gl_image = image_manager()->LookupImage(image_id);
   if (!gl_image) {
     SetGLError(GL_INVALID_OPERATION,
                "glReleaseTexImage2DCHROMIUM",
                "no image found with the given ID");
     return;
   }
 
   // Do nothing when image is not currently bound.
   if (info->GetLevelImage(target, 0) != gl_image)
     return;
 
   gl_image->ReleaseTexImage();
 
   texture_manager()->SetLevelInfo(
       info, target, 0, GL_RGBA, 0, 0, 1, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, false);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
-    uint32 immediate_data_size, const gles2::TraceBeginCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::TraceBeginCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string command_name;
   if (!bucket->GetAsString(&command_name)) {
     return error::kInvalidArguments;
   }
   TRACE_EVENT_COPY_ASYNC_BEGIN0("gpu", command_name.c_str(), this);
   if (!gpu_tracer_->Begin(command_name)) {
     SetGLError(GL_INVALID_OPERATION,
                "glTraceBeginCHROMIUM", "unable to create begin trace");
     return error::kNoError;
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
   if (gpu_tracer_->CurrentName().empty()) {
     SetGLError(GL_INVALID_OPERATION,
                "glTraceEndCHROMIUM", "no trace begin found");
     return;
   }
   TRACE_EVENT_COPY_ASYNC_END0("gpu", gpu_tracer_->CurrentName().c_str(), this);
   gpu_tracer_->End();
 }
 
 bool GLES2DecoderImpl::ValidateAsyncTransfer(
     const char* function_name,
-    TextureManager::TextureInfo* info,
+    Texture* info,
     GLenum target,
     GLint level,
     const void * data) {
   // We only support async uploads to 2D textures for now.
   if (GL_TEXTURE_2D != target) {
     SetGLErrorInvalidEnum(function_name, target, "target");
     return false;
   }
   // We only support uploads to level zero for now.
   if (level != 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "level != 0");
     return false;
   }
   // A transfer buffer must be bound, even for asyncTexImage2D.
   if (data == NULL) {
     SetGLError(GL_INVALID_OPERATION, function_name, "buffer == 0");
     return false;
   }
   // We only support one async transfer in progress.
   if (!info || info->AsyncTransferIsInProgress()) {
     SetGLError(GL_INVALID_OPERATION,
         function_name, "transfer already in progress");
     return false;
   }
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
-    uint32 immediate_data_size, const gles2::AsyncTexImage2DCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::AsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
@@ skipping 17 matching lines @@
   }
 
   // All the normal glTexSubImage2D validation.
   if (!ValidateTexImage2D(
       "glAsyncTexImage2DCHROMIUM", target, level, internal_format,
       width, height, border, format, type, pixels, pixels_size)) {
     return error::kNoError;
   }
 
   // Extra async validation.
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!ValidateAsyncTransfer(
       "glAsyncTexImage2DCHROMIUM", info, target, level, pixels))
     return error::kNoError;
 
   // Don't allow async redefinition of a textures.
   if (info->IsDefined()) {
     SetGLError(GL_INVALID_OPERATION,
         "glAsyncTexImage2DCHROMIUM", "already defined");
     return error::kNoError;
   }
@@ skipping 33 matching lines @@
   // after the the transfer is complete.
   texture_manager()->AddPendingAsyncPixelTransfer(
       info->GetAsyncTransferState()->AsWeakPtr(), info);
 
   async_pixel_transfer_delegate_->AsyncTexImage2D(
       info->GetAsyncTransferState(), tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
-    uint32 immediate_data_size, const gles2::AsyncTexSubImage2DCHROMIUM& c) {
+    uint32 immediate_data_size, const cmds::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
 
   // TODO(epenner): Move this and copies of this memory validation
   // into ValidateTexSubImage2D step.
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, state_.unpack_alignment, &data_size,
       NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.data_shm_id, c.data_shm_offset, data_size);
 
   // All the normal glTexSubImage2D validation.
   error::Error error = error::kNoError;
   if (!ValidateTexSubImage2D(&error, "glAsyncTexSubImage2DCHROMIUM",
       target, level, xoffset, yoffset, width, height, format, type, pixels)) {
     return error;
   }
 
   // Extra async validation.
-  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  Texture* info = GetTextureInfoForTarget(target);
   if (!ValidateAsyncTransfer(
          "glAsyncTexSubImage2DCHROMIUM", info, target, level, pixels))
     return error::kNoError;
 
   // Guarantee async textures are always 'cleared' as follows:
   // - AsyncTexImage2D can not redefine an existing texture
   // - AsyncTexImage2D must initialize the entire image via non-null buffer.
   // - AsyncTexSubImage2D clears synchronously if not already cleared.
   // - Textures become immutable after an async call.
   // This way we know in all cases that an async texture is always clear.
@@ skipping 31 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