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

chrome/gpu/gpu_channel.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.
 
-#include "chrome/gpu/gpu_channel.h"
-
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
+#include "chrome/gpu/gpu_channel.h"
+
 #include "base/command_line.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/gpu/gpu_thread.h"
 #include "chrome/gpu/gpu_video_service.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
-GpuChannel::GpuChannel(GpuThread* gpu_thread, int renderer_id)
+GpuChannel::GpuChannel(GpuThread* gpu_thread,
+                       int renderer_id)
     : gpu_thread_(gpu_thread),
-      renderer_id_(renderer_id) {
+      renderer_id_(renderer_id),
+      renderer_process_(NULL),
+      renderer_pid_(NULL) {
   DCHECK(gpu_thread);
+  DCHECK(renderer_id);
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
 }
 
 GpuChannel::~GpuChannel() {
-}
-
-void GpuChannel::OnChannelConnected(int32 peer_pid) {
-  if (!renderer_process_.Open(peer_pid)) {
-    NOTREACHED();
-  }
+#if defined(OS_WIN)
+  if (renderer_process_)
+    CloseHandle(renderer_process_);
+#endif
 }
 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   if (log_messages_) {
     VLOG(1) << "received message @" << &message << " on channel @" << this
             << " with type " << message.type();
   }
 
   if (message.routing_id() == MSG_ROUTING_CONTROL)
     return OnControlMessageReceived(message);
 
   // Fail silently if the GPU process has destroyed while the IPC message was
   // en-route.
   return router_.RouteMessage(message);
 }
 
 void GpuChannel::OnChannelError() {
   gpu_thread_->RemoveChannel(renderer_id_);
 }
 
+void GpuChannel::OnChannelConnected(int32 peer_pid) {
+  renderer_pid_ = peer_pid;
+}
+
 bool GpuChannel::Send(IPC::Message* message) {
   if (log_messages_) {
     VLOG(1) << "sending message @" << message << " on channel @" << this
             << " with type " << message->type();
   }
 
   if (!channel_.get()) {
     delete message;
     return false;
   }
@@ skipping 37 matching lines @@
 }
 
 bool GpuChannel::IsRenderViewGone(int32 renderer_route_id) {
   return destroyed_renderer_routes_.count(renderer_route_id) > 0;
 }
 #endif
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_Initialize, OnInitialize)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateOffscreenCommandBuffer,
         OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateVideoDecoder,
         OnCreateVideoDecoder)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyVideoDecoder,
         OnDestroyVideoDecoder)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
   return handled;
 }
 
 int GpuChannel::GenerateRouteID() {
   static int last_id = 0;
   return ++last_id;
 }
 
+void GpuChannel::OnInitialize(base::ProcessHandle renderer_process) {
+  // Initialize should only happen once.
+  DCHECK(!renderer_process_);
+
+  // Verify that the renderer has passed its own process handle.
+  if (base::GetProcId(renderer_process) == renderer_pid_)
+    renderer_process_ = renderer_process;
+}
+
 void GpuChannel::OnCreateOffscreenCommandBuffer(
     int32 parent_route_id,
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     uint32 parent_texture_id,
     int32* route_id) {
 #if defined(ENABLE_GPU)
   *route_id = GenerateRouteID();
   GpuCommandBufferStub* parent_stub = NULL;
   if (parent_route_id != 0)
@@ skipping 80 matching lines @@
 #if defined(OS_POSIX)
 int GpuChannel::GetRendererFileDescriptor() {
   int fd = -1;
   if (channel_.get()) {
     fd = channel_->GetClientFileDescriptor();
   }
   return fd;
 }
 #endif  // defined(OS_POSIX)