gpu: Change Produce/ConsumeTexture to allow texture sharing

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/mailbox_manager.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;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::StrictMock;
 using ::testing::_;
 
@@ skipping 76 matching lines @@
 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.
-  TextureRef* texture = manager_->GetTexture(kClient1Id);
+  scoped_refptr<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);
+  EXPECT_EQ(kClient1Id, texture->client_id());
+  EXPECT_EQ(texture->texture(), manager_->GetTextureForServiceId(
+      texture->service_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);
+  EXPECT_EQ(0u, texture->client_id());
 }
 
 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.
   TextureRef* texture_ref = manager_->GetTexture(kClient1Id);
   ASSERT_TRUE(texture_ref != NULL);
@@ skipping 247 matching lines @@
         kMaxTextureSize, kMaxCubeMapTextureSize));
     decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     manager_->CreateTexture(kClient1Id, kService1Id);
     texture_ref_ = manager_->GetTexture(kClient1Id);
     ASSERT_TRUE(texture_ref_.get() != NULL);
   }
 
   virtual void TearDown() {
     if (texture_ref_.get()) {
-      GLuint client_id = 0;
       // If it's not in the manager then setting texture_ref_ to NULL will
       // delete the texture.
-      if (!manager_->GetClientId(texture_ref_->service_id(), &client_id)) {
+      if (!texture_ref_->client_id()) {
         // Check that it gets deleted when the last reference is released.
         EXPECT_CALL(*gl_,
             DeleteTextures(1, ::testing::Pointee(texture_ref_->service_id())))
             .Times(1)
             .RetiresOnSaturation();
       }
       texture_ref_ = NULL;
     }
     manager_->Destroy(false);
     manager_.reset();
@@ skipping 909 matching lines @@
   // Check putting it back genenerates the same signature
   SetParameter(texture_ref_, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_NO_ERROR);
   signature2.clear();
   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 {
+class ProduceConsumeTextureTest : public TextureTest {
  public:
   virtual void SetUp() {
     TextureTest::SetUpBase(NULL, "GL_OES_EGL_image_external");
     manager_->CreateTexture(kClient2Id, kService2Id);
     texture2_ = manager_->GetTexture(kClient2Id);
 
     EXPECT_CALL(*decoder_.get(), GetErrorState())
       .WillRepeatedly(Return(error_state_.get()));
   }
 
   virtual void TearDown() {
     if (texture2_.get()) {
-      GLuint client_id = 0;
       // If it's not in the manager then setting texture2_ to NULL will
       // delete the texture.
-      if (!manager_->GetClientId(texture2_->service_id(), &client_id)) {
+      if (!texture2_->client_id()) {
         // Check that it gets deleted when the last reference is released.
         EXPECT_CALL(
             *gl_,
             DeleteTextures(1, ::testing::Pointee(texture2_->service_id())))
             .Times(1).RetiresOnSaturation();
       }
       texture2_ = NULL;
     }
     TextureTest::TearDown();
   }
@@ skipping 67 matching lines @@
     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(TextureRef* texture_ref) {
-    EXPECT_CALL(*gl_, GenTextures(_, _))
-        .WillOnce(SetArgumentPointee<1>(kEmptyTextureServiceId));
-    TextureDefinition* definition = manager_->Save(texture_ref);
-    EXPECT_TRUE(definition != NULL);
-    return definition;
+  Texture* Produce(TextureRef* texture_ref) {
+    Texture* texture = manager_->Produce(texture_ref);
+    EXPECT_TRUE(texture != NULL);
+    return texture;
   }
 
-  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_ref, definition));
+  void Consume(GLuint client_id, Texture* texture) {
+    EXPECT_TRUE(manager_->Consume(client_id, texture));
   }
 
   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;
+const GLuint ProduceConsumeTextureTest::kClient2Id = 2;
+const GLuint ProduceConsumeTextureTest::kService2Id = 12;
 
-TEST_F(SaveRestoreTextureTest, SaveRestore2D) {
+TEST_F(ProduceConsumeTextureTest, ProduceConsume2D) {
   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_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());
+  Texture* produced_texture = Produce(texture_ref_);
+  EXPECT_EQ(produced_texture, texture);
 
   // Make this texture bigger with more levels, and make sure they get
-  // clobbered correctly during Restore().
+  // clobbered correctly during Consume().
   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_));
   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));
+
+  GLuint client_id = texture2_->client_id();
+  manager_->RemoveTexture(client_id);
+  Consume(client_id, produced_texture);
+  scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
+  EXPECT_EQ(produced_texture, restored_texture->texture());
+  EXPECT_EQ(level0, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 0));
+  EXPECT_EQ(level1, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 1));
+  EXPECT_EQ(level2, GetLevelInfo(restored_texture.get(), GL_TEXTURE_2D, 2));
+  texture = restored_texture->texture();
   EXPECT_EQ(64U + 16U + 4U, texture->estimated_size());
   GLint w, h;
