gpu: Refactor to support cross-channel shared textures

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/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
+#include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
 using ::testing::AtLeast;
 using ::testing::Pointee;
@@ skipping 48 matching lines @@
   }
 
   virtual void TearDown() {
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   void SetParameter(
-      Texture* texture, GLenum pname, GLint value, GLenum error) {
+      TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameterWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
-        texture, pname, value, error);
+        texture_ref, 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<MockErrorState> error_state_;
 };
 
 // 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_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* texture = manager_->GetTexture(kClient1Id);
+  TextureRef* texture = manager_->GetTexture(kClient1Id);
   ASSERT_TRUE(texture != NULL);
   EXPECT_EQ(kService1Id, texture->service_id());
   GLuint client_id = 0;
   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);
   // Check trying to a remove non-existent textures does not crash.
   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_->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_->CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  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);
+  TextureRef* texture_ref = manager_->GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  Texture* texture = texture_ref->texture();
+  manager_->SetTarget(texture_ref, GL_TEXTURE_2D);
+  SetParameter(texture_ref, 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);
+  SetParameter(texture_ref, 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);
+  SetParameter(texture_ref, 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);
+  SetParameter(texture_ref, 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_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1, GL_NO_ERROR);
+  SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2, GL_NO_ERROR);
   SetParameter(
-      texture, GL_TEXTURE_MIN_FILTER, GL_CLAMP_TO_EDGE, GL_INVALID_ENUM);
+      texture_ref, 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);
+      texture_ref, 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);
+  SetParameter(texture_ref, 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);
+  SetParameter(texture_ref, 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);
+  SetParameter(texture_ref, GL_TEXTURE_MAX_ANISOTROPY_EXT, 0, GL_INVALID_VALUE);
 }
 
 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.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
   TestHelper::SetTexParameterWithExpectations(
-      gl_.get(), error_state_.get(), &manager, texture,
+      gl_.get(), error_state_.get(), &manager, texture_ref,
       GL_TEXTURE_USAGE_ANGLE, GL_FRAMEBUFFER_ATTACHMENT_ANGLE,GL_NO_ERROR);
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_ATTACHMENT_ANGLE),
-            texture->usage());
+            texture_ref->texture()->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.CreateTexture(kClient1Id, kService1Id);
   // Check texture got created.
-  Texture* texture = manager.GetTexture(kClient1Id);
+  TextureRef* 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.
   texture = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture == 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.
-  Texture* created_texture =
+  TextureRef* created_texture =
       manager.CreateTexture(kClient1Id, kService1Id);
-  created_texture->SetNotOwned();
+  created_texture->texture()->SetNotOwned();
 
   // Check texture got created.
-  Texture* texture = manager.GetTexture(kClient1Id);
+  TextureRef* 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);
   texture = manager.GetTexture(kClient1Id);
   ASSERT_TRUE(texture == NULL);
 }
 
 TEST_F(TextureManagerTest, MaxValues) {
@@ skipping 129 matching lines @@
   static const GLint kMaxCubeMapTextureSize = 8;
   static const GLint kMax2dLevels = 5;
   static const GLint kMaxCubeMapLevels = 4;
   static const GLuint kClient1Id = 1;
   static const GLuint kService1Id = 11;
 
   TextureTestBase()
       : feature_info_(new FeatureInfo()) {
   }
   virtual ~TextureTestBase() {
-    texture_ = NULL;
+    texture_ref_ = NULL;
   }
 
  protected:
   void SetUpBase(MemoryTracker* memory_tracker, std::string extensions) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
 
     if (!extensions.empty()) {
       TestHelper::SetupFeatureInfoInitExpectations(gl_.get(),
                                                    extensions.c_str());
       feature_info_->Initialize(NULL);
     }
 
     manager_.reset(new TextureManager(
         memory_tracker, feature_info_.get(),
         kMaxTextureSize, kMaxCubeMapTextureSize));
     decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     manager_->CreateTexture(kClient1Id, kService1Id);
-    texture_ = manager_->GetTexture(kClient1Id);
-    ASSERT_TRUE(texture_.get() != NULL);
+    texture_ref_ = manager_->GetTexture(kClient1Id);
+    ASSERT_TRUE(texture_ref_.get() != NULL);
   }
 
   virtual void TearDown() {
-    if (texture_.get()) {
+    if (texture_ref_.get()) {
       GLuint client_id = 0;
-      // If it's not in the manager then setting texture_ to NULL will
+      // If it's not in the manager then setting texture_ref_ to NULL will
       // delete the texture.
-      if (!manager_->GetClientId(texture_->service_id(), &client_id)) {
+      if (!manager_->GetClientId(texture_ref_->service_id(), &client_id)) {
         // Check that it gets deleted when the last reference is released.
         EXPECT_CALL(*gl_,
-            DeleteTextures(1, ::testing::Pointee(texture_->service_id())))
+            DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id())))
             .Times(1)
             .RetiresOnSaturation();
       }
-      texture_ = NULL;
+      texture_ref_ = NULL;
     }
     manager_->Destroy(false);
     manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   void SetParameter(
-      Texture* texture, GLenum pname, GLint value, GLenum error) {
+      TextureRef* texture_ref, GLenum pname, GLint value, GLenum error) {
     TestHelper::SetTexParameterWithExpectations(
         gl_.get(), error_state_.get(), manager_.get(),
-        texture, pname, value, error);
+        texture_ref, pname, value, error);
   }
 
   scoped_ptr<MockGLES2Decoder> decoder_;
   scoped_ptr<MockErrorState> error_state_;
   // 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> texture_;
