Convert plugin and GPU process to brokered handle duplication.

content/common/gpu/gpu_channel.cc

 // Copyright (c) 2012 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(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 22 matching lines @@
 const int64 kHandleMoreWorkPeriodBusyMs = 1;
 }
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        int client_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       client_id_(client_id),
-      renderer_process_(base::kNullProcessHandle),
-      renderer_pid_(base::kNullProcessId),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
       processed_get_state_fast_(false),
       num_contexts_preferring_discrete_gpu_(0),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
   disallowed_features_.driver_bug_workarounds =
       command_line->HasSwitch(switches::kDisableGpuDriverBugWorkarounds);
 }
 
-GpuChannel::~GpuChannel() {
-#if defined(OS_WIN)
-  if (renderer_process_)
-    CloseHandle(renderer_process_);
-#endif
-}
+GpuChannel::~GpuChannel() { }

[apatrick_chromium, 2012/04/09 18:40:58]

nit: drop } to next line so I can set breakpoints here.

[jschuh, 2012/04/10 19:02:12]

Done.

 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   if (log_messages_) {
     DVLOG(1) << "received message @" << &message << " on channel @" << this
              << " with type " << message.type();
   }
 
   // Control messages are not deferred and can be handled out of order with
   // respect to routed ones.
   if (message.routing_id() == MSG_ROUTING_CONTROL)
@@ skipping 26 matching lines @@
 
   OnScheduled();
 
   return true;
 }
 
 void GpuChannel::OnChannelError() {
   gpu_channel_manager_->RemoveChannel(client_id_);
 }
 
-void GpuChannel::OnChannelConnected(int32 peer_pid) {
-  renderer_pid_ = peer_pid;
-}
-
 bool GpuChannel::Send(IPC::Message* message) {
   // The GPU process must never send a synchronous IPC message to the renderer
   // process. This could result in deadlock.
   DCHECK(!message->is_sync());
   if (log_messages_) {
     DVLOG(1) << "sending message @" << message << " on channel @" << this
              << " with type " << message->type();
   }
 
   if (!channel_.get()) {
@@ skipping 74 matching lines @@
 
 GpuCommandBufferStub* GpuChannel::LookupCommandBuffer(int32 route_id) {
   return stubs_.Lookup(route_id);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_Initialize, OnInitialize)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_CreateOffscreenCommandBuffer,
                                     OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_DestroyCommandBuffer,
                                     OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_WillGpuSwitchOccur,
                                     OnWillGpuSwitchOccur)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
@@ skipping 80 matching lines @@
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
 bool GpuChannel::ShouldPreferDiscreteGpu() const {
   return num_contexts_preferring_discrete_gpu_ > 0;
 }
 
-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(
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     IPC::Message* reply_message) {
   int32 route_id = MSG_ROUTING_NONE;
 
   content::GetContentClient()->SetActiveURL(init_params.active_url);
 #if defined(ENABLE_GPU)
   WillCreateCommandBuffer(init_params.gpu_preference);
 
@@ skipping 110 matching lines @@
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
   if (!channel_.get()) {
     NOTREACHED();
     return -1;
   }
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX)