mojo/gpu: use SharedBuffer instead of base::SharedMemory with hacks

mojo/gles2/command_buffer_client_impl.cc

 // Copyright 2014 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 "mojo/gles2/command_buffer_client_impl.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "base/process/process_handle.h"
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/public/cpp/bindings/sync_dispatcher.h"
 #include "mojo/services/gles2/command_buffer_type_conversions.h"
+#include "mojo/services/gles2/mojo_buffer_backing.h"
 
 namespace mojo {
 namespace gles2 {
 
+namespace {
+
+bool CreateMapAndDupSharedBuffer(size_t size,
+                                 void** memory,
+                                 mojo::ScopedSharedBufferHandle* handle,
+                                 mojo::ScopedSharedBufferHandle* duped) {
+  MojoResult result = mojo::CreateSharedBuffer(NULL, size, handle);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  DCHECK(handle->is_valid());
+
+  result = mojo::MapBuffer(
+      handle->get(), 0, size, memory, MOJO_MAP_BUFFER_FLAG_NONE);
+  if (result != MOJO_RESULT_OK)
+    return false;
+  DCHECK(*memory);
+
+  result = mojo::DuplicateBuffer(handle->get(), NULL, duped);
+  if (result != MOJO_RESULT_OK)
+    return false;

[viettrungluu, 2014/04/02 20:15:59]

Note that on failure, you leak the mapping.

Arguably, you should do the duplicate first to avoid that.

Possibly, I should also improve the C++ wrappers to make handling this easier.

(In Chromium code, I guess you could also use a scoped_ptr<> with a suitable
deleter (namely, one that calls UnmapBuffer()).)

[piman, 2014/04/02 20:22:53]

Good point. Because the other calls return into Scoped things, the easiest thing
is to do the mapping last.

Re: c++ wrappers, agreed, we may want something to the level of
base::SharedMemory that lets you encapsulate the handle and provide you with
Map/Unmap/Duplicate.
Should mojo::SharedBuffer be that?

+  DCHECK(duped->is_valid());
+
+  return true;
+}
+}
+
 CommandBufferDelegate::~CommandBufferDelegate() {}
 
 void CommandBufferDelegate::ContextLost() {}
 void CommandBufferDelegate::DrawAnimationFrame() {}
 
 CommandBufferClientImpl::CommandBufferClientImpl(
     CommandBufferDelegate* delegate,
     MojoAsyncWaiter* async_waiter,
     ScopedCommandBufferHandle command_buffer_handle)
     : delegate_(delegate),
       command_buffer_(command_buffer_handle.Pass(), this, this, async_waiter),
+      shared_state_(NULL),
       last_put_offset_(-1),
       next_transfer_buffer_id_(0),
       initialize_result_(false) {}
 
 CommandBufferClientImpl::~CommandBufferClientImpl() {}
 
 bool CommandBufferClientImpl::Initialize() {
-  shared_state_shm_.reset(new base::SharedMemory);
-  if (!shared_state_shm_->CreateAndMapAnonymous(
-           sizeof(gpu::CommandBufferSharedState)))
+  const size_t kSharedStateSize = sizeof(gpu::CommandBufferSharedState);
+  void* memory = NULL;
+  mojo::ScopedSharedBufferHandle duped;
+  bool result = CreateMapAndDupSharedBuffer(
+      kSharedStateSize, &memory, &shared_state_handle_, &duped);
+  if (!result)
     return false;
 
-  base::SharedMemoryHandle handle;
-  shared_state_shm_->ShareToProcess(base::GetCurrentProcessHandle(), &handle);
-  if (!base::SharedMemory::IsHandleValid(handle))
-    return false;
+  shared_state_ = static_cast<gpu::CommandBufferSharedState*>(memory);
 
   shared_state()->Initialize();
 
   InterfacePipe<CommandBufferSyncClient, NoInterface> sync_pipe;
   sync_dispatcher_.reset(new SyncDispatcher<CommandBufferSyncClient>(
       sync_pipe.handle_to_peer.Pass(), this));
   AllocationScope scope;
-  command_buffer_->Initialize(sync_pipe.handle_to_self.Pass(), handle);
+  command_buffer_->Initialize(sync_pipe.handle_to_self.Pass(), duped.Pass());
   // Wait for DidInitialize to come on the sync client pipe.
   if (!sync_dispatcher_->WaitAndDispatchOneMessage()) {
     VLOG(1) << "Channel encountered error while creating command buffer";
     return false;
   }
   return initialize_result_;
 }
 
 gpu::CommandBuffer::State CommandBufferClientImpl::GetState() {
   MakeProgressAndUpdateState();
@@ skipping 39 matching lines @@
   command_buffer_->SetGetBuffer(shm_id);
   last_put_offset_ = -1;
 }
 
 scoped_refptr<gpu::Buffer> CommandBufferClientImpl::CreateTransferBuffer(
     size_t size,
     int32* id) {
   if (size >= std::numeric_limits<uint32_t>::max())
     return NULL;
 
-  scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
-  if (!shared_memory->CreateAndMapAnonymous(size))
-    return NULL;
-
-  base::SharedMemoryHandle handle;
-  shared_memory->ShareToProcess(base::GetCurrentProcessHandle(), &handle);
-  if (!base::SharedMemory::IsHandleValid(handle))
+  void* memory = NULL;
+  mojo::ScopedSharedBufferHandle handle;
+  mojo::ScopedSharedBufferHandle duped;
+  if (!CreateMapAndDupSharedBuffer(size, &memory, &handle, &duped))
     return NULL;
 
   *id = ++next_transfer_buffer_id_;
 
   AllocationScope scope;
   command_buffer_->RegisterTransferBuffer(
-      *id, handle, static_cast<uint32_t>(size));
+      *id, duped.Pass(), static_cast<uint32_t>(size));
 
-  scoped_refptr<gpu::Buffer> buffer =
-      gpu::MakeBufferFromSharedMemory(shared_memory.Pass(), size);
+  scoped_ptr<gpu::BufferBacking> backing(
+      new MojoBufferBacking(handle.Pass(), memory, size));
+  scoped_refptr<gpu::Buffer> buffer(new gpu::Buffer(backing.Pass()));
   return buffer;
 }
 
 void CommandBufferClientImpl::DestroyTransferBuffer(int32 id) {
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 gpu::Capabilities CommandBufferClientImpl::GetCapabilities() {
   // TODO(piman)
   NOTIMPLEMENTED();
@@ skipping 98 matching lines @@
     return;
   }
 }
 
 void CommandBufferClientImpl::DrawAnimationFrame() {
   delegate_->DrawAnimationFrame();
 }
 
 }  // namespace gles2
 }  // namespace mojo