Revert 132218 - Convert plugin and GPU process to brokered handle duplication.

content/browser/gpu/gpu_process_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/browser/gpu/gpu_process_host.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 249 matching lines @@
     GpuProcessHost* host = g_gpu_process_hosts[i];
     if (host && host->host_id_ == host_id && HostIsValid(host))
       return host;
   }
 
   return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
     : host_id_(host_id),
+      gpu_process_(base::kNullProcessHandle),
       in_process_(false),
       software_rendering_(false),
       kind_(kind),
       process_launched_(false) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU))
     in_process_ = true;
 
   // If the 'single GPU process' policy ever changes, we still want to maintain
   // it for 'gpu thread' mode and only create one instance of host and thread.
@@ skipping 50 matching lines @@
                             status,
                             base::TERMINATION_STATUS_MAX_ENUM);
 
   if (status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
       status == base::TERMINATION_STATUS_ABNORMAL_TERMINATION) {
     UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessExitCode",
                               exit_code,
                               content::RESULT_CODE_LAST_CODE);
   }
 
+#if defined(OS_WIN)
+  if (gpu_process_)
+    CloseHandle(gpu_process_);
+#endif
+
   // In case we never started, clean up.
   while (!queued_messages_.empty()) {
     delete queued_messages_.front();
     queued_messages_.pop();
   }
 
   // This is only called on the IO thread so no race against the constructor
   // for another GpuProcessHost.
   if (g_gpu_process_hosts[kind_] == this)
     g_gpu_process_hosts[kind_] = NULL;
@@ skipping 135 matching lines @@
 #if defined(TOOLKIT_GTK)
     surface_refs_.insert(std::make_pair(surface_id, surface_ref));
 #endif
   } else {
     CreateCommandBufferError(callback, MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle) {
+  // The GPU process should have launched at this point and this object should
+  // have been notified of its process handle.
+  DCHECK(gpu_process_);
+
   EstablishChannelCallback callback = channel_requests_.front();
   channel_requests_.pop();
 
   // Currently if any of the GPU features are blacklisted, we don't establish a
   // GPU channel.
   if (!channel_handle.name.empty() &&
       !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed()) {
     Send(new GpuMsg_CloseChannel(channel_handle));
     EstablishChannelError(callback,
                           IPC::ChannelHandle(),
                           base::kNullProcessHandle,
                           content::GPUInfo());
     RouteOnUIThread(GpuHostMsg_OnLogMessage(
         logging::LOG_WARNING,
         "WARNING",
         "Hardware acceleration is unavailable."));
     return;
   }
 
-  callback.Run(channel_handle,
+  callback.Run(channel_handle, gpu_process_,
                GpuDataManagerImpl::GetInstance()->GetGPUInfo());
 }
 
 void GpuProcessHost::OnCommandBufferCreated(const int32 route_id) {
   if (!create_command_buffer_requests_.empty()) {
     CreateCommandBufferCallback callback =
         create_command_buffer_requests_.front();
     create_command_buffer_requests_.pop();
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback, route_id);
@@ skipping 81 matching lines @@
       AcceleratedPresenter::GetForWindow(handle.handle));
   if (!presenter)
     return;
 
   presenter->ReleaseSurface();
 }
 
 #endif  // OS_WIN && !USE_AURA
 
 void GpuProcessHost::OnProcessLaunched() {
+  // Send the GPU process handle to the UI thread before it has to
+  // respond to any requests to establish a GPU channel. The response
+  // to such requests require that the GPU process handle be known.
+
+  base::ProcessHandle child_handle = in_process_ ?
+      base::GetCurrentProcessHandle() : process_->GetData().handle;
+
+#if defined(OS_WIN)
+  DuplicateHandle(base::GetCurrentProcessHandle(),
+                  child_handle,
+                  base::GetCurrentProcessHandle(),
+                  &gpu_process_,
+                  PROCESS_DUP_HANDLE,
+                  FALSE,
+                  0);
+#else
+  gpu_process_ = child_handle;
+#endif
+
   UMA_HISTOGRAM_TIMES("GPU.GPUProcessLaunchTime",
                       base::TimeTicks::Now() - init_start_time_);
 }
 
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
 }
 
 bool GpuProcessHost::software_rendering() {
   return software_rendering_;
@@ skipping 112 matching lines @@
                           base::kNullProcessHandle,
                           content::GPUInfo());
   }
 }
 
 void GpuProcessHost::EstablishChannelError(
     const EstablishChannelCallback& callback,
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
-  callback.Run(channel_handle, gpu_info);
+  callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }