Added a master switch to enable/disable gpu acceleration.

chrome/browser/gpu_process_host.cc

 // Copyright (c) 2010 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 "chrome/browser/gpu_process_host.h"
 
 #include "app/app_switches.h"
 #include "base/command_line.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/gpu_process_host_ui_shim.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/renderer_host/resource_message_filter.h"
+#include "chrome/browser/tab_contents/render_view_host_delegate_helper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_info.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/render_messages.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "media/base/media_switches.h"
 
 #if defined(OS_LINUX)
 #include "app/x11_util.h"
@@ skipping 15 matching lines @@
   IPC::Message msg_;
 };
 
 // Global GpuProcessHost instance.
 // We can not use Singleton<GpuProcessHost> because that gets
 // terminated on the wrong thread (main thread). We need the
 // GpuProcessHost to be terminated on the same thread on which it is
 // initialized, the IO thread.
 static GpuProcessHost* sole_instance_ = NULL;
 
+// Number of times the gpu process has crashed in the current browser session.
+static int g_gpu_crash_count = 0;
+// Maximaum number of times the gpu process is allowed to crash in a session.

[apatrick_chromium, 2010/11/29 20:59:31]

typo: Maximum

+// Once this limit is reached, any request to launch the gpu process will fail.
+static const int kGpuMaxCrashCount = 3;
+
 void RouteOnUIThread(const IPC::Message& message) {
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           new RouteOnUIThreadTask(message));
 }
 }  // anonymous namespace
 
 GpuProcessHost::GpuProcessHost()
     : BrowserChildProcessHost(GPU_PROCESS, NULL),
       initialized_(false),
@@ skipping 276 matching lines @@
     uint32 request_id,
     const ViewHostMsg_Resource_Request& request_data) {
   return NULL;
 }
 
 bool GpuProcessHost::CanShutdown() {
   return true;
 }
 
 void GpuProcessHost::OnProcessCrashed() {
-  // TODO(alokp): Update gpu process crash rate.
+  if (++g_gpu_crash_count >= kGpuMaxCrashCount) {
+    // The gpu process is too unstable to use. Disable it for current session.
+    RenderViewHostDelegateHelper::set_gpu_enabled(false);
+  }
   BrowserChildProcessHost::OnProcessCrashed();
 }
 
 bool GpuProcessHost::CanLaunchGpuProcess() const {
-  // TODO(alokp): Answer based on crash rate.
-  return true;
+  return RenderViewHostDelegateHelper::gpu_enabled();
 }
 
 bool GpuProcessHost::LaunchGpuProcess() {

[apatrick, 2010/11/29 17:45:38]

Does making this function return false when g_gpu_crash_count not work? It might
be that the renderer processes are not yet sufficiently robust that case but
long term that us the the plan and it would simplify this code.

[alokp, 2010/11/29 18:34:38]

yes it works and I do that too via CanLaunchGpuProcess(). Two things going on
here:
1. I am disabling gpu acceleration for all new renderer processes through a
gpu_enabled flag in RenderViewHostDelegateHelper. The command-line passed to the
new renderer process instructs it to NOT use gpu-acceleration.
2. The exisiting tabs that have crashed will try to re-launch the gpu process.
CanLaunchGpuProcess() prevents those tabs from launch the gpu-process if it is
too crashy. Now the code to relaunch the gpu process is not ready, so I am not
sure if there is a better way.

   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   CommandLine::StringType gpu_launcher =
       browser_command_line.GetSwitchValueNative(switches::kGpuLauncher);
 
   FilePath exe_path = ChildProcessHost::GetChildPath(gpu_launcher.empty());
   if (exe_path.empty())
     return false;
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType, switches::kGpuProcess);
@@ skipping 22 matching lines @@
       FilePath(),
 #elif defined(OS_POSIX)
       false,  // Never use the zygote (GPU plugin can't be sandboxed).
       base::environment_vector(),
 #endif
       cmd_line);
 
   return true;
 }