Added CommandBufferClient, CommandBufferStub and some IPC messages....

chrome/renderer/command_buffer_proxy.cc

+// 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();
+}