Refactor gpu::Buffer to allow different types of backing

This is so that we can use either base::SharedMemory or mojo::SharedBuffer to
back gpu::Buffer.

BUG=333157
R=darin@chromium.org, viettrungluu@chromium.org

Review URL: https://codereview.chromium.org/213353005

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

13 files changed, 110 insertions, 70 deletions

diff --git a/gpu/command_buffer/client/client_test_helper.cc b/gpu/command_buffer/client/client_test_helper.cc
index f5e58f2..46011ad 100644
--- a/gpu/command_buffer/client/client_test_helper.cc
+++ b/gpu/command_buffer/client/client_test_helper.cc
@@ -75,7 +75,8 @@ scoped_refptr<gpu::Buffer> MockCommandBufferBase::CreateTransferBuffer(
     int32 ndx = *id - kTransferBufferBaseId;
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(size);
-    transfer_buffer_buffers_[ndx] = new gpu::Buffer(shared_memory.Pass(), size);
+    transfer_buffer_buffers_[ndx] =
+        MakeBufferFromSharedMemory(shared_memory.Pass(), size);
   }
   return GetTransferBuffer(*id);
 }
diff --git a/gpu/command_buffer/client/mapped_memory_unittest.cc b/gpu/command_buffer/client/mapped_memory_unittest.cc
index d853119..4ebe5ec 100644
--- a/gpu/command_buffer/client/mapped_memory_unittest.cc
+++ b/gpu/command_buffer/client/mapped_memory_unittest.cc
@@ -102,7 +102,7 @@ class MemoryChunkTest : public MappedMemoryTestBase {
     MappedMemoryTestBase::SetUp();
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(kBufferSize);
-    buffer_ = new gpu::Buffer(shared_memory.Pass(), kBufferSize);
+    buffer_ = MakeBufferFromSharedMemory(shared_memory.Pass(), kBufferSize);
     chunk_.reset(new MemoryChunk(kShmId,
                                  buffer_,
                                  helper_.get(),
diff --git a/gpu/command_buffer/common/buffer.cc b/gpu/command_buffer/common/buffer.cc
index bbf40a1..3b3da43 100644
--- a/gpu/command_buffer/common/buffer.cc
+++ b/gpu/command_buffer/common/buffer.cc
@@ -9,11 +9,23 @@
 #include "base/numerics/safe_math.h"
 
 namespace gpu {
+SharedMemoryBufferBacking::SharedMemoryBufferBacking(
+    scoped_ptr<base::SharedMemory> shared_memory,
+    size_t size)
+    : shared_memory_(shared_memory.Pass()), size_(size) {}
 
-Buffer::Buffer(scoped_ptr<base::SharedMemory> shared_memory, size_t size)
-    : shared_memory_(shared_memory.Pass()),
-      memory_(shared_memory_->memory()),
-      size_(size) {
+SharedMemoryBufferBacking::~SharedMemoryBufferBacking() {}
+
+void* SharedMemoryBufferBacking::GetMemory() const {
+  return shared_memory_->memory();
+}
+
+size_t SharedMemoryBufferBacking::GetSize() const { return size_; }
+
+Buffer::Buffer(scoped_ptr<BufferBacking> backing)
+    : backing_(backing.Pass()),
+      memory_(backing_->GetMemory()),
+      size_(backing_->GetSize()) {
   DCHECK(memory_) << "The memory must be mapped to create a Buffer";
 }
 
diff --git a/gpu/command_buffer/common/buffer.h b/gpu/command_buffer/common/buffer.h
index e9a1558..5a31035 100644
--- a/gpu/command_buffer/common/buffer.h
+++ b/gpu/command_buffer/common/buffer.h
@@ -17,12 +17,34 @@ namespace base {
 
 namespace gpu {
 
+class GPU_EXPORT BufferBacking {
+ public:
+  virtual ~BufferBacking() {}
+  virtual void* GetMemory() const = 0;
+  virtual size_t GetSize() const = 0;
+};
+
+class GPU_EXPORT SharedMemoryBufferBacking : public BufferBacking {
+ public:
+  SharedMemoryBufferBacking(scoped_ptr<base::SharedMemory> shared_memory,
+                            size_t size);
+  virtual ~SharedMemoryBufferBacking();
+  virtual void* GetMemory() const OVERRIDE;
+  virtual size_t GetSize() const OVERRIDE;
+  base::SharedMemory* shared_memory() { return shared_memory_.get(); }
+
+ private:
+  scoped_ptr<base::SharedMemory> shared_memory_;
+  size_t size_;
+  DISALLOW_COPY_AND_ASSIGN(SharedMemoryBufferBacking);
+};
+
 // Buffer owns a piece of shared-memory of a certain size.
 class GPU_EXPORT Buffer : public base::RefCountedThreadSafe<Buffer> {
  public:
-  Buffer(scoped_ptr<base::SharedMemory> shared_memory, size_t size);
+  explicit Buffer(scoped_ptr<BufferBacking> backing);
 
-  base::SharedMemory* shared_memory() const { return shared_memory_.get(); }
+  BufferBacking* backing() const { return backing_.get(); }
   void* memory() const { return memory_; }
   size_t size() const { return size_; }
 
@@ -33,13 +55,26 @@ class GPU_EXPORT Buffer : public base::RefCountedThreadSafe<Buffer> {
   friend class base::RefCountedThreadSafe<Buffer>;
   ~Buffer();
 
-  scoped_ptr<base::SharedMemory> shared_memory_;
+  scoped_ptr<BufferBacking> backing_;
   void* memory_;
   size_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(Buffer);
 };
 
+static inline scoped_ptr<BufferBacking> MakeBackingFromSharedMemory(
+    scoped_ptr<base::SharedMemory> shared_memory,
+    size_t size) {
+  return scoped_ptr<BufferBacking>(
+      new SharedMemoryBufferBacking(shared_memory.Pass(), size));
+}
+
+static inline scoped_refptr<Buffer> MakeBufferFromSharedMemory(
+    scoped_ptr<base::SharedMemory> shared_memory,
+    size_t size) {
+  return new Buffer(MakeBackingFromSharedMemory(shared_memory.Pass(), size));
+}
+
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_BUFFER_H_
diff --git a/gpu/command_buffer/service/command_buffer_service.cc b/gpu/command_buffer/service/command_buffer_service.cc
index df2bd07..30617c8 100644
--- a/gpu/command_buffer/service/command_buffer_service.cc
+++ b/gpu/command_buffer/service/command_buffer_service.cc
@@ -103,17 +103,15 @@ void CommandBufferService::SetGetBuffer(int32 transfer_buffer_id) {
   UpdateState();
 }
 
-bool CommandBufferService::SetSharedStateBuffer(
-    scoped_ptr<base::SharedMemory> shared_state_shm) {
-  shared_state_shm_.reset(shared_state_shm.release());
-  if (!shared_state_shm_->Map(sizeof(*shared_state_)))
-    return false;
+void CommandBufferService::SetSharedStateBuffer(
+    scoped_ptr<BufferBacking> shared_state_buffer) {
+  shared_state_buffer_ = shared_state_buffer.Pass();
+  DCHECK(shared_state_buffer_->GetSize() >= sizeof(*shared_state_));
 
   shared_state_ =
-      static_cast<CommandBufferSharedState*>(shared_state_shm_->memory());
+      static_cast<CommandBufferSharedState*>(shared_state_buffer_->GetMemory());
 
   UpdateState();
-  return true;
 }
 
 void CommandBufferService::SetGetOffset(int32 get_offset) {
@@ -132,7 +130,8 @@ scoped_refptr<Buffer> CommandBufferService::CreateTransferBuffer(size_t size,
   static int32 next_id = 1;
   *id = next_id++;
 
-  if (!RegisterTransferBuffer(*id, shared_memory.Pass(), size)) {
+  if (!RegisterTransferBuffer(
+          *id, MakeBackingFromSharedMemory(shared_memory.Pass(), size))) {
     *id = -1;
     return NULL;
   }
@@ -157,10 +156,8 @@ scoped_refptr<Buffer> CommandBufferService::GetTransferBuffer(int32 id) {
 
 bool CommandBufferService::RegisterTransferBuffer(
     int32 id,
-    scoped_ptr<base::SharedMemory> shared_memory,
-    size_t size) {
-  return transfer_buffer_manager_->RegisterTransferBuffer(
-      id, shared_memory.Pass(), size);
+    scoped_ptr<BufferBacking> buffer) {
+  return transfer_buffer_manager_->RegisterTransferBuffer(id, buffer.Pass());
 }
 
 void CommandBufferService::SetToken(int32 token) {
diff --git a/gpu/command_buffer/service/command_buffer_service.h b/gpu/command_buffer/service/command_buffer_service.h
index c3c67d9..740e897 100644
--- a/gpu/command_buffer/service/command_buffer_service.h
+++ b/gpu/command_buffer/service/command_buffer_service.h
@@ -79,22 +79,19 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   virtual void SetParseErrorCallback(const base::Closure& callback);
 
   // Setup the shared memory that shared state should be copied into.
-  bool SetSharedStateBuffer(scoped_ptr<base::SharedMemory> shared_state_shm);
+  void SetSharedStateBuffer(scoped_ptr<BufferBacking> shared_state_buffer);
 
   // Copy the current state into the shared state transfer buffer.
   void UpdateState();
 
-  // Register an existing shared memory object and get an ID that can be used
-  // to identify it in the command buffer. Callee dups the handle until
-  // DestroyTransferBuffer is called.
-  bool RegisterTransferBuffer(int32 id,
-                              scoped_ptr<base::SharedMemory> shared_memory,
-                              size_t size);
+  // Registers an existing shared memory object and get an ID that can be used
+  // to identify it in the command buffer.
+  bool RegisterTransferBuffer(int32 id, scoped_ptr<BufferBacking> buffer);
 
  private:
   int32 ring_buffer_id_;
   scoped_refptr<Buffer> ring_buffer_;
-  scoped_ptr<base::SharedMemory> shared_state_shm_;
+  scoped_ptr<BufferBacking> shared_state_buffer_;
   CommandBufferSharedState* shared_state_;
   int32 num_entries_;
   int32 get_offset_;
diff --git a/gpu/command_buffer/service/common_decoder_unittest.cc b/gpu/command_buffer/service/common_decoder_unittest.cc
index 5e89a5f..11274e0 100644
--- a/gpu/command_buffer/service/common_decoder_unittest.cc
+++ b/gpu/command_buffer/service/common_decoder_unittest.cc
@@ -83,7 +83,7 @@ class MockCommandBufferEngine : public CommandBufferEngine {
         get_offset_(0) {
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(kBufferSize);
-    buffer_ = new gpu::Buffer(shared_memory.Pass(), kBufferSize);
+    buffer_ = MakeBufferFromSharedMemory(shared_memory.Pass(), kBufferSize);
   }
 
   // Overridden from CommandBufferEngine.
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index c582019..9a815c8 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -1411,7 +1411,7 @@ MockCommandBufferEngine() {
 
   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
   shm->CreateAndMapAnonymous(kSharedBufferSize);
-  valid_buffer_ = new gpu::Buffer(shm.Pass(), kSharedBufferSize);
+  valid_buffer_ = MakeBufferFromSharedMemory(shm.Pass(), kSharedBufferSize);
 
   ClearSharedMemory();
 }
diff --git a/gpu/command_buffer/service/gpu_scheduler_unittest.cc b/gpu/command_buffer/service/gpu_scheduler_unittest.cc
index 7a663d0..6859208 100644
--- a/gpu/command_buffer/service/gpu_scheduler_unittest.cc
+++ b/gpu/command_buffer/service/gpu_scheduler_unittest.cc
@@ -37,7 +37,7 @@ class GpuSchedulerTest : public testing::Test {
     shared_memory->CreateAndMapAnonymous(kRingBufferSize);
     buffer_ = static_cast<int32*>(shared_memory->memory());
     shared_memory_buffer_ =
-        new gpu::Buffer(shared_memory.Pass(), kRingBufferSize);
+        MakeBufferFromSharedMemory(shared_memory.Pass(), kRingBufferSize);
     memset(buffer_, 0, kRingBufferSize);
 
     command_buffer_.reset(new MockCommandBuffer);
diff --git a/gpu/command_buffer/service/query_manager_unittest.cc b/gpu/command_buffer/service/query_manager_unittest.cc
index b5f6609..0acbbec 100644
--- a/gpu/command_buffer/service/query_manager_unittest.cc
+++ b/gpu/command_buffer/service/query_manager_unittest.cc
@@ -93,7 +93,8 @@ class QueryManagerTest : public testing::Test {
     MockCommandBufferEngine() {
       scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
       shared_memory->CreateAndMapAnonymous(kSharedBufferSize);
-      valid_buffer_ = new gpu::Buffer(shared_memory.Pass(), kSharedBufferSize);
+      valid_buffer_ =
+          MakeBufferFromSharedMemory(shared_memory.Pass(), kSharedBufferSize);
       data_ = static_cast<uint8*>(valid_buffer_->memory());
       ClearSharedMemory();
     }
diff --git a/gpu/command_buffer/service/transfer_buffer_manager.cc b/gpu/command_buffer/service/transfer_buffer_manager.cc
index 7f81115..4404a9e 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager.cc
@@ -40,8 +40,7 @@ bool TransferBufferManager::Initialize() {
 
 bool TransferBufferManager::RegisterTransferBuffer(
     int32 id,
-    scoped_ptr<base::SharedMemory> shared_memory,
-    size_t size) {
+    scoped_ptr<BufferBacking> buffer_backing) {
   if (id <= 0) {
     DVLOG(0) << "Cannot register transfer buffer with non-positive ID.";
     return false;
@@ -54,13 +53,13 @@ bool TransferBufferManager::RegisterTransferBuffer(
   }
 
   // Register the shared memory with the ID.
-  scoped_refptr<Buffer> buffer = new gpu::Buffer(shared_memory.Pass(), size);
+  scoped_refptr<Buffer> buffer(new gpu::Buffer(buffer_backing.Pass()));
 
   // Check buffer alignment is sane.
   DCHECK(!(reinterpret_cast<uintptr_t>(buffer->memory()) &
            (kCommandBufferEntrySize - 1)));
 
-  shared_memory_bytes_allocated_ += size;
+  shared_memory_bytes_allocated_ += buffer->size();
   TRACE_COUNTER_ID1(
       "gpu", "GpuTransferBufferMemory", this, shared_memory_bytes_allocated_);
 
diff --git a/gpu/command_buffer/service/transfer_buffer_manager.h b/gpu/command_buffer/service/transfer_buffer_manager.h
index 5f8f946..d8bb3bb 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager.h
+++ b/gpu/command_buffer/service/transfer_buffer_manager.h
@@ -20,10 +20,8 @@ class GPU_EXPORT TransferBufferManagerInterface {
  public:
   virtual ~TransferBufferManagerInterface();
 
-  virtual bool RegisterTransferBuffer(
-      int32 id,
-      scoped_ptr<base::SharedMemory> shared_memory,
-      size_t size) = 0;
+  virtual bool RegisterTransferBuffer(int32 id,
+                                      scoped_ptr<BufferBacking> buffer) = 0;
   virtual void DestroyTransferBuffer(int32 id) = 0;
   virtual scoped_refptr<Buffer> GetTransferBuffer(int32 id) = 0;
 };
@@ -34,10 +32,9 @@ class GPU_EXPORT TransferBufferManager
   TransferBufferManager();
 
   bool Initialize();
-  virtual bool RegisterTransferBuffer(
-      int32 id,
-      scoped_ptr<base::SharedMemory> shared_memory,
-      size_t size) OVERRIDE;
+  virtual bool RegisterTransferBuffer(int32 id,
+                                      scoped_ptr<BufferBacking> buffer_backing)
+      OVERRIDE;
   virtual void DestroyTransferBuffer(int32 id) OVERRIDE;
   virtual scoped_refptr<Buffer> GetTransferBuffer(int32 id) OVERRIDE;
 
diff --git a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
index c7dc04a..4af0936 100644
--- a/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/transfer_buffer_manager_unittest.cc
@@ -41,20 +41,34 @@ TEST_F(TransferBufferManagerTest, CanRegisterTransferBuffer) {
   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, shm.Pass(), kBufferSize));
+      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(shm_raw_pointer, registered->shared_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) {
-  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
-  shm->CreateAndMapAnonymous(kBufferSize);
   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm.Pass(), kBufferSize));
+      1, scoped_ptr<BufferBacking>(new FakeBufferBacking)));
   transfer_buffer_manager_->DestroyTransferBuffer(1);
   scoped_refptr<Buffer> registered =
       transfer_buffer_manager_->GetTransferBuffer(1);
@@ -64,31 +78,20 @@ TEST_F(TransferBufferManagerTest, CanDestroyTransferBuffer) {
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegregisterTransferBufferId) {
-  scoped_ptr<base::SharedMemory> shm1(new base::SharedMemory());
-  scoped_ptr<base::SharedMemory> shm2(new base::SharedMemory());
-  scoped_ptr<base::SharedMemory> shm3(new base::SharedMemory());
-  shm1->CreateAndMapAnonymous(kBufferSize);
-  shm2->CreateAndMapAnonymous(kBufferSize);
-  shm3->CreateAndMapAnonymous(kBufferSize);
-
   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm1.Pass(), kBufferSize));
+      1, FakeBufferBacking::Make()));
   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm2.Pass(), kBufferSize));
+      1, FakeBufferBacking::Make()));
   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm3.Pass(), kBufferSize));
+      1, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, CanReuseTransferBufferIdAfterDestroying) {
-  scoped_ptr<base::SharedMemory> shm1(new base::SharedMemory());
-  scoped_ptr<base::SharedMemory> shm2(new base::SharedMemory());
-  shm1->CreateAndMapAnonymous(kBufferSize);
-  shm2->CreateAndMapAnonymous(kBufferSize);
   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm1.Pass(), kBufferSize));
+      1, FakeBufferBacking::Make()));
   transfer_buffer_manager_->DestroyTransferBuffer(1);
   EXPECT_TRUE(transfer_buffer_manager_->RegisterTransferBuffer(
-      1, shm2.Pass(), kBufferSize));
+      1, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, DestroyUnusedTransferBufferIdDoesNotCrash) {
@@ -96,17 +99,15 @@ TEST_F(TransferBufferManagerTest, DestroyUnusedTransferBufferIdDoesNotCrash) {
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegisterNullTransferBuffer) {
-  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
-  shm->CreateAndMapAnonymous(kBufferSize);
   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
-      0, shm.Pass(), kBufferSize));
+      0, FakeBufferBacking::Make()));
 }
 
 TEST_F(TransferBufferManagerTest, CannotRegisterNegativeTransferBufferId) {
   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory());
   shm->CreateAndMapAnonymous(kBufferSize);
   EXPECT_FALSE(transfer_buffer_manager_->RegisterTransferBuffer(
-      -1, shm.Pass(), kBufferSize));
+      -1, FakeBufferBacking::Make()));
 }
 
 }  // namespace gpu