1 files changed, 51 insertions, 53 deletions

diff --git a/chromium/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc b/chromium/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
index 68c5c2ec21c..4af09368cb0 100644
--- a/chromium/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
+++ b/chromium/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
@@ -17,83 +17,81 @@ const static size_t kBufferSize = 1024;
 class TransferBufferManagerTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    for (size_t i = 0; i < arraysize(buffers_); ++i) {
-      buffers_[i].CreateAnonymous(kBufferSize);
-      buffers_[i].Map(kBufferSize);
-    }
-
     TransferBufferManager* manager = new TransferBufferManager();
     transfer_buffer_manager_.reset(manager);
     ASSERT_TRUE(manager->Initialize());
   }
 
-  base::SharedMemory buffers_[3];
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
 };
 
 TEST_F(TransferBufferManagerTest, ZeroHandleMapsToNull) {
-  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(0).ptr);
+  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(0));
 }
 
 TEST_F(TransferBufferManagerTest, NegativeHandleMapsToNull) {
-  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(-1).ptr);
+  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(-1));
 }
 
 TEST_F(TransferBufferManagerTest, OutOfRangeHandleMapsToNull) {
-  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(1).ptr);
+  EXPECT_TRUE(NULL == transfer_buffer_manager_->GetTransferBuffer(1));
 }
 
 TEST_F(TransferBufferManagerTest, CanRegisterTransferBuffer) {
-  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                               &buffers_[0],
-                                                               kBufferSize));
-  Buffer registered = transfer_buffer_manager_->GetTransferBuffer(1);
-
-  // Distinct memory range and shared memory handle from that originally
-  // registered.
-  EXPECT_NE(static_cast<void*>(NULL), registered.ptr);
-  EXPECT_NE(buffers_[0].memory(), registered.ptr);
-  EXPECT_EQ(kBufferSize, registered.size);
-  EXPECT_NE(&buffers_[0], registered.shared_memory);
-
-  // But maps to the same physical memory.
-  *static_cast<int*>(registered.ptr) = 7;
-  *static_cast<int*>(buffers_[0].memory()) = 8;
-  EXPECT_EQ(8, *static_cast<int*>(registered.ptr));
+  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
+  shm->CreateAndMapAnonymous(kBufferSize);
+  base::SharedMemory* shm_raw_pointer = shm.get();
+  scoped_ptr<SharedMemoryBufferBacking> backing(
+      new SharedMemoryBufferBacking(shm.Pass(), kBufferSize));
+  SharedMemoryBufferBacking* backing_raw_ptr = backing.get();
+
+  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, backing.PassAs<BufferBacking>()));
+  scoped_refptr<Buffer> registered =
+      transfer_buffer_manager_->GetTransferBuffer(1);
+
+  // Shared-memory ownership is transfered. It should be the same memory.
+  EXPECT_EQ(backing_raw_ptr, registered->backing());
+  EXPECT_EQ(shm_raw_pointer, backing_raw_ptr->shared_memory());
 }
 
+class FakeBufferBacking : public BufferBacking {
+ public:
+  virtual void* GetMemory() const OVERRIDE {
+    return reinterpret_cast<void*>(0xBADF00D0);
+  }
+  virtual size_t GetSize() const OVERRIDE { return 42; }
+  static scoped_ptr<BufferBacking> Make() {
+    return scoped_ptr<BufferBacking>(new FakeBufferBacking);
+  }
+};
+
 TEST_F(TransferBufferManagerTest, CanDestroyTransferBuffer) {
-  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                               &buffers_[0],
-                                                               kBufferSize));
+  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, scoped_ptr<BufferBacking>(new FakeBufferBacking)));
   transfer_buffer_manager_->DestroyTransferBuffer(1);
-  Buffer registered = transfer_buffer_manager_->GetTransferBuffer(1);
+  scoped_refptr<Buffer> registered =
+      transfer_buffer_manager_->GetTransferBuffer(1);
 
-  EXPECT_EQ(static_cast<void*>(NULL), registered.ptr);
-  EXPECT_EQ(0U, registered.size);
-  EXPECT_EQ(static_cast<base::SharedMemory*>(NULL), registered.shared_memory);
+  scoped_refptr<Buffer> null_buffer;
+  EXPECT_EQ(null_buffer, registered);
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegregisterTransferBufferId) {
-  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                               &buffers_[0],
-                                                               kBufferSize));
-  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                                &buffers_[0],
-                                                                kBufferSize));
-  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                                &buffers_[1],
-                                                                kBufferSize));
+  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, FakeBufferBacking::Make()));
+  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, FakeBufferBacking::Make()));
+  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, CanReuseTransferBufferIdAfterDestroying) {
-  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                               &buffers_[0],
-                                                               kBufferSize));
+  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, FakeBufferBacking::Make()));
   transfer_buffer_manager_->DestroyTransferBuffer(1);
-  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(1,
-                                                               &buffers_[1],
-                                                               kBufferSize));
+  EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
+      1, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, DestroyUnusedTransferBufferIdDoesNotCrash) {
@@ -101,15 +99,15 @@ TEST_F(TransferBufferManagerTest, DestroyUnusedTransferBufferIdDoesNotCrash) {
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegisterNullTransferBuffer) {
-  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(0,
-                                                                &buffers_[0],
-                                                                kBufferSize));
+  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
+      0, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegisterNegativeTransferBufferId) {
-  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(-1,
-                                                                &buffers_[0],
-                                                                kBufferSize));
+  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
+  shm->CreateAndMapAnonymous(kBufferSize);
+  EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
+      -1, FakeBufferBacking::Make()));
 }
 
 }  // namespace gpu