-  EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
-  EXPECT_EQ(0, w);
-  EXPECT_EQ(0, h);
+  EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 3, &w, &h));
+
+  // However the old texture ref still exists if it was referenced somewhere.
+  EXPECT_EQ(1024U + 256U + 64U + 16U + 4U,
+            texture2_->texture()->estimated_size());
 }
 
-TEST_F(SaveRestoreTextureTest, SaveRestoreClearRectangle) {
+TEST_F(ProduceConsumeTextureTest, ProduceConsumeClearRectangle) {
   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_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());
+  Texture* produced_texture = Produce(texture_ref_);
+  EXPECT_EQ(produced_texture, texture);
+  EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_RECTANGLE_ARB),
+            produced_texture->target());
+
+  GLuint client_id = texture2_->client_id();
+  manager_->RemoveTexture(client_id);
+  Consume(client_id, produced_texture);
+  scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
+  EXPECT_EQ(produced_texture, restored_texture->texture());
 
   // See if we can clear the previously uncleared level now.
-  EXPECT_EQ(level0, GetLevelInfo(texture2_.get(), GL_TEXTURE_RECTANGLE_ARB, 0));
+  EXPECT_EQ(level0,
+            GetLevelInfo(restored_texture.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));
+      decoder_.get(), restored_texture, GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
-TEST_F(SaveRestoreTextureTest, SaveRestoreStreamTexture) {
+TEST_F(ProduceConsumeTextureTest, ProduceConsumeStreamTexture) {
   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_->texture()->IsStreamTexture());
-  EXPECT_TRUE(texture2_->texture()->IsImmutable());
-  EXPECT_EQ(service_id, texture2_->service_id());
+  Texture* produced_texture = Produce(texture_ref_);
+  EXPECT_TRUE(texture->IsStreamTexture());
+
+  GLuint client_id = texture2_->client_id();
+  manager_->RemoveTexture(client_id);
+  Consume(client_id, produced_texture);
+  scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
+  EXPECT_EQ(produced_texture, restored_texture->texture());
+  EXPECT_TRUE(restored_texture->texture()->IsStreamTexture());
+  EXPECT_TRUE(restored_texture->texture()->IsImmutable());
+  EXPECT_EQ(service_id, restored_texture->service_id());
 }
 
-TEST_F(SaveRestoreTextureTest, SaveRestoreCube) {
+TEST_F(ProduceConsumeTextureTest, ProduceConsumeCube) {
   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_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());
+  Texture* produced_texture = Produce(texture_ref_);
+  EXPECT_EQ(produced_texture, texture);
+
+  GLuint client_id = texture2_->client_id();
+  manager_->RemoveTexture(client_id);
+  Consume(client_id, produced_texture);
+  scoped_refptr<TextureRef> restored_texture = manager_->GetTexture(client_id);
+  EXPECT_EQ(produced_texture, restored_texture->texture());
   EXPECT_EQ(face0,
-            GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0));
+            GetLevelInfo(restored_texture, GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0));
   EXPECT_EQ(face5,
-            GetLevelInfo(texture2_.get(), GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0));
+            GetLevelInfo(restored_texture, 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,
@@ skipping 61 matching lines @@
   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());
+  scoped_refptr<TextureRef> ref2 =
+      texture_manager2_->Consume(20, 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;
+  texture_manager2_->RemoveTexture(20);
   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.
+  // Newly created texture is renderable.
   scoped_refptr<TextureRef> ref1 = texture_manager1_->CreateTexture(10, 10);
   EXPECT_FALSE(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());
+  scoped_refptr<TextureRef> ref2 =
+      texture_manager2_->Consume(20, ref1->texture());
   EXPECT_FALSE(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);
   EXPECT_TRUE(texture_manager1_->HaveUnrenderableTextures());
   EXPECT_FALSE(texture_manager1_->HaveUnsafeTextures());
   EXPECT_FALSE(texture_manager1_->HaveUnclearedMips());
@@ skipping 14 matching lines @@
   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);
+  texture_manager2_->RemoveTexture(20);
 }
 
 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());
+  scoped_refptr<TextureRef> ref2 =
+      texture_manager2_->Consume(20, 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
@@ skipping 10 matching lines @@
 
   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);
+  texture_manager2_->RemoveTexture(20);
 }
 
 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());
+  scoped_refptr<TextureRef> ref2 =
+      texture_manager2_->Consume(20, 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;
+  texture_manager2_->RemoveTexture(20);
   EXPECT_EQ(initial_memory2,
             memory_tracker2_->GetSize(MemoryTracker::kUnmanaged));
 }
 
 }  // namespace gles2
 }  // namespace gpu