Refactor a bunch of Texture related GPU code

gpu/command_buffer/service/texture_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 
 #include <list>
 #include <string>
 #include <vector>
@@ skipping 412 matching lines @@
 
   // Returns true if mipmaps can be generated by GL.
   bool CanGenerateMipmaps(const Texture* texture) const {
     return texture->CanGenerateMipmaps(feature_info_);
   }
 
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP
   //   max_levels: The maximum levels this type of target can have.
-  void SetInfoTarget(
-      Texture* info,
+  void SetTarget(
+      Texture* texture,
       GLenum target);
 
   // Set the info for a particular level in a TexureInfo.
   void SetLevelInfo(
-      Texture* info,
+      Texture* texture,
       GLenum target,
       GLint level,
       GLenum internal_format,
       GLsizei width,
       GLsizei height,
       GLsizei depth,
       GLint border,
       GLenum format,
       GLenum type,
       bool cleared);
 
   // Save the texture definition and leave it undefined.
-  TextureDefinition* Save(Texture* info);
+  TextureDefinition* Save(Texture* texture);
 
   // Redefine all the levels from the texture definition.
-  bool Restore(Texture* info,
-               TextureDefinition* definition);
+  bool Restore(
+      const char* function_name,
+      GLES2Decoder* decoder,
+      Texture* texture,
+      TextureDefinition* definition);
 
   // Sets a mip as cleared.
-  void SetLevelCleared(Texture* info, GLenum target,
+  void SetLevelCleared(Texture* texture, GLenum target,
                        GLint level, bool cleared);
 
   // Sets a texture parameter of a Texture
   // Returns GL_NO_ERROR on success. Otherwise the error to generate.
   // TODO(gman): Expand to SetParameteri,f,iv,fv
-  GLenum SetParameter(
-      Texture* info, GLenum pname, GLint param);
+  void SetParameter(
+      const char* function_name, GLES2Decoder* decoder,
+      Texture* texture, GLenum pname, GLint param);
 
   // Makes each of the mip levels as though they were generated.
   // Returns false if that's not allowed for the given texture.
-  bool MarkMipmapsGenerated(Texture* info);
+  bool MarkMipmapsGenerated(Texture* texture);
 
   // Clears any uncleared renderable levels.
-  bool ClearRenderableLevels(GLES2Decoder* decoder, Texture* info);
+  bool ClearRenderableLevels(GLES2Decoder* decoder, Texture* texture);
 
   // Clear a specific level.
   bool ClearTextureLevel(
-      GLES2Decoder* decoder,Texture* info, GLenum target, GLint level);
+      GLES2Decoder* decoder,Texture* texture, GLenum target, GLint level);
 
   // Creates a new texture info.
   Texture* CreateTexture(GLuint client_id, GLuint service_id);
 
   // Gets the texture info for the given texture.
   Texture* GetTexture(GLuint client_id) const;
 
   // Removes a texture info.
   void RemoveTexture(GLuint client_id);
 
@@ skipping 44 matching lines @@
     }
   }
 
   size_t mem_represented() const {
     return
         memory_tracker_managed_->GetMemRepresented() +
         memory_tracker_unmanaged_->GetMemRepresented();
   }
 
   void SetLevelImage(
-      Texture* info,
+      Texture* texture,
       GLenum target,
       GLint level,
       gfx::GLImage* image);
 
   void AddToSignature(
-      Texture* info,
+      Texture* texture,
       GLenum target,
       GLint level,
       std::string* signature) const;
 
   // Transfers added will get their Texture updated at the same time
   // the async transfer is bound to the real texture.
   void AddPendingAsyncPixelTransfer(
-      base::WeakPtr<gfx::AsyncPixelTransferState> state, Texture* info);
+      base::WeakPtr<gfx::AsyncPixelTransferState> state, Texture* texture);
   void BindFinishedAsyncPixelTransfers(bool* texture_dirty,
                                        bool* framebuffer_dirty);
 
  private:
   friend class Texture;
 
   // Helper for Initialize().
   scoped_refptr<Texture> CreateDefaultAndBlackTextures(
       GLenum target,
       GLuint* black_texture);
 
-  void StartTracking(Texture* info);
-  void StopTracking(Texture* info);
+  void StartTracking(Texture* texture);
+  void StopTracking(Texture* texture);
 
   MemoryTypeTracker* GetMemTracker(GLenum texture_pool);
   scoped_ptr<MemoryTypeTracker> memory_tracker_managed_;
   scoped_ptr<MemoryTypeTracker> memory_tracker_unmanaged_;
 
   scoped_refptr<FeatureInfo> feature_info_;
 
   // Info for each texture in the system.
-  typedef base::hash_map<GLuint, scoped_refptr<Texture> > TextureInfoMap;
-  TextureInfoMap texture_infos_;
+  typedef base::hash_map<GLuint, scoped_refptr<Texture> > TextureMap;
+  TextureMap textures_;
 
   GLsizei max_texture_size_;
   GLsizei max_cube_map_texture_size_;
   GLint max_levels_;
   GLint max_cube_map_levels_;
 
   int num_unrenderable_textures_;
   int num_unsafe_textures_;
   int num_uncleared_mips_;
 
-  // Counts the number of Texture allocated with 'this' as its manager.
+  // Counts the number of Textures allocated with 'this' as its manager.
   // Allows to check no Texture will outlive this.
-  unsigned int texture_info_count_;
+  unsigned int texture_count_;
 
   bool have_context_;
 
   // Black (0,0,0,1) textures for when non-renderable textures are used.
   // NOTE: There is no corresponding Texture for these textures.
   // TextureInfos are only for textures the client side can access.
   GLuint black_texture_ids_[kNumDefaultTextures];
 
   // The default textures for each target (texture name = 0)
   scoped_refptr<Texture> default_textures_[kNumDefaultTextures];
 
   // Async texture allocations which haven't been bound to their textures
   // yet. This facilitates updating the Texture at the same time the
   // real texture data is bound.
   typedef std::pair<base::WeakPtr<gfx::AsyncPixelTransferState>,
                     Texture*> PendingAsyncTransfer;
   typedef std::list<PendingAsyncTransfer> PendingAsyncTransferList;
   PendingAsyncTransferList pending_async_transfers_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_