Refactor a bunch of Texture related GPU code

gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include "base/atomicops.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
@@ skipping 1803 matching lines @@
       0, 0);
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 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);
   EXPECT_CALL(*gl_, TexParameteri(
       GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GenerateMipmapEXT(GL_TEXTURE_2D))
       .Times(1);
   EXPECT_CALL(*gl_, TexParameteri(
       GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   GenerateMipmap cmd;
   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) {
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_))
        .Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   SetupClearTextureExpections(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
@@ skipping 2857 matching lines @@
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   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))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, TexImage2D(target, level, internal_format,
                                width, height, border, format, type, _))
       .Times(1)
       .RetiresOnSaturation();
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            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) {
   GLenum target = GL_ARRAY_BUFFER;
   GLsizeiptr size = 4;
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   BufferManager* manager = group().buffer_manager();
   Buffer* buffer = manager->GetBuffer(client_buffer_id_);
   ASSERT_TRUE(buffer != NULL);
   EXPECT_EQ(0, buffer->size());
@@ skipping 13 matching lines @@
 
 TEST_F(GLES2DecoderTest, CopyTexImage2DGLError) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   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))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(
       target, level, internal_format, 0, 0, width, height, border))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   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) {
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
@@ skipping 495 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   // Test CompressedTexSubImage not allowed
   CompressedTexSubImage2DBucket sub_cmd;
   bucket->SetSize(kBlockSize);
   sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 4, 4, kFormat, kBucketId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
   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,
            kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(texsub_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test CopyTexSubImage not allowed for ETC1 compressed texture
   CopyTexSubImage2D copy_cmd;
   copy_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
@@ skipping 86 matching lines @@
       false,   // request depth
       false,   // request stencil
       true);   // bind generates resource
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   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) {
   InitDecoder(
       "GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 27 matching lines @@
       "GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       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) {
   InitDecoder(
       "GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 32 matching lines @@
            GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES,
            GL_TEXTURE_WRAP_T,
            GL_CLAMP_TO_EDGE);
   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) {
   InitDecoder(
       "GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 14 matching lines @@
            GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES,
            GL_TEXTURE_WRAP_T,
            GL_REPEAT);
   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) {
   InitDecoder(
       "GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 67 matching lines @@
       .WillOnce(Return(kObjectId))
       .RetiresOnSaturation();
 
   CreateStreamTextureCHROMIUM cmd;
   CreateStreamTextureCHROMIUM::Result* result =
       static_cast<CreateStreamTextureCHROMIUM::Result*>(shared_memory_address_);
   cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
   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) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 34 matching lines @@
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       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_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, BindStreamTextureCHROMIUM) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       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();
 
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, BindStreamTextureCHROMIUMInvalid) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       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_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindTexture cmd2;
   cmd2.Init(GL_TEXTURE_CUBE_MAP, client_texture_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUM) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       true);   // bind generates resource
 
   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)
       .RetiresOnSaturation();
 
   DestroyStreamTextureCHROMIUM cmd;
   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) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       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_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, DestroyStreamTextureCHROMIUMBadId) {
   InitDecoder(
       "GL_CHROMIUM_stream_texture",  // extensions
@@ skipping 20 matching lines @@
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       true);   // bind generates resource
 
   CreateStreamTextureCHROMIUM cmd;
   cmd.Init(client_texture_id_, shared_memory_id_, shared_memory_offset_);
   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_);
   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd2));
   GetGLError(); // ignore internal error
 }
 
 TEST_F(GLES2DecoderManualInitTest, ReCreateStreamTextureCHROMIUM) {
   const GLuint kObjectId = 123;
   InitDecoder(
       "GL_CHROMIUM_stream_texture GL_OES_EGL_image_external",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       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))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(manager, CreateStreamTexture(kServiceTextureId,
                                            client_texture_id_))
       .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());
 
   DestroyStreamTextureCHROMIUM cmd;
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       true);   // bind generates resource
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_RECTANGLE_ARB, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 29 matching lines @@
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       false,   // request stencil
       true);   // bind generates resource
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 33 matching lines @@
            GL_CLAMP_TO_EDGE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB,
            GL_TEXTURE_WRAP_T,
            GL_CLAMP_TO_EDGE);
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 15 matching lines @@
            GL_REPEAT);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB,
            GL_TEXTURE_WRAP_T,
            GL_REPEAT);
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
@@ skipping 305 matching lines @@
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_FRAMEBUFFER_OPERATION, GetGLError());
 }
 
 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))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 1, 0))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   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) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, 0);
 
   SetupClearTextureExpections(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
@@ skipping 25 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CompressedTexImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0,
            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) {
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
@@ skipping 751 matching lines @@
   group().mailbox_manager()->GenerateMailboxName(
       reinterpret_cast<MailboxName*>(mailbox));
 
   memcpy(shared_memory_address_, mailbox, sizeof(mailbox));
 
   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);
   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, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kNewServiceId))
       .Times(1)
       .RetiresOnSaturation();
 
   ProduceTextureCHROMIUM produce_cmd;
   produce_cmd.Init(GL_TEXTURE_2D, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(produce_cmd));
 
   // Texture is zero-by-zero.
   GLsizei width;
   GLsizei height;
   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, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, kServiceTextureId))
       .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());
 }
 
 
 TEST_F(GLES2DecoderTest, CanChangeSurface) {
   scoped_refptr<GLSurfaceMock> other_surface(new GLSurfaceMock);
   EXPECT_CALL(*other_surface.get(), GetBackingFrameBufferObject()).
       WillOnce(Return(7));
   EXPECT_CALL(*gl_, BindFramebufferEXT(GL_FRAMEBUFFER_EXT, 7));
 
   decoder_->SetSurface(other_surface);
@@ skipping 491 matching lines @@
 }
 TEST_F(GLES2DecoderEmulatedVertexArraysOESTest,
     BindVertexArrayOESValidArgsNewId) {
   BindVertexArrayOESValidArgsNewId();
 }
 
 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);
 
   GLsizei width;
   GLsizei height;
   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);
 
   GLsizei width;
   GLsizei height;
   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) {
   InitDecoder(
       "GL_ARB_texture_rectangle",  // extensions
       false,   // has alpha
       false,   // has depth
       false,   // has stencil
       false,   // request alpha
       false,   // request depth
       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);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_POOL_CHROMIUM,
            GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_POOL_CHROMIUM,
            GL_TEXTURE_POOL_MANAGED_CHROMIUM);
   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,
            GL_NONE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
   InitDecoder(
       "GL_CHROMIUM_async_pixel_transfers",  // extensions
       false, false, false,  // has alpha/depth/stencil
       false, false, false,  // request alpha/depth/stencil
       true);   // bind generates resource
 
   // 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.
   StrictMock<gfx::MockAsyncPixelTransferDelegate>* delegate =
       new StrictMock<gfx::MockAsyncPixelTransferDelegate>;
   decoder_->SetAsyncPixelTransferDelegate(delegate);
   StrictMock<gfx::MockAsyncPixelTransferState>* state = NULL;
 
   // Tex(Sub)Image2D upload commands.
   AsyncTexImage2DCHROMIUM teximage_cmd;
   teximage_cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA,
                     GL_UNSIGNED_BYTE, kSharedMemoryId, kSharedMemoryOffset);
   AsyncTexSubImage2DCHROMIUM texsubimage_cmd;
   texsubimage_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 8, 8, GL_RGBA,
                       GL_UNSIGNED_BYTE, kSharedMemoryId, kSharedMemoryOffset);
   WaitAsyncTexImage2DCHROMIUM wait_cmd;
   wait_cmd.Init(GL_TEXTURE_2D);
   gfx::AsyncTexImage2DParams teximage_params =
       {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
   {
     // Create transfer state since it doesn't exist.
     EXPECT_CALL(*delegate, CreateRawPixelTransferState(kServiceTextureId))
         .WillOnce(Return(
             state = new StrictMock<gfx::MockAsyncPixelTransferState>))
         .RetiresOnSaturation();
     EXPECT_CALL(*delegate, AsyncTexImage2D(state, _, _))
         .RetiresOnSaturation();
     // 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))
         .RetiresOnSaturation();
     EXPECT_CALL(*state, BindTransfer(_))
         .WillOnce(SetArgPointee<0>(teximage_params))
         .RetiresOnSaturation();
     TextureManager* manager = decoder_->GetContextGroup()->texture_manager();
     bool texture_dirty, framebuffer_dirty;
     manager->BindFinishedAsyncPixelTransfers(&texture_dirty,
                                              &framebuffer_dirty);
     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))
         .WillOnce(Return(
             state = new StrictMock<gfx::MockAsyncPixelTransferState>))
         .RetiresOnSaturation();
     EXPECT_CALL(*delegate, AsyncTexSubImage2D(state, _, _))
         .RetiresOnSaturation();
     // 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.
     EXPECT_CALL(*state, TransferIsInProgress())
         .WillOnce(Return(false))  // texSubImage validation
         .WillOnce(Return(false))  // async validation
         .RetiresOnSaturation();
     EXPECT_CALL(*delegate, AsyncTexSubImage2D(state, _, _))
         .RetiresOnSaturation();
     // 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!
     EXPECT_CALL(*state, TransferIsInProgress())
         .WillOnce(Return(true))
         .RetiresOnSaturation();
     // 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
   {
     // Get a fresh texture since the existing texture cannot be respecified
     // 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(
             state = new StrictMock<gfx::MockAsyncPixelTransferState>))
         .RetiresOnSaturation();
     EXPECT_CALL(*delegate, AsyncTexImage2D(state, _, _))
         .RetiresOnSaturation();
     // 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())
         .WillOnce(Return(false))
         .RetiresOnSaturation();
     EXPECT_CALL(*state, BindTransfer(_))
         .WillOnce(SetArgPointee<0>(teximage_params))
         .RetiresOnSaturation();
     // State restoration after binding.
     EXPECT_CALL(*gl_, ActiveTexture(_));
     EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_2D, _));
     EXPECT_EQ(error::kNoError, ExecuteCmd(wait_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
   }
 
   decoder_->SetAsyncPixelTransferDelegate(NULL);
-  info->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
+  texture->SetAsyncTransferState(scoped_ptr<gfx::AsyncPixelTransferState>());
 }
 
 namespace {
 
 class SizeOnlyMemoryTracker : public MemoryTracker {
  public:
   SizeOnlyMemoryTracker() {
     // These are the default textures. 1 for TEXTURE_2D and 6 faces for
     // TEXTURE_CUBE_MAP.
     const size_t kInitialUnmanagedPoolSize = 7 * 4;
@@ skipping 272 matching lines @@
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 // TODO(gman): UseProgram
 
 // TODO(gman): SwapBuffers
 
 }  // namespace gles2
 }  // namespace gpu