Added CommandBufferProxy, CommandBufferStub. Replaced NPAPI with IPC for synchronous messages. WebPluginDelegateImpl can instantiate a command buffer. Removed remaining dependencies on NPAPI.

TEST=none
BUG=none

Review URL: http://codereview.chromium.org/465040

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

4 files changed, 263 insertions, 0 deletions

diff --git a/chrome/renderer/command_buffer_proxy.cc b/chrome/renderer/command_buffer_proxy.cc
new file mode 100644
index 0000000..262bb8e
--- /dev/null
+++ b/chrome/renderer/command_buffer_proxy.cc
@@ -0,0 +1,173 @@
+// Copyright (c) 2009 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 "base/logging.h"
+#include "base/process_util.h"
+#include "chrome/common/command_buffer_messages.h"
+#include "chrome/common/plugin_messages.h"
+#include "chrome/renderer/command_buffer_proxy.h"
+#include "chrome/renderer/plugin_channel_host.h"
+
+CommandBufferProxy::CommandBufferProxy(
+    PluginChannelHost* channel,
+    int route_id)
+    : size_(0),
+      channel_(channel),
+      route_id_(route_id) {
+}
+
+CommandBufferProxy::~CommandBufferProxy() {
+}
+
+bool CommandBufferProxy::Send(IPC::Message* msg) {
+  if (channel_)
+    return channel_->Send(msg);
+
+  // Callee takes ownership of message, regardless of whether Send is
+  // successful. See IPC::Message::Sender.
+  delete msg;
+  return false;
+}
+
+base::SharedMemory* CommandBufferProxy::Initialize(int32 size) {
+  DCHECK(!ring_buffer_.get());
+
+  // Initialize the service. Assuming we are in the renderer process, the GPU
+  // process is responsible for duplicating the handle. This might not be true
+  // for NaCl.
+  base::SharedMemoryHandle handle;
+  if (Send(new CommandBufferMsg_Initialize(route_id_, size, &handle)) &&
+      base::SharedMemory::IsHandleValid(handle)) {
+    ring_buffer_.reset(new base::SharedMemory(handle, false));
+    if (ring_buffer_->Map(size * sizeof(int32))) {
+      size_ = size;
+      return ring_buffer_.get();
+    }
+
+    ring_buffer_.reset();
+  }
+
+  return NULL;
+}
+
+base::SharedMemory* CommandBufferProxy::GetRingBuffer() {
+  // Return locally cached ring buffer.
+  return ring_buffer_.get();
+}
+
+int32 CommandBufferProxy::GetSize() {
+  // Return locally cached size.
+  return size_;
+}
+
+int32 CommandBufferProxy::SyncOffsets(int32 put_offset) {
+  int32 get_offset;
+  if (Send(new CommandBufferMsg_SyncOffsets(route_id_,
+                                            put_offset,
+                                            &get_offset)))
+    return get_offset;
+
+  return -1;
+}
+
+int32 CommandBufferProxy::GetGetOffset() {
+  int32 get_offset;
+  if (Send(new CommandBufferMsg_GetGetOffset(route_id_, &get_offset)))
+    return get_offset;
+
+  return -1;
+}
+
+void CommandBufferProxy::SetGetOffset(int32 get_offset) {
+  // Not implemented in proxy.
+  NOTREACHED();
+}
+
+int32 CommandBufferProxy::GetPutOffset() {
+  int put_offset;
+  if (Send(new CommandBufferMsg_GetPutOffset(route_id_, &put_offset)))
+    return put_offset;
+
+  return -1;
+}
+
+void CommandBufferProxy::SetPutOffsetChangeCallback(Callback0::Type* callback) {
+  // Not implemented in proxy.
+  NOTREACHED();
+}
+
+int32 CommandBufferProxy::CreateTransferBuffer(size_t size) {
+  int32 id;
+  if (Send(new CommandBufferMsg_CreateTransferBuffer(route_id_, size, &id)))
+    return id;
+
+  return -1;
+}
+
+void CommandBufferProxy::DestroyTransferBuffer(int32 id) {
+  // Remove the transfer buffer from the client side4 cache.
+  transfer_buffers_.erase(id);
+
+  Send(new CommandBufferMsg_DestroyTransferBuffer(route_id_, id));
+}
+
+base::SharedMemory* CommandBufferProxy::GetTransferBuffer(int32 id) {
+  // Check local cache to see if there is already a client side shared memory
+  // object for this id.
+  TransferBufferMap::iterator it = transfer_buffers_.find(id);
+  if (it != transfer_buffers_.end())
+    return it->second.get();
+
+  // Assuming we are in the renderer process, the service is responsible for
+  // duplicating the handle. This might not be true for NaCl.
+  base::SharedMemoryHandle handle;
+  if (!Send(new CommandBufferMsg_GetTransferBuffer(route_id_, id, &handle)))
+    return NULL;
+
+  // Cache the transfer buffer shared memory object client side.
+  base::SharedMemory* transfer_buffer =
+      new base::SharedMemory(handle, false, base::GetCurrentProcessHandle());
+  transfer_buffers_[id].reset(transfer_buffer);
+
+  return transfer_buffer;
+}
+
+int32 CommandBufferProxy::GetToken() {
+  int32 token;
+  if (Send(new CommandBufferMsg_GetToken(route_id_, &token)))
+    return token;
+
+  return -1;
+}
+
+void CommandBufferProxy::SetToken(int32 token) {
+  // Not implemented in proxy.
+  NOTREACHED();
+}
+
+int32 CommandBufferProxy::ResetParseError() {
+  int32 parse_error;
+  if (Send(new CommandBufferMsg_ResetParseError(route_id_, &parse_error)))
+    return parse_error;
+
+  return -1;
+}
+
+void CommandBufferProxy::SetParseError(int32 parse_error) {
+  // Not implemented in proxy.
+  NOTREACHED();
+}
+
+bool CommandBufferProxy::GetErrorStatus() {
+  bool status;
+  if (Send(new CommandBufferMsg_GetErrorStatus(route_id_, &status)))
+    return status;
+
+  return true;
+}
+
+void CommandBufferProxy::RaiseErrorStatus() {
+  // Not implemented in proxy.
+  NOTREACHED();
+}
diff --git a/chrome/renderer/command_buffer_proxy.h b/chrome/renderer/command_buffer_proxy.h
new file mode 100644
index 0000000..5abfead
--- /dev/null
+++ b/chrome/renderer/command_buffer_proxy.h
@@ -0,0 +1,71 @@
+// Copyright (c) 2009 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.
+
+#ifndef CHROME_RENDERER_COMMAND_BUFFER_PROXY_H_
+#define CHROME_RENDERER_COMMAND_BUFFER_PROXY_H_
+
+#if defined(ENABLE_GPU)
+
+#include <map>
+
+#include "base/linked_ptr.h"
+#include "base/ref_counted.h"
+#include "base/scoped_ptr.h"
+#include "base/shared_memory.h"
+#include "gpu/command_buffer/common/command_buffer.h"
+#include "ipc/ipc_channel.h"
+#include "ipc/ipc_message.h"
+
+class PluginChannelHost;
+
+// Client side proxy that forwards messages synchronously to a
+// CommandBufferStub.
+class CommandBufferProxy : public gpu::CommandBuffer,
+                           public IPC::Message::Sender {
+ public:
+  explicit CommandBufferProxy(
+      PluginChannelHost* channel,
+      int route_id);
+  virtual ~CommandBufferProxy();
+
+  // IPC::Message::Sender implementation:
+  virtual bool Send(IPC::Message* msg);
+
+  // CommandBuffer implementation:
+  virtual base::SharedMemory* Initialize(int32 size);
+  virtual base::SharedMemory* GetRingBuffer();
+  virtual int32 GetSize();
+  virtual int32 SyncOffsets(int32 put_offset);
+  virtual int32 GetGetOffset();
+  virtual void SetGetOffset(int32 get_offset);
+  virtual int32 GetPutOffset();
+  virtual void SetPutOffsetChangeCallback(Callback0::Type* callback);
+  virtual int32 CreateTransferBuffer(size_t size);
+  virtual void DestroyTransferBuffer(int32 id);
+  virtual base::SharedMemory* GetTransferBuffer(int32 handle);
+  virtual int32 GetToken();
+  virtual void SetToken(int32 token);
+  virtual int32 ResetParseError();
+  virtual void SetParseError(int32 parse_error);
+  virtual bool GetErrorStatus();
+  virtual void RaiseErrorStatus();
+
+ private:
+  // As with the service, the client takes ownership of the ring buffer.
+  int32 size_;
+  scoped_ptr<base::SharedMemory> ring_buffer_;
+
+  // Local cache of id to transfer buffer mapping.
+  typedef std::map<int32, linked_ptr<base::SharedMemory> > TransferBufferMap;
+  TransferBufferMap transfer_buffers_;
+
+  scoped_refptr<PluginChannelHost> channel_;
+  int route_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(CommandBufferProxy);
+};
+
+#endif  // ENABLE_GPU
+
+#endif  // CHROME_RENDERER_COMMAND_BUFFER_PROXY_H_
diff --git a/chrome/renderer/webplugin_delegate_proxy.cc b/chrome/renderer/webplugin_delegate_proxy.cc
index 66aa755..78f3dfe 100644
--- a/chrome/renderer/webplugin_delegate_proxy.cc
+++ b/chrome/renderer/webplugin_delegate_proxy.cc
@@ -27,6 +27,7 @@
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_stub.h"
 #include "chrome/plugin/npobject_util.h"
