Refactor a bunch of Texture related GPU code

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 693 matching lines @@
   }
 
   // Creates a Texture for the given texture.
   Texture* CreateTexture(
       GLuint client_id, GLuint service_id) {
     return texture_manager()->CreateTexture(client_id, service_id);
   }
 
   // Gets the texture info for the given texture. Returns NULL if none exists.
   Texture* GetTexture(GLuint client_id) const {
-    Texture* info =
-        texture_manager()->GetTexture(client_id);
-    return info;
+    return texture_manager()->GetTexture(client_id);
   }
 
   // Deletes the texture info for the given texture.
   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();
@@ skipping 97 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,
-      Texture* info,
+      Texture* texture,
       GLenum target,
       GLint level,
       const void * data);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
       GLsizei width,
       GLsizei height,
       GLuint io_surface_id,
@@ skipping 200 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(Texture* info);
+  bool ClearTexture(Texture* texture);
 
   // Clears any uncleared attachments attached to the given frame buffer.
   // Returns false if there was a generated GL error.
   void ClearUnclearedAttachments(
       GLenum target, Framebuffer* info);
 
   // overridden from GLES2Decoder
   virtual bool ClearLevel(unsigned service_id,
                           unsigned bind_target,
                           unsigned target,
@@ skipping 336 matching lines @@
     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.
   Texture* GetTextureInfoForTarget(GLenum target) {
     TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
-    Texture* info = NULL;
+    Texture* texture = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
-        info = unit.bound_texture_2d;
+        texture = 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;
+        texture = unit.bound_texture_cube_map;
         break;
       case GL_TEXTURE_EXTERNAL_OES:
-        info = unit.bound_texture_external_oes;
+        texture = unit.bound_texture_external_oes;
         break;
       case GL_TEXTURE_RECTANGLE_ARB:
-        info = unit.bound_texture_rectangle_arb;
+        texture = unit.bound_texture_rectangle_arb;
         break;
       default:
         NOTREACHED();
         return NULL;
     }
-    return info;
+    return texture;
   }
 
   Texture* GetTextureInfoForTargetUnlessDefault(
       GLenum target) {
-    Texture* info = GetTextureInfoForTarget(target);
-    if (!info)
+    Texture* texture = GetTextureInfoForTarget(target);
+    if (!texture)
       return NULL;
-    if (info == texture_manager()->GetDefaultTextureInfo(target))
+    if (texture == texture_manager()->GetDefaultTextureInfo(target))
       return NULL;
-    return info;
+    return texture;
   }
 
   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;
@@ skipping 799 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.
-    Texture* info;
+    Texture* texture;
     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());
+      texture = texture_manager()->GetDefaultTextureInfo(
+          GL_TEXTURE_EXTERNAL_OES);
+      state_.texture_units[tt].bound_texture_external_oes = texture;
+      glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture->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());
+      texture = texture_manager()->GetDefaultTextureInfo(
+          GL_TEXTURE_RECTANGLE_ARB);
+      state_.texture_units[tt].bound_texture_rectangle_arb = texture;
+      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture->service_id());
     }
-    info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
-    state_.texture_units[tt].bound_texture_cube_map = info;
-    glBindTexture(GL_TEXTURE_CUBE_MAP, info->service_id());
-    info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
-    state_.texture_units[tt].bound_texture_2d = info;
-    glBindTexture(GL_TEXTURE_2D, info->service_id());
+    texture = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
+    state_.texture_units[tt].bound_texture_cube_map = texture;
+    glBindTexture(GL_TEXTURE_CUBE_MAP, texture->service_id());
+    texture = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
+    state_.texture_units[tt].bound_texture_2d = texture;
+    glBindTexture(GL_TEXTURE_2D, texture->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
   ContextCreationAttribParser attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
 
   // These are NOT if the back buffer has these proprorties. They are
   // if we want the command buffer to enforce them regardless of what
@@ skipping 690 matching lines @@
         0,  // level
         GL_RGBA,
         offscreen_size_.width(),
         offscreen_size_.height(),
         1,  // depth
         0,  // border
         GL_RGBA,
         GL_UNSIGNED_BYTE,
         true);
     parent_texture_manager->SetParameter(
+        "UpdateParentTextureInfo",
+        this,
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_MAG_FILTER,
         GL_NEAREST);
     parent_texture_manager->SetParameter(
+        "UpdateParentTextureInfo",
+        this,
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_MIN_FILTER,
         GL_NEAREST);
     parent_texture_manager->SetParameter(
+        "UpdateParentTextureInfo",
+        this,
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_S,
         GL_CLAMP_TO_EDGE);
     parent_texture_manager->SetParameter(
+        "UpdateParentTextureInfo",
+        this,
         offscreen_saved_color_texture_info_,
         GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
   } else {
     offscreen_saved_color_texture_info_ = NULL;
   }
 }
 
 void GLES2DecoderImpl::SetResizeCallback(
     const base::Callback<void(gfx::Size)>& callback) {
@@ skipping 18 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) {
-  Texture* texture =
-      texture_manager()->GetTexture(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 179 matching lines @@
     // Replace texture info when ID is already in use by parent.
     if (new_parent_impl->texture_manager()->GetTexture(
         new_parent_texture_id))
       new_parent_impl->texture_manager()->RemoveTexture(
           new_parent_texture_id);
 
     offscreen_saved_color_texture_info_ =
         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);
+       SetTarget(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;
   }
 
   return true;
@@ skipping 513 matching lines @@
       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) {
-  Texture* info = NULL;
+  Texture* texture = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
-    info = GetTexture(client_id);
-    if (!info) {
+    texture = GetTexture(client_id);
+    if (!texture) {
       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.
+      // It's a new id so make a texture texture for it.
       glGenTextures(1, &service_id);
       DCHECK_NE(0u, service_id);
       CreateTexture(client_id, service_id);
-      info = GetTexture(client_id);
+      texture = GetTexture(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kTextures);
       id_allocator->MarkAsUsed(client_id);
     }
   } else {
-    info = texture_manager()->GetDefaultTextureInfo(target);
+    texture = texture_manager()->GetDefaultTextureInfo(target);
   }
 
   // Check the texture exists
   // Check that we are not trying to bind it to a different target.
-  if (info->target() != 0 && info->target() != target) {
+  if (texture->target() != 0 && texture->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
-  if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
+  if (texture->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
-  LogClientServiceForInfo(info, client_id, "glBindTexture");
-  if (info->target() == 0) {
-    texture_manager()->SetInfoTarget(info, target);
+  LogClientServiceForInfo(texture, client_id, "glBindTexture");
+  if (texture->target() == 0) {
+    texture_manager()->SetTarget(texture, target);
   }
-  glBindTexture(target, info->service_id());
+  glBindTexture(target, texture->service_id());
 
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
-      unit.bound_texture_2d = info;
+      unit.bound_texture_2d = texture;
       break;
     case GL_TEXTURE_CUBE_MAP:
-      unit.bound_texture_cube_map = info;
+      unit.bound_texture_cube_map = texture;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
-      unit.bound_texture_external_oes = info;
-      if (info->IsStreamTexture()) {
+      unit.bound_texture_external_oes = texture;
+      if (texture->IsStreamTexture()) {
         DCHECK(stream_texture_manager_);
         StreamTexture* stream_tex =
-            stream_texture_manager_->LookupStreamTexture(info->service_id());
+            stream_texture_manager_->LookupStreamTexture(texture->service_id());
         if (stream_tex)
           stream_tex->Update();
       }
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
-      unit.bound_texture_rectangle_arb = info;
+      unit.bound_texture_rectangle_arb = texture;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, false)) {
     if (index != 0 ||
@@ skipping 56 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) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info ||
-      !texture_manager()->CanGenerateMipmaps(info)) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture ||
+      !texture_manager()->CanGenerateMipmaps(texture)) {
     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;
-      if (!texture_manager()->ClearTextureLevel(this, info, face, 0)) {
+      if (!texture_manager()->ClearTextureLevel(this, texture, face, 0)) {
         SetGLError(GL_OUT_OF_MEMORY, "glGenerateMipmaps", "dimensions too big");
         return;
       }
     }
   } else {
-    if (!texture_manager()->ClearTextureLevel(this, info, target, 0)) {
+    if (!texture_manager()->ClearTextureLevel(this, texture, target, 0)) {
       SetGLError(GL_OUT_OF_MEMORY, "glGenerateMipmaps", "dimensions too big");
       return;
     }
   }
 
   CopyRealGLErrorsToWrapper();
   // Workaround for Mac driver bug. In the large scheme of things setting
   // glTexParamter twice for glGenerateMipmap is probably not a lage performance
   // hit so there's probably no need to make this conditional. The bug appears
   // to be that if the filtering mode is set to something that doesn't require
   // mipmaps for rendering, or is never set to something other than the default,
   // then glGenerateMipmap misbehaves.
   if (workarounds().set_texture_filter_before_generating_mipmap) {
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
   }
   glGenerateMipmapEXT(target);
   if (workarounds().set_texture_filter_before_generating_mipmap) {
-    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, info->min_filter());
+    glTexParameteri(target, GL_TEXTURE_MIN_FILTER, texture->min_filter());
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
-    texture_manager()->MarkMipmapsGenerated(info);
+    texture_manager()->MarkMipmapsGenerated(texture);
   }
 }
 
 bool GLES2DecoderImpl::GetHelper(
     GLenum pname, GLint* params, GLsizei* num_written) {
   DCHECK(num_written);
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     switch (pname) {
       case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
         *num_written = 1;
@@ skipping 827 matching lines @@
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint client_texture_id, GLint level) {
   Framebuffer* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
                "glFramebufferTexture2D", "no framebuffer bound.");
     return;
   }
   GLuint service_id = 0;
-  Texture* info = NULL;
+  Texture* texture = NULL;
   if (client_texture_id) {
-    info = GetTexture(client_texture_id);
-    if (!info) {
+    texture = GetTexture(client_texture_id);
+    if (!texture) {
       SetGLError(GL_INVALID_OPERATION,
                  "glFramebufferTexture2D", "unknown texture");
       return;
     }
-    service_id = info->service_id();
+    service_id = texture->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);
+    framebuffer_info->AttachTexture(attachment, texture, textarget, level);
   }
   if (framebuffer_info == state_.bound_draw_framebuffer) {
     clear_state_dirty_ = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   Framebuffer* framebuffer_info =
       GetFramebufferInfoForTarget(target);
@@ skipping 202 matching lines @@
       if (workarounds().use_current_program_after_successful_link) {
         glUseProgram(program->service_id());
       }
       program_manager()->ClearUniforms(program);
     }
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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);
+  texture_manager()->SetParameter(
+      "glTexParameterf", this, texture, pname, static_cast<GLint>(param));
 }
 
 void GLES2DecoderImpl::DoTexParameteri(
     GLenum target, GLenum pname, GLint param) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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);
