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

mojo/services/gles2/command_buffer_impl.cc

 // Copyright 2013 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/services/gles2/command_buffer_impl.h"
 
 #include "base/bind.h"
 #include "base/memory/shared_memory.h"
 
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_control_service.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/services/gles2/command_buffer_type_conversions.h"
+#include "mojo/services/gles2/mojo_buffer_backing.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 
 namespace mojo {
 namespace services {
 
 namespace {
 
 class MemoryTrackerStub : public gpu::gles2::MemoryTracker {
  public:
@@ skipping 18 matching lines @@
 
 CommandBufferImpl::CommandBufferImpl(ScopedCommandBufferClientHandle client,
                                      gfx::AcceleratedWidget widget,
                                      const gfx::Size& size)
     : client_(client.Pass(), this), widget_(widget), size_(size) {}
 
 CommandBufferImpl::~CommandBufferImpl() { client_->DidDestroy(); }
 
 void CommandBufferImpl::Initialize(
     ScopedCommandBufferSyncClientHandle sync_client,
-    const ShmHandle& shared_state) {
+    mojo::ScopedSharedBufferHandle shared_state) {
   sync_client_.reset(sync_client.Pass(), NULL);
-  sync_client_->DidInitialize(DoInitialize(shared_state));
+  sync_client_->DidInitialize(DoInitialize(shared_state.Pass()));
 }
 
-bool CommandBufferImpl::DoInitialize(const ShmHandle& shared_state) {
+bool CommandBufferImpl::DoInitialize(
+    mojo::ScopedSharedBufferHandle shared_state) {
   // TODO(piman): offscreen surface.
   scoped_refptr<gfx::GLSurface> surface =
       gfx::GLSurface::CreateViewGLSurface(widget_);
   if (!surface.get())
     return false;
 
   // TODO(piman): context sharing, virtual contexts, gpu preference.
   scoped_refptr<gfx::GLContext> context = gfx::GLContext::CreateGLContext(
       NULL, surface.get(), gfx::PreferIntegratedGpu);
   if (!context.get())
@@ skipping 37 matching lines @@
   command_buffer_->SetPutOffsetChangeCallback(base::Bind(
       &gpu::GpuScheduler::PutChanged, base::Unretained(scheduler_.get())));
   command_buffer_->SetGetBufferChangeCallback(base::Bind(
       &gpu::GpuScheduler::SetGetBuffer, base::Unretained(scheduler_.get())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&CommandBufferImpl::OnParseError, base::Unretained(this)));
 
   // TODO(piman): other callbacks
 
   const size_t kSize = sizeof(gpu::CommandBufferSharedState);
-  scoped_ptr<base::SharedMemory> shared_state_shm(
-      new base::SharedMemory(shared_state, false));
-  if (!shared_state_shm->Map(kSize))
+  scoped_ptr<gpu::BufferBacking> backing(
+      gles2::MojoBufferBacking::Create(shared_state.Pass(), kSize));
+  if (!backing.get())
     return false;
 
-  command_buffer_->SetSharedStateBuffer(
-      gpu::MakeBackingFromSharedMemory(shared_state_shm.Pass(), kSize));
+  command_buffer_->SetSharedStateBuffer(backing.Pass());
   return true;
 }
 
 void CommandBufferImpl::SetGetBuffer(int32_t buffer) {
   command_buffer_->SetGetBuffer(buffer);
 }
 
 void CommandBufferImpl::Flush(int32_t put_offset) {
   command_buffer_->Flush(put_offset);
 }
 
 void CommandBufferImpl::MakeProgress(int32_t last_get_offset) {
   // TODO(piman): handle out-of-order.
   AllocationScope scope;
   sync_client_->DidMakeProgress(command_buffer_->GetState());
 }
 
-void CommandBufferImpl::RegisterTransferBuffer(int32_t id,
-                                               const ShmHandle& transfer_buffer,
-                                               uint32_t size) {
+void CommandBufferImpl::RegisterTransferBuffer(
+    int32_t id,
+    mojo::ScopedSharedBufferHandle transfer_buffer,
+    uint32_t size) {
   // Take ownership of the memory and map it into this process.
   // This validates the size.
-  scoped_ptr<base::SharedMemory> shared_memory(
-      new base::SharedMemory(transfer_buffer, false));
-  if (!shared_memory->Map(size)) {
+  scoped_ptr<gpu::BufferBacking> backing(
+      gles2::MojoBufferBacking::Create(transfer_buffer.Pass(), size));
+  if (!backing.get()) {
     DVLOG(0) << "Failed to map shared memory.";
     return;
   }
-
-  command_buffer_->RegisterTransferBuffer(
-      id, gpu::MakeBackingFromSharedMemory(shared_memory.Pass(), size));
+  command_buffer_->RegisterTransferBuffer(id, backing.Pass());
 }
 
 void CommandBufferImpl::DestroyTransferBuffer(int32_t id) {
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 void CommandBufferImpl::Echo(const Callback<void()>& callback) {
   callback.Run();
 }
 
 void CommandBufferImpl::RequestAnimationFrames() {
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromMilliseconds(16),
                this,
                &CommandBufferImpl::DrawAnimationFrame);
 }
 
 void CommandBufferImpl::CancelAnimationFrames() { timer_.Stop(); }
 
 void CommandBufferImpl::OnParseError() {
   gpu::CommandBuffer::State state = command_buffer_->GetState();
   client_->LostContext(state.context_lost_reason);
 }
 
 void CommandBufferImpl::DrawAnimationFrame() { client_->DrawAnimationFrame(); }
 
 }  // namespace services
 }  // namespace mojo