Add CommandBuffer::SetGetBuffer

ppapi/proxy/ppb_context_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_context_3d_proxy.h"
 
 #include "base/hash_tables.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 59 matching lines @@
 
 }  // namespace
 
 class PepperCommandBuffer : public gpu::CommandBuffer {
  public:
   PepperCommandBuffer(const HostResource& resource,
                       PluginDispatcher* dispatcher);
   virtual ~PepperCommandBuffer();
 
   // CommandBuffer implementation:
-  virtual bool Initialize(int32 size);
-  virtual bool Initialize(base::SharedMemory* buffer, int32 size);
-  virtual gpu::Buffer GetRingBuffer();
+  virtual bool Initialize();
   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 shm_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);
@@ skipping 28 matching lines @@
   // 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 PepperCommandBuffer::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_PPBContext3D_Initialize(
-          API_ID_PPB_CONTEXT_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 PepperCommandBuffer::Initialize(base::SharedMemory* buffer, int32 size) {
-  // Not implemented in proxy.
-  NOTREACHED();
-  return false;
-}
-
-gpu::Buffer PepperCommandBuffer::GetRingBuffer() {
-  // Return locally cached ring buffer.
-  gpu::Buffer buffer;
-  buffer.ptr = ring_buffer_->memory();
-  buffer.size = num_entries_ * sizeof(gpu::CommandBufferEntry);
-  buffer.shared_memory = ring_buffer_.get();
-  return buffer;
+bool PepperCommandBuffer::Initialize() {
+  return Send(new PpapiHostMsg_PPBContext3D_Initialize(
+      API_ID_PPB_CONTEXT_3D, resource_));
 }
 
 gpu::CommandBuffer::State PepperCommandBuffer::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_PPBContext3D_GetState(
              API_ID_PPB_CONTEXT_3D, resource_, &state)))
       UpdateState(state);
   }
@@ skipping 30 matching lines @@
               last_known_get, &state)))
         UpdateState(state);
     }
   } else {
     Flush(put_offset);
   }
 
   return last_state_;
 }
 
+void PepperCommandBuffer::SetGetBuffer(int32 shm_id) {
+  if (last_state_.error == gpu::error::kNoError) {
+    Send(new PpapiHostMsg_PPBContext3D_SetGetBuffer(

[piman, 2011/11/20 01:19:16]

Note: I can see that this message is not handled, meaning, this is not
functional (you'd need to add SetGetBuffer to PPB_Context3DTrusted_Dev too).
However, Context3D/Surface3D has been superseded by Graphics3D, so I think we
can probably just rip them out. I think they're not called anymore.

+        API_ID_PPB_CONTEXT_3D, resource_, shm_id));
+  }
+}
+
 void PepperCommandBuffer::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 int32 PepperCommandBuffer::CreateTransferBuffer(size_t size, int32 id_request) {
   if (last_state_.error == gpu::error::kNoError) {
     int32 id;
     if (Send(new PpapiHostMsg_PPBContext3D_CreateTransferBuffer(
             API_ID_PPB_CONTEXT_3D, resource_, size, &id))) {
@@ skipping 118 matching lines @@
   return this;
 }
 
 bool Context3D::CreateImplementation() {
   PluginDispatcher* dispatcher = PluginDispatcher::GetForResource(this);
   if (!dispatcher)
     return false;
 
   command_buffer_.reset(new PepperCommandBuffer(host_resource(), dispatcher));
 
-  if (!command_buffer_->Initialize(kCommandBufferSize))
+  if (!command_buffer_->Initialize())
     return false;
 
   helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer_.get()));
   if (!helper_->Initialize(kCommandBufferSize))
     return false;
 
   transfer_buffer_id_ =
       command_buffer_->CreateTransferBuffer(kTransferBufferSize, -1);
   if (transfer_buffer_id_ < 0)
     return false;
@@ skipping 68 matching lines @@
   read_ = read_surface;
   return PP_OK;
 }
 
 int32_t Context3D::GetBoundSurfaces(PP_Resource* draw, PP_Resource* read) {
   *draw = draw_ ? draw_->pp_resource() : 0;
   *read = read_ ? read_->pp_resource() : 0;
   return PP_OK;
 }
 
-PP_Bool Context3D::InitializeTrusted(int32_t size) {
+PP_Bool Context3D::InitializeTrusted() {
   // Trusted interface not implemented in the proxy.
   return PP_FALSE;
 }
 
-PP_Bool Context3D::GetRingBuffer(int* shm_handle,
-                                 uint32_t* shm_size) {
+PP_Bool Context3D::SetGetBuffer(int32_t shm_id) {
   // Trusted interface not implemented in the proxy.
   return PP_FALSE;
 }
 
 PP_Context3DTrustedState Context3D::GetState() {
   // Trusted interface not implemented in the proxy.
   return GetErrorState();
 }
 
 PP_Bool Context3D::Flush(int32_t put_offset) {
@@ skipping 143 matching lines @@
   EnterHostFromHostResource<PPB_Context3D_API> enter(context);
   if (enter.succeeded()) {
     *result = enter.object()->BindSurfaces(draw.host_resource(),
                                            read.host_resource());
   } else {
     *result = PP_ERROR_BADRESOURCE;
   }
 }
 
 void PPB_Context3D_Proxy::OnMsgInitialize(
-    const HostResource& context,
-    int32 size,
-    base::SharedMemoryHandle* ring_buffer) {
-  *ring_buffer = base::SharedMemory::NULLHandle();
-  EnterHostFromHostResource<PPB_Context3D_API> enter(context);
+    const HostResource& context) {
+ EnterHostFromHostResource<PPB_Context3D_API> enter(context);
   if (enter.failed())
     return;
 
-  if (!enter.object()->InitializeTrusted(size))
+  if (!enter.object()->InitializeTrusted())
     return;
-
-  int shm_handle;
-  uint32_t shm_size;
-  if (!enter.object()->GetRingBuffer(&shm_handle, &shm_size))
-    return;
-  *ring_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
 }
 
 void PPB_Context3D_Proxy::OnMsgGetState(const HostResource& context,
                                         gpu::CommandBuffer::State* state) {
   EnterHostFromHostResource<PPB_Context3D_API> enter(context);
   if (enter.failed())
     return;
   PP_Context3DTrustedState pp_state = enter.object()->GetState();
   *state = GPUStateFromPPState(pp_state);
 }
@@ skipping 49 matching lines @@
   uint32_t shm_size = 0;
   if (enter.succeeded() &&
       enter.object()->GetTransferBuffer(id, &shm_handle, &shm_size)) {
     *transfer_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
     *size = shm_size;
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi