Add more tests for MemoryTracker usage.

BUG=NONE


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

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

3 files changed, 211 insertions, 104 deletions

diff --git a/gpu/command_buffer/service/buffer_manager.h b/gpu/command_buffer/service/buffer_manager.h
index ae8fcbb..bd83537 100644
--- a/gpu/command_buffer/service/buffer_manager.h
+++ b/gpu/command_buffer/service/buffer_manager.h
@@ -69,7 +69,7 @@ class GPU_EXPORT BufferManager {
 
    private:
     friend class BufferManager;
-    friend class BufferManagerTest;
+    friend class BufferManagerTestBase;
     friend class base::RefCounted<BufferInfo>;
 
     // Represents a range in a buffer.
diff --git a/gpu/command_buffer/service/buffer_manager_unittest.cc b/gpu/command_buffer/service/buffer_manager_unittest.cc
index ab8cb99..7620dfac 100644
--- a/gpu/command_buffer/service/buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/buffer_manager_unittest.cc
@@ -3,27 +3,26 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/buffer_manager.h"
+#include "gpu/command_buffer/service/mocks.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
+using ::testing::StrictMock;
+
 namespace gpu {
 namespace gles2 {
 
-class BufferManagerTest : public testing::Test {
- public:
-  BufferManagerTest() : manager_(NULL) {
-  }
-  ~BufferManagerTest() {
-    manager_.Destroy(false);
-  }
-
+class BufferManagerTestBase : public testing::Test {
  protected:
-  virtual void SetUp() {
+  void SetUpBase(MemoryTracker* memory_tracker) {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
+    manager_.reset(new BufferManager(memory_tracker));
   }
 
   virtual void TearDown() {
+    manager_->Destroy(false);
+    manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
@@ -34,18 +33,41 @@ class BufferManagerTest : public testing::Test {
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  BufferManager manager_;
+  scoped_ptr<BufferManager> manager_;
 };
 
+class BufferManagerTest : public BufferManagerTestBase {
+ protected:
+  virtual void SetUp() {
+    SetUpBase(NULL);
+  }
+};
+
+class BufferManagerMemoryTrackerTest : public BufferManagerTestBase {
+ protected:
+  virtual void SetUp() {
+    mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
+    SetUpBase(mock_memory_tracker_.get());
+  }
+
+  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(BufferManagerTest, Basic) {
   const GLuint kClientBuffer1Id = 1;
   const GLuint kServiceBuffer1Id = 11;
   const GLsizeiptr kBuffer1Size = 123;
   const GLuint kClientBuffer2Id = 2;
   // Check we can create buffer.
-  manager_.CreateBufferInfo(kClientBuffer1Id, kServiceBuffer1Id);
+  manager_->CreateBufferInfo(kClientBuffer1Id, kServiceBuffer1Id);
   // Check buffer got created.
-  BufferManager::BufferInfo* info1 = manager_.GetBufferInfo(kClientBuffer1Id);
+  BufferManager::BufferInfo* info1 = manager_->GetBufferInfo(kClientBuffer1Id);
   ASSERT_TRUE(info1 != NULL);
   EXPECT_EQ(0u, GetTarget(info1));
   EXPECT_EQ(0, info1->size());
@@ -53,42 +75,64 @@ TEST_F(BufferManagerTest, Basic) {
   EXPECT_FALSE(info1->IsDeleted());
   EXPECT_EQ(kServiceBuffer1Id, info1->service_id());
   GLuint client_id = 0;
-  EXPECT_TRUE(manager_.GetClientId(info1->service_id(), &client_id));
+  EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id));
   EXPECT_EQ(kClientBuffer1Id, client_id);
-  manager_.SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER);
   EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(info1));
   // Check we and set its size.
-  manager_.SetInfo(info1, kBuffer1Size, GL_DYNAMIC_DRAW);
+  manager_->SetInfo(info1, kBuffer1Size, GL_DYNAMIC_DRAW);
   EXPECT_EQ(kBuffer1Size, info1->size());
   EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), info1->usage());
   // Check we get nothing for a non-existent buffer.
-  EXPECT_TRUE(manager_.GetBufferInfo(kClientBuffer2Id) == NULL);
+  EXPECT_TRUE(manager_->GetBufferInfo(kClientBuffer2Id) == NULL);
   // Check trying to a remove non-existent buffers does not crash.
-  manager_.RemoveBufferInfo(kClientBuffer2Id);
+  manager_->RemoveBufferInfo(kClientBuffer2Id);
   // Check that it gets deleted when the last reference is released.
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBuffer1Id)))
       .Times(1)
       .RetiresOnSaturation();
   // Check we can't get the buffer after we remove it.
-  manager_.RemoveBufferInfo(kClientBuffer1Id);
-  EXPECT_TRUE(manager_.GetBufferInfo(kClientBuffer1Id) == NULL);
+  manager_->RemoveBufferInfo(kClientBuffer1Id);
+  EXPECT_TRUE(manager_->GetBufferInfo(kClientBuffer1Id) == NULL);
+}
+
+TEST_F(BufferManagerMemoryTrackerTest, Basic) {
+  const GLuint kClientBuffer1Id = 1;
+  const GLuint kServiceBuffer1Id = 11;
+  const GLsizeiptr kBuffer1Size1 = 123;
+  const GLsizeiptr kBuffer1Size2 = 456;
+  // Check we can create buffer.
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged);
+  manager_->CreateBufferInfo(kClientBuffer1Id, kServiceBuffer1Id);
+  // Check buffer got created.
+  BufferManager::BufferInfo* info1 = manager_->GetBufferInfo(kClientBuffer1Id);
+  ASSERT_TRUE(info1 != NULL);
+  manager_->SetTarget(info1, GL_ELEMENT_ARRAY_BUFFER);
+  // Check we and set its size.
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged);
+  manager_->SetInfo(info1, kBuffer1Size1, GL_DYNAMIC_DRAW);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged);
+  manager_->SetInfo(info1, kBuffer1Size2, GL_DYNAMIC_DRAW);
+  // On delete it will get freed.
+  EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged);
 }
 
 TEST_F(BufferManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create buffer.
-  manager_.CreateBufferInfo(kClient1Id, kService1Id);
+  manager_->CreateBufferInfo(kClient1Id, kService1Id);
   // Check buffer got created.
   BufferManager::BufferInfo* info1 =
-      manager_.GetBufferInfo(kClient1Id);
+      manager_->GetBufferInfo(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
-  manager_.Destroy(true);
+  manager_->Destroy(true);
   // Check the resources were released.
-  info1 = manager_.GetBufferInfo(kClient1Id);
+  info1 = manager_->GetBufferInfo(kClient1Id);
   ASSERT_TRUE(info1 == NULL);
 }
 
@@ -96,18 +140,18 @@ TEST_F(BufferManagerTest, SetRange) {
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
   const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   EXPECT_TRUE(info->SetRange(0, sizeof(data), data));
   EXPECT_TRUE(info->SetRange(sizeof(data), 0, data));
   EXPECT_FALSE(info->SetRange(sizeof(data), 1, data));
   EXPECT_FALSE(info->SetRange(0, sizeof(data) + 1, data));
   EXPECT_FALSE(info->SetRange(-1, sizeof(data), data));
   EXPECT_FALSE(info->SetRange(0, -1, data));
-  manager_.SetInfo(info, 1, GL_STATIC_DRAW);
+  manager_->SetInfo(info, 1, GL_STATIC_DRAW);
   const int size = 0x20000;
   scoped_array<uint8> temp(new uint8[size]);
   EXPECT_FALSE(info->SetRange(0 - size, size, temp.get()));
@@ -118,11 +162,11 @@ TEST_F(BufferManagerTest, GetRange) {
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
   const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   const char* buf = static_cast<const char*>(info->GetRange(0, sizeof(data)));
   ASSERT_TRUE(buf != NULL);
   const char* buf1 =
@@ -133,7 +177,7 @@ TEST_F(BufferManagerTest, GetRange) {
   EXPECT_TRUE(info->GetRange(-1, sizeof(data)) == NULL);
   EXPECT_TRUE(info->GetRange(-0, -1) == NULL);
   const int size = 0x20000;
-  manager_.SetInfo(info, size / 2, GL_STATIC_DRAW);
+  manager_->SetInfo(info, size / 2, GL_STATIC_DRAW);
   EXPECT_TRUE(info->GetRange(0 - size, size) == NULL);
   EXPECT_TRUE(info->GetRange(1, size / 2) == NULL);
 }
@@ -143,11 +187,11 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) {
   const GLuint kServiceBufferId = 11;
   const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   const uint8 new_data[] = {100, 120, 110};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   EXPECT_TRUE(info->SetRange(0, sizeof(data), data));
   GLuint max_value;
   // Check entire range succeeds.
@@ -173,11 +217,11 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) {
   const GLuint kServiceBufferId = 11;
   const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   const uint16 new_data[] = {100, 120, 110};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   EXPECT_TRUE(info->SetRange(0, sizeof(data), data));
   GLuint max_value;
   // Check entire range succeeds.
@@ -205,11 +249,11 @@ TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) {
   const GLuint kServiceBufferId = 11;
   const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
   const uint32 new_data[] = {100, 120, 110};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetTarget(info, GL_ELEMENT_ARRAY_BUFFER);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   EXPECT_TRUE(info->SetRange(0, sizeof(data), data));
   GLuint max_value;
   // Check entire range succeeds.
@@ -238,14 +282,15 @@ TEST_F(BufferManagerTest, UseDeletedBuffer) {
   const GLuint kClientBufferId = 1;
   const GLuint kServiceBufferId = 11;
   const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
-  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
-  BufferManager::BufferInfo::Ref info = manager_.GetBufferInfo(kClientBufferId);
+  manager_->CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo::Ref info =
+      manager_->GetBufferInfo(kClientBufferId);
   ASSERT_TRUE(info != NULL);
-  manager_.SetTarget(info, GL_ARRAY_BUFFER);
+  manager_->SetTarget(info, GL_ARRAY_BUFFER);
   // Remove buffer
-  manager_.RemoveBufferInfo(kClientBufferId);
+  manager_->RemoveBufferInfo(kClientBufferId);
   // Use it after removing
-  manager_.SetInfo(info, sizeof(data), GL_STATIC_DRAW);
+  manager_->SetInfo(info, sizeof(data), GL_STATIC_DRAW);
   // Check that it gets deleted when the last reference is released.
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBufferId)))
       .Times(1)
diff --git a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
index b9d7287..dba97dc 100644
--- a/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager_unittest.cc
@@ -5,91 +5,116 @@
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 
 #include <set>
+#include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/service/mocks.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
 
+using ::testing::StrictMock;
+
 namespace gpu {
 namespace gles2 {
 
-class RenderbufferManagerTest : public testing::Test {
+class RenderbufferManagerTestBase : public testing::Test {
  public:
   static const GLint kMaxSize = 128;
   static const GLint kMaxSamples = 4;
 
-  RenderbufferManagerTest()
-      : manager_(NULL, kMaxSize, kMaxSamples) {
-  }
-  ~RenderbufferManagerTest() {
-    manager_.Destroy(false);
-  }
-
  protected:
-  virtual void SetUp() {
+  void SetUpBase(MemoryTracker* memory_tracker) {
     gl_.reset(new ::testing::StrictMock<gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
+    manager_.reset(new RenderbufferManager(
+        memory_tracker, kMaxSize, kMaxSamples));
   }
 
   virtual void TearDown() {
+    manager_->Destroy(true);
+    manager_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
-  RenderbufferManager manager_;
+  scoped_ptr<RenderbufferManager> manager_;
 };
 
+class RenderbufferManagerTest : public RenderbufferManagerTestBase {
+ protected:
+  virtual void SetUp() {
+    SetUpBase(NULL);
+  }
+};
+
+class RenderbufferManagerMemoryTrackerTest
+    : public RenderbufferManagerTestBase {
+ protected:
+  virtual void SetUp() {
+    mock_memory_tracker_ = new StrictMock<MockMemoryTracker>();
+    SetUpBase(mock_memory_tracker_.get());
+  }
+
+  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() \
+
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef COMPILER_MSVC
-const GLint RenderbufferManagerTest::kMaxSize;
-const GLint RenderbufferManagerTest::kMaxSamples;
+const GLint RenderbufferManagerTestBase::kMaxSize;
+const GLint RenderbufferManagerTestBase::kMaxSamples;
 #endif
 
 TEST_F(RenderbufferManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
-  EXPECT_EQ(kMaxSize, manager_.max_renderbuffer_size());
-  EXPECT_EQ(kMaxSamples, manager_.max_samples());
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  EXPECT_EQ(kMaxSize, manager_->max_renderbuffer_size());
+  EXPECT_EQ(kMaxSamples, manager_->max_samples());
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
   // Check we can create renderbuffer.
-  manager_.CreateRenderbufferInfo(kClient1Id, kService1Id);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
   // Check renderbuffer got created.
   RenderbufferManager::RenderbufferInfo* info1 =
-      manager_.GetRenderbufferInfo(kClient1Id);
+      manager_->GetRenderbufferInfo(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
   GLuint client_id = 0;
-  EXPECT_TRUE(manager_.GetClientId(info1->service_id(), &client_id));
+  EXPECT_TRUE(manager_->GetClientId(info1->service_id(), &client_id));
   EXPECT_EQ(kClient1Id, client_id);
   // Check we get nothing for a non-existent renderbuffer.
-  EXPECT_TRUE(manager_.GetRenderbufferInfo(kClient2Id) == NULL);
+  EXPECT_TRUE(manager_->GetRenderbufferInfo(kClient2Id) == NULL);
   // Check trying to a remove non-existent renderbuffers does not crash.
-  manager_.RemoveRenderbufferInfo(kClient2Id);
+  manager_->RemoveRenderbufferInfo(kClient2Id);
   // Check that the renderbuffer is deleted when the last ref is released.
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
   // Check we can't get the renderbuffer after we remove it.
-  manager_.RemoveRenderbufferInfo(kClient1Id);
-  EXPECT_TRUE(manager_.GetRenderbufferInfo(kClient1Id) == NULL);
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  manager_->RemoveRenderbufferInfo(kClient1Id);
+  EXPECT_TRUE(manager_->GetRenderbufferInfo(kClient1Id) == NULL);
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
 }
 
 TEST_F(RenderbufferManagerTest, Destroy) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create renderbuffer.
-  manager_.CreateRenderbufferInfo(kClient1Id, kService1Id);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
   // Check renderbuffer got created.
   RenderbufferManager::RenderbufferInfo* info1 =
-      manager_.GetRenderbufferInfo(kClient1Id);
+      manager_->GetRenderbufferInfo(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
-  manager_.Destroy(true);
-  info1 = manager_.GetRenderbufferInfo(kClient1Id);
+  manager_->Destroy(true);
+  info1 = manager_->GetRenderbufferInfo(kClient1Id);
   ASSERT_TRUE(info1 == NULL);
 }
 
@@ -97,10 +122,10 @@ TEST_F(RenderbufferManagerTest, RenderbufferInfo) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   // Check we can create renderbuffer.
-  manager_.CreateRenderbufferInfo(kClient1Id, kService1Id);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
   // Check renderbuffer got created.
   RenderbufferManager::RenderbufferInfo* info1 =
-      manager_.GetRenderbufferInfo(kClient1Id);
+      manager_->GetRenderbufferInfo(kClient1Id);
   ASSERT_TRUE(info1 != NULL);
   EXPECT_EQ(kService1Id, info1->service_id());
   EXPECT_EQ(0, info1->samples());
@@ -115,50 +140,83 @@ TEST_F(RenderbufferManagerTest, RenderbufferInfo) {
   const GLenum kFormat = GL_RGBA4;
   const GLsizei kWidth = 128;
   const GLsizei kHeight = 64;
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
   EXPECT_EQ(kSamples, info1->samples());
   EXPECT_EQ(kFormat, info1->internal_format());
   EXPECT_EQ(kWidth, info1->width());
   EXPECT_EQ(kHeight, info1->height());
   EXPECT_FALSE(info1->cleared());
   EXPECT_FALSE(info1->IsDeleted());
-  EXPECT_TRUE(manager_.HaveUnclearedRenderbuffers());
+  EXPECT_TRUE(manager_->HaveUnclearedRenderbuffers());
   EXPECT_EQ(kWidth * kHeight * 4u * 2u, info1->EstimatedSize());
 
-  manager_.SetCleared(info1, true);
+  manager_->SetCleared(info1, true);
   EXPECT_TRUE(info1->cleared());
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
 
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
-  EXPECT_TRUE(manager_.HaveUnclearedRenderbuffers());
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
+  EXPECT_TRUE(manager_->HaveUnclearedRenderbuffers());
 
   // Check that the renderbuffer is deleted when the last ref is released.
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
       .Times(1)
       .RetiresOnSaturation();
-  manager_.RemoveRenderbufferInfo(kClient1Id);
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  manager_->RemoveRenderbufferInfo(kClient1Id);
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
+}
+
+TEST_F(RenderbufferManagerMemoryTrackerTest, Basic) {
+  const GLuint kClient1Id = 1;
+  const GLuint kService1Id = 11;
+  EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kUnmanaged);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
+  RenderbufferManager::RenderbufferInfo* info1 =
+      manager_->GetRenderbufferInfo(kClient1Id);
+  ASSERT_TRUE(info1 != NULL);
+
+  const GLsizei kSamples = 4;
+  const GLenum kFormat = GL_RGBA4;
+  const GLsizei kWidth = 128;
+  const GLsizei kHeight1 = 64;
+  const GLsizei kHeight2 = 32;
+  size_t expected_size_1 = kWidth * kHeight1 * kSamples *
+      GLES2Util::RenderbufferBytesPerPixel(kFormat);
+  size_t expected_size_2 = kWidth * kHeight2 * kSamples *
+      GLES2Util::RenderbufferBytesPerPixel(kFormat);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(
+      0, expected_size_1, MemoryTracker::kUnmanaged);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight1);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(
+      expected_size_1, 0, MemoryTracker::kUnmanaged);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(
+      0, expected_size_2, MemoryTracker::kUnmanaged);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight2);
+  EXPECT_MEMORY_ALLOCATION_CHANGE(
+      expected_size_2, 0, MemoryTracker::kUnmanaged);
+  EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
+      .Times(1)
+      .RetiresOnSaturation();
 }
 
 TEST_F(RenderbufferManagerTest, UseDeletedRenderbufferInfo) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
-  manager_.CreateRenderbufferInfo(kClient1Id, kService1Id);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
   RenderbufferManager::RenderbufferInfo::Ref info1(
-      manager_.GetRenderbufferInfo(kClient1Id));
+      manager_->GetRenderbufferInfo(kClient1Id));
   ASSERT_TRUE(info1 != NULL);
   // Remove it.
-  manager_.RemoveRenderbufferInfo(kClient1Id);
+  manager_->RemoveRenderbufferInfo(kClient1Id);
   // Use after removing.
   const GLsizei kSamples = 4;
   const GLenum kFormat = GL_RGBA4;
   const GLsizei kWidth = 128;
   const GLsizei kHeight = 64;
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
   // See that it still affects manager.
-  EXPECT_TRUE(manager_.HaveUnclearedRenderbuffers());
-  manager_.SetCleared(info1, true);
-  EXPECT_FALSE(manager_.HaveUnclearedRenderbuffers());
+  EXPECT_TRUE(manager_->HaveUnclearedRenderbuffers());
+  manager_->SetCleared(info1, true);
+  EXPECT_FALSE(manager_->HaveUnclearedRenderbuffers());
   // Check that the renderbuffer is deleted when the last ref is released.
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
       .Times(1)
@@ -179,15 +237,15 @@ bool InSet(std::set<std::string>* string_set, const std::string& str) {
 TEST_F(RenderbufferManagerTest, AddToSignature) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
-  manager_.CreateRenderbufferInfo(kClient1Id, kService1Id);
+  manager_->CreateRenderbufferInfo(kClient1Id, kService1Id);
   RenderbufferManager::RenderbufferInfo::Ref info1(
-      manager_.GetRenderbufferInfo(kClient1Id));
+      manager_->GetRenderbufferInfo(kClient1Id));
   ASSERT_TRUE(info1 != NULL);
   const GLsizei kSamples = 4;
   const GLenum kFormat = GL_RGBA4;
   const GLsizei kWidth = 128;
   const GLsizei kHeight = 64;
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
   std::string signature1;
   std::string signature2;
   info1->AddToSignature(&signature1);
@@ -196,33 +254,37 @@ TEST_F(RenderbufferManagerTest, AddToSignature) {
   EXPECT_FALSE(InSet(&string_set, signature1));
 
   // change things and see that the signatures change.
-  manager_.SetInfo(info1, kSamples +  1, kFormat, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples +  1, kFormat, kWidth, kHeight);
   info1->AddToSignature(&signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_.SetInfo(info1, kSamples, kFormat + 1, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat + 1, kWidth, kHeight);
   signature2.clear();
   info1->AddToSignature(&signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth + 1, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth + 1, kHeight);
   signature2.clear();
   info1->AddToSignature(&signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight + 1);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight + 1);
   signature2.clear();
   info1->AddToSignature(&signature2);
   EXPECT_FALSE(InSet(&string_set, signature2));
 
   // put it back to the same and it should be the same.
-  manager_.SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
+  manager_->SetInfo(info1, kSamples, kFormat, kWidth, kHeight);
   signature2.clear();
   info1->AddToSignature(&signature2);
   EXPECT_EQ(signature1, signature2);
 
   // Check the set was acutally getting different signatures.
   EXPECT_EQ(5u, string_set.size());
+
+  EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, ::testing::Pointee(kService1Id)))
+      .Times(1)
+      .RetiresOnSaturation();
 }
 
 }  // namespace gles2