Convert plugin and GPU process to brokered handle duplication.

content/common/gpu/client/gpu_channel_host.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.
 
 #include "content/common/gpu/client/gpu_channel_host.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
@@ skipping 75 matching lines @@
   }
 
   listeners_.clear();
 
   MessageLoop* main_loop = parent_->factory_->GetMainLoop();
   main_loop->PostTask(FROM_HERE,
                       base::Bind(&GpuChannelHost::OnChannelError, parent_));
 }
 
 GpuChannelHost::GpuChannelHost(
-    GpuChannelHostFactory* factory, int gpu_process_id, int client_id)
+    GpuChannelHostFactory* factory, int gpu_host_id, int client_id)
     : factory_(factory),
-      gpu_process_id_(gpu_process_id),
       client_id_(client_id),
+      gpu_host_id_(gpu_host_id),
       state_(kUnconnected) {
 }
 
 GpuChannelHost::~GpuChannelHost() {
 }
 
 void GpuChannelHost::Connect(
-    const IPC::ChannelHandle& channel_handle,
-    base::ProcessHandle client_process_for_gpu) {
+    const IPC::ChannelHandle& channel_handle) {
   DCHECK(factory_->IsMainThread());
   // Open a channel to the GPU process. We pass NULL as the main listener here
   // since we need to filter everything to route it to the right thread.
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   channel_.reset(new IPC::SyncChannel(
       channel_handle, IPC::Channel::MODE_CLIENT, NULL,
       io_loop, true,
       factory_->GetShutDownEvent()));
 
   sync_filter_ = new IPC::SyncMessageFilter(
       factory_->GetShutDownEvent());
 
   channel_->AddFilter(sync_filter_.get());
 
   channel_filter_ = new MessageFilter(this);
 
   // Install the filter last, because we intercept all leftover
   // messages.
   channel_->AddFilter(channel_filter_.get());
 
   // It is safe to send IPC messages before the channel completes the connection
   // and receives the hello message from the GPU process. The messages get
   // cached.
   state_ = kConnected;
-
-  // Notify the GPU process of our process handle. This gives it the ability
-  // to map client handles into the GPU process.
-  Send(new GpuChannelMsg_Initialize(client_process_for_gpu));
 }
 
 void GpuChannelHost::set_gpu_info(const content::GPUInfo& gpu_info) {
   gpu_info_ = gpu_info;
 }
 
 const content::GPUInfo& GpuChannelHost::gpu_info() const {
   return gpu_info_;
 }
 
@@ skipping 160 matching lines @@
                                                  &result))) {
     return false;
   }
   return result;
 }
 
 void GpuChannelHost::ForciblyCloseChannel() {
   Send(new GpuChannelMsg_CloseChannel());
   SetStateLost();
 }