Moved creation of GPU transfer buffers into the browser process....

chrome/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2010 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/common/child_thread.h"
@@ skipping 152 matching lines @@
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateTransferBuffer,
                         OnCreateTransferBuffer);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
+                        OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetTransferBuffer,
                         OnGetTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ResizeOffscreenFrameBuffer,
                         OnResizeOffscreenFrameBuffer);
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetWindowSize, OnSetWindowSize);
 #endif  // defined(OS_MACOSX)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ skipping 45 matching lines @@
           parent_processor,
           parent_texture_id_)) {
         command_buffer_->SetPutOffsetChangeCallback(
             NewCallback(processor_.get(),
                         &gpu::GPUProcessor::ProcessCommands));
         processor_->SetSwapBuffersCallback(
             NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
 
         // Assume service is responsible for duplicating the handle from the
         // calling process.
-        buffer.shared_memory->ShareToProcess(channel_->renderer_handle(),
+        buffer.shared_memory->ShareToProcess(channel_->renderer_process(),
                                              ring_buffer);
 #if defined(OS_MACOSX)
         if (handle_) {
           // This context conceptually puts its output directly on the
           // screen, rendered by the accelerated plugin layer in
           // RenderWidgetHostViewMac. Set up a pathway to notify the
           // browser process when its contents change.
           processor_->SetSwapBuffersCallback(
               NewCallback(this,
                           &GpuCommandBufferStub::SwapBuffersCallback));
@@ skipping 33 matching lines @@
 
 void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset) {
   gpu::CommandBuffer::State state = command_buffer_->FlushSync(put_offset);
   Send(new GpuCommandBufferMsg_UpdateState(route_id_, state));
 }
 
 void GpuCommandBufferStub::OnCreateTransferBuffer(int32 size, int32* id) {
   *id = command_buffer_->CreateTransferBuffer(size);
 }
 
+void GpuCommandBufferStub::OnRegisterTransferBuffer(
+    base::SharedMemoryHandle transfer_buffer,
+    size_t size,
+    int32* id) {
+#if defined(OS_WIN)
+  base::SharedMemory shared_memory(transfer_buffer,
+                                   false,
+                                   channel_->renderer_process());
+#else
+  base::SharedMemory shared_memory(transfer_buffer, false);
+#endif
+  *id = command_buffer_->RegisterTransferBuffer(&shared_memory, size);
+}
+
 void GpuCommandBufferStub::OnDestroyTransferBuffer(int32 id) {
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnGetTransferBuffer(
     int32 id,
     base::SharedMemoryHandle* transfer_buffer,
     uint32* size) {
   *transfer_buffer = base::SharedMemoryHandle();
   *size = 0;
 
+  // Fail if the renderer process has not provided its process handle.
+  if (!channel_->renderer_process())
+    return;
+
   Buffer buffer = command_buffer_->GetTransferBuffer(id);
   if (buffer.shared_memory) {
     // Assume service is responsible for duplicating the handle to the calling
     // process.
-    buffer.shared_memory->ShareToProcess(channel_->renderer_handle(),
+    buffer.shared_memory->ShareToProcess(channel_->renderer_process(),
                                          transfer_buffer);
-    *size = buffer.shared_memory->created_size();
+    *size = buffer.size;
   }
 }
 
 void GpuCommandBufferStub::OnResizeOffscreenFrameBuffer(const gfx::Size& size) {
   processor_->ResizeOffscreenFrameBuffer(size);
 }
 
 void GpuCommandBufferStub::OnSwapBuffers() {
   Send(new GpuCommandBufferMsg_SwapBuffers(route_id_));
 }
@@ skipping 54 matching lines @@
 #elif defined(OS_WIN)
     HWND hwnd = static_cast<HWND>(compositor_window_);
     UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
       SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
     SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
 #endif  // defined(OS_LINUX)
   }
 }
 
 #endif  // defined(ENABLE_GPU)