Moved creation of GPU command buffer shared memory into the browser process....

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 "base/shared_memory.h"
 #include "base/task.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/plugin_messages.h"
@@ skipping 50 matching lines @@
     channel_error_callback_->Run();
 }
 
 void CommandBufferProxy::SetChannelErrorCallback(Callback0::Type* callback) {
   channel_error_callback_.reset(callback);
 }
 
 bool CommandBufferProxy::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.
+  RenderThread* render_thread = RenderThread::current();
+  if (!render_thread)
+    return false;
+
   base::SharedMemoryHandle handle;
-  if (Send(new GpuCommandBufferMsg_Initialize(route_id_, 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();
+  if (!render_thread->Send(new ViewHostMsg_AllocateSharedMemoryBuffer(
+      size,
+      &handle))) {
+    return false;
   }
 
-  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_,
+                                               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;
   buffer.ptr = ring_buffer_->memory();
   buffer.size = num_entries_ * sizeof(gpu::CommandBufferEntry);
   buffer.shared_memory = ring_buffer_.get();
   return buffer;
@@ skipping 262 matching lines @@
   pending_async_flush_tasks_.pop();
 
   if (task.get()) {
     // Although we need need to update last_state_ while potentially waiting
     // for a synchronous flush to complete, we do not need to invoke the
     // callback synchonously. Also, post it as a non nestable task so it is
     // always invoked by the outermost message loop.
     MessageLoop::current()->PostNonNestableTask(FROM_HERE, task.release());
   }
 }