Refactor GpuProcessHost::GetForClient to GpuProcessHost::Get, which takes a GPU process kind rather…

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 61 matching lines @@
 
 #if defined(TOOLKIT_USES_GTK)
 
 void ReleasePermanentXIDDispatcher(gfx::PluginWindowHandle surface) {
   GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
   manager->ReleasePermanentXID(surface);
 }
 
 #endif
 
-void SendGpuProcessMessage(int client_id,
+void SendGpuProcessMessage(GpuProcessHost::GpuProcessKind kind,
                            content::CauseForGpuLaunch cause,
                            IPC::Message* message) {
-  GpuProcessHost* host = GpuProcessHost::GetForClient(client_id, cause);
+  GpuProcessHost* host = GpuProcessHost::Get(kind, cause);
   if (host) {
     host->Send(message);
   } else {
     delete message;
   }
 }
 
 void AcceleratedSurfaceBuffersSwappedCompleted(int host_id,
                                                int route_id,
                                                bool alive) {
@@ skipping 105 matching lines @@
       host->software_rendering() ||
       !GpuDataManagerImpl::GetInstance()->ShouldUseSoftwareRendering()) {
     return true;
   }
 
   host->ForceShutdown();
   return false;
 }
 
 // static
-GpuProcessHost* GpuProcessHost::GetForClient(
-    int client_id, content::CauseForGpuLaunch cause) {
+GpuProcessHost* GpuProcessHost::Get(GpuProcessKind kind,
+                                    content::CauseForGpuLaunch cause) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Don't grant further access to GPU if it is not allowed.
   GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
   if (gpu_data_manager != NULL && !gpu_data_manager->GpuAccessAllowed())
     return NULL;
 
-  // The current policy is to ignore the renderer ID and use a single GPU
-  // process (the first valid host in the host-id map) for all renderers. Later
-  // this will be extended to allow the use of multiple GPU processes.
+  // TODO(apatrick): This is a mess. There are only two GpuProcessHosts that
+  // can legitimately be returned by this function: the sandboxed one or the
+  // unsandboxed one. There should be no need for a map indexed by host ID.
+  // Historical note: there was once a command line switch to launch one GPU
+  // process per renderer process and this is its legacy.
   for (IDMap<GpuProcessHost>::iterator it(g_hosts_by_id.Pointer());
        !it.IsAtEnd(); it.Advance()) {
     GpuProcessHost* host = it.GetCurrentValue();
 
-    if (host->sandboxed() != (client_id != 0))
+    if (host->kind() != kind)
       continue;
 
     if (HostIsValid(host))
       return host;
   }
 
   if (cause == content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH)
     return NULL;
 
   int host_id;
   host_id = ++g_last_host_id;
 
   UMA_HISTOGRAM_ENUMERATION("GPU.GPUProcessLaunchCause",
                             cause,
                             content::CAUSE_FOR_GPU_LAUNCH_MAX_ENUM);
 
-  GpuProcessHost* host = new GpuProcessHost(host_id, client_id != 0);
+  GpuProcessHost* host = new GpuProcessHost(host_id, kind);
   if (host->Init())
     return host;
 
   delete host;
   return NULL;
 }
 
 // static
-void GpuProcessHost::SendOnIO(int client_id,
+void GpuProcessHost::SendOnIO(GpuProcessKind kind,
                               content::CauseForGpuLaunch cause,
                               IPC::Message* message) {
   BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(
-            &SendGpuProcessMessage, client_id, cause, message));
+            &SendGpuProcessMessage, kind, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
   GpuProcessHost* host = g_hosts_by_id.Pointer()->Lookup(host_id);
   if (HostIsValid(host))
     return host;
 
   return NULL;
 }
 
-GpuProcessHost::GpuProcessHost(int host_id, bool sandboxed)
+GpuProcessHost::GpuProcessHost(int host_id, GpuProcessKind kind)
     : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       in_process_(false),
       software_rendering_(false),
-      sandboxed_(sandboxed),
+      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.
   DCHECK(!in_process_ || g_hosts_by_id.Pointer()->IsEmpty());
 
   g_hosts_by_id.Pointer()->AddWithID(this, host_id_);
@@ skipping 12 matching lines @@
       new BrowserChildProcessHostImpl(content::PROCESS_TYPE_GPU, this));
 }
 
 GpuProcessHost::~GpuProcessHost() {
   DCHECK(CalledOnValidThread());
 
   SendOutstandingReplies();
   // Ending only acts as a failure if the GPU process was actually started and
   // was intended for actual rendering (and not just checking caps or other
   // options).
-  if (process_launched_ && sandboxed_) {
+  if (process_launched_ && kind_ == GPU_PROCESS_KIND_SANDBOXED) {
     if (software_rendering_) {
       if (++g_gpu_software_crash_count >= kGpuMaxCrashCount) {
         // The software renderer is too unstable to use. Disable it for current
         // session.
         gpu_enabled_ = false;
       }
     } else {
       if (++g_gpu_crash_count >= kGpuMaxCrashCount) {
         // The gpu process is too unstable to use. Disable it for current
         // session.
@@ skipping 224 matching lines @@
 void GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params) {
   TRACE_EVENT0("renderer",
       "GpuProcessHost::OnAcceleratedSurfaceBuffersSwapped");
 
   GpuSurfaceTracker::Get()->AsyncPresentAndAcknowledge(
       params.surface_id,
       params.size,
       params.surface_handle,
       base::Bind(&AcceleratedSurfaceBuffersSwappedCompleted,
-                 host_id_,
+                 GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                  params.route_id));
 }
 
 void GpuProcessHost::OnAcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params) {
   TRACE_EVENT0("renderer",
       "GpuProcessHost::OnAcceleratedSurfacePostSubBuffer");
 
   NOTIMPLEMENTED();
 }
@@ skipping 29 matching lines @@
 }
 
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
 }
 
 bool GpuProcessHost::software_rendering() {
   return software_rendering_;
 }
 
-bool GpuProcessHost::sandboxed() {
-  return sandboxed_;
+GpuProcessHost::GpuProcessKind GpuProcessHost::kind() {
+  return kind_;
 }
 
 void GpuProcessHost::ForceShutdown() {
   g_hosts_by_id.Pointer()->Remove(host_id_);
   process_->ForceShutdown();
 }
 
 bool GpuProcessHost::LaunchGpuProcess(const std::string& channel_id) {
   if (!(gpu_enabled_ &&
       GpuDataManagerImpl::GetInstance()->ShouldUseSoftwareRendering()) &&
@@ skipping 15 matching lines @@
 #endif
 
   FilePath exe_path = ChildProcessHost::GetChildPath(child_flags);
   if (exe_path.empty())
     return false;
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
   cmd_line->AppendSwitchASCII(switches::kProcessChannelID, channel_id);
 
-  if (!sandboxed_)
+  if (kind_ == GPU_PROCESS_KIND_UNSANDBOXED)
     cmd_line->AppendSwitch(switches::kDisableGpuSandbox);
 
   // Propagate relevant command line switches.
   static const char* const kSwitchNames[] = {
     switches::kDisableBreakpad,
     switches::kDisableGLMultisampling,
     switches::kDisableGpuDriverBugWorkarounds,
     switches::kDisableGpuSandbox,
     switches::kReduceGpuSandbox,
     switches::kDisableGpuVsync,
@@ skipping 62 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& 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);
 }