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

content/renderer/gpu/command_buffer_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 "content/renderer/gpu/command_buffer_proxy.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
 #include "base/task.h"
 #include "content/common/child_process_messages.h"
 #include "content/common/child_thread.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "ui/gfx/size.h"
 
 using gpu::Buffer;
 
 CommandBufferProxy::CommandBufferProxy(
     GpuChannelHost* channel,
     int route_id)
-    : channel_(channel),
+    : num_entries_(0),
+      channel_(channel),
       route_id_(route_id),
       flush_count_(0) {
 }
 
 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) {
@@ skipping 46 matching lines @@
   base::Closure callback = echo_tasks_.front();
   echo_tasks_.pop();
   callback.Run();
 }
 
 void CommandBufferProxy::SetChannelErrorCallback(
     const base::Closure& callback) {
   channel_error_callback_ = callback;
 }
 
-bool CommandBufferProxy::Initialize() {
+bool CommandBufferProxy::Initialize(int32 size) {
+  DCHECK(!ring_buffer_.get());
+
   ChildThread* child_thread = ChildThread::current();
   if (!child_thread)
     return false;
 
+  base::SharedMemoryHandle handle;
+  if (!child_thread->Send(new ChildProcessHostMsg_SyncAllocateSharedMemory(
+      size,
+      &handle))) {
+    return false;
+  }
+
+  if (!base::SharedMemory::IsHandleValid(handle))
+    return false;
+
+#if defined(OS_POSIX)
+  handle.auto_close = false;
+#endif
+
+  // Take ownership of shared memory. This will close the handle if Send below
+  // fails. Otherwise, callee takes ownership before this variable
+  // goes out of scope.
+  base::SharedMemory shared_memory(handle, false);
+
+  return Initialize(&shared_memory, size);
+}
+
+bool CommandBufferProxy::Initialize(base::SharedMemory* buffer, int32 size) {
   bool result;
-  if (!Send(new GpuCommandBufferMsg_Initialize(route_id_, &result))) {
+  if (!Send(new GpuCommandBufferMsg_Initialize(route_id_,
+                                               buffer->handle(),
+                                               size,
+                                               &result))) {
     LOG(ERROR) << "Could not send GpuCommandBufferMsg_Initialize.";
     return false;
   }
 
   if (!result) {
     LOG(ERROR) << "Failed to initialize command buffer service.";
     return false;
   }
 
+  base::SharedMemoryHandle handle;
+  if (!buffer->GiveToProcess(base::GetCurrentProcessHandle(), &handle)) {
+    LOG(ERROR) << "Failed to duplicate command buffer handle.";
+    return false;
+  }
+
+  ring_buffer_.reset(new base::SharedMemory(handle, false));
+  if (!ring_buffer_->Map(size)) {
+    LOG(ERROR) << "Failed to map shared memory for command buffer.";
+    ring_buffer_.reset();
+    return false;
+  }
+
+  num_entries_ = size / sizeof(gpu::CommandBufferEntry);
   return true;
 }
 
+Buffer CommandBufferProxy::GetRingBuffer() {
+  DCHECK(ring_buffer_.get());
+  // Return locally cached ring buffer.
+  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 CommandBufferProxy::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 GpuCommandBufferMsg_GetState(route_id_, &state)))
       OnUpdateState(state);
   }
 
   return last_state_;
 }
@@ skipping 24 matching lines @@
       gpu::CommandBuffer::State state;
       if (Send(new GpuCommandBufferMsg_GetStateFast(route_id_,
                                                     &state)))
         OnUpdateState(state);
     }
   }
 
   return last_state_;
 }
 
-void CommandBufferProxy::SetGetBuffer(int32 shm_id) {
-  if (last_state_.error != gpu::error::kNoError)
-    return;
-
-  Send(new GpuCommandBufferMsg_SetGetBuffer(route_id_, shm_id));
-}
-
 void CommandBufferProxy::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 int32 CommandBufferProxy::CreateTransferBuffer(size_t size, int32 id_request) {
   if (last_state_.error != gpu::error::kNoError)
     return -1;
 
   ChildThread* child_thread = ChildThread::current();
@@ skipping 230 matching lines @@
   delete msg;
   return false;
 }
 
 void CommandBufferProxy::OnUpdateState(const gpu::CommandBuffer::State& state) {
   // Handle wraparound. It works as long as we don't have more than 2B state
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }