Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/service/texture_manager_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/texture_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
@@ skipping 40 matching lines @@
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  FeatureInfo::Ref feature_info_;
+  scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
 const GLint TextureManagerTest::kMaxTextureSize;
 const GLint TextureManagerTest::kMaxCubeMapTextureSize;
 const GLint TextureManagerTest::kMaxExternalTextureSize;
 const GLint TextureManagerTest::kMax2dLevels;
 const GLint TextureManagerTest::kMaxCubeMapLevels;
 const GLint TextureManagerTest::kMaxExternalLevels;
 #endif
 
 TEST_F(TextureManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   // Check we can create texture.
-  manager_->CreateTextureInfo(kClient1Id, kService1Id);
+  manager_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  TextureManager::TextureInfo* info1 = manager_->GetTextureInfo(kClient1Id);
+  Texture* info1 = manager_->GetTexture(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
   EXPECT_EQ(kService1Id, info1->service_id());
   GLuint client_id = 0;
   EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id));
   EXPECT_EQ(kClient1Id, client_id);
   // Check we get nothing for a non-existent texture.
-  EXPECT_TRUE(manager_->GetTextureInfo(kClient2Id) == NULL);
+  EXPECT_TRUE(manager_->GetTexture(kClient2Id) == NULL);
   // Check trying to a remove non-existent textures does not crash.
-  manager_->RemoveTextureInfo(kClient2Id);
+  manager_->RemoveTexture(kClient2Id);
   // Check that it gets deleted when the last reference is released.
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
   // Check we can't get the texture after we remove it.
-  manager_->RemoveTextureInfo(kClient1Id);
-  EXPECT_TRUE(manager_->GetTextureInfo(kClient1Id) == NULL);
+  manager_->RemoveTexture(kClient1Id);
+  EXPECT_TRUE(manager_->GetTexture(kClient1Id) == NULL);
 }
 
 TEST_F(TextureManagerTest, SetParameter) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create texture.
-  manager_->CreateTextureInfo(kClient1Id, kService1Id);
+  manager_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  TextureManager::TextureInfo* info = manager_->GetTextureInfo(kClient1Id);
+  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());
@@ skipping 22 matching lines @@
 
 TEST_F(TextureManagerTest, TextureUsageExt) {
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(),
                                                   "GL_ANGLE_texture_usage");
   TextureManager manager(
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create texture.
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
+  manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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));
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
             info->usage());
   manager.Destroy(false);
 }
 
 TEST_F(TextureManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
   TextureManager manager(
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   // Check we can create texture.
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
+  manager.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  TextureManager::TextureInfo* info1 = manager.GetTextureInfo(kClient1Id);
+  Texture* info1 = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(info1 != 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.GetTextureInfo(kClient1Id);
+  info1 = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(info1 == NULL);
 }
 
 TEST_F(TextureManagerTest, DestroyUnowned) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
   TextureManager manager(
       NULL, feature_info_.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.Initialize();
   // Check we can create texture.
-  TextureManager::TextureInfo* created_info =
-      manager.CreateTextureInfo(kClient1Id, kService1Id);
+  Texture* created_info =
+      manager.CreateTexture(kClient1Id, kService1Id);
   created_info->SetNotOwned();
 
   // Check texture got created.
-  TextureManager::TextureInfo* info1 = manager.GetTextureInfo(kClient1Id);
+  Texture* info1 = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
 
   // Check that it is not freed if it is not owned.
   TestHelper::SetupTextureManagerDestructionExpectations(gl_.get(), "");
   manager.Destroy(true);
-  info1 = manager.GetTextureInfo(kClient1Id);
+  info1 = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(info1 == NULL);
 }
 
 TEST_F(TextureManagerTest, MaxValues) {
   // Check we get the right values for the max sizes.
   EXPECT_EQ(kMax2dLevels, manager_->MaxLevelsForTarget(GL_TEXTURE_2D));
   EXPECT_EQ(kMaxCubeMapLevels,
             manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP));
   EXPECT_EQ(kMaxCubeMapLevels,
             manager_->MaxLevelsForTarget(GL_TEXTURE_CUBE_MAP_POSITIVE_X));
@@ skipping 95 matching lines @@
         GL_TEXTURE_CUBE_MAP, level,
         (kMaxCubeMapTextureSize >> level) * 2,
         (kMaxCubeMapTextureSize >> level) * 2,
         1));
   }
 }
 
 TEST_F(TextureManagerTest, ValidForTargetNPOT) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
      NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   // Check NPOT width on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 5, 2, 1));
   // Check NPOT height on level 0
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 0, 2, 5, 1));
   // Check NPOT width on level 1
   EXPECT_TRUE(manager.ValidForTarget(GL_TEXTURE_2D, 1, 5, 2, 1));
   // Check NPOT height on level 1
@@ skipping 17 matching lines @@
     info_ = NULL;
   }
 
  protected:
   void SetUpBase(MemoryTracker* memory_tracker) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
     manager_.reset(new TextureManager(
         memory_tracker, feature_info_.get(),
         kMaxTextureSize, kMaxCubeMapTextureSize));
-    manager_->CreateTextureInfo(kClient1Id, kService1Id);
-    info_ = manager_->GetTextureInfo(kClient1Id);
+    manager_->CreateTexture(kClient1Id, kService1Id);
+    info_ = manager_->GetTexture(kClient1Id);
     ASSERT_TRUE(info_.get() != NULL);
   }
 
   virtual void TearDown() {
     if (info_.get()) {
       GLuint client_id = 0;
       // If it's not in the manager then setting info_ to NULL will
       // delete the texture.
       if (!manager_->GetClientId(info_->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())))
             .Times(1)
             .RetiresOnSaturation();
       }
       info_ = NULL;
     }
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  FeatureInfo::Ref feature_info_;
+  scoped_refptr<FeatureInfo> feature_info_;
   scoped_ptr<TextureManager> manager_;
