Added Pepper 3D render context that instantiates the GPU plugin....

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"
+#include "gpu/command_buffer/common/cmd_buffer_common.h"
+
+using gpu::Buffer;
 
 CommandBufferProxy::CommandBufferProxy(
     PluginChannelHost* channel,
     int route_id)
     : size_(0),
       channel_(channel),
       route_id_(route_id) {
 }
 
 CommandBufferProxy::~CommandBufferProxy() {
+  // 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 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) {
+bool CommandBufferProxy::Initialize(int32 size) {
   DCHECK(!ring_buffer_.get());
 
-  // Initialize the service. Assuming we are in the renderer process, the GPU
+  // 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 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();
+      return true;
     }
 
     ring_buffer_.reset();
   }
 
-  return NULL;
+  return false;
 }
 
-base::SharedMemory* CommandBufferProxy::GetRingBuffer() {
+Buffer CommandBufferProxy::GetRingBuffer() {
   // Return locally cached ring buffer.
-  return ring_buffer_.get();
+  Buffer buffer;
+  buffer.ptr = ring_buffer_->memory();
+  buffer.size = size_ * sizeof(gpu::CommandBufferEntry);
+  buffer.shared_memory = ring_buffer_.get();
+  return buffer;
 }
 
 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_,
@@ skipping 33 matching lines @@
 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);
+  TransferBufferMap::iterator it = transfer_buffers_.find(id);
+  DCHECK(it != transfer_buffers_.end());
+
+  // Delete the shared memory object, closing the handle in this process.
+  delete it->second.shared_memory;
+
+  transfer_buffers_.erase(it);
 
   Send(new CommandBufferMsg_DestroyTransferBuffer(route_id_, id));
 }
 
-base::SharedMemory* CommandBufferProxy::GetTransferBuffer(int32 id) {
+Buffer 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();
+  if (it != transfer_buffers_.end()) {
+    return it->second;
+  }
 
   // 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;
+  size_t size;
+  if (!Send(new CommandBufferMsg_GetTransferBuffer(route_id_,
+                                                   id,
+                                                   &handle,
+                                                   &size))) {
+    return Buffer();
+  }
 
   // Cache the transfer buffer shared memory object client side.
-  base::SharedMemory* transfer_buffer =
+  base::SharedMemory* shared_memory =
       new base::SharedMemory(handle, false, base::GetCurrentProcessHandle());
-  transfer_buffers_[id].reset(transfer_buffer);
 
-  return transfer_buffer;
+  // Map the shared memory on demand.
+  if (!shared_memory->memory()) {
+    if (!shared_memory->Map(shared_memory->max_size())) {
+      delete shared_memory;
+      return Buffer();
+    }
+  }
+
+  Buffer buffer;
+  buffer.ptr = shared_memory->memory();
+  buffer.size = size;
+  buffer.shared_memory = shared_memory;
+  transfer_buffers_[id] = buffer;
+
+  return buffer;
 }
 
 int32 CommandBufferProxy::GetToken() {
   int32 token;
   if (Send(new CommandBufferMsg_GetToken(route_id_, &token)))
     return token;
 
   return -1;
 }
 
@@ skipping 20 matching lines @@
   if (Send(new CommandBufferMsg_GetErrorStatus(route_id_, &status)))
     return status;
 
   return true;
 }
 
 void CommandBufferProxy::RaiseErrorStatus() {
   // Not implemented in proxy.
   NOTREACHED();
 }