+  texture_manager()->SetParameter(
+      "glTexParameteri", this, texture, pname, param);
 }
 
 void GLES2DecoderImpl::DoTexParameterfv(
     GLenum target, GLenum pname, const GLfloat* params) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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);
+  texture_manager()->SetParameter(
+      "glTexParameterfv", this, texture, pname, static_cast<GLint>(params[0]));
 }
 
 void GLES2DecoderImpl::DoTexParameteriv(
   GLenum target, GLenum pname, const GLint* params) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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;
-  }
-  glTexParameteriv(target, pname, params);
+  texture_manager()->SetParameter(
+      "glTexParameteriv", this, texture, pname, *params);
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
   if (!state_.current_program) {
     // The program does not exist.
     SetGLError(GL_INVALID_OPERATION, function_name, "no program in use");
     return false;
   }
   if (!state_.current_program->InUse()) {
     SetGLError(GL_INVALID_OPERATION, function_name, "program not linked");
@@ skipping 535 matching lines @@
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     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];
-        Texture* texture_info =
+        Texture* texture =
             texture_unit.GetInfoForSamplerType(uniform_info->type);
-        if (!texture_info || !texture_manager()->CanRender(texture_info)) {
+        if (!texture || !texture_manager()->CanRender(texture)) {
           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 "
@@ skipping 11 matching lines @@
   const Program::SamplerIndices& sampler_indices =
      state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     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];
-        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)) {
+        Texture* texture = uniform_info->type == GL_SAMPLER_2D ?
+            texture_unit.bound_texture_2d :
+            texture_unit.bound_texture_cube_map;
+        if (!texture || !texture_manager()->CanRender(texture)) {
           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 = 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);
+                        texture ? texture->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 Program::SamplerIndices& sampler_indices =
        state_.current_program->sampler_indices();
     for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
       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];
-          Texture* texture_info =
+          Texture* texture =
               texture_unit.GetInfoForSamplerType(uniform_info->type);
-          if (texture_info && !texture_info->SafeToRenderFrom()) {
-            if (!texture_manager()->ClearRenderableLevels(this, texture_info)) {
+          if (texture && !texture->SafeToRenderFrom()) {
+            if (!texture_manager()->ClearRenderableLevels(this, texture)) {
               return false;
             }
           }
         }
       }
     }
   }
   return true;
 }
 
@@ skipping 1561 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;
   }
-  Texture* info = GetTextureInfoForTarget(bind_target);
-  glBindTexture(bind_target, info ? info->service_id() : 0);
+  Texture* texture = GetTextureInfoForTarget(bind_target);
+  glBindTexture(bind_target, texture ? texture->service_id() : 0);
   return true;
 }
 
 namespace {
 
 const int kS3TCBlockWidth = 4;
 const int kS3TCBlockHeight = 4;
 const int kS3TCDXT1BlockSize = 8;
 const int kS3TCDXT3AndDXT5BlockSize = 16;
 const int kETC1BlockWidth = 4;
@@ skipping 151 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;
   }
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexImage2D", "unknown texture target");
     return error::kNoError;
   }
-  if (info->IsImmutable()) {
+  if (texture->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCompressedTexImage2D", "texture is immutable");
     return error::kNoError;
   }
 
   if (!ValidateCompressedTexDimensions(
       "glCompressedTexImage2D", level, width, height, internal_format) ||
       !ValidateCompressedTexFuncData(
       "glCompressedTexImage2D", width, height, internal_format, image_size)) {
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(image_size)) {
     SetGLError(GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
-  if (info->IsAttachedToFramebuffer()) {
+  if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   scoped_array<int8> zero;
   if (!data) {
     zero.reset(new int8[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   CopyRealGLErrorsToWrapper();
   glCompressedTexImage2D(
       target, level, internal_format, width, height, border, image_size, data);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
-        info, target, level, internal_format, width, height, 1, border, 0, 0,
+        texture, target, level, internal_format, width, height, 1, border, 0, 0,
         true);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCompressedTexImage2D(
     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);
@@ skipping 165 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;
   }
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "unknown texture for target");
     return false;
   }
-  if (info->IsImmutable()) {
+  if (texture->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "texture is immutable");
     return false;
   }
   return true;
 }
 
 void GLES2DecoderImpl::DoTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLenum format,
     GLenum type,
     const void* pixels,
     uint32 pixels_size) {
   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;
   }
 
-  Texture* info = GetTextureInfoForTarget(target);
+  Texture* texture = 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) &&
+      texture->GetLevelSize(target, level, &tex_width, &tex_height) &&
+      texture->GetLevelType(target, level, &tex_type, &tex_format) &&
       width == tex_width && height == tex_height &&
       type == tex_type && format == tex_format;
 
   if (level_is_same && !pixels) {
-    // Just set the level info but mark the texture as uncleared.
+    // Just set the level texture but mark the texture as uncleared.
     texture_manager()->SetLevelInfo(
-        info,
+        texture,
         target, level, internal_format, width, height, 1, border, format, type,
         false);
     tex_image_2d_failed_ = false;
     return;
   }
 