+  scoped_refptr<TextureRef> texture_ref_;
 };
 
 class TextureTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     SetUpBase(NULL, std::string());
   }
 };
 
 class TextureMemoryTrackerTest : public TextureTestBase {
  protected:
   virtual void SetUp() {
     mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
     SetUpBase(mock_memory_tracker_.get(), std::string());
   }
 
   scoped_refptr<MockMemoryTracker> mock_memory_tracker_;
 };
 
 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \
     EXPECT_CALL(*mock_memory_tracker_, \
                 TrackMemoryAllocatedChange(old_size, new_size, pool)) \
         .Times(1) \
         .RetiresOnSaturation() \
 
 TEST_F(TextureTest, Basic) {
-  EXPECT_EQ(0u, texture_->target());
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
-  EXPECT_FALSE(texture_->IsImmutable());
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(0u, texture->target());
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  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());
+            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, texture_->estimated_size());
+  EXPECT_EQ(0u, texture->estimated_size());
 }
 
 TEST_F(TextureTest, SetTargetTexture2D) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
-  EXPECT_FALSE(texture_->IsImmutable());
+  Texture* texture = texture_ref_->texture();
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  EXPECT_FALSE(texture->IsImmutable());
 }
 
 TEST_F(TextureTest, SetTargetTextureExternalOES) {
-  manager_->SetTarget(texture_, GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
-  EXPECT_TRUE(texture_->IsImmutable());
-  manager_->SetStreamTexture(texture_, true);
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  Texture* texture = texture_ref_->texture();
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_EXTERNAL_OES);
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  EXPECT_TRUE(texture->SafeToRenderFrom());
+  EXPECT_TRUE(texture->IsImmutable());
+  manager_->SetStreamTexture(texture_ref_, true);
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
 }
 
 TEST_F(TextureTest, ZeroSizeCanNotRender) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->CanRender(texture_));
-  manager_->SetLevelInfo(texture_,
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 0, 0, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
 }
 
 TEST_F(TextureTest, EstimatedSize) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_EQ(8u * 4u * 4u, texture_->estimated_size());
-  manager_->SetLevelInfo(texture_,
+  EXPECT_EQ(8u * 4u * 4u, texture_ref_->texture()->estimated_size());
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 2, GL_RGBA, 8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_EQ(8u * 4u * 4u * 2u, texture_->estimated_size());
+  EXPECT_EQ(8u * 4u * 4u * 2u, texture_ref_->texture()->estimated_size());
 }
 
 TEST_F(TextureMemoryTrackerTest, EstimatedSize) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       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(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       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(TextureMemoryTrackerTest, SetParameterPool) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 128, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       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);
   SetParameter(
-      texture_, GL_TEXTURE_POOL_CHROMIUM, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+      texture_ref_, 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(TextureTest, POT2D) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to POT
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  EXPECT_EQ(0, texture->num_uncleared_mips());
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set filters to something that will work with a single mip.
-  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set them back.
-  SetParameter(
-      texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER,
+               GL_LINEAR_MIPMAP_LINEAR, GL_NO_ERROR);
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change a mip.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureMemoryTrackerTest, MarkMipmapsGenerated) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 64, MemoryTracker::kUnmanaged);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       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(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
   EXPECT_MEMORY_ALLOCATION_CHANGE(84, 0, MemoryTracker::kUnmanaged);
   EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
 }
 
 TEST_F(TextureTest, UnusedMips) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Set level zero to large size.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set level zero to large smaller (levels unused mips)
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Set an unused level to some size
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 4, GL_RGBA, 16, 16, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureTest, NPOT2D) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_LINEAR, GL_NO_ERROR);
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   // Change it to POT.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 }
 
 TEST_F(TextureTest, NPOT2DNPOTOK) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_npot");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  Texture* texture = texture_ref->texture();
 
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   // Check Setting level 0 to NPOT
-  manager.SetLevelInfo(texture,
+  manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   EXPECT_TRUE(TextureTestHelper::IsNPOT(texture));
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
-  EXPECT_TRUE(manager.CanGenerateMipmaps(texture));
-  EXPECT_FALSE(manager.CanRender(texture));
+  EXPECT_TRUE(manager.CanGenerateMipmaps(texture_ref));
+  EXPECT_FALSE(manager.CanRender(texture_ref));
   EXPECT_TRUE(manager.HaveUnrenderableTextures());
-  EXPECT_TRUE(manager.MarkMipmapsGenerated(texture));
+  EXPECT_TRUE(manager.MarkMipmapsGenerated(texture_ref));
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
-  EXPECT_TRUE(manager.CanRender(texture));
+  EXPECT_TRUE(manager.CanRender(texture_ref));
   EXPECT_FALSE(manager.HaveUnrenderableTextures());
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, POTCubeMap) {
-  manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_CUBE_MAP);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
   // Check Setting level 0 each face to POT
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_X,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_FALSE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_FALSE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
-  EXPECT_FALSE(manager_->CanRender(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
+  EXPECT_FALSE(manager_->CanRender(texture_ref_));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
 
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_TRUE(manager_->CanRender(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref_));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
 
   // Change a mip.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture_));
-  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_FALSE(TextureTestHelper::IsNPOT(texture));
+  EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
   // Set a level past the number of mips that would get generated.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
       3, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_));
+  EXPECT_TRUE(manager_->CanGenerateMipmaps(texture_ref_));
   // Make mips.
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture_));
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_TRUE(TextureTestHelper::IsCubeComplete(texture));
 }
 
 TEST_F(TextureTest, GetLevelSize) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   GLsizei width = -1;
   GLsizei height = -1;
