Refactor a bunch of Texture related GPU code

Rename info->texture
Move TexParameter guts into TextureManager

BUG=none


Review URL: https://chromiumcodereview.appspot.com/12647003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@187120 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 1209 insertions, 1106 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index af9b5d5..4edac65 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1177,6 +1177,9 @@ _PEPPER_INTERFACES = [
 # pepper_interface: The pepper interface that is used for this extension
 # invalid_test: False if no invalid test needed.
 # shadowed:     True = the value is shadowed so no glGetXXX call will be made.
+# first_element_only: For PUT types, True if only the first element of an
+#               array is used and we end up calling the single value
+#               corresponding function. eg. TexParameteriv -> TexParameteri
 
 _FUNCTION_INFO = {
   'ActiveTexture': {
@@ -1892,6 +1895,7 @@ _FUNCTION_INFO = {
   },
   'TexParameterf': {
     'decoder_func': 'DoTexParameterf',
+    'gl_test_func': 'glTexParameteri',
     'valid_args': {
       '2': 'GL_NEAREST'
     },
@@ -1908,6 +1912,8 @@ _FUNCTION_INFO = {
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameterfv',
+    'gl_test_func': 'glTexParameteri',
+    'first_element_only': True,
   },
   'TexParameteriv': {
     'type': 'PUT',
@@ -1915,6 +1921,8 @@ _FUNCTION_INFO = {
     'data_value': 'GL_NEAREST',
     'count': 1,
     'decoder_func': 'DoTexParameteriv',
+    'gl_test_func': 'glTexParameteri',
+    'first_element_only': True,
   },
   'TexSubImage2D': {
     'type': 'Manual',
@@ -2760,6 +2768,10 @@ COMPILE_ASSERT(offsetof(%(cmd_name)s::Result, %(field_name)s) == %(offset)d,
       'gl_args': ", ".join(gl_arg_strings),
     }
     vars.update(extra)
+    old_test = ""
+    while (old_test != test):
+      old_test = test
+      test = test % vars
     file.Write(test % vars)
 
   def WriteInvalidUnitTest(self, func, file, test, extra = {}):
@@ -4524,13 +4536,21 @@ class PUTHandler(TypeHandler):
 
   def WriteServiceUnitTest(self, func, file):
     """Writes the service unit test for a command."""
+    expected_call = "EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));"
+    if func.GetInfo("first_element_only"):
+      gl_arg_strings = []
+      for count, arg in enumerate(func.GetOriginalArgs()):
+        gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
+      gl_arg_strings[-1] = "*" + gl_arg_strings[-1]
+      expected_call = ("EXPECT_CALL(*gl_, %%(gl_func_name)s(%s));" %
+          ", ".join(gl_arg_strings))
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
-  EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   cmds::%(name)s cmd;
   cmd.Init(%(args)s);
   GetSharedMemoryAs<%(data_type)s*>()[0] = %(data_value)s;
+  %(expected_call)s
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -4538,6 +4558,7 @@ TEST_F(%(test_name)s, %(name)sValidArgs) {
     extra = {
       'data_type': func.GetInfo('data_type'),
       'data_value': func.GetInfo('data_value') or '0',
+      'expected_call': expected_call,
     }
     self.WriteValidUnitTest(func, file, valid_test, extra)
 
@@ -4558,13 +4579,13 @@ TEST_F(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   cmds::%(name)s& cmd = *GetImmediateAs<cmds::%(name)s>();
-  EXPECT_CALL(
-      *gl_,
-      %(gl_func_name)s(%(gl_args)s,
-          reinterpret_cast<%(data_type)s*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::%(name)s, 0>(true);
   %(data_type)s temp[%(data_count)s] = { %(data_value)s, };
   cmd.Init(%(gl_args)s, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      %(gl_func_name)s(%(gl_args)s, %(data_ref)sreinterpret_cast<
+          %(data_type)s*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -4576,6 +4597,7 @@ TEST_F(%(test_name)s, %(name)sValidArgs) {
       gl_arg_strings.append(arg.GetValidGLArg(func, count, 0))
       gl_any_strings.append("_")
     extra = {
+      'data_ref': ("*" if func.GetInfo('first_element_only') else ""),
       'data_type': func.GetInfo('data_type'),
       'data_count': func.GetInfo('count'),
       'data_value': func.GetInfo('data_value') or '0',
diff --git a/gpu/command_buffer/service/framebuffer_manager_unittest.cc b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
index f563157..06d2fda 100644
--- a/gpu/command_buffer/service/framebuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
@@ -4,7 +4,9 @@
 
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
+#include "gpu/command_buffer/service/test_helper.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
@@ -131,6 +133,7 @@ class FramebufferInfoTest : public testing::Test {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
     manager_.CreateFramebuffer(kClient1Id, kService1Id);
+    decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     info_ = manager_.GetFramebuffer(kClient1Id);
     ASSERT_TRUE(info_ != NULL);
   }
@@ -146,6 +149,7 @@ class FramebufferInfoTest : public testing::Test {
   Framebuffer* info_;
   TextureManager texture_manager_;
   RenderbufferManager renderbuffer_manager_;
+  scoped_ptr<MockGLES2Decoder> decoder_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
@@ -417,12 +421,12 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
             info_->IsPossiblyComplete());
 
   texture_manager_.CreateTexture(kTextureClient1Id, kTextureService1Id);
-  scoped_refptr<Texture> tex_info1(
+  scoped_refptr<Texture> texture1(
       texture_manager_.GetTexture(kTextureClient1Id));
-  ASSERT_TRUE(tex_info1 != NULL);
+  ASSERT_TRUE(texture1 != NULL);
 
   // check adding one attachment
-  info_->AttachTexture(GL_COLOR_ATTACHMENT0, tex_info1, kTarget1, kLevel1);
+  info_->AttachTexture(GL_COLOR_ATTACHMENT0, texture1, kTarget1, kLevel1);
   EXPECT_FALSE(info_->HasUnclearedAttachment(GL_COLOR_ATTACHMENT0));
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT),
             info_->IsPossiblyComplete());
@@ -430,9 +434,9 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
   EXPECT_EQ(static_cast<GLenum>(0), info_->GetColorAttachmentFormat());
 
   // Try format that doesn't work with COLOR_ATTACHMENT0
-  texture_manager_.SetInfoTarget(tex_info1, GL_TEXTURE_2D);
+  texture_manager_.SetTarget(texture1, GL_TEXTURE_2D);
   texture_manager_.SetLevelInfo(
-      tex_info1, GL_TEXTURE_2D, kLevel1,
+      texture1, GL_TEXTURE_2D, kLevel1,
       kBadFormat1, kWidth1, kHeight1, kDepth, kBorder, kBadFormat1, kType,
       true);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT),
@@ -440,13 +444,13 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
 
   // Try a good format.
   texture_manager_.SetLevelInfo(
-      tex_info1, GL_TEXTURE_2D, kLevel1,
+      texture1, GL_TEXTURE_2D, kLevel1,
       kFormat1, kWidth1, kHeight1, kDepth, kBorder, kFormat1, kType, false);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             info_->IsPossiblyComplete());
   EXPECT_FALSE(info_->IsCleared());
   texture_manager_.SetLevelInfo(
-      tex_info1, GL_TEXTURE_2D, kLevel1,
+      texture1, GL_TEXTURE_2D, kLevel1,
       kFormat1, kWidth1, kHeight1, kDepth, kBorder, kFormat1, kType, true);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             info_->IsPossiblyComplete());
@@ -464,15 +468,15 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
 
   // Check replacing an attachment
   texture_manager_.CreateTexture(kTextureClient2Id, kTextureService2Id);
-  scoped_refptr<Texture> tex_info2(
+  scoped_refptr<Texture> texture2(
       texture_manager_.GetTexture(kTextureClient2Id));
-  ASSERT_TRUE(tex_info2 != NULL);
-  texture_manager_.SetInfoTarget(tex_info2, GL_TEXTURE_2D);
+  ASSERT_TRUE(texture2 != NULL);
+  texture_manager_.SetTarget(texture2, GL_TEXTURE_2D);
   texture_manager_.SetLevelInfo(
-      tex_info2, GL_TEXTURE_2D, kLevel2,
+      texture2, GL_TEXTURE_2D, kLevel2,
       kFormat2, kWidth2, kHeight2, kDepth, kBorder, kFormat2, kType, true);
 
-  info_->AttachTexture(GL_COLOR_ATTACHMENT0, tex_info2, kTarget2, kLevel2);
+  info_->AttachTexture(GL_COLOR_ATTACHMENT0, texture2, kTarget2, kLevel2);
   EXPECT_EQ(static_cast<GLenum>(kFormat2), info_->GetColorAttachmentFormat());
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             info_->IsPossiblyComplete());
@@ -488,7 +492,7 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
 
   // Check changing attachment
   texture_manager_.SetLevelInfo(
-      tex_info2, GL_TEXTURE_2D, kLevel3,
+      texture2, GL_TEXTURE_2D, kLevel3,
       kFormat3, kWidth3, kHeight3, kDepth, kBorder, kFormat3, kType, false);
   attachment = info_->GetAttachment(GL_COLOR_ATTACHMENT0);
   ASSERT_TRUE(attachment != NULL);
@@ -504,7 +508,7 @@ TEST_F(FramebufferInfoTest, AttachTexture) {
 
   // Set to size 0
   texture_manager_.SetLevelInfo(
-      tex_info2, GL_TEXTURE_2D, kLevel3,
+      texture2, GL_TEXTURE_2D, kLevel3,
       kFormat3, 0, 0, kDepth, kBorder, kFormat3, kType, false);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT),
             info_->IsPossiblyComplete());
@@ -563,27 +567,27 @@ TEST_F(FramebufferInfoTest, UnbindTexture) {
   const GLint kLevel1 = 0;
 
   texture_manager_.CreateTexture(kTextureClient1Id, kTextureService1Id);
-  scoped_refptr<Texture> tex_info1(
+  scoped_refptr<Texture> texture1(
       texture_manager_.GetTexture(kTextureClient1Id));
-  ASSERT_TRUE(tex_info1 != NULL);
+  ASSERT_TRUE(texture1 != NULL);
   texture_manager_.CreateTexture(kTextureClient2Id, kTextureService2Id);
-  scoped_refptr<Texture> tex_info2(
+  scoped_refptr<Texture> texture2(
       texture_manager_.GetTexture(kTextureClient2Id));
-  ASSERT_TRUE(tex_info2 != NULL);
+  ASSERT_TRUE(texture2 != NULL);
 
   // Attach to 2 attachment points.
-  info_->AttachTexture(GL_COLOR_ATTACHMENT0, tex_info1, kTarget1, kLevel1);
-  info_->AttachTexture(GL_DEPTH_ATTACHMENT, tex_info1, kTarget1, kLevel1);
+  info_->AttachTexture(GL_COLOR_ATTACHMENT0, texture1, kTarget1, kLevel1);
+  info_->AttachTexture(GL_DEPTH_ATTACHMENT, texture1, kTarget1, kLevel1);
   // Check they were attached.
   EXPECT_TRUE(info_->GetAttachment(GL_COLOR_ATTACHMENT0) != NULL);
   EXPECT_TRUE(info_->GetAttachment(GL_DEPTH_ATTACHMENT) != NULL);
   // Unbind unattached texture.
-  info_->UnbindTexture(kTarget1, tex_info2);
+  info_->UnbindTexture(kTarget1, texture2);
   // Should be no-op.
   EXPECT_TRUE(info_->GetAttachment(GL_COLOR_ATTACHMENT0) != NULL);
   EXPECT_TRUE(info_->GetAttachment(GL_DEPTH_ATTACHMENT) != NULL);
   // Unbind texture.
-  info_->UnbindTexture(kTarget1, tex_info1);
+  info_->UnbindTexture(kTarget1, texture1);
   // Check they were detached
   EXPECT_TRUE(info_->GetAttachment(GL_COLOR_ATTACHMENT0) == NULL);
   EXPECT_TRUE(info_->GetAttachment(GL_DEPTH_ATTACHMENT) == NULL);
@@ -603,16 +607,16 @@ TEST_F(FramebufferInfoTest, IsCompleteMarkAsComplete) {
       renderbuffer_manager_.GetRenderbuffer(kRenderbufferClient1Id);
   ASSERT_TRUE(rb_info1 != NULL);
   texture_manager_.CreateTexture(kTextureClient2Id, kTextureService2Id);
-  scoped_refptr<Texture> tex_info2(
+  scoped_refptr<Texture> texture2(
       texture_manager_.GetTexture(kTextureClient2Id));
-  ASSERT_TRUE(tex_info2 != NULL);
+  ASSERT_TRUE(texture2 != NULL);
 
   // Check MarkAsComlete marks as complete.
   manager_.MarkAsComplete(info_);
   EXPECT_TRUE(manager_.IsComplete(info_));
 
   // Check at attaching marks as not complete.
-  info_->AttachTexture(GL_COLOR_ATTACHMENT0, tex_info2, kTarget1, kLevel1);
+  info_->AttachTexture(GL_COLOR_ATTACHMENT0, texture2, kTarget1, kLevel1);
   EXPECT_FALSE(manager_.IsComplete(info_));
   manager_.MarkAsComplete(info_);
   EXPECT_TRUE(manager_.IsComplete(info_));
@@ -629,11 +633,11 @@ TEST_F(FramebufferInfoTest, IsCompleteMarkAsComplete) {
   EXPECT_FALSE(manager_.IsComplete(info_));
   manager_.MarkAsComplete(info_);
   EXPECT_TRUE(manager_.IsComplete(info_));
-  info_->UnbindTexture(kTarget1, tex_info2);
+  info_->UnbindTexture(kTarget1, texture2);
   EXPECT_FALSE(manager_.IsComplete(info_));
 }
 
-TEST_F(FramebufferInfoTest, Gettatus) {
+TEST_F(FramebufferInfoTest, GetStatus) {
   const GLuint kRenderbufferClient1Id = 33;
   const GLuint kRenderbufferService1Id = 333;
   const GLuint kTextureClient2Id = 34;
@@ -647,10 +651,10 @@ TEST_F(FramebufferInfoTest, Gettatus) {
       renderbuffer_manager_.GetRenderbuffer(kRenderbufferClient1Id);
   ASSERT_TRUE(rb_info1 != NULL);
   texture_manager_.CreateTexture(kTextureClient2Id, kTextureService2Id);
-  scoped_refptr<Texture> tex_info2(
+  scoped_refptr<Texture> texture2(
       texture_manager_.GetTexture(kTextureClient2Id));
-  ASSERT_TRUE(tex_info2 != NULL);
-  texture_manager_.SetInfoTarget(tex_info2, GL_TEXTURE_2D);
+  ASSERT_TRUE(texture2 != NULL);
+  texture_manager_.SetTarget(texture2, GL_TEXTURE_2D);
 
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
@@ -661,7 +665,7 @@ TEST_F(FramebufferInfoTest, Gettatus) {
   info_->GetStatus(&texture_manager_, GL_FRAMEBUFFER);
 
   // Check changing the attachments calls CheckFramebufferStatus.
-  info_->AttachTexture(GL_COLOR_ATTACHMENT0, tex_info2, kTarget1, kLevel1);
+  info_->AttachTexture(GL_COLOR_ATTACHMENT0, texture2, kTarget1, kLevel1);
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_COMPLETE))
       .RetiresOnSaturation();
@@ -690,7 +694,9 @@ TEST_F(FramebufferInfoTest, Gettatus) {
   info_->GetStatus(&texture_manager_, GL_READ_FRAMEBUFFER);
 
   // Check changing the format calls CheckFramebuffferStatus.
-  texture_manager_.SetParameter(tex_info2, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &texture_manager_,
+      texture2, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
 
   EXPECT_CALL(*gl_, CheckFramebufferStatusEXT(GL_READ_FRAMEBUFFER))
       .WillOnce(Return(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT))
@@ -703,7 +709,9 @@ TEST_F(FramebufferInfoTest, Gettatus) {
   info_->GetStatus(&texture_manager_, GL_READ_FRAMEBUFFER);
 
   // Check putting it back does not call CheckFramebufferStatus.
-  texture_manager_.SetParameter(tex_info2, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &texture_manager_,
+      texture2, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
   info_->GetStatus(&texture_manager_, GL_READ_FRAMEBUFFER);
 
   // Check Unbinding does not call CheckFramebufferStatus
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index ba2baaa..1b6e92f 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -711,9 +711,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
 
   // 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.
@@ -831,7 +829,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
   // Extra validation for async tex(Sub)Image2D.
   bool ValidateAsyncTransfer(
       const char* function_name,
-      Texture* info,
+      Texture* texture,
       GLenum target,
       GLint level,
       const void * data);
@@ -1052,7 +1050,7 @@ class GLES2DecoderImpl : public GLES2Decoder {
 
   // 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.
@@ -1409,10 +1407,10 @@ class GLES2DecoderImpl : public GLES2Decoder {
   // 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:
@@ -1421,29 +1419,29 @@ class GLES2DecoderImpl : public GLES2Decoder {
       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) {
@@ -2263,23 +2261,25 @@ bool GLES2DecoderImpl::Initialize(
   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());
-    }
-    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_RECTANGLE_ARB);
+      state_.texture_units[tt].bound_texture_rectangle_arb = texture;
+      glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture->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();
@@ -2990,18 +2990,26 @@ void GLES2DecoderImpl::UpdateParentTextureInfo() {
         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);
@@ -3040,8 +3048,7 @@ void GLES2DecoderImpl::SetAsyncPixelTransferDelegate(
 
 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;
@@ -3241,7 +3248,7 @@ bool GLES2DecoderImpl::SetParent(GLES2Decoder* new_parent,
         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);
 
@@ -3775,69 +3782,69 @@ void GLES2DecoderImpl::DoBindRenderbuffer(GLenum target, GLuint client_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.
@@ -3914,9 +3921,9 @@ void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
 }
 
 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;
@@ -3925,13 +3932,13 @@ void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   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;
     }
@@ -3949,11 +3956,11 @@ void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   }
   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);
   }
 }
 
@@ -4801,15 +4808,15 @@ void GLES2DecoderImpl::DoFramebufferTexture2D(
     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)) {
@@ -4822,7 +4829,7 @@ void GLES2DecoderImpl::DoFramebufferTexture2D(
   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;
@@ -5050,75 +5057,50 @@ void GLES2DecoderImpl::DoLinkProgram(GLuint program_id) {
 
 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) {
@@ -5674,9 +5656,9 @@ bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
       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(
@@ -5708,18 +5690,17 @@ void GLES2DecoderImpl::RestoreStateForNonRenderableTextures() {
       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);
         }
       }
     }
@@ -5746,10 +5727,10 @@ bool GLES2DecoderImpl::ClearUnclearedTextures() {
         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;
             }
           }
@@ -7331,8 +7312,8 @@ bool GLES2DecoderImpl::ClearLevel(
     }
     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;
 }
 
@@ -7504,13 +7485,13 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
                "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;
@@ -7528,7 +7509,7 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
     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.
@@ -7547,7 +7528,7 @@ error::Error GLES2DecoderImpl::DoCompressedTexImage2D(
   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;
@@ -7733,13 +7714,13 @@ bool GLES2DecoderImpl::ValidateTexImage2D(
         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;
@@ -7768,28 +7749,28 @@ void GLES2DecoderImpl::DoTexImage2D(
     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.
@@ -7798,7 +7779,7 @@ void GLES2DecoderImpl::DoTexImage2D(
 
   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;
   }
@@ -7810,7 +7791,7 @@ void GLES2DecoderImpl::DoTexImage2D(
   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;
@@ -7890,15 +7871,15 @@ void GLES2DecoderImpl::DoCompressedTexSubImage2D(
   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.");
@@ -7910,7 +7891,7 @@ void GLES2DecoderImpl::DoCompressedTexSubImage2D(
         "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.");
@@ -7921,7 +7902,7 @@ void GLES2DecoderImpl::DoCompressedTexSubImage2D(
       "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;
   }
 
@@ -7961,13 +7942,13 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
     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");
   }
@@ -8019,7 +8000,7 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
   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.
@@ -8040,9 +8021,9 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
       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;
     }
@@ -8062,7 +8043,7 @@ void GLES2DecoderImpl::DoCopyTexImage2D(
   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);
   }
 }
@@ -8077,22 +8058,22 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
     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;
@@ -8130,7 +8111,7 @@ void GLES2DecoderImpl::DoCopyTexSubImage2D(
   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;
   }
@@ -8199,15 +8180,15 @@ bool GLES2DecoderImpl::ValidateTexSubImage2D(
     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;
@@ -8222,12 +8203,12 @@ bool GLES2DecoderImpl::ValidateTexSubImage2D(
                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;
@@ -8261,14 +8242,14 @@ error::Error GLES2DecoderImpl::DoTexSubImage2D(
       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;
     }
@@ -8278,7 +8259,7 @@ error::Error GLES2DecoderImpl::DoTexSubImage2D(
     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.
@@ -8289,7 +8270,7 @@ error::Error GLES2DecoderImpl::DoTexSubImage2D(
     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;
 }
 
@@ -9311,23 +9292,22 @@ error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(
   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.");
@@ -9338,10 +9318,10 @@ error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(
     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", ""
@@ -9356,14 +9336,13 @@ 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.");
@@ -9417,9 +9396,8 @@ void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
 
   // 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;
@@ -9439,11 +9417,11 @@ void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
   }
 
   // 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());
@@ -9467,7 +9445,7 @@ void GLES2DecoderImpl::DoTexImageIOSurface2DCHROMIUM(
   }
 
   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
@@ -9524,10 +9502,10 @@ static GLenum ExtractFormatFromStorageFormat(GLenum internalformat) {
 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;
   }
@@ -9538,15 +9516,15 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     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");
@@ -9574,17 +9552,16 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
 
   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.
@@ -9593,7 +9570,7 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
       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);
@@ -9604,17 +9581,18 @@ void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     }
 
     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_,
@@ -9679,16 +9657,16 @@ void GLES2DecoderImpl::DoTexStorage2DEXT(
         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;
@@ -9729,12 +9707,12 @@ void GLES2DecoderImpl::DoTexStorage2DEXT(
     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);
   }
 }
 
@@ -9753,14 +9731,14 @@ error::Error GLES2DecoderImpl::HandleGenMailboxCHROMIUM(
 
 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");
@@ -9772,20 +9750,21 @@ void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum 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;
@@ -9801,13 +9780,12 @@ void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
     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(
@@ -9845,9 +9823,8 @@ void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
 
   // 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;
@@ -9870,9 +9847,9 @@ void GLES2DecoderImpl::DoBindTexImage2DCHROMIUM(
 
   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(
@@ -9888,9 +9865,8 @@ void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
 
   // 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;
@@ -9905,13 +9881,13 @@ void GLES2DecoderImpl::DoReleaseTexImage2DCHROMIUM(
   }
 
   // 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);
 }
 
@@ -9946,7 +9922,7 @@ void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
 
 bool GLES2DecoderImpl::ValidateAsyncTransfer(
     const char* function_name,
-    Texture* info,
+    Texture* texture,
     GLenum target,
     GLint level,
     const void * data) {
@@ -9966,7 +9942,7 @@ bool GLES2DecoderImpl::ValidateAsyncTransfer(
     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;
@@ -10013,13 +9989,13 @@ error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
   }
 
   // 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;
@@ -10039,13 +10015,13 @@ error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
   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 =
@@ -10056,13 +10032,13 @@ error::Error GLES2DecoderImpl::HandleAsyncTexImage2DCHROMIUM(
                                        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;
 }
 
@@ -10097,9 +10073,9 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   }
 
   // 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:
@@ -10108,8 +10084,8 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   // - 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;
@@ -10124,13 +10100,13 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   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,
@@ -10138,7 +10114,7 @@ error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
   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;
 }
 
@@ -10151,14 +10127,14 @@ error::Error GLES2DecoderImpl::HandleWaitAsyncTexImage2DCHROMIUM(
     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;
 }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
index ddab2df..e4dd9cb 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc
@@ -1821,12 +1821,11 @@ TEST_F(GLES2DecoderTest, GenerateMipmapWrongFormatsFails) {
 TEST_F(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
-  Texture* info =
-      manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(info != NULL);
+  Texture* texture = manager->GetTexture(client_texture_id_);
+  ASSERT_TRUE(texture != NULL);
   GLint width = 0;
   GLint height = 0;
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       kSharedMemoryId, kSharedMemoryOffset);
@@ -1848,7 +1847,7 @@ TEST_F(GLES2DecoderTest, GenerateMipmapHandlesOutOfMemory) {
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 2, &width, &height));
 }
 
 TEST_F(GLES2DecoderTest, GenerateMipmapClearsUnclearedTexture) {
@@ -4726,10 +4725,9 @@ TEST_F(GLES2DecoderTest, TexImage2DGLError) {
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
-  Texture* info =
-      manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(info != NULL);
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
+  Texture* texture = manager->GetTexture(client_texture_id_);
+  ASSERT_TRUE(texture != NULL);
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
@@ -4743,7 +4741,7 @@ TEST_F(GLES2DecoderTest, TexImage2DGLError) {
            type, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
 }
 
 TEST_F(GLES2DecoderTest, BufferDataGLError) {
@@ -4777,10 +4775,9 @@ TEST_F(GLES2DecoderTest, CopyTexImage2DGLError) {
   GLint border = 0;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureManager* manager = group().texture_manager();
-  Texture* info =
-      manager->GetTexture(client_texture_id_);
-  ASSERT_TRUE(info != NULL);
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
+  Texture* texture = manager->GetTexture(client_texture_id_);
+  ASSERT_TRUE(texture != NULL);
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
@@ -4793,7 +4790,7 @@ TEST_F(GLES2DecoderTest, CopyTexImage2DGLError) {
   cmd.Init(target, level, internal_format, 0, 0, width, height, border);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
-  EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, level, &width, &height));
 }
 
 TEST_F(GLES2DecoderTest, FramebufferRenderbufferGLError) {
@@ -5309,10 +5306,10 @@ TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test TexSubImage not allowed for ETC1 compressed texture
-  Texture* info = GetTexture(client_texture_id_);
-  ASSERT_TRUE(info != NULL);
+  Texture* texture = GetTexture(client_texture_id_);
+  ASSERT_TRUE(texture != NULL);
   GLenum type, internal_format;
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(kFormat, internal_format);
   TexSubImage2D texsub_cmd;
   texsub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_RGBA, GL_UNSIGNED_BYTE,
@@ -5419,9 +5416,9 @@ TEST_F(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  Texture* info = GetTexture(kNewClientId);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_EXTERNAL_OES);
+  Texture* texture = GetTexture(kNewClientId);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
@@ -5469,12 +5466,12 @@ TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
       true);   // bind generates resource
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
@@ -5527,12 +5524,12 @@ TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
@@ -5567,12 +5564,12 @@ TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
@@ -5660,9 +5657,9 @@ TEST_F(GLES2DecoderManualInitTest, CreateStreamTextureCHROMIUM) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(kObjectId, *result);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->IsStreamTexture());
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->IsStreamTexture());
 }
 
 TEST_F(GLES2DecoderManualInitTest, CreateStreamTextureCHROMIUMBadId) {
@@ -5717,8 +5714,8 @@ TEST_F(GLES2DecoderManualInitTest, CreateStreamTextureCHROMIUMAlreadySet) {
       false,   // request stencil
       true);   // bind generates resource
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   CreateStreamTextureCHROMIUM cmd;
   cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
@@ -5738,19 +5735,19 @@ TEST_F(GLES2DecoderManualInitTest, BindStreamTextureCHROMIUM) {
       true);   // bind generates resource
 
   StrictMock<MockStreamTextureManager> manager;
-  StrictMock<MockStreamTexture> texture;
+  StrictMock<MockStreamTexture> stream_texture;
   decoder_->SetStreamTextureManager(&manager);
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kServiceTextureId))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(manager, LookupStreamTexture(kServiceTextureId))
-      .WillOnce(Return(&texture))
+      .WillOnce(Return(&stream_texture))
       .RetiresOnSaturation();
-  EXPECT_CALL(texture, Update())
+  EXPECT_CALL(stream_texture, Update())
       .Times(1)
       .RetiresOnSaturation();
 
@@ -5771,8 +5768,8 @@ TEST_F(GLES2DecoderManualInitTest, BindStreamTextureCHROMIUMInvalid) {
       false,   // request stencil
       true);   // bind generates resource
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_2D, client_texture_id_);
@@ -5799,8 +5796,8 @@ TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUM) {
   StrictMock<MockStreamTextureManager> manager;
   decoder_->SetStreamTextureManager(&manager);
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   EXPECT_CALL(manager, DestroyStreamTexture(kServiceTextureId))
       .Times(1)
@@ -5810,8 +5807,8 @@ TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUM) {
   cmd.Init(client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_FALSE(info->IsStreamTexture());
-  EXPECT_EQ(0U, info->target());
+  EXPECT_FALSE(texture->IsStreamTexture());
+  EXPECT_EQ(0U, texture->target());
 }
 
 TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUMInvalid) {
@@ -5825,8 +5822,8 @@ TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUMInvalid) {
       false,   // request stencil
       true);   // bind generates resource
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(false);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(false);
 
   DestroyStreamTextureCHROMIUM cmd;
   cmd.Init(client_texture_id_);
@@ -5867,8 +5864,8 @@ TEST_F(GLES2DecoderManualInitTest, StreamTextureCHROMIUMNullMgr) {
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
   GetGLError(); // ignore internal error
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   DestroyStreamTextureCHROMIUM cmd2;
   cmd2.Init(client_texture_id_);
@@ -5889,13 +5886,13 @@ TEST_F(GLES2DecoderManualInitTest, ReCreateStreamTextureCHROMIUM) {
       true);   // bind generates resource
 
   StrictMock<MockStreamTextureManager> manager;
-  StrictMock<MockStreamTexture> texture;
+  StrictMock<MockStreamTexture> stream_texture;
   decoder_->SetStreamTextureManager(&manager);
 
   EXPECT_CALL(manager, LookupStreamTexture(kServiceTextureId))
-      .WillOnce(Return(&texture))
+      .WillOnce(Return(&stream_texture))
       .RetiresOnSaturation();
-  EXPECT_CALL(texture, Update())
+  EXPECT_CALL(stream_texture, Update())
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(manager, DestroyStreamTexture(kServiceTextureId))
@@ -5906,8 +5903,8 @@ TEST_F(GLES2DecoderManualInitTest, ReCreateStreamTextureCHROMIUM) {
       .WillOnce(Return(kObjectId))
       .RetiresOnSaturation();
 
-  Texture* info = GetTexture(client_texture_id_);
-  info->SetStreamTexture(true);
+  Texture* texture = GetTexture(client_texture_id_);
+  texture->SetStreamTexture(true);
 
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -5916,13 +5913,13 @@ TEST_F(GLES2DecoderManualInitTest, ReCreateStreamTextureCHROMIUM) {
   cmd.Init(client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_FALSE(info->IsStreamTexture());
+  EXPECT_FALSE(texture->IsStreamTexture());
 
   CreateStreamTextureCHROMIUM cmd2;
   cmd2.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  EXPECT_TRUE(info->IsStreamTexture());
+  EXPECT_TRUE(texture->IsStreamTexture());
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
@@ -5942,9 +5939,9 @@ TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
-  Texture* info = GetTexture(kNewClientId);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_RECTANGLE_ARB);
+  Texture* texture = GetTexture(kNewClientId);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
@@ -5994,12 +5991,12 @@ TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_RECTANGLE_ARB);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
@@ -6053,12 +6050,12 @@ TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_RECTANGLE_ARB);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
@@ -6094,12 +6091,12 @@ TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->target() == GL_TEXTURE_RECTANGLE_ARB);
-  EXPECT_TRUE(info->min_filter() == GL_LINEAR);
-  EXPECT_TRUE(info->wrap_s() == GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(info->wrap_t() == GL_CLAMP_TO_EDGE);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
+  EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
+  EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
+  EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
@@ -6425,8 +6422,7 @@ TEST_F(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TextureManager* manager = group().texture_manager();
-  Texture* info =
-      manager->GetTexture(client_texture_id_);
+  Texture* texture = manager->GetTexture(client_texture_id_);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
@@ -6441,7 +6437,7 @@ TEST_F(GLES2DecoderTest, CopyTexImage2DMarksTextureAsCleared) {
   cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
-  EXPECT_TRUE(info->SafeToRenderFrom());
+  EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_F(GLES2DecoderTest, CopyTexSubImage2DClearsUnclearedTexture) {
@@ -6487,9 +6483,8 @@ TEST_F(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
            8, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   TextureManager* manager = group().texture_manager();
-  Texture* info =
-      manager->GetTexture(client_texture_id_);
-  EXPECT_TRUE(info->SafeToRenderFrom());
+  Texture* texture = manager->GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
 }
 
 TEST_F(GLES2DecoderWithShaderTest, UnClearedAttachmentsGetClearedOnClear) {
@@ -7261,9 +7256,8 @@ TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
-  Texture* info =
-      group().texture_manager()->GetTexture(client_texture_id_);
-  EXPECT_EQ(kServiceTextureId, info->service_id());
+  Texture* texture = group().texture_manager()->GetTexture(client_texture_id_);
+  EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   // Assigns and binds new service side texture ID.
   EXPECT_CALL(*gl_, GenTextures(1, _))
@@ -7283,22 +7277,22 @@ TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
   GLenum type;
   GLenum internal_format;
 
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   EXPECT_EQ(0, width);
   EXPECT_EQ(0, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
 
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
   EXPECT_EQ(0, width);
   EXPECT_EQ(0, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
 
   // Service ID has changed.
-  EXPECT_EQ(kNewServiceId, info->service_id());
+  EXPECT_EQ(kNewServiceId, texture->service_id());
 
   // Assigns and binds original service size texture ID.
   EXPECT_CALL(*gl_, DeleteTextures(1, _))
@@ -7308,27 +7302,51 @@ TEST_F(GLES2DecoderTest, ProduceAndConsumeTextureCHROMIUM) {
       .Times(1)
       .RetiresOnSaturation();
 
+  // TextureManager::Restore will set TexParameters.
+  EXPECT_CALL(*gl_, TexParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, TexParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, TexParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*gl_, TexParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT))
+      .Times(1)
+      .RetiresOnSaturation();
+  #if 0
+  EXPECT_CALL(*gl_, TexParameteri(
+      GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE, GL_NONE))
+      .Times(1)
+      .RetiresOnSaturation();
+  #endif
+
   ConsumeTextureCHROMIUM consume_cmd;
   consume_cmd.Init(GL_TEXTURE_2D, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(consume_cmd));
 
   // Texture is redefined.
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
 
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
   EXPECT_EQ(2, width);
   EXPECT_EQ(4, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 1, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
 
   // Service ID is restored.
-  EXPECT_EQ(kServiceTextureId, info->service_id());
+  EXPECT_EQ(kServiceTextureId, texture->service_id());
 }
 
 
@@ -7840,9 +7858,8 @@ TEST_F(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
-  Texture* info =
-      group().texture_manager()->GetTexture(client_texture_id_);
-  EXPECT_EQ(kServiceTextureId, info->service_id());
+  Texture* texture = group().texture_manager()->GetTexture(client_texture_id_);
+  EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0), 1);
   EXPECT_FALSE(group().image_manager()->LookupImage(1) == NULL);
@@ -7852,37 +7869,36 @@ TEST_F(GLES2DecoderTest, BindTexImage2DCHROMIUM) {
   GLenum type;
   GLenum internal_format;
 
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
-  EXPECT_TRUE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 
   // Bind image to texture.
   BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
   bind_tex_image_2d_cmd.Init(GL_TEXTURE_2D, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   // Image should now be set.
-  EXPECT_FALSE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 
   // Define new texture image.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   // Image should no longer be set.
-  EXPECT_TRUE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 }
 
 TEST_F(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
-  Texture* info =
-      group().texture_manager()->GetTexture(client_texture_id_);
-  EXPECT_EQ(kServiceTextureId, info->service_id());
+  Texture* texture = group().texture_manager()->GetTexture(client_texture_id_);
+  EXPECT_EQ(kServiceTextureId, texture->service_id());
 
   group().image_manager()->AddImage(gfx::GLImage::CreateGLImage(0), 1);
   EXPECT_FALSE(group().image_manager()->LookupImage(1) == NULL);
@@ -7892,29 +7908,29 @@ TEST_F(GLES2DecoderTest, ReleaseTexImage2DCHROMIUM) {
   GLenum type;
   GLenum internal_format;
 
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   EXPECT_EQ(3, width);
   EXPECT_EQ(1, height);
-  EXPECT_TRUE(info->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
+  EXPECT_TRUE(texture->GetLevelType(GL_TEXTURE_2D, 0, &type, &internal_format));
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), internal_format);
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
-  EXPECT_TRUE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 
   // Bind image to texture.
   BindTexImage2DCHROMIUM bind_tex_image_2d_cmd;
   bind_tex_image_2d_cmd.Init(GL_TEXTURE_2D, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(bind_tex_image_2d_cmd));
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   // Image should now be set.
-  EXPECT_FALSE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 
   // Release image from texture.
   ReleaseTexImage2DCHROMIUM release_tex_image_2d_cmd;
   release_tex_image_2d_cmd.Init(GL_TEXTURE_2D, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(release_tex_image_2d_cmd));
-  EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   // Image should no longer be set.
-  EXPECT_TRUE(info->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 0) == NULL);
 }
 
 TEST_F(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
@@ -7928,9 +7944,9 @@ TEST_F(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
       false,   // request stencil
       true);   // bind generates resource
 
-  Texture* info = GetTexture(client_texture_id_);
-  EXPECT_TRUE(info != NULL);
-  EXPECT_TRUE(info->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
+  Texture* texture = GetTexture(client_texture_id_);
+  EXPECT_TRUE(texture != NULL);
+  EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
 
   DoBindTexture(
       GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
@@ -7948,7 +7964,7 @@ TEST_F(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
-  EXPECT_TRUE(info->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
+  EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
 
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_POOL_CHROMIUM,
@@ -7966,7 +7982,7 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
 
   // Set up the texture.
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-  Texture* info = GetTexture(client_texture_id_);
+  Texture* texture = GetTexture(client_texture_id_);
 
   // Set a mock Async delegate
   // Async state is returned as a scoped_ptr, but we keep a raw copy.
@@ -7988,7 +8004,7 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
       {GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE};
 
   // No transfer state exists initially.
-  EXPECT_FALSE(info->GetAsyncTransferState());
+  EXPECT_FALSE(texture->GetAsyncTransferState());
 
   // AsyncTexImage2D
   {
@@ -8002,27 +8018,27 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // Command succeeds.
     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
     // The texture is safe but the level has not been defined yet.
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
     GLsizei width, height;
-    EXPECT_FALSE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+    EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
   }
   {
     // Async redefinitions are not allowed!
     // Command fails.
     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
   }
 
   // Lazy binding/defining of the async transfer
   {
     // We the code should check that the transfer is done,
-    // call bind transfer on it, and update the texture info.
+    // call bind transfer on it, and update the texture texture.
     InSequence scoped_in_sequence;
     EXPECT_CALL(*state, TransferIsInProgress())
         .WillOnce(Return(false))
@@ -8037,16 +8053,16 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     EXPECT_TRUE(texture_dirty);
     EXPECT_FALSE(framebuffer_dirty);
     // Texture is safe, and has the right size etc.
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
     GLsizei width, height;
-    EXPECT_TRUE(info->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+    EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
     EXPECT_EQ(width, 8);
     EXPECT_EQ(height, 8);
   }
 
   // AsyncTexSubImage2D
-  info->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
-  info->SetImmutable(false);
+  texture->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
+  texture->SetImmutable(false);
   {
     // Create transfer state since it doesn't exist.
     EXPECT_CALL(*delegate, CreateRawPixelTransferState(kServiceTextureId))
@@ -8058,9 +8074,9 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // Command succeeds.
     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
   }
   {
     // No transfer is in progress.
@@ -8073,9 +8089,9 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // Command succeeds.
     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
   }
   {
     // A transfer is still in progress!
@@ -8085,9 +8101,9 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // No async call, command fails.
     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
-    EXPECT_TRUE(info->SafeToRenderFrom());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
+    EXPECT_TRUE(texture->SafeToRenderFrom());
   }
 
   // WaitAsyncTexImage2D
@@ -8096,12 +8112,12 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // asynchronously and AsyncTexSubImage2D does not involved binding.
     EXPECT_CALL(*gl_, GenTextures(1, _))
         .WillOnce(SetArgumentPointee<1>(kServiceTextureId));
-    info->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
+    texture->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
     DoDeleteTexture(client_texture_id_, kServiceTextureId);
     DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
-    info = GetTexture(client_texture_id_);
-    info->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
-    info->SetImmutable(false);
+    texture = GetTexture(client_texture_id_);
+    texture->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
+    texture->SetImmutable(false);
     // Create transfer state since it doesn't exist.
     EXPECT_CALL(*delegate, CreateRawPixelTransferState(kServiceTextureId))
         .WillOnce(Return(
@@ -8112,8 +8128,8 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
     // Start async transfer.
     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
-    EXPECT_TRUE(info->GetAsyncTransferState());
-    EXPECT_TRUE(info->IsImmutable());
+    EXPECT_TRUE(texture->GetAsyncTransferState());
+    EXPECT_TRUE(texture->IsImmutable());
     // Wait for completion.
     EXPECT_CALL(*delegate, WaitForTransferCompletion(state));
     EXPECT_CALL(*state, TransferIsInProgress())
@@ -8130,7 +8146,7 @@ TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
   }
 
   decoder_->SetAsyncPixelTransferDelegate(NULL);
-  info->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
+  texture->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
 }
 
 namespace {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 14a73e8..c10a61b 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -390,7 +390,7 @@ TEST_F(GLES2DecoderTest2, StencilOpSeparateValidArgs) {
 
 TEST_F(GLES2DecoderTest2, TexParameterfValidArgs) {
   EXPECT_CALL(
-      *gl_, TexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
+      *gl_, TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
   SpecializedSetup<cmds::TexParameterf, 0>(true);
   cmds::TexParameterf cmd;
   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -399,7 +399,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfValidArgs) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -408,7 +408,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -417,7 +417,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs0_1) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, TexParameterf(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterf, 0>(false);
   cmds::TexParameterf cmd;
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_NEAREST);
@@ -426,22 +426,22 @@ TEST_F(GLES2DecoderTest2, TexParameterfInvalidArgs1_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvValidArgs) {
-  EXPECT_CALL(
-      *gl_, TexParameterfv(
-          GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-          reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::TexParameterfv, 0>(true);
   cmds::TexParameterfv cmd;
   cmd.Init(
       GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   GetSharedMemoryAs<GLfloat*>()[0] = GL_NEAREST;
+  EXPECT_CALL(
+      *gl_, TexParameteri(
+          GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+          *reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
   cmd.Init(
@@ -453,7 +453,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
   cmd.Init(
@@ -465,7 +465,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs0_1) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
   cmd.Init(
@@ -477,7 +477,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs1_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
@@ -486,7 +486,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfv, 0>(false);
   cmds::TexParameterfv cmd;
   cmd.Init(
@@ -499,13 +499,13 @@ TEST_F(GLES2DecoderTest2, TexParameterfvInvalidArgs2_1) {
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      TexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-          reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::TexParameterfvImmediate, 0>(true);
   GLfloat temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, *reinterpret_cast<
+          GLfloat*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -514,7 +514,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateValidArgs) {
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
   GLfloat temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
@@ -526,7 +526,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_0) {
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
   GLfloat temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
@@ -538,7 +538,7 @@ TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs0_1) {
 TEST_F(GLES2DecoderTest2, TexParameterfvImmediateInvalidArgs1_0) {
   cmds::TexParameterfvImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterfvImmediate>();
-  EXPECT_CALL(*gl_, TexParameterfv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterfvImmediate, 0>(false);
   GLfloat temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
@@ -585,22 +585,22 @@ TEST_F(GLES2DecoderTest2, TexParameteriInvalidArgs1_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivValidArgs) {
-  EXPECT_CALL(
-      *gl_, TexParameteriv(
-          GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, reinterpret_cast<const GLint*>(
-              shared_memory_address_)));
   SpecializedSetup<cmds::TexParameteriv, 0>(true);
   cmds::TexParameteriv cmd;
   cmd.Init(
       GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, shared_memory_id_,
       shared_memory_offset_);
   GetSharedMemoryAs<GLint*>()[0] = GL_NEAREST;
+  EXPECT_CALL(
+      *gl_, TexParameteri(
+          GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, *reinterpret_cast<const GLint*>(
+              shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
   cmd.Init(
@@ -612,7 +612,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
   cmd.Init(
@@ -624,7 +624,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs0_1) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
   cmd.Init(
@@ -636,7 +636,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs1_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, kInvalidSharedMemoryId, 0);
@@ -645,7 +645,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_0) {
 }
 
 TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameteriv, 0>(false);
   cmds::TexParameteriv cmd;
   cmd.Init(
@@ -658,13 +658,13 @@ TEST_F(GLES2DecoderTest2, TexParameterivInvalidArgs2_1) {
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      TexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
-          reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::TexParameterivImmediate, 0>(true);
   GLint temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, *reinterpret_cast<
+          GLint*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -673,7 +673,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateValidArgs) {
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
   GLint temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, &temp[0]);
@@ -685,7 +685,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_0) {
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
   GLint temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, &temp[0]);
@@ -697,7 +697,7 @@ TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs0_1) {
 TEST_F(GLES2DecoderTest2, TexParameterivImmediateInvalidArgs1_0) {
   cmds::TexParameterivImmediate& cmd =
       *GetImmediateAs<cmds::TexParameterivImmediate>();
-  EXPECT_CALL(*gl_, TexParameteriv(_, _, _)).Times(0);
+  EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(0);
   SpecializedSetup<cmds::TexParameterivImmediate, 0>(false);
   GLint temp[1] = { GL_NEAREST, };
   cmd.Init(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &temp[0]);
@@ -1505,13 +1505,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib1fValidArgs) {
 }
 
 TEST_F(GLES2DecoderTest2, VertexAttrib1fvValidArgs) {
-  EXPECT_CALL(
-      *gl_, VertexAttrib1fv(
-          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::VertexAttrib1fv, 0>(true);
   cmds::VertexAttrib1fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   GetSharedMemoryAs<GLfloat*>()[0] = 0;
+  EXPECT_CALL(
+      *gl_, VertexAttrib1fv(
+          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1537,13 +1537,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib1fvInvalidArgs1_1) {
 TEST_F(GLES2DecoderTest2, VertexAttrib1fvImmediateValidArgs) {
   cmds::VertexAttrib1fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib1fvImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      VertexAttrib1fv(1,
-          reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::VertexAttrib1fvImmediate, 0>(true);
   GLfloat temp[1] = { 0, };
   cmd.Init(1, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      VertexAttrib1fv(1, reinterpret_cast<
+          GLfloat*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -1559,13 +1559,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib2fValidArgs) {
 }
 
 TEST_F(GLES2DecoderTest2, VertexAttrib2fvValidArgs) {
-  EXPECT_CALL(
-      *gl_, VertexAttrib2fv(
-          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::VertexAttrib2fv, 0>(true);
   cmds::VertexAttrib2fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   GetSharedMemoryAs<GLfloat*>()[0] = 0;
+  EXPECT_CALL(
+      *gl_, VertexAttrib2fv(
+          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1591,13 +1591,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib2fvInvalidArgs1_1) {
 TEST_F(GLES2DecoderTest2, VertexAttrib2fvImmediateValidArgs) {
   cmds::VertexAttrib2fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib2fvImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      VertexAttrib2fv(1,
-          reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::VertexAttrib2fvImmediate, 0>(true);
   GLfloat temp[2] = { 0, };
   cmd.Init(1, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      VertexAttrib2fv(1, reinterpret_cast<
+          GLfloat*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -1613,13 +1613,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib3fValidArgs) {
 }
 
 TEST_F(GLES2DecoderTest2, VertexAttrib3fvValidArgs) {
-  EXPECT_CALL(
-      *gl_, VertexAttrib3fv(
-          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::VertexAttrib3fv, 0>(true);
   cmds::VertexAttrib3fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   GetSharedMemoryAs<GLfloat*>()[0] = 0;
+  EXPECT_CALL(
+      *gl_, VertexAttrib3fv(
+          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1645,13 +1645,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib3fvInvalidArgs1_1) {
 TEST_F(GLES2DecoderTest2, VertexAttrib3fvImmediateValidArgs) {
   cmds::VertexAttrib3fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib3fvImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      VertexAttrib3fv(1,
-          reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::VertexAttrib3fvImmediate, 0>(true);
   GLfloat temp[3] = { 0, };
   cmd.Init(1, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      VertexAttrib3fv(1, reinterpret_cast<
+          GLfloat*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ -1667,13 +1667,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib4fValidArgs) {
 }
 
 TEST_F(GLES2DecoderTest2, VertexAttrib4fvValidArgs) {
-  EXPECT_CALL(
-      *gl_, VertexAttrib4fv(
-          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<cmds::VertexAttrib4fv, 0>(true);
   cmds::VertexAttrib4fv cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   GetSharedMemoryAs<GLfloat*>()[0] = 0;
+  EXPECT_CALL(
+      *gl_, VertexAttrib4fv(
+          1, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
@@ -1699,13 +1699,13 @@ TEST_F(GLES2DecoderTest2, VertexAttrib4fvInvalidArgs1_1) {
 TEST_F(GLES2DecoderTest2, VertexAttrib4fvImmediateValidArgs) {
   cmds::VertexAttrib4fvImmediate& cmd =
       *GetImmediateAs<cmds::VertexAttrib4fvImmediate>();
-  EXPECT_CALL(
-      *gl_,
-      VertexAttrib4fv(1,
-          reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<cmds::VertexAttrib4fvImmediate, 0>(true);
   GLfloat temp[4] = { 0, };
   cmd.Init(1, &temp[0]);
+  EXPECT_CALL(
+      *gl_,
+      VertexAttrib4fv(1, reinterpret_cast<
+          GLfloat*>(ImmediateDataAddress(&cmd))));
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
diff --git a/gpu/command_buffer/service/test_helper.cc b/gpu/command_buffer/service/test_helper.cc
index 2cbef21..71a5c39 100644
--- a/gpu/command_buffer/service/test_helper.cc
+++ b/gpu/command_buffer/service/test_helper.cc
@@ -14,6 +14,7 @@
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/program_manager.h"
+#include "gpu/command_buffer/service/texture_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
@@ -517,6 +518,28 @@ void TestHelper::DoBufferData(
   manager->DoBufferData(decoder, buffer, size, usage, data);
 }
 
+void TestHelper::SetTexParameterWithExpectations(
+    ::gfx::MockGLInterface* gl, MockGLES2Decoder* decoder,
+    TextureManager* manager, Texture* texture,
+    GLenum pname, GLint value, GLenum error) {
+  if (error == GL_NO_ERROR) {
+    if (pname != GL_TEXTURE_POOL_CHROMIUM) {
+      EXPECT_CALL(*gl, TexParameteri(texture->target(), pname, value))
+          .Times(1)
+          .RetiresOnSaturation();
+    }
+  } else if (error == GL_INVALID_ENUM) {
+    EXPECT_CALL(*decoder, SetGLErrorInvalidEnum(_, value, _))
+        .Times(1)
+        .RetiresOnSaturation();
+  } else {
+    EXPECT_CALL(*decoder, SetGLErrorInvalidParam(error, _, _, _))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+  manager->SetParameter("", decoder, texture, pname, value);
+}
+
 }  // namespace gles2
 }  // namespace gpu
 
diff --git a/gpu/command_buffer/service/test_helper.h b/gpu/command_buffer/service/test_helper.h
index a97cf74..dbe050e 100644
--- a/gpu/command_buffer/service/test_helper.h
+++ b/gpu/command_buffer/service/test_helper.h
@@ -14,6 +14,8 @@ struct DisallowedFeatures;
 class Buffer;
 class BufferManager;
 class MockGLES2Decoder;
+class Texture;
+class TextureManager;
 
 class TestHelper {
  public:
@@ -94,6 +96,11 @@ class TestHelper {
       BufferManager* manager, Buffer* buffer, GLsizeiptr size, GLenum usage,
       const GLvoid* data, GLenum error);
 
+  static void SetTexParameterWithExpectations(
+      ::gfx::MockGLInterface* gl, MockGLES2Decoder* decoder,
+      TextureManager* manager, Texture* texture,
+      GLenum pname, GLint value, GLenum error);
+
  private:
   static void SetupTextureInitializationExpectations(
        ::gfx::MockGLInterface* gl, GLenum target);
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index 104cadd9..94d623b 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -60,11 +60,11 @@ static size_t FaceIndexToGLTarget(size_t index) {
 }
 
 TextureManager::~TextureManager() {
-  DCHECK(texture_infos_.empty());
+  DCHECK(textures_.empty());
 
   // If this triggers, that means something is keeping a reference to
   // a Texture belonging to this.
-  CHECK_EQ(texture_info_count_, 0u);
+  CHECK_EQ(texture_count_, 0u);
 
   DCHECK_EQ(0, num_unrenderable_textures_);
   DCHECK_EQ(0, num_unsafe_textures_);
@@ -73,7 +73,7 @@ TextureManager::~TextureManager() {
 
 void TextureManager::Destroy(bool have_context) {
   have_context_ = have_context;
-  texture_infos_.clear();
+  textures_.clear();
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     default_textures_[ii] = NULL;
   }
@@ -86,8 +86,7 @@ void TextureManager::Destroy(bool have_context) {
   DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
 }
 
-Texture::Texture(TextureManager* manager,
-                                         GLuint service_id)
+Texture::Texture(TextureManager* manager, GLuint service_id)
     : manager_(manager),
       service_id_(service_id),
       deleted_(false),
@@ -159,8 +158,7 @@ Texture::LevelInfo::LevelInfo(const LevelInfo& rhs)
 Texture::LevelInfo::~LevelInfo() {
 }
 
-bool Texture::CanRender(
-    const FeatureInfo* feature_info) const {
+bool Texture::CanRender(const FeatureInfo* feature_info) const {
   if (target_ == 0) {
     return false;
   }
@@ -717,7 +715,7 @@ TextureManager::TextureManager(
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
-      texture_info_count_(0),
+      texture_count_(0),
       have_context_(true) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
@@ -781,7 +779,7 @@ scoped_refptr<Texture>
   // we need to manually manipulate some of the their bookkeeping.
   ++num_unrenderable_textures_;
   scoped_refptr<Texture> default_texture(new Texture(this, ids[1]));
-  SetInfoTarget(default_texture, target);
+  SetTarget(default_texture, target);
   if (needs_faces) {
     for (int ii = 0; ii < GLES2Util::kNumFaces; ++ii) {
       SetLevelInfo(
@@ -823,79 +821,78 @@ bool TextureManager::ValidForTarget(
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
-void TextureManager::SetInfoTarget(
-    Texture* info, GLenum target) {
-  DCHECK(info);
-  if (!info->CanRender(feature_info_)) {
+void TextureManager::SetTarget(Texture* texture, GLenum target) {
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  info->SetTarget(target, MaxLevelsForTarget(target));
-  if (!info->CanRender(feature_info_)) {
+  texture->SetTarget(target, MaxLevelsForTarget(target));
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
 }
 
-void TextureManager::SetLevelCleared(Texture* info,
+void TextureManager::SetLevelCleared(Texture* texture,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
-  DCHECK(info);
-  if (!info->SafeToRenderFrom()) {
+  DCHECK(texture);
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  num_uncleared_mips_ -= info->num_uncleared_mips();
+  num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  info->SetLevelCleared(target, level, cleared);
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  if (!info->SafeToRenderFrom()) {
+  texture->SetLevelCleared(target, level, cleared);
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 bool TextureManager::ClearRenderableLevels(
-    GLES2Decoder* decoder,Texture* info) {
-  DCHECK(info);
-  if (info->SafeToRenderFrom()) {
+    GLES2Decoder* decoder,Texture* texture) {
+  DCHECK(texture);
+  if (texture->SafeToRenderFrom()) {
     return true;
   }
   DCHECK_NE(0, num_unsafe_textures_);
   --num_unsafe_textures_;
-  num_uncleared_mips_ -= info->num_uncleared_mips();
+  num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  bool result = info->ClearRenderableLevels(decoder);
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  if (!info->SafeToRenderFrom()) {
+  bool result = texture->ClearRenderableLevels(decoder);
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 bool TextureManager::ClearTextureLevel(
-    GLES2Decoder* decoder,Texture* info,
+    GLES2Decoder* decoder,Texture* texture,
     GLenum target, GLint level) {
-  DCHECK(info);
-  if (info->num_uncleared_mips() == 0) {
+  DCHECK(texture);
+  if (texture->num_uncleared_mips() == 0) {
     return true;
   }
-  num_uncleared_mips_ -= info->num_uncleared_mips();
+  num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  bool result = info->ClearLevel(decoder, target, level);
-  info->UpdateCleared();
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  if (!info->SafeToRenderFrom()) {
+  bool result = texture->ClearLevel(decoder, target, level);
+  texture->UpdateCleared();
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 void TextureManager::SetLevelInfo(
-    Texture* info,
+    Texture* texture,
     GLenum target,
     GLint level,
     GLenum internal_format,
@@ -906,46 +903,47 @@ void TextureManager::SetLevelInfo(
     GLenum format,
     GLenum type,
     bool cleared) {
-  DCHECK(info);
-  if (!info->CanRender(feature_info_)) {
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  num_uncleared_mips_ -= info->num_uncleared_mips();
+  num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
 
-  GetMemTracker(info->pool_)->TrackMemFree(info->estimated_size());
-  info->SetLevelInfo(
+  GetMemTracker(texture->pool_)->TrackMemFree(texture->estimated_size());
+  texture->SetLevelInfo(
       feature_info_, target, level, internal_format, width, height, depth,
       border, format, type, cleared);
-  GetMemTracker(info->pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(texture->pool_)->TrackMemAlloc(texture->estimated_size());
 
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  if (!info->CanRender(feature_info_)) {
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
-TextureDefinition* TextureManager::Save(Texture* info) {
-  DCHECK(info->owned_);
+TextureDefinition* TextureManager::Save(Texture* texture) {
+  DCHECK(texture->owned_);
 
-  if (info->IsAttachedToFramebuffer())
+  if (texture->IsAttachedToFramebuffer())
     return NULL;
 
-  TextureDefinition::LevelInfos level_infos(info->level_infos_.size());
+  TextureDefinition::LevelInfos level_infos(texture->level_infos_.size());
   for (size_t face = 0; face < level_infos.size(); ++face) {
-    GLenum target = info->target() == GL_TEXTURE_2D ?
+    GLenum target = texture->target() == GL_TEXTURE_2D ?
         GL_TEXTURE_2D : FaceIndexToGLTarget(face);
-    for (size_t level = 0; level < info->level_infos_[face].size(); ++level) {
+    for (size_t level = 0; level < texture->level_infos_[face].size();
+         ++level) {
       const Texture::LevelInfo& level_info =
-          info->level_infos_[face][level];
+          texture->level_infos_[face][level];
       level_infos[face].push_back(
           TextureDefinition::LevelInfo(target,
                                        level_info.internal_format,
@@ -957,7 +955,7 @@ TextureDefinition* TextureManager::Save(Texture* info) {
                                        level_info.type,
                                        level_info.cleared));
 
-      SetLevelInfo(info,
+      SetLevelInfo(texture,
                    target,
                    level,
                    GL_RGBA,
@@ -971,50 +969,54 @@ TextureDefinition* TextureManager::Save(Texture* info) {
     }
   }
 
-  GLuint old_service_id = info->service_id();
-  bool immutable = info->IsImmutable();
+  GLuint old_service_id = texture->service_id();
+  bool immutable = texture->IsImmutable();
 
   GLuint new_service_id = 0;
   glGenTextures(1, &new_service_id);
-  info->SetServiceId(new_service_id);
-  info->SetImmutable(false);
+  texture->SetServiceId(new_service_id);
+  texture->SetImmutable(false);
 
-  return new TextureDefinition(info->target(),
+  return new TextureDefinition(texture->target(),
                                old_service_id,
-                               info->min_filter(),
-                               info->mag_filter(),
-                               info->wrap_s(),
-                               info->wrap_t(),
-                               info->usage(),
+                               texture->min_filter(),
+                               texture->mag_filter(),
+                               texture->wrap_s(),
+                               texture->wrap_t(),
+                               texture->usage(),
                                immutable,
                                level_infos);
 }
 
-bool TextureManager::Restore(Texture* info,
-                             TextureDefinition* definition) {
-  DCHECK(info->owned_);
+bool TextureManager::Restore(
+    const char* function_name,
+    GLES2Decoder* decoder,
+    Texture* texture,
+    TextureDefinition* definition) {
+  DCHECK(texture->owned_);
 
   scoped_ptr<TextureDefinition> scoped_definition(definition);
 
-  if (info->IsAttachedToFramebuffer())
+  if (texture->IsAttachedToFramebuffer())
     return false;
 
-  if (info->target() != definition->target())
+  if (texture->target() != definition->target())
     return false;
 
-  if (info->level_infos_.size() != definition->level_infos().size())
+  if (texture->level_infos_.size() != definition->level_infos().size())
     return false;
 
-  if (info->level_infos_[0].size() != definition->level_infos()[0].size())
+  if (texture->level_infos_[0].size() != definition->level_infos()[0].size())
     return false;
 
-  for (size_t face = 0; face < info->level_infos_.size(); ++face) {
-    GLenum target = info->target() == GL_TEXTURE_2D ?
+  for (size_t face = 0; face < texture->level_infos_.size(); ++face) {
+    GLenum target = texture->target() == GL_TEXTURE_2D ?
         GL_TEXTURE_2D : FaceIndexToGLTarget(face);
-    for (size_t level = 0; level < info->level_infos_[face].size(); ++level) {
+    for (size_t level = 0; level < texture->level_infos_[face].size();
+         ++level) {
       const TextureDefinition::LevelInfo& level_info =
           definition->level_infos()[face][level];
-      SetLevelInfo(info,
+      SetLevelInfo(texture,
                    target,
                    level,
                    level_info.internal_format,
@@ -1028,61 +1030,86 @@ bool TextureManager::Restore(Texture* info,
     }
   }
 
-  GLuint old_service_id = info->service_id();
+  GLuint old_service_id = texture->service_id();
   glDeleteTextures(1, &old_service_id);
-  info->SetServiceId(definition->ReleaseServiceId());
-  info->SetImmutable(definition->immutable());
-  SetParameter(info, GL_TEXTURE_MIN_FILTER, definition->min_filter());
-  SetParameter(info, GL_TEXTURE_MAG_FILTER, definition->mag_filter());
-  SetParameter(info, GL_TEXTURE_WRAP_S, definition->wrap_s());
-  SetParameter(info, GL_TEXTURE_WRAP_T, definition->wrap_t());
-  SetParameter(info, GL_TEXTURE_USAGE_ANGLE, definition->usage());
+  texture->SetServiceId(definition->ReleaseServiceId());
+  glBindTexture(texture->target(), texture->service_id());
+  texture->SetImmutable(definition->immutable());
+  SetParameter(function_name, decoder, texture, GL_TEXTURE_MIN_FILTER,
+               definition->min_filter());
+  SetParameter(function_name, decoder, texture, GL_TEXTURE_MAG_FILTER,
+               definition->mag_filter());
+  SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_S,
+               definition->wrap_s());
+  SetParameter(function_name, decoder, texture, GL_TEXTURE_WRAP_T,
+               definition->wrap_t());
+  if (feature_info_->validators()->texture_parameter.IsValid(
+      GL_TEXTURE_USAGE_ANGLE)) {
+    SetParameter(function_name, decoder, texture, GL_TEXTURE_USAGE_ANGLE,
+                 definition->usage());
+  }
 
   return true;
 }
 
-GLenum TextureManager::SetParameter(
-    Texture* info, GLenum pname, GLint param) {
-  DCHECK(info);
-  if (!info->CanRender(feature_info_)) {
+void TextureManager::SetParameter(
+    const char* function_name, GLES2Decoder* decoder,
+    Texture* texture, GLenum pname, GLint param) {
+  DCHECK(decoder);
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  GLenum result = info->SetParameter(feature_info_, pname, param);
-  if (!info->CanRender(feature_info_)) {
+  GLenum result = texture->SetParameter(feature_info_, pname, param);
+  if (result != GL_NO_ERROR) {
+    if (result == GL_INVALID_ENUM) {
+      decoder->SetGLErrorInvalidEnum(function_name, param, "param");
+    } else {
+      decoder->SetGLErrorInvalidParam(
+          result, function_name, pname, static_cast<GLint>(param));
+    }
+  } else {
+    // 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) {
+      glTexParameteri(texture->target(), pname, param);
+    }
+  }
+
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
-  return result;
 }
 
-bool TextureManager::MarkMipmapsGenerated(Texture* info) {
-  DCHECK(info);
-  if (!info->CanRender(feature_info_)) {
+bool TextureManager::MarkMipmapsGenerated(Texture* texture) {
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  num_uncleared_mips_ -= info->num_uncleared_mips();
+  num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  GetMemTracker(info->pool_)->TrackMemFree(info->estimated_size());
-  bool result = info->MarkMipmapsGenerated(feature_info_);
-  GetMemTracker(info->pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(texture->pool_)->TrackMemFree(texture->estimated_size());
+  bool result = texture->MarkMipmapsGenerated(feature_info_);
+  GetMemTracker(texture->pool_)->TrackMemAlloc(texture->estimated_size());
 
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  if (!info->CanRender(feature_info_)) {
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
@@ -1091,41 +1118,41 @@ bool TextureManager::MarkMipmapsGenerated(Texture* info) {
 Texture* TextureManager::CreateTexture(
     GLuint client_id, GLuint service_id) {
   DCHECK_NE(0u, service_id);
-  scoped_refptr<Texture> info(new Texture(this, service_id));
-  std::pair<TextureInfoMap::iterator, bool> result =
-      texture_infos_.insert(std::make_pair(client_id, info));
+  scoped_refptr<Texture> texture(new Texture(this, service_id));
+  std::pair<TextureMap::iterator, bool> result =
+      textures_.insert(std::make_pair(client_id, texture));
   DCHECK(result.second);
-  if (!info->CanRender(feature_info_)) {
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
-  num_uncleared_mips_ += info->num_uncleared_mips();
-  return info.get();
+  num_uncleared_mips_ += texture->num_uncleared_mips();
+  return texture.get();
 }
 
 Texture* TextureManager::GetTexture(
     GLuint client_id) const {
-  TextureInfoMap::const_iterator it = texture_infos_.find(client_id);
-  return it != texture_infos_.end() ? it->second : NULL;
+  TextureMap::const_iterator it = textures_.find(client_id);
+  return it != textures_.end() ? it->second : NULL;
 }
 
 void TextureManager::RemoveTexture(GLuint client_id) {
-  TextureInfoMap::iterator it = texture_infos_.find(client_id);
-  if (it != texture_infos_.end()) {
-    Texture* info = it->second;
-    info->MarkAsDeleted();
-    texture_infos_.erase(it);
+  TextureMap::iterator it = textures_.find(client_id);
+  if (it != textures_.end()) {
+    Texture* texture = it->second;
+    texture->MarkAsDeleted();
+    textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(Texture* /* texture */) {
-  ++texture_info_count_;
+  ++texture_count_;
 }
 
 void TextureManager::StopTracking(Texture* texture) {
-  --texture_info_count_;
+  --texture_count_;
   if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
@@ -1156,8 +1183,8 @@ MemoryTypeTracker* TextureManager::GetMemTracker(GLenum tracking_pool) {
 
 bool TextureManager::GetClientId(GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
-  for (TextureInfoMap::const_iterator it = texture_infos_.begin();
-       it != texture_infos_.end(); ++it) {
+  for (TextureMap::const_iterator it = textures_.begin();
+       it != textures_.end(); ++it) {
     if (it->second->service_id() == service_id) {
       *client_id = it->first;
       return true;
@@ -1172,39 +1199,39 @@ GLsizei TextureManager::ComputeMipMapCount(
 }
 
 void TextureManager::SetLevelImage(
-    Texture* info,
+    Texture* texture,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
-  DCHECK(info);
-  if (!info->CanRender(feature_info_)) {
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
-  info->SetLevelImage(feature_info_, target, level, image);
-  if (!info->CanRender(feature_info_)) {
+  texture->SetLevelImage(feature_info_, target, level, image);
+  if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
-  if (!info->SafeToRenderFrom()) {
+  if (!texture->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 void TextureManager::AddToSignature(
-    Texture* info,
+    Texture* texture,
     GLenum target,
     GLint level,
     std::string* signature) const {
-  info->AddToSignature(feature_info_.get(), target, level, signature);
+  texture->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
 void TextureManager::AddPendingAsyncPixelTransfer(
-    base::WeakPtr<gfx::AsyncPixelTransferState> state, Texture* info) {
-  pending_async_transfers_.push_back(PendingAsyncTransfer(state,info));
+    base::WeakPtr<gfx::AsyncPixelTransferState> state, Texture* texture) {
+  pending_async_transfers_.push_back(PendingAsyncTransfer(state, texture));
 }
 
 void TextureManager::BindFinishedAsyncPixelTransfers(
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index b756e7a..18dda7a 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -430,13 +430,13 @@ class GPU_EXPORT TextureManager {
   // 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,
@@ -449,32 +449,36 @@ class GPU_EXPORT TextureManager {
       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);
@@ -539,13 +543,13 @@ class GPU_EXPORT TextureManager {
   }
 
   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;
@@ -553,7 +557,7 @@ class GPU_EXPORT TextureManager {
   // 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);
 
@@ -565,8 +569,8 @@ class GPU_EXPORT TextureManager {
       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_;
@@ -575,8 +579,8 @@ class GPU_EXPORT TextureManager {
   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_;
@@ -587,9 +591,9 @@ class GPU_EXPORT TextureManager {
   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_;
 
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 6c704ae..677d9aa 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -47,6 +47,7 @@ class TextureManagerTest : public testing::Test {
         kMaxTextureSize, kMaxCubeMapTextureSize));
     TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
     manager_->Initialize();
+    decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
   }
 
   virtual void TearDown() {
@@ -56,10 +57,18 @@ class TextureManagerTest : public testing::Test {
     gl_.reset();
   }
 
+  void SetParameter(
+      Texture* texture, GLenum pname, GLint value, GLenum error) {
+    TestHelper::SetTexParameterWithExpectations(
+        gl_.get(), decoder_.get(), manager_.get(),
+        texture, pname, value, error);
+  }
+
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
+  scoped_ptr<MockGLES2Decoder> decoder_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
@@ -82,11 +91,11 @@ TEST_F(TextureManagerTest, Basic) {
   // Check we can create texture.
   manager_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* info1 = manager_->GetTexture(kClient1Id);
-  ASSERT_TRUE(info1 != NULL);
-  EXPECT_EQ(kService1Id, info1->service_id());
+  Texture* texture = manager_->GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  EXPECT_EQ(kService1Id, texture->service_id());
   GLuint client_id = 0;
-  EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id));
+  EXPECT_TRUE(manager_->GetClientId(texture->service_id(), &client_id));
   EXPECT_EQ(kClient1Id, client_id);
   // Check we get nothing for a non-existent texture.
   EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL);
@@ -107,38 +116,30 @@ TEST_F(TextureManagerTest, SetParameter) {
   // Check we can create texture.
   manager_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* info = manager_->GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
-  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
-  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->mag_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
-  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_s());
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_t());
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1));
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2));
-  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter(
-      info, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE));
-  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter(
-      info, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE));
-  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), info->min_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter(
-      info, GL_TEXTURE_WRAP_S, GL_NEAREST));
-  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_s());
-  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), manager_->SetParameter(
-      info, GL_TEXTURE_WRAP_T, GL_NEAREST));
-  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), info->wrap_t());
-  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), manager_->SetParameter(
-      info, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0));
+  Texture* texture = manager_->GetTexture(kClient1Id);
+  manager_->SetTarget(texture, GL_TEXTURE_2D);
+  ASSERT_TRUE(texture != NULL);
+  SetParameter(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
+  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
+  SetParameter(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->mag_filter());
+  SetParameter(texture, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
+  SetParameter(texture, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
+  SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR);
+  SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR);
+  SetParameter(
+      texture, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
+  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
+  SetParameter(
+      texture, GL_TEXTURE_MAG_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
+  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST), texture->min_filter());
+  SetParameter(texture, GL_TEXTURE_WRAP_S, GL_NEAREST, GL_INVALID_ENUM);
+  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_s());
+  SetParameter(texture, GL_TEXTURE_WRAP_T, GL_NEAREST, GL_INVALID_ENUM);
+  EXPECT_EQ(static_cast<GLenum>(GL_CLAMP_TO_EDGE), texture->wrap_t());
+  SetParameter(texture, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
 }
 
 TEST_F(TextureManagerTest, TextureUsageExt) {
@@ -152,12 +153,13 @@ TEST_F(TextureManagerTest, TextureUsageExt) {
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager.SetParameter(
-      info, GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &manager, texture,
+      GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
-            info->usage());
+            texture->usage());
   manager.Destroy(false);
 }
 
@@ -171,16 +173,16 @@ TEST_F(TextureManagerTest, Destroy) {
   // Check we can create texture.
   manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* info1 = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info1 != NULL);
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
   TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), "");
   manager.Destroy(true);
   // Check that resources got freed.
-  info1 = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info1 == NULL);
+  texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture == NULL);
 }
 
 TEST_F(TextureManagerTest, DestroyUnowned) {
@@ -191,19 +193,19 @@ TEST_F(TextureManagerTest, DestroyUnowned) {
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   // Check we can create texture.
-  Texture* created_info =
+  Texture* created_texture =
       manager.CreateTexture(kClient1Id, kService1Id);
-  created_info->SetNotOwned();
+  created_texture->SetNotOwned();
 
   // Check texture got created.
-  Texture* info1 = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info1 != NULL);
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
 
   // Check that it is not freed if it is not owned.
   TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), "");
   manager.Destroy(true);
-  info1 = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info1 == NULL);
+  texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture == NULL);
 }
 
 TEST_F(TextureManagerTest, MaxValues) {
@@ -333,7 +335,7 @@ TEST_F(TextureManagerTest, ValidForTargetNPOT) {
   manager.Destroy(false);
 }
 
-class TextureInfoTestBase : public testing::Test {
+class TextureTestBase : public testing::Test {
  public:
   static const GLint kMaxTextureSize = 16;
   static const GLint kMaxCubeMapTextureSize = 8;
@@ -342,11 +344,11 @@ class TextureInfoTestBase : public testing::Test {
   static const GLuint kClient1Id = 1;
   static const GLuint kService1Id = 11;
 
-  TextureInfoTestBase()
+  TextureTestBase()
       : feature_info_(new FeatureInfo()) {
   }
-  virtual ~TextureInfoTestBase() {
-    info_ = NULL;
+  virtual ~TextureTestBase() {
+    texture_ = NULL;
   }
 
  protected:
@@ -356,24 +358,25 @@ class TextureInfoTestBase : public testing::Test {
     manager_.reset(new TextureManager(
         memory_tracker, feature_info_.get(),
         kMaxTextureSize, kMaxCubeMapTextureSize));
+    decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     manager_->CreateTexture(kClient1Id, kService1Id);
-    info_ = manager_->GetTexture(kClient1Id);
-    ASSERT_TRUE(info_.get() != NULL);
+    texture_ = manager_->GetTexture(kClient1Id);
+    ASSERT_TRUE(texture_.get() != NULL);
   }
 
   virtual void TearDown() {
-    if (info_.get()) {
+    if (texture_.get()) {
       GLuint client_id = 0;
-      // If it's not in the manager then setting info_ to NULL will
+      // If it's not in the manager then setting texture_ to NULL will
       // delete the texture.
-      if (!manager_->GetClientId(info_->service_id(), &client_id)) {
+      if (!manager_->GetClientId(texture_->service_id(), &client_id)) {
         // Check that it gets deleted when the last reference is released.
         EXPECT_CALL(*gl_,
-            DeleteTextures(1, ::testing::Pointee(info_->service_id())))
+            DeleteTextures(1, ::testing::Pointee(texture_->service_id())))
             .Times(1)
             .RetiresOnSaturation();
       }
-      info_ = NULL;
+      texture_ = NULL;
     }
     manager_->Destroy(false);
     manager_.reset();
@@ -381,21 +384,29 @@ class TextureInfoTestBase : public testing::Test {
     gl_.reset();
   }
 
+  void SetParameter(
+      Texture* texture, GLenum pname, GLint value, GLenum error) {
+    TestHelper::SetTexParameterWithExpectations(
+        gl_.get(), decoder_.get(), manager_.get(),
+        texture, pname, value, error);
+  }
+
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
   scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
-  scoped_refptr<Texture> info_;
+  scoped_ptr<MockGLES2Decoder> decoder_;
+  scoped_refptr<Texture> texture_;
 };
 
-class TextureInfoTest : public TextureInfoTestBase {
+class TextureTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     SetUpBase(NULL);
   }
 };
 
-class TextureInfoMemoryTrackerTest : public TextureInfoTestBase {
+class TextureMemoryTrackerTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
@@ -411,178 +422,181 @@ class TextureInfoMemoryTrackerTest : public TextureInfoTestBase {
         .Times(1) \
         .RetiresOnSaturation() \
 
-TEST_F(TextureInfoTest, Basic) {
-  EXPECT_EQ(0u, info_->target());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(info_->npot());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  EXPECT_FALSE(manager_->CanRender(info_));
-  EXPECT_TRUE(info_->SafeToRenderFrom());
-  EXPECT_FALSE(info_->IsImmutable());
-  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR), info_->min_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), info_->mag_filter());
-  EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), info_->wrap_s());
-  EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), info_->wrap_t());
+TEST_F(TextureTest, Basic) {
+  EXPECT_EQ(0u, texture_->target());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->IsImmutable());
+  EXPECT_EQ(static_cast<GLenum>(GL_NEAREST_MIPMAP_LINEAR),
+            texture_->min_filter());
+  EXPECT_EQ(static_cast<GLenum>(GL_LINEAR), texture_->mag_filter());
+  EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_s());
+  EXPECT_EQ(static_cast<GLenum>(GL_REPEAT), texture_->wrap_t());
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
-  EXPECT_EQ(0u, info_->estimated_size());
+  EXPECT_EQ(0u, texture_->estimated_size());
 }
 
-TEST_F(TextureInfoTest, EstimatedSize) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, EstimatedSize) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_EQ(8u * 4u * 4u, info_->estimated_size());
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(8u * 4u * 4u, texture_->estimated_size());
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_EQ(8u * 4u * 4u * 2u, info_->estimated_size());
+  EXPECT_EQ(8u * 4u * 4u * 2u, texture_->estimated_size());
 }
 
-TEST_F(TextureInfoMemoryTrackerTest, EstimatedSize) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
+TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 256, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   // Add expectation for texture deletion.
   EXPECT_MEMORY_ALLOCATION_CHANGE(256, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
 }
 
-TEST_F(TextureInfoMemoryTrackerTest, SetParameterPool) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
+TEST_F(TextureMemoryTrackerTest, SetParameterPool) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kManaged);
-  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), manager_->SetParameter(
-      info_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM));
+  SetParameter(
+      texture_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+      GL_NO_ERROR);
   // Add expectation for texture deletion.
   EXPECT_MEMORY_ALLOCATION_CHANGE(128, 0, MemoryTracker::kManaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
 }
 
-TEST_F(TextureInfoTest, POT2D) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target());
+TEST_F(TextureTest, POT2D) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
   // Check Setting level 0 to POT
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(manager_->CanRender(info_));
-  EXPECT_EQ(0, info_->num_uncleared_mips());
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set filters to something that will work with a single mip.
-  manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  EXPECT_TRUE(manager_->CanRender(info_));
+  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set them back.
-  manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+  SetParameter(
+      texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR);
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanRender(info_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change a mip.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_TRUE(manager_->CanRender(info_));
-  EXPECT_TRUE(info_->texture_complete());
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_TRUE(texture_->texture_complete());
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
-TEST_F(TextureInfoMemoryTrackerTest, MarkMipmapsGenerated) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
+TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   EXPECT_MEMORY_ALLOCATION_CHANGE(64, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 84, MemoryTracker::kUnmanaged);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
   EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
 }
 
-TEST_F(TextureInfoTest, UnusedMips) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target());
+TEST_F(TextureTest, UnusedMips) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
   // Set level zero to large size.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_FALSE(info_->npot());
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanRender(info_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set level zero to large smaller (levels unused mips)
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_FALSE(info_->npot());
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanRender(info_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set an unused level to some size
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 4, GL_RGBA, 16, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
-TEST_F(TextureInfoTest, NPOT2D) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info_->target());
+TEST_F(TextureTest, NPOT2D) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
   // Check Setting level 0 to NPOT
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_TRUE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-  EXPECT_FALSE(manager_->CanRender(info_));
+  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-  EXPECT_FALSE(manager_->CanRender(info_));
+  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-  EXPECT_TRUE(manager_->CanRender(info_));
+  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change it to POT.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
-TEST_F(TextureInfoTest, NPOT2DNPOTOK) {
+TEST_F(TextureTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -590,194 +604,194 @@ TEST_F(TextureInfoTest, NPOT2DNPOTOK) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info_ != NULL);
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
 
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target());
+  manager.SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
-  manager.SetLevelInfo(info,
+  manager.SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(info->npot());
-  EXPECT_FALSE(info->texture_complete());
-  EXPECT_TRUE(manager.CanGenerateMipmaps(info));
-  EXPECT_FALSE(manager.CanRender(info));
+  EXPECT_TRUE(texture->npot());
+  EXPECT_FALSE(texture->texture_complete());
+  EXPECT_TRUE(manager.CanGenerateMipmaps(texture));
+  EXPECT_FALSE(manager.CanRender(texture));
   EXPECT_TRUE(manager.HaveUnrenderableTextures());
-  EXPECT_TRUE(manager.MarkMipmapsGenerated(info));
-  EXPECT_TRUE(info->texture_complete());
-  EXPECT_TRUE(manager.CanRender(info));
+  EXPECT_TRUE(manager.MarkMipmapsGenerated(texture));
+  EXPECT_TRUE(texture->texture_complete());
+  EXPECT_TRUE(manager.CanRender(texture));
   EXPECT_FALSE(manager.HaveUnrenderableTextures());
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, POTCubeMap) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_CUBE_MAP);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), info_->target());
+TEST_F(TextureTest, POTCubeMap) {
+  manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
   // Check Setting level 0 each face to POT
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_X,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanRender(info_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_FALSE(info_->cube_complete());
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_FALSE(texture_->cube_complete());
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_TRUE(info_->cube_complete());
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
-  EXPECT_FALSE(manager_->CanRender(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_TRUE(texture_->cube_complete());
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(info_->cube_complete());
-  EXPECT_TRUE(manager_->CanRender(info_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(texture_->cube_complete());
+  EXPECT_TRUE(manager_->CanRender(texture_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 
   // Change a mip.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(info_->npot());
-  EXPECT_FALSE(info_->texture_complete());
-  EXPECT_TRUE(info_->cube_complete());
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_FALSE(texture_->npot());
+  EXPECT_FALSE(texture_->texture_complete());
+  EXPECT_TRUE(texture_->cube_complete());
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(info_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(info_));
-  EXPECT_TRUE(info_->texture_complete());
-  EXPECT_TRUE(info_->cube_complete());
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
+  EXPECT_TRUE(texture_->texture_complete());
+  EXPECT_TRUE(texture_->cube_complete());
 }
 
-TEST_F(TextureInfoTest, GetLevelSize) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, GetLevelSize) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   GLsizei width = -1;
   GLsizei height = -1;
-  EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height));
-  EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height));
-  EXPECT_FALSE(info_->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
-  EXPECT_TRUE(info_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+  EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, -1, &width, &height));
+  EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 1000, &width, &height));
+  EXPECT_FALSE(texture_->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
+  EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
   EXPECT_EQ(4, width);
   EXPECT_EQ(5, height);
   manager_->RemoveTexture(kClient1Id);
-  EXPECT_TRUE(info_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
+  EXPECT_TRUE(texture_->GetLevelSize(GL_TEXTURE_2D, 1, &width, &height));
   EXPECT_EQ(4, width);
   EXPECT_EQ(5, height);
 }
 
-TEST_F(TextureInfoTest, GetLevelType) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, GetLevelType) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   GLenum type = -1;
   GLenum format = -1;
-  EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
-  EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
-  EXPECT_FALSE(info_->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
-  EXPECT_TRUE(info_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
+  EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, -1, &type, &format));
+  EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 1000, &type, &format));
+  EXPECT_FALSE(texture_->GetLevelType(GL_TEXTURE_2D, 0, &type, &format));
+  EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
   manager_->RemoveTexture(kClient1Id);
-  EXPECT_TRUE(info_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
+  EXPECT_TRUE(texture_->GetLevelType(GL_TEXTURE_2D, 1, &type, &format));
   EXPECT_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
 }
 
-TEST_F(TextureInfoTest, ValidForTexture) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, ValidForTexture) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   // Check bad face.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad level.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad xoffset.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, -1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad xoffset + width > width.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad yoffset.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, -1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad yoffset + height > height.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad width.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad height.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad format.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE));
   // Check bad type.
-  EXPECT_FALSE(info_->ValidForTexture(
+  EXPECT_FALSE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4));
   // Check valid full size
-  EXPECT_TRUE(info_->ValidForTexture(
+  EXPECT_TRUE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check valid particial size.
-  EXPECT_TRUE(info_->ValidForTexture(
+  EXPECT_TRUE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE));
   manager_->RemoveTexture(kClient1Id);
-  EXPECT_TRUE(info_->ValidForTexture(
+  EXPECT_TRUE(texture_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
 }
 
-TEST_F(TextureInfoTest, FloatNotLinear) {
+TEST_F(TextureTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -785,21 +799,25 @@ TEST_F(TextureInfoTest, FloatNotLinear) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target());
-  manager.SetLevelInfo(info,
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
+  manager.SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
-  EXPECT_FALSE(info->texture_complete());
-  manager.SetParameter(info, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  EXPECT_FALSE(info->texture_complete());
-  manager.SetParameter(info, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-  EXPECT_TRUE(info->texture_complete());
+  EXPECT_FALSE(texture->texture_complete());
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &manager,
+      texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+  EXPECT_FALSE(texture->texture_complete());
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &manager,
+      texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+  EXPECT_TRUE(texture->texture_complete());
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, FloatLinear) {
+TEST_F(TextureTest, FloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -807,17 +825,17 @@ TEST_F(TextureInfoTest, FloatLinear) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target());
-  manager.SetLevelInfo(info,
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
+  manager.SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
-  EXPECT_TRUE(info->texture_complete());
+  EXPECT_TRUE(texture->texture_complete());
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, HalfFloatNotLinear) {
+TEST_F(TextureTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -825,21 +843,25 @@ TEST_F(TextureInfoTest, HalfFloatNotLinear) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target());
-  manager.SetLevelInfo(info,
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
+  manager.SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
-  EXPECT_FALSE(info->texture_complete());
-  manager.SetParameter(info, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-  EXPECT_FALSE(info->texture_complete());
-  manager.SetParameter(info, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
-  EXPECT_TRUE(info->texture_complete());
+  EXPECT_FALSE(texture->texture_complete());
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &manager,
+      texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+  EXPECT_FALSE(texture->texture_complete());
+  TestHelper::SetTexParameterWithExpectations(
+      gl_.get(), decoder_.get(), &manager,
+      texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+  EXPECT_TRUE(texture->texture_complete());
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, HalfFloatLinear) {
+TEST_F(TextureTest, HalfFloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -847,17 +869,17 @@ TEST_F(TextureInfoTest, HalfFloatLinear) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), info->target());
-  manager.SetLevelInfo(info,
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
+  manager.SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
-  EXPECT_TRUE(info->texture_complete());
+  EXPECT_TRUE(texture->texture_complete());
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, EGLImageExternal) {
+TEST_F(TextureTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -865,15 +887,15 @@ TEST_F(TextureInfoTest, EGLImageExternal) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), info->target());
-  EXPECT_FALSE(manager.CanGenerateMipmaps(info));
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
+  EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, DepthTexture) {
+TEST_F(TextureTest, DepthTexture) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_ANGLE_depth_texture");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
@@ -881,122 +903,122 @@ TEST_F(TextureInfoTest, DepthTexture) {
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* info = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(info != NULL);
-  manager.SetInfoTarget(info, GL_TEXTURE_2D);
+  Texture* texture = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture != NULL);
+  manager.SetTarget(texture, GL_TEXTURE_2D);
   manager.SetLevelInfo(
-      info, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
+      texture, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
       GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
-  EXPECT_FALSE(manager.CanGenerateMipmaps(info));
+  EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
   manager.Destroy(false);
 }
 
-TEST_F(TextureInfoTest, SafeUnsafe) {
+TEST_F(TextureTest, SafeUnsafe) {
   static const GLuint kClient2Id = 2;
   static const GLuint kService2Id = 12;
   static const GLuint kClient3Id = 3;
   static const GLuint kService3Id = 13;
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info_->num_uncleared_mips());
-  manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 0, true);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture_->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info_->num_uncleared_mips());
-  manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 1, true);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture_->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, info_->num_uncleared_mips());
-  manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 0, true);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture_->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info_->num_uncleared_mips());
-  manager_->SetLevelCleared(info_, GL_TEXTURE_2D, 1, true);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture_->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info_->num_uncleared_mips());
-  manager_->MarkMipmapsGenerated(info_);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture_->num_uncleared_mips());
+  manager_->MarkMipmapsGenerated(texture_);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
 
   manager_->CreateTexture(kClient2Id, kService2Id);
-  scoped_refptr<Texture> info2(
+  scoped_refptr<Texture> texture2(
       manager_->GetTexture(kClient2Id));
-  ASSERT_TRUE(info2.get() != NULL);
-  manager_->SetInfoTarget(info2, GL_TEXTURE_2D);
+  ASSERT_TRUE(texture2.get() != NULL);
+  manager_->SetTarget(texture2, GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info2->num_uncleared_mips());
-  manager_->SetLevelInfo(info2,
+  EXPECT_EQ(0, texture2->num_uncleared_mips());
+  manager_->SetLevelInfo(texture2,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info2->num_uncleared_mips());
-  manager_->SetLevelInfo(info2,
+  EXPECT_EQ(0, texture2->num_uncleared_mips());
+  manager_->SetLevelInfo(texture2,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info2->num_uncleared_mips());
+  EXPECT_EQ(1, texture2->num_uncleared_mips());
 
   manager_->CreateTexture(kClient3Id, kService3Id);
-  scoped_refptr<Texture> info3(
+  scoped_refptr<Texture> texture3(
       manager_->GetTexture(kClient3Id));
-  ASSERT_TRUE(info3.get() != NULL);
-  manager_->SetInfoTarget(info3, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info3,
+  ASSERT_TRUE(texture3.get() != NULL);
+  manager_->SetTarget(texture3, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture3,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info3->num_uncleared_mips());
-  manager_->SetLevelCleared(info2, GL_TEXTURE_2D, 0, true);
+  EXPECT_EQ(1, texture3->num_uncleared_mips());
+  manager_->SetLevelCleared(texture2, GL_TEXTURE_2D, 0, true);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info2->num_uncleared_mips());
-  manager_->SetLevelCleared(info3, GL_TEXTURE_2D, 0, true);
+  EXPECT_EQ(0, texture2->num_uncleared_mips());
+  manager_->SetLevelCleared(texture3, GL_TEXTURE_2D, 0, true);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info3->num_uncleared_mips());
+  EXPECT_EQ(0, texture3->num_uncleared_mips());
 
-  manager_->SetLevelInfo(info2,
+  manager_->SetLevelInfo(texture2,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(info3,
+  manager_->SetLevelInfo(texture3,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info2->num_uncleared_mips());
-  EXPECT_EQ(1, info3->num_uncleared_mips());
+  EXPECT_EQ(1, texture2->num_uncleared_mips());
+  EXPECT_EQ(1, texture3->num_uncleared_mips());
   manager_->RemoveTexture(kClient3Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
@@ -1006,103 +1028,102 @@ TEST_F(TextureInfoTest, SafeUnsafe) {
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
-  info2 = NULL;
+  texture2 = NULL;
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
       .Times(1)
       .RetiresOnSaturation();
-  info3 = NULL;
+  texture3 = NULL;
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
 }
 
-TEST_F(TextureInfoTest, ClearTexture) {
-  scoped_ptr<MockGLES2Decoder> decoder(new gles2::MockGLES2Decoder());
-  EXPECT_CALL(*decoder, ClearLevel(_, _, _, _, _, _, _, _, _))
+TEST_F(TextureTest, ClearTexture) {
+  EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, info_->num_uncleared_mips());
-  manager_->ClearRenderableLevels(decoder.get(), info_);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture_->num_uncleared_mips());
+  manager_->ClearRenderableLevels(decoder_.get(), texture_);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
-  manager_->SetLevelInfo(info_,
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, info_->num_uncleared_mips());
-  manager_->ClearTextureLevel(decoder.get(), info_, GL_TEXTURE_2D, 0);
-  EXPECT_FALSE(info_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture_->num_uncleared_mips());
+  manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 0);
+  EXPECT_FALSE(texture_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, info_->num_uncleared_mips());
-  manager_->ClearTextureLevel(decoder.get(), info_, GL_TEXTURE_2D, 1);
-  EXPECT_TRUE(info_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture_->num_uncleared_mips());
+  manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 1);
+  EXPECT_TRUE(texture_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, info_->num_uncleared_mips());
+  EXPECT_EQ(0, texture_->num_uncleared_mips());
 }
 
-TEST_F(TextureInfoTest, UseDeletedTexture) {
+TEST_F(TextureTest, UseDeletedTexture) {
   static const GLuint kClient2Id = 2;
   static const GLuint kService2Id = 12;
   // Make the default texture renderable
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Make a new texture
   manager_->CreateTexture(kClient2Id, kService2Id);
-  scoped_refptr<Texture> info(
+  scoped_refptr<Texture> texture(
       manager_->GetTexture(kClient2Id));
-  manager_->SetInfoTarget(info, GL_TEXTURE_2D);
-  EXPECT_FALSE(manager_->CanRender(info));
+  manager_->SetTarget(texture, GL_TEXTURE_2D);
+  EXPECT_FALSE(manager_->CanRender(texture));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Remove it.
   manager_->RemoveTexture(kClient2Id);
-  EXPECT_FALSE(manager_->CanRender(info));
+  EXPECT_FALSE(manager_->CanRender(texture));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Check that we can still manipulate it and it effects the manager.
-  manager_->SetLevelInfo(info,
+  manager_->SetLevelInfo(texture,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_TRUE(manager_->CanRender(info));
+  EXPECT_TRUE(manager_->CanRender(texture));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
-  info = NULL;
+  texture = NULL;
 }
 
-TEST_F(TextureInfoTest, GetLevelImage) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, GetLevelImage) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Set image.
-  manager_->SetLevelImage(info_,
+  manager_->SetLevelImage(texture_,
       GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
-  EXPECT_FALSE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_FALSE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Remove it.
-  manager_->SetLevelImage(info_, GL_TEXTURE_2D, 1, NULL);
-  EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
-  manager_->SetLevelImage(info_,
+  manager_->SetLevelImage(texture_, GL_TEXTURE_2D, 1, NULL);
+  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  manager_->SetLevelImage(texture_,
       GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
   // Image should be reset when SetLevelInfo is called.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(info_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
 }
 
 namespace {
@@ -1115,113 +1136,112 @@ bool InSet(std::set<std::string>* string_set, const std::string& str) {
 
 }  // anonymous namespace
 
-TEST_F(TextureInfoTest, AddToSignature) {
-  manager_->SetInfoTarget(info_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(info_,
+TEST_F(TextureTest, AddToSignature) {
+  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   std::string signature1;
   std::string signature2;
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature1);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature1);
 
   std::set<std::string> string_set;
   EXPECT_FALSE(InSet(&string_set, signature1));
 
   // check changing 1 thing makes a different signature.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // check putting it back makes the same signature.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check setting cleared status does not change signature.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check changing other settings changes signature.
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_FLOAT,
       false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // put it back
-  manager_->SetLevelInfo(info_,
+  manager_->SetLevelInfo(texture_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       false);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // check changing parameters changes signature.
-  manager_->SetParameter(info_, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetParameter(
-      info_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
-  manager_->SetParameter(info_, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  SetParameter(
+      texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR);
+  SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetParameter(info_, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
+  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_S, GL_REPEAT);
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
+  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // Check putting it back genenerates the same signature
-  manager_->SetParameter(info_, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(info_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check the set was acutally getting different signatures.
   EXPECT_EQ(11u, string_set.size());
 }
 
-
 }  // namespace gles2
 }  // namespace gpu