-  if (info->IsAttachedToFramebuffer()) {
+  if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   if (!teximage2d_faster_than_texsubimage2d_ && level_is_same && pixels) {
     glTexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
-    texture_manager()->SetLevelCleared(info, target, level, true);
+    texture_manager()->SetLevelCleared(texture, target, level, true);
     tex_image_2d_failed_ = false;
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   WrappedTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
-        info,
+        texture,
         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 cmds::TexImage2D& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleTexImage2D");
@@ skipping 59 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) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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)) {
+  if (!texture->GetLevelType(target, level, &type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glCompressedTexSubImage2D", "level does not exist.");
     return;
   }
   if (internal_format != format) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glCompressedTexSubImage2D", "format does not match internal format.");
     return;
   }
-  if (!info->ValidForTexture(
+  if (!texture->ValidForTexture(
       target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glCompressedTexSubImage2D", "bad dimensions.");
     return;
   }
 
   if (!ValidateCompressedTexFuncData(
       "glCompressedTexSubImage2D", width, height, format, image_size) ||
       !ValidateCompressedTexSubDimensions(
       "glCompressedTexSubImage2D",
-      target, level, xoffset, yoffset, width, height, format, info)) {
+      target, level, xoffset, yoffset, width, height, format, texture)) {
     return;
   }
 
 
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage2D already cleared the texture.
   glCompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, image_size, data);
@@ skipping 19 matching lines @@
 void GLES2DecoderImpl::DoCopyTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
   DCHECK(!ShouldDeferReads());
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "unknown texture for target");
     return;
   }
-  if (info->IsImmutable()) {
+  if (texture->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexImage2D", "texture is immutable");
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     SetGLError(GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
     return;
   }
   if (!ValidateTextureParameters(
       "glCopyTexImage2D", target, internal_format, GL_UNSIGNED_BYTE, level)) {
@@ skipping 31 matching lines @@
   }
 
   if (!CheckBoundFramebuffersValid("glCopyTexImage2D")) {
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
-  if (info->IsAttachedToFramebuffer()) {
+  if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     framebuffer_manager()->IncFramebufferStateChangeCount();
   }
 
   // Clip to size to source dimensions
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the texture.
     if (!ClearLevel(
-        info->service_id(), info->target(),
+        texture->service_id(), texture->target(),
         target, level, internal_format, GL_UNSIGNED_BYTE, width, height,
-        info->IsImmutable())) {
+        texture->IsImmutable())) {
       SetGLError(GL_OUT_OF_MEMORY, "glCopyTexImage2D", "dimensions too big");
       return;
     }
     if (copyHeight > 0 && copyWidth > 0) {
       GLint dx = copyX - x;
       GLint dy = copyY - y;
       GLint destX = dx;
       GLint destY = dy;
       glCopyTexSubImage2D(target, level,
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
     glCopyTexImage2D(target, level, internal_format,
                      copyX, copyY, copyWidth, copyHeight, border);
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(
-        info, target, level, internal_format, width, height, 1,
+        texture, target, level, internal_format, width, height, 1,
         border, internal_format, GL_UNSIGNED_BYTE, true);
   }
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
   DCHECK(!ShouldDeferReads());
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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(
+  if (!texture->GetLevelType(target, level, &type, &format) ||
+      !texture->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTexSubImage2D", "bad dimensions.");
     return;
   }
-  if (info->AsyncTransferIsInProgress()) {
+  if (texture->AsyncTransferIsInProgress()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCopyTexSubImage2D", "async upload pending for texture");
     return;
   }
 
   // Check we have compatible formats.
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
   uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32 channels_needed = GLES2Util::GetChannelsForFormat(format);
 
@@ skipping 17 matching lines @@
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
   Clip(y, height, size.height(), &copyY, &copyHeight);
 
-  if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+  if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
     SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D", "dimensions too big");
     return;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
@@ skipping 48 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;
   }
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     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)) {
+  if (!texture->GetLevelType(target, level, &current_type, &internal_format)) {
     SetGLError(
         GL_INVALID_OPERATION, function_name, "level does not exist.");
     return false;
   }
   if (format != internal_format) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "format does not match internal format.");
     return false;
   }
   if (type != current_type) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "type does not match type of texture.");
     return false;
   }
-  if (info->AsyncTransferIsInProgress()) {
+  if (texture->AsyncTransferIsInProgress()) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "async upload pending for texture");
     return false;
   }
-  if (!info->ValidForTexture(
+  if (!texture->ValidForTexture(
           target, level, xoffset, yoffset, width, height, format, type)) {
     SetGLError(GL_INVALID_VALUE, function_name, "bad dimensions.");
     return false;
   }
   if ((GLES2Util::GetChannelsForFormat(format) &
        (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
     SetGLError(
         GL_INVALID_OPERATION,
         function_name, "can not supply data for depth or stencil textures");
     return false;
@@ skipping 13 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;
   }
-  Texture* info = GetTextureInfoForTarget(target);
+  Texture* texture = GetTextureInfoForTarget(target);
   GLsizei tex_width = 0;
   GLsizei tex_height = 0;
-  bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
+  bool ok = texture->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)) {
+    if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
       SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");
       return error::kNoError;
     }
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
     return error::kNoError;
   }
 
-  if (teximage2d_faster_than_texsubimage2d_ && !info->IsImmutable()) {
+  if (teximage2d_faster_than_texsubimage2d_ && !texture->IsImmutable()) {
     ScopedTextureUploadTimer timer(this);
     // NOTE: In OpenGL ES 2.0 border is always zero and format is always the
     // same as internal_foramt. If that changes we'll need to look them up.
     WrappedTexImage2D(
         target, level, format, width, height, 0, format, type, data);
   } else {
     ScopedTextureUploadTimer timer(this);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height, format, type, data);
   }
-  texture_manager()->SetLevelCleared(info, target, level, true);
+  texture_manager()->SetLevelCleared(texture, target, level, true);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     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;
 
@@ skipping 1001 matching lines @@
   }
 
   uint32 client_id = c.client_id;
   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;
-  Texture* info =
-      texture_manager()->GetTexture(client_id);
-  if (!info) {
+  Texture* texture = texture_manager()->GetTexture(client_id);
+  if (!texture) {
     SetGLError(GL_INVALID_VALUE,
                "glCreateStreamTextureCHROMIUM", ""
                "bad texture id.");
     return error::kNoError;
   }
 
-  if (info->IsStreamTexture()) {
+  if (texture->IsStreamTexture()) {
     SetGLError(GL_INVALID_OPERATION,
                "glCreateStreamTextureCHROMIUM", ""
                "is already a stream texture.");
     return error::kNoError;
   }
 
-  if (info->target() && info->target() != GL_TEXTURE_EXTERNAL_OES) {
+  if (texture->target() && texture->target() != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glCreateStreamTextureCHROMIUM", ""
                "is already bound to incompatible target.");
     return error::kNoError;
   }
 
   if (!stream_texture_manager_)
     return error::kInvalidArguments;
 
   GLuint object_id = stream_texture_manager_->CreateStreamTexture(
-      info->service_id(), client_id);
+      texture->service_id(), client_id);
 
   if (object_id) {
-    info->SetStreamTexture(true);
+    texture->SetStreamTexture(true);
   } else {
     SetGLError(GL_OUT_OF_MEMORY,
                "glCreateStreamTextureCHROMIUM", ""
                "failed to create platform texture.");
   }
 
   *result = object_id;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDestroyStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const cmds::DestroyStreamTextureCHROMIUM& c) {
   GLuint client_id = c.texture;
-  Texture* info =
-      texture_manager()->GetTexture(client_id);
-  if (info && info->IsStreamTexture()) {
+  Texture* texture = texture_manager()->GetTexture(client_id);
+  if (texture && texture->IsStreamTexture()) {
     if (!stream_texture_manager_)
       return error::kInvalidArguments;
 
-    stream_texture_manager_->DestroyStreamTexture(info->service_id());
-    info->SetStreamTexture(false);
+    stream_texture_manager_->DestroyStreamTexture(texture->service_id());
+    texture->SetStreamTexture(false);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glDestroyStreamTextureCHROMIUM", "bad texture id.");
   }
 
   return error::kNoError;
 }
 
 #if defined(OS_MACOSX)
 void GLES2DecoderImpl::ReleaseIOSurfaceForTexture(GLuint texture_id) {
@@ skipping 33 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.
-  Texture* info = GetTextureInfoForTargetUnlessDefault(
-      target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture) {
     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
   // this process gets a chance to look it up. Hold on to any old
   // IOSurface in this case.
   CFTypeRef surface = surface_support->IOSurfaceLookup(io_surface_id);
   if (!surface) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "no IOSurface with the given ID");
     return;
   }
 
   // Release any IOSurface previously bound to this texture.
-  ReleaseIOSurfaceForTexture(info->service_id());
+  ReleaseIOSurfaceForTexture(texture->service_id());
 
   // Make sure we release the IOSurface even if CGLTexImageIOSurface2D fails.
   texture_to_io_surface_map_.insert(
-      std::make_pair(info->service_id(), surface));
+      std::make_pair(texture->service_id(), surface));
 
   CGLContextObj context =
       static_cast<CGLContextObj>(context_->GetHandle());
 
   CGLError err = surface_support->CGLTexImageIOSurface2D(
       context,
       target,
       GL_RGBA,
       width,
       height,
       GL_BGRA,
       GL_UNSIGNED_INT_8_8_8_8_REV,
       surface,
       plane);
 
   if (err != kCGLNoError) {
     SetGLError(
         GL_INVALID_OPERATION,
         "glTexImageIOSurface2DCHROMIUM", "error in CGLTexImageIOSurface2D");
     return;
   }
 
   texture_manager()->SetLevelInfo(
-      info, target, 0, GL_RGBA, width, height, 1, 0,
+      texture, target, 0, GL_RGBA, width, height, 1, 0,
       GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, true);
 
 #else
   SetGLError(GL_INVALID_OPERATION,
              "glTexImageIOSurface2DCHROMIUM", "not supported.");
 #endif
 }
 
 static GLenum ExtractFormatFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