-  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));
+  Texture* texture = texture_ref_->texture();
+  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(texture_->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(TextureTest, GetLevelType) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   GLenum type = -1;
   GLenum format = -1;
-  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));
+  Texture* texture = texture_ref_->texture();
+  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(texture_->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(TextureTest, ValidForTexture) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 5, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   // Check bad face.
-  EXPECT_FALSE(texture_->ValidForTexture(
+  Texture* texture = texture_ref_->texture();
+  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(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 0, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad xoffset.
-  EXPECT_FALSE(texture_->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(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 1, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad yoffset.
-  EXPECT_FALSE(texture_->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(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 1, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad width.
-  EXPECT_FALSE(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 5, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad height.
-  EXPECT_FALSE(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 6, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check bad format.
-  EXPECT_FALSE(texture_->ValidForTexture(
+  EXPECT_FALSE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGB, GL_UNSIGNED_BYTE));
   // Check bad type.
-  EXPECT_FALSE(texture_->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(texture_->ValidForTexture(
+  EXPECT_TRUE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
   // Check valid particial size.
-  EXPECT_TRUE(texture_->ValidForTexture(
+  EXPECT_TRUE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 1, 1, 2, 3, GL_RGBA, GL_UNSIGNED_BYTE));
   manager_->RemoveTexture(kClient1Id);
-  EXPECT_TRUE(texture_->ValidForTexture(
+  EXPECT_TRUE(texture->ValidForTexture(
       GL_TEXTURE_2D, 1, 0, 0, 4, 5, GL_RGBA, GL_UNSIGNED_BYTE));
 }
 
 TEST_F(TextureTest, FloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+  Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture,
+  manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameterWithExpectations(
       gl_.get(), error_state_.get(), &manager,
-      texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+      texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameterWithExpectations(
-      gl_.get(), error_state_.get(), &manager,
-      texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+      gl_.get(), error_state_.get(), &manager, texture_ref,
+      GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, FloatLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_float GL_OES_texture_float_linear");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+  Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture,
+  manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_FLOAT, true);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, HalfFloatNotLinear) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_texture_half_float");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+  Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture,
+  manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameterWithExpectations(
       gl_.get(), error_state_.get(), &manager,
-      texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+      texture_ref, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   EXPECT_FALSE(TextureTestHelper::IsTextureComplete(texture));
   TestHelper::SetTexParameterWithExpectations(
-      gl_.get(), error_state_.get(), &manager,
-      texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
+      gl_.get(), error_state_.get(), &manager, texture_ref,
+      GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST, GL_NO_ERROR);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 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());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
+  Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
-  manager.SetLevelInfo(texture,
+  manager.SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_HALF_FLOAT_OES, true);
   EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, EGLImageExternal) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_OES_EGL_image_external");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_EXTERNAL_OES);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
+  Texture* texture = texture_ref->texture();
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
-  EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
+  EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
 TEST_F(TextureTest, DepthTexture) {
   TestHelper::SetupFeatureInfoInitExpectations(
       gl_.get(), "GL_ANGLE_depth_texture");
   scoped_refptr<FeatureInfo> feature_info(new FeatureInfo());
   feature_info->Initialize(NULL);
   TextureManager manager(
       NULL, feature_info.get(), kMaxTextureSize, kMaxCubeMapTextureSize);
   manager.CreateTexture(kClient1Id, kService1Id);
-  Texture* texture = manager.GetTexture(kClient1Id);
-  ASSERT_TRUE(texture != NULL);
-  manager.SetTarget(texture, GL_TEXTURE_2D);
+  TextureRef* texture_ref = manager.GetTexture(kClient1Id);
+  ASSERT_TRUE(texture_ref != NULL);
+  manager.SetTarget(texture_ref, GL_TEXTURE_2D);
   manager.SetLevelInfo(
-      texture, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
+      texture_ref, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 4, 4, 1, 0,
       GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
-  EXPECT_FALSE(manager.CanGenerateMipmaps(texture));
+  EXPECT_FALSE(manager.CanGenerateMipmaps(texture_ref));
   manager.Destroy(false);
 }
 
 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, texture_->num_uncleared_mips());
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture_->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 0, true);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_,
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture_->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 1, true);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_,
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture_->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 0, true);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 0, true);
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture_->num_uncleared_mips());
-  manager_->SetLevelCleared(texture_, GL_TEXTURE_2D, 1, true);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture->num_uncleared_mips());
+  manager_->SetLevelCleared(texture_ref_, GL_TEXTURE_2D, 1, true);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_,
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture_->num_uncleared_mips());
-  manager_->MarkMipmapsGenerated(texture_);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture->num_uncleared_mips());
+  manager_->MarkMipmapsGenerated(texture_ref_);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  EXPECT_EQ(0, texture->num_uncleared_mips());
 
   manager_->CreateTexture(kClient2Id, kService2Id);
-  scoped_refptr<Texture> texture2(
+  scoped_refptr<TextureRef> texture_ref2(
       manager_->GetTexture(kClient2Id));
-  ASSERT_TRUE(texture2.get() != NULL);
-  manager_->SetTarget(texture2, GL_TEXTURE_2D);
+  ASSERT_TRUE(texture_ref2.get() != NULL);
+  manager_->SetTarget(texture_ref2, GL_TEXTURE_2D);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
+  Texture* texture2 = texture_ref2->texture();
   EXPECT_EQ(0, texture2->num_uncleared_mips());
-  manager_->SetLevelInfo(texture2,
+  manager_->SetLevelInfo(texture_ref2,
       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, texture2->num_uncleared_mips());
-  manager_->SetLevelInfo(texture2,
+  manager_->SetLevelInfo(texture_ref2,
       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, texture2->num_uncleared_mips());
 
   manager_->CreateTexture(kClient3Id, kService3Id);
-  scoped_refptr<Texture> texture3(
+  scoped_refptr<TextureRef> texture_ref3(
       manager_->GetTexture(kClient3Id));
-  ASSERT_TRUE(texture3.get() != NULL);
-  manager_->SetTarget(texture3, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture3,
+  ASSERT_TRUE(texture_ref3.get() != NULL);
+  manager_->SetTarget(texture_ref3, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref3,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
+  Texture* texture3 = texture_ref3->texture();
   EXPECT_EQ(1, texture3->num_uncleared_mips());
-  manager_->SetLevelCleared(texture2, GL_TEXTURE_2D, 0, true);
+  manager_->SetLevelCleared(texture_ref2, GL_TEXTURE_2D, 0, true);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, texture2->num_uncleared_mips());
-  manager_->SetLevelCleared(texture3, GL_TEXTURE_2D, 0, true);
+  manager_->SetLevelCleared(texture_ref3, GL_TEXTURE_2D, 0, true);
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
   EXPECT_EQ(0, texture3->num_uncleared_mips());
 
-  manager_->SetLevelInfo(texture2,
+  manager_->SetLevelInfo(texture_ref2,
       GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(texture3,
+  manager_->SetLevelInfo(texture_ref3,
       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, texture2->num_uncleared_mips());
   EXPECT_EQ(1, texture3->num_uncleared_mips());
   manager_->RemoveTexture(kClient3Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   manager_->RemoveTexture(kClient2Id);
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
-  texture2 = NULL;
+  texture_ref2 = NULL;
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService3Id)))
       .Times(1)
       .RetiresOnSaturation();
-  texture3 = NULL;
+  texture_ref3 = NULL;
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
 }
 
 TEST_F(TextureTest, ClearTexture) {
   EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  Texture* texture = texture_ref_->texture();
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture_->num_uncleared_mips());
-  manager_->ClearRenderableLevels(decoder_.get(), texture_);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture->num_uncleared_mips());
+  manager_->ClearRenderableLevels(decoder_.get(), texture_ref_);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
-  manager_->SetLevelInfo(texture_,
+  EXPECT_EQ(0, texture->num_uncleared_mips());
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(2, texture_->num_uncleared_mips());
-  manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 0);
-  EXPECT_FALSE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(2, texture->num_uncleared_mips());
+  manager_->ClearTextureLevel(decoder_.get(), texture_ref_, GL_TEXTURE_2D, 0);
+  EXPECT_FALSE(texture->SafeToRenderFrom());
   EXPECT_TRUE(manager_->HaveUnsafeTextures());
   EXPECT_TRUE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(1, texture_->num_uncleared_mips());
-  manager_->ClearTextureLevel(decoder_.get(), texture_, GL_TEXTURE_2D, 1);
-  EXPECT_TRUE(texture_->SafeToRenderFrom());
+  EXPECT_EQ(1, texture->num_uncleared_mips());
+  manager_->ClearTextureLevel(decoder_.get(), texture_ref_, GL_TEXTURE_2D, 1);
+  EXPECT_TRUE(texture->SafeToRenderFrom());
   EXPECT_FALSE(manager_->HaveUnsafeTextures());
   EXPECT_FALSE(manager_->HaveUnclearedMips());
-  EXPECT_EQ(0, texture_->num_uncleared_mips());
+  EXPECT_EQ(0, texture->num_uncleared_mips());
 }
 
 TEST_F(TextureTest, UseDeletedTexture) {
   static const GLuint kClient2Id = 2;
   static const GLuint kService2Id = 12;
   // Make the default texture renderable
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       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> texture(
+  scoped_refptr<TextureRef> texture_ref(
       manager_->GetTexture(kClient2Id));
-  manager_->SetTarget(texture, GL_TEXTURE_2D);
-  EXPECT_FALSE(manager_->CanRender(texture));
+  manager_->SetTarget(texture_ref, GL_TEXTURE_2D);
+  EXPECT_FALSE(manager_->CanRender(texture_ref));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Remove it.
   manager_->RemoveTexture(kClient2Id);
-  EXPECT_FALSE(manager_->CanRender(texture));
+  EXPECT_FALSE(manager_->CanRender(texture_ref));
   EXPECT_TRUE(manager_->HaveUnrenderableTextures());
   // Check that we can still manipulate it and it effects the manager.
-  manager_->SetLevelInfo(texture,
+  manager_->SetLevelInfo(texture_ref,
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
-  EXPECT_TRUE(manager_->CanRender(texture));
+  EXPECT_TRUE(manager_->CanRender(texture_ref));
   EXPECT_FALSE(manager_->HaveUnrenderableTextures());
   EXPECT_CALL(*gl_, DeleteTextures(1, ::testing::Pointee(kService2Id)))
       .Times(1)
       .RetiresOnSaturation();
-  texture = NULL;
+  texture_ref = NULL;
 }
 
 TEST_F(TextureTest, GetLevelImage) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Set image.
-  manager_->SetLevelImage(texture_,
+  manager_->SetLevelImage(texture_ref_,
       GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
-  EXPECT_FALSE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_FALSE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
   // Remove it.
-  manager_->SetLevelImage(texture_, GL_TEXTURE_2D, 1, NULL);
-  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
-  manager_->SetLevelImage(texture_,
+  manager_->SetLevelImage(texture_ref_, GL_TEXTURE_2D, 1, NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  manager_->SetLevelImage(texture_ref_,
       GL_TEXTURE_2D, 1, gfx::GLImage::CreateGLImage(0));
   // Image should be reset when SetLevelInfo is called.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  EXPECT_TRUE(texture_->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
+  EXPECT_TRUE(texture->GetLevelImage(GL_TEXTURE_2D, 1) == NULL);
 }
 
 namespace {
 
 bool InSet(std::set<std::string>* string_set, const std::string& str) {
   std::pair<std::set<std::string>::iterator, bool> result =
       string_set->insert(str);
   return !result.second;
 }
 
 }  // anonymous namespace
 
 TEST_F(TextureTest, AddToSignature) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  manager_->SetLevelInfo(texture_,
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   std::string signature1;
   std::string signature2;
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature1);
+  manager_->AddToSignature(texture_ref_, 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(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 4, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // check putting it back makes the same signature.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, true);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check setting cleared status does not change signature.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check changing other settings changes signature.
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 4, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_FLOAT,
       false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // put it back
-  manager_->SetLevelInfo(texture_,
+  manager_->SetLevelInfo(texture_ref_,
       GL_TEXTURE_2D, 1, GL_RGBA, 2, 2, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       false);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // check changing parameters changes signature.
-  SetParameter(texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  SetParameter(
-      texture_, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR);
-  SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_MIN_FILTER,
+               GL_NEAREST_MIPMAP_LINEAR, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_MAG_FILTER, GL_NEAREST, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  SetParameter(texture_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
-  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_MAG_FILTER, GL_LINEAR, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  SetParameter(texture_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
-  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_S, GL_REPEAT, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // Check putting it back genenerates the same signature
-  SetParameter(texture_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
+  SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
   signature2.clear();
-  manager_->AddToSignature(texture_, GL_TEXTURE_2D, 1, &signature2);
+  manager_->AddToSignature(texture_ref_, GL_TEXTURE_2D, 1, &signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check the set was acutally getting different signatures.
   EXPECT_EQ(11u, string_set.size());
 }
 
 class SaveRestoreTextureTest : public TextureTest {
  public:
   virtual void SetUp() {
     TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external");
@@ skipping 60 matching lines @@
     GLenum target;
     GLenum format;
     GLsizei width;
     GLsizei height;
     GLsizei depth;
     GLint border;
     GLenum type;
     bool cleared;
   };
 
-  void SetLevelInfo(Texture* texture, GLint level, const LevelInfo& info) {
-    manager_->SetLevelInfo(texture,
+  void SetLevelInfo(TextureRef* texture_ref,
+                    GLint level,
+                    const LevelInfo& info) {
+    manager_->SetLevelInfo(texture_ref,
                            info.target,
                            level,
                            info.format,
                            info.width,
                            info.height,
                            info.depth,
                            info.border,
                            info.format,
                            info.type,
                            info.cleared);
   }
 
-  static LevelInfo GetLevelInfo(const Texture* texture,
+  static LevelInfo GetLevelInfo(const TextureRef* texture_ref,
                                 GLint target,
                                 GLint level) {
+    const Texture* texture = texture_ref->texture();
     LevelInfo info;
     info.target = target;
     EXPECT_TRUE(texture->GetLevelSize(target, level, &info.width,
                                       &info.height));
     EXPECT_TRUE(texture->GetLevelType(target, level, &info.type,
                                       &info.format));
     info.cleared = texture->IsLevelCleared(target, level);
     return info;
   }
 
-  TextureDefinition* Save(Texture* texture) {
+  TextureDefinition* Save(TextureRef* texture_ref) {
     EXPECT_CALL(*gl_, GenTextures(_, _))
         .WillOnce(SetArgumentPointee<1>(kEmptyTextureServiceId));
-    TextureDefinition* definition = manager_->Save(texture);
+    TextureDefinition* definition = manager_->Save(texture_ref);
     EXPECT_TRUE(definition != NULL);
     return definition;
   }
 
-  void Restore(Texture* texture, TextureDefinition* definition) {
-    EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(texture->service_id())))
+  void Restore(TextureRef* texture_ref, TextureDefinition* definition) {
+    EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(texture_ref->service_id())))
         .Times(1).RetiresOnSaturation();
     EXPECT_CALL(*gl_,
                 BindTexture(definition->target(), definition->service_id()))
         .Times(1).RetiresOnSaturation();
     EXPECT_CALL(*gl_, TexParameteri(_, _, _)).Times(AtLeast(1));
 
-    EXPECT_TRUE(
-        manager_->Restore("TextureTest", decoder_.get(), texture, definition));
+    EXPECT_TRUE(manager_->Restore("TextureTest", decoder_.get(),
+                                  texture_ref, definition));
   }
 
-  scoped_refptr<Texture> texture2_;
+  scoped_refptr<TextureRef> texture2_;
 
  private:
   static const GLuint kEmptyTextureServiceId;
   static const GLuint kClient2Id;
   static const GLuint kService2Id;
 };
 
 const GLuint SaveRestoreTextureTest::kClient2Id = 2;
 const GLuint SaveRestoreTextureTest::kService2Id = 12;
 const GLuint SaveRestoreTextureTest::kEmptyTextureServiceId = 13;
 
 TEST_F(SaveRestoreTextureTest, SaveRestore2D) {
-  manager_->SetTarget(texture_, GL_TEXTURE_2D);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_2D);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D), texture->target());
   LevelInfo level0(
       GL_TEXTURE_2D, GL_RGBA, 4, 4, 1, 0, GL_UNSIGNED_BYTE, true);
-  SetLevelInfo(texture_, 0, level0);
-  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  LevelInfo level1 = GetLevelInfo(texture_.get(), GL_TEXTURE_2D, 1);
-  LevelInfo level2 = GetLevelInfo(texture_.get(), GL_TEXTURE_2D, 2);
-  scoped_ptr<TextureDefinition> definition(Save(texture_));
+  SetLevelInfo(texture_ref_, 0, level0);
+  EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture_ref_));
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  LevelInfo level1 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 1);
+  LevelInfo level2 = GetLevelInfo(texture_ref_.get(), GL_TEXTURE_2D, 2);
+  scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
   const TextureDefinition::LevelInfos& infos = definition->level_infos();
   EXPECT_EQ(1U, infos.size());
   EXPECT_EQ(3U, infos[0].size());
 
   // Make this texture bigger with more levels, and make sure they get
   // clobbered correctly during Restore().
   manager_->SetTarget(texture2_, GL_TEXTURE_2D);
   SetLevelInfo(
       texture2_,
       0,
       LevelInfo(GL_TEXTURE_2D, GL_RGBA, 16, 16, 1, 0, GL_UNSIGNED_BYTE, false));
   EXPECT_TRUE(manager_->MarkMipmapsGenerated(texture2_));
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture2_));
-  EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture2_->estimated_size());
+  texture = texture2_->texture();
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  EXPECT_EQ(1024U + 256U + 64U + 16U + 4U, texture->estimated_size());
   Restore(texture2_, definition.release());
   EXPECT_EQ(level0, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 0));
   EXPECT_EQ(level1, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 1));
   EXPECT_EQ(level2, GetLevelInfo(texture2_.get(), GL_TEXTURE_2D, 2));
-  EXPECT_EQ(64U + 16U + 4U, texture2_->estimated_size());
+  EXPECT_EQ(64U + 16U + 4U, texture->estimated_size());
   GLint w, h;
-  EXPECT_TRUE(texture2_->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
+  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
   EXPECT_EQ(0, w);
   EXPECT_EQ(0, h);
 }
 
 TEST_F(SaveRestoreTextureTest, SaveRestoreClearRectangle) {
-  manager_->SetTarget(texture_, GL_TEXTURE_RECTANGLE_ARB);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_RECTANGLE_ARB);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), texture->target());
   LevelInfo level0(
       GL_TEXTURE_RECTANGLE_ARB, GL_RGBA, 1, 1, 1, 0, GL_UNSIGNED_BYTE, false);
-  SetLevelInfo(texture_, 0, level0);
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  scoped_ptr<TextureDefinition> definition(Save(texture_));
+  SetLevelInfo(texture_ref_, 0, level0);
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
   const TextureDefinition::LevelInfos& infos = definition->level_infos();
   EXPECT_EQ(1U, infos.size());
   EXPECT_EQ(1U, infos[0].size());
   EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB), infos[0][0].target);
   manager_->SetTarget(texture2_, GL_TEXTURE_RECTANGLE_ARB);
   Restore(texture2_, definition.release());
 
   // See if we can clear the previously uncleared level now.
   EXPECT_EQ(level0, GetLevelInfo(texture2_.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
   EXPECT_CALL(*decoder_, ClearLevel(_, _, _, _, _, _, _, _, _))
       .WillRepeatedly(Return(true));
   EXPECT_TRUE(manager_->ClearTextureLevel(
       decoder_.get(), texture2_, GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 TEST_F(SaveRestoreTextureTest, SaveRestoreStreamTexture) {
-  manager_->SetTarget(texture_, GL_TEXTURE_EXTERNAL_OES);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture_->target());
-  manager_->SetStreamTexture(texture_, true);
-  GLuint service_id = texture_->service_id();
-  scoped_ptr<TextureDefinition> definition(Save(texture_));
-  EXPECT_FALSE(texture_->IsStreamTexture());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_EXTERNAL_OES);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), texture->target());
+  manager_->SetStreamTexture(texture_ref_, true);
+  GLuint service_id = texture->service_id();
+  scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
+  EXPECT_FALSE(texture->IsStreamTexture());
   manager_->SetTarget(texture2_, GL_TEXTURE_EXTERNAL_OES);
   Restore(texture2_, definition.release());
-  EXPECT_TRUE(texture2_->IsStreamTexture());
-  EXPECT_TRUE(texture2_->IsImmutable());
+  EXPECT_TRUE(texture2_->texture()->IsStreamTexture());
+  EXPECT_TRUE(texture2_->texture()->IsImmutable());
   EXPECT_EQ(service_id, texture2_->service_id());
 }
 
 TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
-  manager_->SetTarget(texture_, GL_TEXTURE_CUBE_MAP);
-  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture_->target());
+  manager_->SetTarget(texture_ref_, GL_TEXTURE_CUBE_MAP);
+  Texture* texture = texture_ref_->texture();
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_CUBE_MAP), texture->target());
   LevelInfo face0(GL_TEXTURE_CUBE_MAP_POSITIVE_X,
                   GL_RGBA,
                   1,
                   1,
                   1,
                   0,
                   GL_UNSIGNED_BYTE,
                   true);
   LevelInfo face5(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
                   GL_RGBA,
                   3,
                   3,
                   1,
                   0,
                   GL_UNSIGNED_BYTE,
                   true);
-  SetLevelInfo(texture_, 0, face0);
-  SetLevelInfo(texture_, 0, face5);
-  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture_));
-  scoped_ptr<TextureDefinition> definition(Save(texture_));
+  SetLevelInfo(texture_ref_, 0, face0);
+  SetLevelInfo(texture_ref_, 0, face5);
+  EXPECT_TRUE(TextureTestHelper::IsTextureComplete(texture));
+  scoped_ptr<TextureDefinition> definition(Save(texture_ref_));
   const TextureDefinition::LevelInfos& infos = definition->level_infos();
   EXPECT_EQ(6U, infos.size());
   EXPECT_EQ(1U, infos[0].size());
   manager_->SetTarget(texture2_, GL_TEXTURE_CUBE_MAP);
   Restore(texture2_, definition.release());
   EXPECT_EQ(face0,
             GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0));
   EXPECT_EQ(face5,
             GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0));
 }
 
+class CountingMemoryTracker : public MemoryTracker {
+ public:
+  CountingMemoryTracker() {
+    current_size_[0] = 0;
+    current_size_[1] = 0;
+  }
+
+  virtual void TrackMemoryAllocatedChange(size_t old_size,
+                                          size_t new_size,
+                                          Pool pool)  OVERRIDE {
+    DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
+    current_size_[pool] += new_size - old_size;
+  }
+
+  virtual bool EnsureGPUMemoryAvailable(size_t size_needed) OVERRIDE {
+    return true;
+  }
+
+  size_t GetSize(Pool pool) {
+    DCHECK_LT(static_cast<size_t>(pool), arraysize(current_size_));
+    return current_size_[pool];
+  }
+
+ private:
+  virtual ~CountingMemoryTracker() {}
+
+  size_t current_size_[2];
+  DISALLOW_COPY_AND_ASSIGN(CountingMemoryTracker);
+};
+
+class SharedTextureTest : public testing::Test {
+ public:
+  SharedTextureTest()
+      : feature_info_(new FeatureInfo()) {
+  }
+
+  virtual ~SharedTextureTest() {
+  }
+
+  virtual void SetUp() {
+    gl_.reset(new ::gfx::MockGLInterface());
+    ::gfx::GLInterface::SetGLInterface(gl_.get());
+
+    memory_tracker1_ = new CountingMemoryTracker;
+    texture_manager1_.reset(new TextureManager(
+        memory_tracker1_, feature_info_.get(),
+        TextureManagerTest::kMaxTextureSize,
+        TextureManagerTest::kMaxCubeMapTextureSize));
+    memory_tracker2_ = new CountingMemoryTracker;
+    texture_manager2_.reset(new TextureManager(
+        memory_tracker2_, feature_info_.get(),
+        TextureManagerTest::kMaxTextureSize,
+        TextureManagerTest::kMaxCubeMapTextureSize));
+    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    texture_manager1_->Initialize();
+    TestHelper::SetupTextureManagerInitExpectations(gl_.get(), "");
+    texture_manager2_->Initialize();
+  }
+
+  virtual void TearDown() {
+    texture_manager2_->Destroy(false);
+    texture_manager2_.reset();
+    texture_manager1_->Destroy(false);
+    texture_manager1_.reset();
+    ::gfx::GLInterface::SetGLInterface(NULL);
+    gl_.reset();
+  }
+
+ protected:
+  scoped_ptr< ::gfx::MockGLInterface > gl_;
+  scoped_refptr<FeatureInfo> feature_info_;
+  scoped_refptr<CountingMemoryTracker> memory_tracker1_;
+  scoped_ptr<TextureManager> texture_manager1_;
+  scoped_refptr<CountingMemoryTracker> memory_tracker2_;
+  scoped_ptr<TextureManager> texture_manager2_;
+};
+
+TEST_F(SharedTextureTest, DeleteTextures) {
+  scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+  scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+                                                  ref1->texture());
+  EXPECT_CALL(*gl_, DeleteTextures(1, _))
+      .Times(0);
+  ref1 = NULL;
+  texture_manager1_->RemoveTexture(10);
+  testing::Mock::VerifyAndClearExpectations(gl_.get());
+
+  EXPECT_CALL(*gl_, DeleteTextures(1, _))
+      .Times(1)
+      .RetiresOnSaturation();
+  ref2 = NULL;
+  testing::Mock::VerifyAndClearExpectations(gl_.get());
+}
+
+TEST_F(SharedTextureTest, TextureSafetyAccounting) {
+  EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
+  EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+  EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
+  EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+  // Newly created texture is unrenderable.
+  scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+  EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures());
+  EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+
+  // Associate new texture ref to other texture manager, should account for it
+  // too.
+  scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+                                                  ref1->texture());
+  EXPECT_TRUE(texture_manager2_->HaveUnrenderableTextures());
+  EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+  // Make texture renderable but uncleared on one texture manager, should affect
+  // other one.
+  texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+  texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                                  GL_RGBA, GL_UNSIGNED_BYTE, false);
+  EXPECT_FALSE(texture_manager1_->HaveUnrenderableTextures());
+  EXPECT_TRUE(texture_manager1_->HaveUnsafeTextures());
+  EXPECT_TRUE(texture_manager1_->HaveUnclearedMips());
+  EXPECT_FALSE(texture_manager2_->HaveUnrenderableTextures());
+  EXPECT_TRUE(texture_manager2_->HaveUnsafeTextures());
+  EXPECT_TRUE(texture_manager2_->HaveUnclearedMips());
+
+  // Make texture cleared on one texture manager, should affect other one.
+  texture_manager1_->SetLevelCleared(ref1, GL_TEXTURE_2D, 0, true);
+  EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
+  EXPECT_FALSE(texture_manager2_->HaveUnsafeTextures());
+  EXPECT_FALSE(texture_manager2_->HaveUnclearedMips());
+
+  EXPECT_CALL(*gl_, DeleteTextures(1, _))
+      .Times(1)
+      .RetiresOnSaturation();
+  texture_manager1_->RemoveTexture(10);
+}
+
+TEST_F(SharedTextureTest, FBOCompletenessCheck) {
+  const GLenum kCompleteValue = GL_FRAMEBUFFER_COMPLETE;
+  FramebufferManager framebuffer_manager1(1, 1);
+  texture_manager1_->set_framebuffer_manager(&framebuffer_manager1);
+  FramebufferManager framebuffer_manager2(1, 1);
+  texture_manager2_->set_framebuffer_manager(&framebuffer_manager2);
+
+  scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+  framebuffer_manager1.CreateFramebuffer(10, 10);
+  scoped_refptr<Framebuffer> framebuffer1 =
+      framebuffer_manager1.GetFramebuffer(10);
+  framebuffer1->AttachTexture(GL_COLOR_ATTACHMENT0, ref1, GL_TEXTURE_2D, 0);
+  EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1));
+  EXPECT_NE(kCompleteValue, framebuffer1->IsPossiblyComplete());
+
+  // Make FBO complete in manager 1.
+  texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+  texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                                  GL_RGBA, GL_UNSIGNED_BYTE, true);
+  EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
+  framebuffer_manager1.MarkAsComplete(framebuffer1);
+  EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1));
+
+  // Share texture with manager 2.
+  scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+                                                  ref1->texture());
+  framebuffer_manager2.CreateFramebuffer(20, 20);
+  scoped_refptr<Framebuffer> framebuffer2 =
+      framebuffer_manager2.GetFramebuffer(20);
+  framebuffer2->AttachTexture(GL_COLOR_ATTACHMENT0, ref2, GL_TEXTURE_2D, 0);
+  EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2));
+  EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
+  framebuffer_manager2.MarkAsComplete(framebuffer2);
+  EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2));
+
+  // Change level for texture, both FBOs should be marked incomplete
+  texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 1, 0,
+                                  GL_RGBA, GL_UNSIGNED_BYTE, true);
+  EXPECT_FALSE(framebuffer_manager1.IsComplete(framebuffer1));
+  EXPECT_EQ(kCompleteValue, framebuffer1->IsPossiblyComplete());
+  framebuffer_manager1.MarkAsComplete(framebuffer1);
+  EXPECT_TRUE(framebuffer_manager1.IsComplete(framebuffer1));
+  EXPECT_FALSE(framebuffer_manager2.IsComplete(framebuffer2));
+  EXPECT_EQ(kCompleteValue, framebuffer2->IsPossiblyComplete());
+  framebuffer_manager2.MarkAsComplete(framebuffer2);
+  EXPECT_TRUE(framebuffer_manager2.IsComplete(framebuffer2));
+
+  EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, _))
+      .Times(2)
+      .RetiresOnSaturation();
+  framebuffer_manager1.RemoveFramebuffer(10);
+  framebuffer_manager2.RemoveFramebuffer(20);
+  EXPECT_CALL(*gl_, DeleteTextures(1, _))
+      .Times(1)
+      .RetiresOnSaturation();
+  texture_manager1_->RemoveTexture(10);
+}
+
+TEST_F(SharedTextureTest, Memory) {
+  size_t initial_memory1 = memory_tracker1_->GetSize(MemoryTracker::kUnmanaged);
+  size_t initial_memory2 = memory_tracker2_->GetSize(MemoryTracker::kUnmanaged);
+
+  // Newly created texture is unrenderable.
+  scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
+  texture_manager1_->SetTarget(ref1, GL_TEXTURE_2D);
+  texture_manager1_->SetLevelInfo(ref1, GL_TEXTURE_2D, 0, GL_RGBA, 10, 10, 1, 0,
+                                  GL_RGBA, GL_UNSIGNED_BYTE, false);
+
+  EXPECT_LT(0u, ref1->texture()->estimated_size());
+  EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
+            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+
+  // Associate new texture ref to other texture manager, it doesn't account for
+  // the texture memory, the first memory tracker still has it.
+  scoped_refptr<TextureRef> ref2 = new TextureRef(texture_manager2_.get(),
+                                                  ref1->texture());
+  EXPECT_EQ(initial_memory1 + ref1->texture()->estimated_size(),
+            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(initial_memory2,
+            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+
+  // Delete the texture, memory should go to the remaining tracker.
+  texture_manager1_->RemoveTexture(10);
+  ref1 = NULL;
+  EXPECT_EQ(initial_memory1,
+            memory_tracker1_->GetSize(MemoryTracker::kUnmanaged));
+  EXPECT_EQ(initial_memory2 + ref2->texture()->estimated_size(),
+            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+
+  EXPECT_CALL(*gl_, DeleteTextures(1, _))
+      .Times(1)
+      .RetiresOnSaturation();
+  ref2 = NULL;
+  EXPECT_EQ(initial_memory2,
+            memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
+}
+
 }  // namespace gles2
 }  // namespace gpu
-
-