+#include "chrome/renderer/command_buffer_proxy.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
 #include "grit/generated_resources.h"
@@ -1141,6 +1142,20 @@ WebPluginDelegateProxy::CreateResourceClient(
   return proxy;
 }
 
+CommandBufferProxy* WebPluginDelegateProxy::CreateCommandBuffer() {
+#if defined(ENABLE_GPU)
+  int command_buffer_id;
+  if (!Send(new PluginMsg_CreateCommandBuffer(instance_id_,
+                                              &command_buffer_id))) {
+    return NULL;
+  }
+
+  return new CommandBufferProxy(channel_host_, command_buffer_id);
+#else
+  return NULL;
+#endif
+}
+
 void WebPluginDelegateProxy::OnCancelDocumentLoad() {
   plugin_->CancelDocumentLoad();
 }
diff --git a/chrome/renderer/webplugin_delegate_proxy.h b/chrome/renderer/webplugin_delegate_proxy.h
index f01ae092..c884c9f 100644
--- a/chrome/renderer/webplugin_delegate_proxy.h
+++ b/chrome/renderer/webplugin_delegate_proxy.h
@@ -16,6 +16,7 @@
 #include "chrome/common/transport_dib.h"
 #include "chrome/renderer/plugin_channel_host.h"
 #include "googleurl/src/gurl.h"
+#include "gpu/command_buffer/common/command_buffer.h"
 #include "ipc/ipc_message.h"
 #include "skia/ext/platform_canvas.h"
 #include "webkit/glue/webplugin.h"
@@ -27,6 +28,7 @@
 #include "base/linked_ptr.h"
 #endif
 
+class CommandBufferProxy;
 struct NPObject;
 class NPObjectStub;
 struct NPVariant_Param;
@@ -97,6 +99,8 @@ class WebPluginDelegateProxy
       intptr_t notify_data,
       intptr_t existing_stream);
 
+  CommandBufferProxy* CreateCommandBuffer();
+
  protected:
   template<class WebPluginDelegateProxy> friend class DeleteTask;
   ~WebPluginDelegateProxy();