@@ skipping 36 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) {
-  Texture* dest_info = GetTexture(dest_id);
-  Texture* source_info = GetTexture(source_id);
+  Texture* dest_texture = GetTexture(dest_id);
+  Texture* source_texture = GetTexture(source_id);
 
-  if (!source_info || !dest_info) {
+  if (!source_texture || !dest_texture) {
     SetGLError(GL_INVALID_VALUE, "glCopyTextureCHROMIUM", "unknown texture id");
     return;
   }
 
   if (GL_TEXTURE_2D != target) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTextureCHROMIUM", "invalid texture target");
     return;
   }
 
-  if (dest_info->target() != GL_TEXTURE_2D ||
-      source_info->target() != GL_TEXTURE_2D) {
+  if (dest_texture->target() != GL_TEXTURE_2D ||
+      source_texture->target() != GL_TEXTURE_2D) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTextureCHROMIUM", "invalid texture target binding");
     return;
   }
 
   int source_width, source_height, dest_width, dest_height;
-  if (!source_info->GetLevelSize(GL_TEXTURE_2D, 0, &source_width,
+  if (!source_texture->GetLevelSize(GL_TEXTURE_2D, 0, &source_width,
                                  &source_height)) {
     SetGLError(GL_INVALID_VALUE,
                "glCopyTextureChromium", "source texture has no level 0");
     return;
   }
 
   // Check that this type of texture is allowed.
   if (!texture_manager()->ValidForTarget(GL_TEXTURE_2D, level, source_width,
                                          source_height, 1)) {
     SetGLError(GL_INVALID_VALUE,
              "glCopyTextureCHROMIUM", "Bad dimensions");
     return;
   }
 
   // Defer initializing the CopyTextureCHROMIUMResourceManager until it is
   // needed because it takes 10s of milliseconds to initialize.
   if (!copy_texture_CHROMIUM_.get()) {
     CopyRealGLErrorsToWrapper();
     copy_texture_CHROMIUM_.reset(new CopyTextureCHROMIUMResourceManager());
     copy_texture_CHROMIUM_->Initialize(this);
     RestoreCurrentFramebufferBindings();
     if (PeekGLError() != GL_NO_ERROR)
       return;
   }
 
   GLenum dest_type;
   GLenum dest_internal_format;
-  bool dest_level_defined = dest_info->GetLevelSize(GL_TEXTURE_2D, level,
-                                                    &dest_width,
-                                                    &dest_height);
+  bool dest_level_defined = dest_texture->GetLevelSize(
+      GL_TEXTURE_2D, level, &dest_width, &dest_height);
 
   if (dest_level_defined) {
-    dest_info->GetLevelType(GL_TEXTURE_2D, level, &dest_type,
-                            &dest_internal_format);
+    dest_texture->GetLevelType(GL_TEXTURE_2D, level, &dest_type,
+                               &dest_internal_format);
   } else {
     GLenum source_internal_format;
-    source_info->GetLevelType(GL_TEXTURE_2D, 0, &dest_type,
-                              &source_internal_format);
+    source_texture->GetLevelType(GL_TEXTURE_2D, 0, &dest_type,
+                                 &source_internal_format);
   }
 
   // Resize the destination texture to the dimensions of the source texture.
   if (!dest_level_defined || dest_width != source_width ||
       dest_height != source_height ||
       dest_internal_format != internal_format) {
     // Ensure that the glTexImage2D succeeds.
     CopyRealGLErrorsToWrapper();
-    glBindTexture(GL_TEXTURE_2D, dest_info->service_id());
+    glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
     WrappedTexImage2D(
         GL_TEXTURE_2D, level, internal_format, source_width, source_height,
         0, internal_format, dest_type, NULL);
     GLenum error = PeekGLError();
     if (error != GL_NO_ERROR) {
       RestoreCurrentTexture2DBindings();
       return;
     }
 
     texture_manager()->SetLevelInfo(
-        dest_info, GL_TEXTURE_2D, level, internal_format, source_width,
+        dest_texture, GL_TEXTURE_2D, level, internal_format, source_width,
         source_height, 1, 0, internal_format, dest_type, true);
   } else {
-    texture_manager()->SetLevelCleared(dest_info, GL_TEXTURE_2D, level, true);
+    texture_manager()->SetLevelCleared(
+        dest_texture, GL_TEXTURE_2D, level, true);
   }
 
   copy_texture_CHROMIUM_->DoCopyTexture(this,
-                                        source_info->target(),
-                                        dest_info->target(),
-                                        source_info->service_id(),
-                                        dest_info->service_id(), level,
+                                        source_texture->target(),
+                                        dest_texture->target(),
+                                        source_texture->service_id(),
+                                        dest_texture->service_id(), level,
                                         source_width, source_height,
                                         unpack_flip_y_,
                                         unpack_premultiply_alpha_,
                                         unpack_unpremultiply_alpha_);
 }
 
 static GLenum ExtractTypeFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
     case GL_RGB565:
       return GL_UNSIGNED_SHORT_5_6_5;
@@ skipping 44 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;
   }
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexStorage2DEXT", "unknown texture for target");
     return;
   }
