Revert 113479 - Revert "Revert 113250 - Add CommandBuffer::SetGetBuffer"

ppapi/proxy/ppb_graphics_3d_proxy.cc

 // Copyright (c) 2011 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 "ppapi/proxy/ppb_graphics_3d_proxy.h"
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/enter_proxy.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
@@ skipping 13 matching lines @@
 namespace {
 const int32 kCommandBufferSize = 1024 * 1024;
 const int32 kTransferBufferSize = 1024 * 1024;
 
 class CommandBuffer : public gpu::CommandBuffer {
  public:
   CommandBuffer(const HostResource& resource, PluginDispatcher* dispatcher);
   virtual ~CommandBuffer();
 
   // gpu::CommandBuffer implementation:
-  virtual bool Initialize();
+  virtual bool Initialize(int32 size);
+  virtual bool Initialize(base::SharedMemory* buffer, int32 size);
+  virtual gpu::Buffer GetRingBuffer();
   virtual State GetState();
   virtual State GetLastState();
   virtual void Flush(int32 put_offset);
   virtual State FlushSync(int32 put_offset, int32 last_known_get);
-  virtual void SetGetBuffer(int32 transfer_buffer_id);
   virtual void SetGetOffset(int32 get_offset);
   virtual int32 CreateTransferBuffer(size_t size, int32 id_request);
   virtual int32 RegisterTransferBuffer(base::SharedMemory* shared_memory,
                                        size_t size,
                                        int32 id_request);
   virtual void DestroyTransferBuffer(int32 id);
   virtual gpu::Buffer GetTransferBuffer(int32 handle);
   virtual void SetToken(int32 token);
   virtual void SetParseError(gpu::error::Error error);
   virtual void SetContextLostReason(gpu::error::ContextLostReason reason);
 
  private:
   bool Send(IPC::Message* msg);
   void UpdateState(const gpu::CommandBuffer::State& state);
 
+  int32 num_entries_;
+  scoped_ptr<base::SharedMemory> ring_buffer_;
+
   typedef base::hash_map<int32, gpu::Buffer> TransferBufferMap;
   TransferBufferMap transfer_buffers_;
 
   State last_state_;
 
   HostResource resource_;
   PluginDispatcher* dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(CommandBuffer);
 };
 
 CommandBuffer::CommandBuffer(const HostResource& resource,
                              PluginDispatcher* dispatcher)
-    : resource_(resource),
+    : num_entries_(0),
+      resource_(resource),
       dispatcher_(dispatcher) {
 }
 
 CommandBuffer::~CommandBuffer() {
   // Delete all the locally cached shared memory objects, closing the handle
   // in this process.
   for (TransferBufferMap::iterator it = transfer_buffers_.begin();
        it != transfer_buffers_.end(); ++it) {
     delete it->second.shared_memory;
     it->second.shared_memory = NULL;
   }
 }
 
-bool CommandBuffer::Initialize() {
-  return Send(new PpapiHostMsg_PPBGraphics3D_InitCommandBuffer(
-      API_ID_PPB_GRAPHICS_3D, resource_));
+bool CommandBuffer::Initialize(int32 size) {
+  DCHECK(!ring_buffer_.get());
+
+  // Initialize the service. Assuming we are sandboxed, the GPU
+  // process is responsible for duplicating the handle. This might not be true
+  // for NaCl.
+  base::SharedMemoryHandle handle;
+  if (Send(new PpapiHostMsg_PPBGraphics3D_InitCommandBuffer(
+          API_ID_PPB_GRAPHICS_3D, resource_, size, &handle)) &&
+      base::SharedMemory::IsHandleValid(handle)) {
+    ring_buffer_.reset(new base::SharedMemory(handle, false));
+    if (ring_buffer_->Map(size)) {
+      num_entries_ = size / sizeof(gpu::CommandBufferEntry);
+      return true;
+    }
+
+    ring_buffer_.reset();
+  }
+
+  return false;
+}
+
+bool CommandBuffer::Initialize(base::SharedMemory* buffer, int32 size) {
+  // Not implemented in proxy.
+  NOTREACHED();
+  return false;
+}
+
+gpu::Buffer CommandBuffer::GetRingBuffer() {
+  // Return locally cached ring buffer.
+  gpu::Buffer buffer;
+  if (ring_buffer_.get()) {
+    buffer.ptr = ring_buffer_->memory();
+    buffer.size = num_entries_ * sizeof(gpu::CommandBufferEntry);
+    buffer.shared_memory = ring_buffer_.get();
+  } else {
+    buffer.ptr = NULL;
+    buffer.size = 0;
+    buffer.shared_memory = NULL;
+  }
+  return buffer;
 }
 
 gpu::CommandBuffer::State CommandBuffer::GetState() {
   // Send will flag state with lost context if IPC fails.
   if (last_state_.error == gpu::error::kNoError) {
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_GetState(
              API_ID_PPB_GRAPHICS_3D, resource_, &state)))
       UpdateState(state);
   }
@@ skipping 30 matching lines @@
               last_known_get, &state)))
         UpdateState(state);
     }
   } else {
     Flush(put_offset);
   }
 
   return last_state_;
 }
 
-void CommandBuffer::SetGetBuffer(int32 transfer_buffer_id) {
-  if (last_state_.error == gpu::error::kNoError) {
-    Send(new PpapiHostMsg_PPBGraphics3D_SetGetBuffer(
-        API_ID_PPB_GRAPHICS_3D, resource_, transfer_buffer_id));
-  }
-}
-
 void CommandBuffer::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 int32 CommandBuffer::CreateTransferBuffer(size_t size, int32 id_request) {
   if (last_state_.error == gpu::error::kNoError) {
     int32 id;
     if (Send(new PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
             API_ID_PPB_GRAPHICS_3D, resource_, size, &id))) {
@@ skipping 143 matching lines @@
 Graphics3D::~Graphics3D() {
   DestroyGLES2Impl();
 }
 
 bool Graphics3D::Init() {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(this);
   if (!dispatcher)
     return false;
 
   command_buffer_.reset(new CommandBuffer(host_resource(), dispatcher));
-  if (!command_buffer_->Initialize())
+  if (!command_buffer_->Initialize(kCommandBufferSize))
     return false;
 
   return CreateGLES2Impl(kCommandBufferSize, kTransferBufferSize);
 }
 
-PP_Bool Graphics3D::InitCommandBuffer() {
+PP_Bool Graphics3D::InitCommandBuffer(int32_t size) {
   return PP_FALSE;
 }
 
-PP_Bool Graphics3D::SetGetBuffer(int32_t /* transfer_buffer_id */) {
+PP_Bool Graphics3D::GetRingBuffer(int* shm_handle, uint32_t* shm_size) {
   return PP_FALSE;
 }
 
 PP_Graphics3DTrustedState Graphics3D::GetState() {
   return GetErrorState();
 }
 
 PP_Bool Graphics3D::Flush(int32_t put_offset) {
   return PP_FALSE;
 }
@@ skipping 80 matching lines @@
   return graphics_3d->GetReference();
 }
 
 bool PPB_Graphics3D_Proxy::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PPB_Graphics3D_Proxy, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_Create,
                         OnMsgCreate)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_InitCommandBuffer,
                         OnMsgInitCommandBuffer)
-    IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_SetGetBuffer,
-                        OnMsgSetGetBuffer)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_GetState,
                         OnMsgGetState)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_Flush,
                         OnMsgFlush)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_AsyncFlush,
                         OnMsgAsyncFlush)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer,
                         OnMsgCreateTransferBuffer)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBGraphics3D_DestroyTransferBuffer,
                         OnMsgDestroyTransferBuffer)
@@ skipping 19 matching lines @@
 
   thunk::EnterResourceCreation enter(instance);
   if (enter.succeeded()) {
     result->SetHostResource(
         instance,
         enter.functions()->CreateGraphics3DRaw(instance, 0, &attribs.front()));
   }
 }
 
 void PPB_Graphics3D_Proxy::OnMsgInitCommandBuffer(
-    const HostResource& context) {
+    const HostResource& context,
+    int32 size,
+    base::SharedMemoryHandle* ring_buffer) {
+  *ring_buffer = base::SharedMemory::NULLHandle();
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.failed())
     return;
 
-  if (!enter.object()->InitCommandBuffer())
+  if (!enter.object()->InitCommandBuffer(size))
     return;
-}
 
-void PPB_Graphics3D_Proxy::OnMsgSetGetBuffer(
-    const HostResource& context,
-    int32 transfer_buffer_id) {
-  EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
-  if (enter.succeeded())
-    enter.object()->SetGetBuffer(transfer_buffer_id);
+  int shm_handle;
+  uint32_t shm_size;
+  if (!enter.object()->GetRingBuffer(&shm_handle, &shm_size))
+    return;
+  *ring_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
 }
 
 void PPB_Graphics3D_Proxy::OnMsgGetState(const HostResource& context,
                                          gpu::CommandBuffer::State* state) {
   EnterHostFromHostResource<PPB_Graphics3D_API> enter(context);
   if (enter.failed())
     return;
   PP_Graphics3DTrustedState pp_state = enter.object()->GetState();
   *state = GPUStateFromPPState(pp_state);
 }
@@ skipping 72 matching lines @@
 void PPB_Graphics3D_Proxy::SendSwapBuffersACKToPlugin(
     int32_t result,
     const HostResource& context) {
   dispatcher()->Send(new PpapiMsg_PPBGraphics3D_SwapBuffersACK(
       API_ID_PPB_GRAPHICS_3D, context, result));
 }
 
 }  // namespace proxy
 }  // namespace ppapi