Allow switching to SwiftShader when GPU is blacklisted

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
@@ skipping 151 matching lines @@
 
  private:
   std::string channel_id_;
   // Deleted in CleanUp() on the gpu thread, so don't use smart pointers.
   GpuProcess* gpu_process_;
   GpuChildThread* child_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMainThread);
 };
 
+static bool HostIsValid(int host_id, GpuProcessHost* host) {
+  if (!host)
+    return false;
+
+  // The Gpu process is invalid if it's not using software, the card is
+  // blacklisted, and we can kill it and start over.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess) ||
+      CommandLine::ForCurrentProcess()->HasSwitch(switches::kInProcessGPU) ||
+      host->IsSoftwareRendering() ||
+      !GpuDataManager::GetInstance()->IsSoftwareRendering()) {
+    return true;
+  }
+
+  host->Send(new GpuMsg_Crash());
+  g_hosts_by_id.Pointer()->Remove(host_id);
+  return false;
+}
+
 // static
 GpuProcessHost* GpuProcessHost::GetForRenderer(
     int renderer_id, content::CauseForGpuLaunch cause) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Don't grant further access to GPU if it is not allowed.
   GpuDataManager* gpu_data_manager = GpuDataManager::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 for all renderers. Later this will be extended to allow the
   // use of multiple GPU processes.
   if (!g_hosts_by_id.Pointer()->IsEmpty()) {
     IDMap<GpuProcessHost>::iterator it(g_hosts_by_id.Pointer());
-    return it.GetCurrentValue();
+    GpuProcessHost *host = it.GetCurrentValue();
+
+    if (HostIsValid(it.GetCurrentKey(), 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,
@@ skipping 17 matching lines @@
             &SendGpuProcessMessage, renderer_id, cause, message));
 }
 
 // static
 GpuProcessHost* GpuProcessHost::FromID(int host_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (host_id == 0)
     return NULL;
 
-  return g_hosts_by_id.Pointer()->Lookup(host_id);
+  GpuProcessHost *host = g_hosts_by_id.Pointer()->Lookup(host_id);
+  if (HostIsValid(host_id, host))
+    return host;
+
+  return NULL;
 }
 
 GpuProcessHost::GpuProcessHost(int host_id)
     : BrowserChildProcessHost(GPU_PROCESS),
       host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
-      in_process_(false) {
+      in_process_(false),
+      software_rendering_(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 266 matching lines @@
 
 void GpuProcessHost::OnProcessCrashed(int exit_code) {
   SendOutstandingReplies();
   if (++g_gpu_crash_count >= kGpuMaxCrashCount) {
     // The gpu process is too unstable to use. Disable it for current session.
     gpu_enabled_ = false;
   }
   BrowserChildProcessHost::OnProcessCrashed(exit_code);
 }
 
+bool GpuProcessHost::IsSoftwareRendering() {
+  return software_rendering_;
+}
+
 bool GpuProcessHost::LaunchGpuProcess() {
   if (!gpu_enabled_ || g_gpu_crash_count >= kGpuMaxCrashCount) {
     SendOutstandingReplies();
     gpu_enabled_ = false;
     return false;
   }
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
 
   CommandLine::StringType gpu_launcher =
@@ skipping 37 matching lines @@
                              arraysize(kSwitchNames));
 
   // If --ignore-gpu-blacklist is passed in, don't send in crash reports
   // because GPU is expected to be unreliable.
   if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) &&
       !cmd_line->HasSwitch(switches::kDisableBreakpad))
     cmd_line->AppendSwitch(switches::kDisableBreakpad);
 
   GpuDataManager::GetInstance()->AppendGpuCommandLine(cmd_line);
 
+  if (cmd_line->HasSwitch(switches::kUseGL))
+    software_rendering_ =

[Zhenyao Mo, 2011/11/05 00:39:19]

I feel like this logic should be in GpuDataManager, and we always check the
status from GpuDataManager instead of keep another cached status here.

See GpuDataManager::UserFlags().

[jbauman, 2011/11/05 00:49:34]

This is per-host, so we can check whether the gpu is blacklisted (and software
rendering should be turned on globally), but the gpu process is still using the
gpu and needs to be shut down.

[Zhenyao Mo, 2011/11/05 01:03:58]

understood.  then you also need to make the accessor function name match the
variable in this class.

+        (cmd_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader");
+
   // If specified, prepend a launcher program to the command line.
   if (!gpu_launcher.empty())
     cmd_line->PrependWrapper(gpu_launcher);
 
   Launch(
 #if defined(OS_WIN)
       FilePath(),
 #elif defined(OS_POSIX)
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
@@ skipping 25 matching lines @@
   scoped_ptr<EstablishChannelCallback> wrapped_callback(callback);
   wrapped_callback->Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     CreateCommandBufferCallback* callback, int32 route_id) {
   scoped_ptr<GpuProcessHost::CreateCommandBufferCallback>
     wrapped_callback(callback);
   callback->Run(route_id);
 }