-  if (info->IsAttachedToFramebuffer()) {
+  if (texture->IsAttachedToFramebuffer()) {
     clear_state_dirty_ = true;
   }
-  if (info->IsImmutable()) {
+  if (texture->IsImmutable()) {
     SetGLError(GL_INVALID_OPERATION,
                "glTexStorage2DEXT", "texture is immutable");
     return;
   }
 
   GLenum format = ExtractFormatFromStorageFormat(internal_format);
   GLenum type = ExtractTypeFromStorageFormat(internal_format);
 
   {
     GLsizei level_width = width;
@@ skipping 20 matching lines @@
 
   CopyRealGLErrorsToWrapper();
   glTexStorage2DEXT(target, levels, GetTexInternalFormat(internal_format),
                     width, height);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     GLsizei level_width = width;
     GLsizei level_height = height;
     for (int ii = 0; ii < levels; ++ii) {
       texture_manager()->SetLevelInfo(
-          info, target, ii, format, level_width, level_height, 1, 0, format,
+          texture, 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);
+    texture->SetImmutable(true);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
     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) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
-  TextureDefinition* definition = texture_manager()->Save(info);
+  TextureDefinition* definition = texture_manager()->Save(texture);
   if (!definition) {
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "invalid texture");
     return;
   }
 
   if (!group_->mailbox_manager()->ProduceTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox),
       definition,
       texture_manager())) {
-    bool success = texture_manager()->Restore(info, definition);
+    bool success = texture_manager()->Restore(
+        "glProductTextureCHROMIUM", this, texture, definition);
     DCHECK(success);
     SetGLError(GL_INVALID_OPERATION,
                "glProduceTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
-  glBindTexture(info->target(), info->service_id());
+  glBindTexture(texture->target(), texture->service_id());
 }
 
 void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
                                                 const GLbyte* mailbox) {
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "unknown texture for target");
     return;
   }
 
   scoped_ptr<TextureDefinition> definition(
       group_->mailbox_manager()->ConsumeTexture(
       target,
       *reinterpret_cast<const MailboxName*>(mailbox)));
   if (!definition.get()) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "invalid mailbox name");
     return;
   }
 
-  if (!texture_manager()->Restore(info, definition.release())) {
+  if (!texture_manager()->Restore(
+      "glConsumeTextureCHROMIUM", this, texture, definition.release())) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "invalid texture");
     return;
   }
-
-  glBindTexture(info->target(), info->service_id());
 }
 
 void GLES2DecoderImpl::DoInsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   if (!marker) {
     marker = "";
   }
   debug_marker_manager_.SetMarker(
       length ? std::string(marker, length) : std::string(marker));
 }
@@ skipping 17 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.
-  Texture* info = GetTextureInfoForTargetUnlessDefault(
-      target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture) {
     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,
                "glBindTexImage2DCHROMIUM",
                "no image found with the given ID");
     return;
   }
 
   if (!gl_image->BindTexImage()) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexImage2DCHROMIUM",
                "fail to bind image with the given ID");
     return;
   }
 
   gfx::Size size = gl_image->GetSize();
   texture_manager()->SetLevelInfo(
-      info, target, 0, GL_RGBA, size.width(), size.height(), 1, 0,
+      texture, target, 0, GL_RGBA, size.width(), size.height(), 1, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, true);
-  texture_manager()->SetLevelImage(info, target, 0, gl_image);
+  texture_manager()->SetLevelImage(texture, target, 0, gl_image);
 }
 
 void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
     GLenum target, GLint image_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM");
   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.
-  Texture* info = GetTextureInfoForTargetUnlessDefault(
-      target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTargetUnlessDefault(target);
+  if (!texture) {
     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)
+  if (texture->GetLevelImage(target, 0) != gl_image)
     return;
 
   gl_image->ReleaseTexImage();
 
   texture_manager()->SetLevelInfo(
-      info, target, 0, GL_RGBA, 0, 0, 1, 0,
+      texture, target, 0, GL_RGBA, 0, 0, 1, 0,
       GL_RGBA, GL_UNSIGNED_BYTE, false);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     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;
@@ skipping 14 matching lines @@
     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,
-    Texture* info,
+    Texture* texture,
     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()) {
+  if (!texture || texture->AsyncTransferIsInProgress()) {
     SetGLError(GL_INVALID_OPERATION,
         function_name, "transfer already in progress");
     return false;
   }
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const cmds::AsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM");
@@ skipping 26 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.
-  Texture* info = GetTextureInfoForTarget(target);
+  Texture* texture = GetTextureInfoForTarget(target);
   if (!ValidateAsyncTransfer(
-      "glAsyncTexImage2DCHROMIUM", info, target, level, pixels))
+      "glAsyncTexImage2DCHROMIUM", texture, target, level, pixels))
     return error::kNoError;
 
   // Don't allow async redefinition of a textures.
-  if (info->IsDefined()) {
+  if (texture->IsDefined()) {
     SetGLError(GL_INVALID_OPERATION,
         "glAsyncTexImage2DCHROMIUM", "already defined");
     return error::kNoError;
   }
 
   if (!EnsureGPUMemoryAvailable(pixels_size)) {
     SetGLError(GL_OUT_OF_MEMORY, "glAsyncTexImage2DCHROMIUM", "out of memory");
     return error::kNoError;
   }
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.pixels_shm_offset;
   uint32 shm_data_size = pixels_size;
 
   // Set up the async state if needed, and make the texture
-  // immutable so the async state stays valid. The level info
+  // immutable so the async state stays valid. The level texture
   // is set up lazily when the transfer completes.
-  DCHECK(!info->GetAsyncTransferState());
-  info->SetAsyncTransferState(
+  DCHECK(!texture->GetAsyncTransferState());
+  texture->SetAsyncTransferState(
       async_pixel_transfer_delegate_->
-          CreatePixelTransferState(info->service_id()));
-  info->SetImmutable(true);
+          CreatePixelTransferState(texture->service_id()));
+  texture->SetImmutable(true);
 
   // Issue the async call and set up the texture.
   GLenum gl_internal_format =
       GetTexInternalFormat(internal_format, format, type);
   gfx::AsyncTexImage2DParams tex_params = {target, level, gl_internal_format,
                                            width, height, border, format, type};
   gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
 
   // Add a pending transfer to the texture manager, which will bind the
-  // transfer data to the texture and set the level info at the same time,
+  // transfer data to the texture and set the level texture at the same time,
   // after the the transfer is complete.
   texture_manager()->AddPendingAsyncPixelTransfer(
-      info->GetAsyncTransferState()->AsWeakPtr(), info);
+      texture->GetAsyncTransferState()->AsWeakPtr(), texture);
 
   async_pixel_transfer_delegate_->AsyncTexImage2D(
-      info->GetAsyncTransferState(), tex_params, mem_params);
+      texture->GetAsyncTransferState(), tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
     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);
@@ skipping 14 matching lines @@
       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.
-  Texture* info = GetTextureInfoForTarget(target);
+  Texture* texture = GetTextureInfoForTarget(target);
   if (!ValidateAsyncTransfer(
-         "glAsyncTexSubImage2DCHROMIUM", info, target, level, pixels))
+         "glAsyncTexSubImage2DCHROMIUM", texture, 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.
-  if (!info->SafeToRenderFrom()) {
-    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+  if (!texture->SafeToRenderFrom()) {
+    if (!texture_manager()->ClearTextureLevel(this, texture, target, level)) {
       SetGLError(GL_OUT_OF_MEMORY,
           "glAsyncTexSubImage2DCHROMIUM", "dimensions too big");
       return error::kNoError;
     }
   }
 
   // We know the memory/size is safe, so get the real shared memory since
   // it might need to be duped to prevent use-after-free of the memory.
   gpu::Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
   base::SharedMemory* shared_memory = buffer.shared_memory;
   uint32 shm_size = buffer.size;
   uint32 shm_data_offset = c.data_shm_offset;
   uint32 shm_data_size = data_size;
 
-  if (!info->GetAsyncTransferState()) {
+  if (!texture->GetAsyncTransferState()) {
     // Set up the async state if needed, and make the texture
     // immutable so the async state stays valid.
-    info->SetAsyncTransferState(
+    texture->SetAsyncTransferState(
         async_pixel_transfer_delegate_->
-            CreatePixelTransferState(info->service_id()));
-    info->SetImmutable(true);
+            CreatePixelTransferState(texture->service_id()));
+    texture->SetImmutable(true);
   }
 
   gfx::AsyncTexSubImage2DParams tex_params = {target, level, xoffset, yoffset,
                                               width, height, format, type};
   gfx::AsyncMemoryParams mem_params = {shared_memory, shm_size,
                                        shm_data_offset, shm_data_size};
   async_pixel_transfer_delegate_->AsyncTexSubImage2D(
-      info->GetAsyncTransferState(), tex_params, mem_params);
+      texture->GetAsyncTransferState(), tex_params, mem_params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM(
     uint32 immediate_data_size, const cmds::WaitAsyncTexImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM");
   GLenum target = static_cast<GLenum>(c.target);
 
   if (GL_TEXTURE_2D != target) {
     SetGLError(GL_INVALID_ENUM, "glWaitAsyncTexImage2DCHROMIUM", "target");
     return error::kNoError;
   }
-  Texture* info = GetTextureInfoForTarget(target);
-  if (!info) {
+  Texture* texture = GetTextureInfoForTarget(target);
+  if (!texture) {
       SetGLError(GL_INVALID_OPERATION,
                  "glWaitAsyncTexImage2DCHROMIUM", "unknown texture");
     return error::kNoError;
   }
   async_pixel_transfer_delegate_->WaitForTransferCompletion(
-      info->GetAsyncTransferState());
+      texture->GetAsyncTransferState());
   ProcessFinishedAsyncTransfers();
   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