-  TextureManager::TextureInfo::Ref info_;
+  scoped_refptr<Texture> info_;
 };
 
 class TextureInfoTest : public TextureInfoTestBase {
  protected:
   virtual void SetUp() {
     SetUpBase(NULL);
   }
 };
 
 class TextureInfoMemoryTrackerTest : public TextureInfoTestBase {
@@ skipping 179 matching lines @@
       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(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureInfoTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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());
   // Check Setting level 0 to NPOT
   manager.SetLevelInfo(info,
       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));
@@ skipping 96 matching lines @@
   manager_->SetLevelInfo(info_,
       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_EQ(4, width);
   EXPECT_EQ(5, height);
-  manager_->RemoveTextureInfo(kClient1Id);
+  manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(info_->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_,
       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_EQ(static_cast<GLenum>(GL_UNSIGNED_BYTE), type);
   EXPECT_EQ(static_cast<GLenum>(GL_RGBA), format);
-  manager_->RemoveTextureInfo(kClient1Id);
+  manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(info_->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_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   // Check bad face.
@@ skipping 26 matching lines @@
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE));
   // Check bad type.
   EXPECT_FALSE(info_->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(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check valid particial size.
   EXPECT_TRUE(info_->ValidForTexture(
       GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE));
-  manager_->RemoveTextureInfo(kClient1Id);
+  manager_->RemoveTexture(kClient1Id);
   EXPECT_TRUE(info_->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
 }
 
 TEST_F(TextureInfoTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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,
       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());
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, FloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
   EXPECT_TRUE(info->texture_complete());
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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,
       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());
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, HalfFloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float GL_OES_texture_half_float_linear");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
   EXPECT_TRUE(info->texture_complete());
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  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));
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, DepthTexture) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_ANGLE_depth_texture");
-  FeatureInfo::Ref feature_info(new FeatureInfo());
+  scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
-  manager.CreateTextureInfo(kClient1Id, kService1Id);
-  TextureManager::TextureInfo* info = manager.GetTextureInfo(kClient1Id);
+  manager.CreateTexture(kClient1Id, kService1Id);
+  Texture* info = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(info != NULL);
   manager.SetInfoTarget(info, GL_TEXTURE_2D);
   manager.SetLevelInfo(
       info, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
       GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
   EXPECT_FALSE(manager.CanGenerateMipmaps(info));
   manager.Destroy(false);
 }
 
 TEST_F(TextureInfoTest, SafeUnsafe) {
@@ skipping 49 matching lines @@
   EXPECT_FALSE(info_->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(1, info_->num_uncleared_mips());
   manager_->MarkMipmapsGenerated(info_);
   EXPECT_TRUE(info_->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, info_->num_uncleared_mips());
 
-  manager_->CreateTextureInfo(kClient2Id, kService2Id);
-  TextureManager::TextureInfo::Ref info2 = manager_->GetTextureInfo(kClient2Id);
+  manager_->CreateTexture(kClient2Id, kService2Id);
+  scoped_refptr<Texture> info2(
+      manager_->GetTexture(kClient2Id));
   ASSERT_TRUE(info2.get() != NULL);
   manager_->SetInfoTarget(info2, GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, info2->num_uncleared_mips());
   manager_->SetLevelInfo(info2,
       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,
       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());
 
-  manager_->CreateTextureInfo(kClient3Id, kService3Id);
-  TextureManager::TextureInfo::Ref info3 = manager_->GetTextureInfo(kClient3Id);
+  manager_->CreateTexture(kClient3Id, kService3Id);
+  scoped_refptr<Texture> info3(
+      manager_->GetTexture(kClient3Id));
   ASSERT_TRUE(info3.get() != NULL);
   manager_->SetInfoTarget(info3, GL_TEXTURE_2D);
   manager_->SetLevelInfo(info3,
       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_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, info2->num_uncleared_mips());
   manager_->SetLevelCleared(info3, GL_TEXTURE_2D, 0, true);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, info3->num_uncleared_mips());
 
   manager_->SetLevelInfo(info2,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   manager_->SetLevelInfo(info3,
       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());
-  manager_->RemoveTextureInfo(kClient3Id);
+  manager_->RemoveTexture(kClient3Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  manager_->RemoveTextureInfo(kClient2Id);
+  manager_->RemoveTexture(kClient2Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
   info2 = NULL;
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
       .Times(1)
@@ skipping 43 matching lines @@
 
 TEST_F(TextureInfoTest, 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_,
       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_->CreateTextureInfo(kClient2Id, kService2Id);
-  TextureManager::TextureInfo::Ref info(manager_->GetTextureInfo(kClient2Id));
+  manager_->CreateTexture(kClient2Id, kService2Id);
+  scoped_refptr<Texture> info(
+      manager_->GetTexture(kClient2Id));
   manager_->SetInfoTarget(info, GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->CanRender(info));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Remove it.
-  manager_->RemoveTextureInfo(kClient2Id);
+  manager_->RemoveTexture(kClient2Id);
   EXPECT_FALSE(manager_->CanRender(info));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Check that we can still manipulate it and it effects the manager.
   manager_->SetLevelInfo(info,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_TRUE(manager_->CanRender(info));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
@@ skipping 134 matching lines @@
 
   // Check the set was acutally getting different signatures.
   EXPECT_EQ(11u, string_set.size());
 }
 
 
 }  // namespace gles2
 }  // namespace gpu