Disabled GPU watchdog thread on Windows....

chrome/gpu/gpu_main.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 <stdlib.h>
 
 #include "app/app_switches.h"
 #include "app/gfx/gl/gl_context.h"
 #include "app/gfx/gl/gl_implementation.h"
 #include "base/environment.h"
 #include "base/message_loop.h"
-#include "base/metrics/field_trial.h"
 #include "base/stringprintf.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/main_function_params.h"
 #include "chrome/gpu/gpu_config.h"
 #include "chrome/gpu/gpu_process.h"
 #include "chrome/gpu/gpu_thread.h"
 #include "chrome/gpu/gpu_watchdog_thread.h"
 
 #if defined(USE_LINUX_BREAKPAD)
 #include "chrome/app/breakpad_linux.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "chrome/common/sandbox_mac.h"
 #endif
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #endif
 
 #if defined(USE_X11)
 #include "gfx/gtk_util.h"
 #endif
 
-// 1% per watchdog trial group.
-const int kFieldTrialSize = 1;
-
-// 5 - 20 seconds timeout.
-const int kMinGpuTimeout = 5;
-const int kMaxGpuTimeout = 20;
+const int kGpuTimeout = 10000;
 
 namespace {
 
 bool InitializeGpuSandbox() {
 #if defined(OS_MACOSX)
   CommandLine* parsed_command_line = CommandLine::ForCurrentProcess();
   SandboxInitWrapper sandbox_wrapper;
   return sandbox_wrapper.InitializeSandbox(*parsed_command_line,
                                            switches::kGpuProcess);
 #else
@@ skipping 61 matching lines @@
 
   // Do this soon before running the message loop so accurate
   // initialization time is recorded in the GPU info. Don't do it before
   // starting the watchdog thread since it can take a significant amount of
   // time to collect GPU information in GpuThread::Init.
   GpuProcess gpu_process;
   GpuThread* gpu_thread = new GpuThread;
   gpu_thread->Init(start_time);
   gpu_process.set_main_thread(gpu_thread);
 
-  // Only enable this experimental feaure for a subset of users.
-  scoped_refptr<base::FieldTrial> watchdog_trial(
-      new base::FieldTrial("GpuWatchdogTrial", 100));
-  int watchdog_timeout = 0;
-  for (int i = kMinGpuTimeout; i <= kMaxGpuTimeout; ++i) {
-    int group = watchdog_trial->AppendGroup(StringPrintf("%dsecs", i),
-                                            kFieldTrialSize);
-    if (group == watchdog_trial->group()) {
-      watchdog_timeout = i;
-      break;
-    }
-  }
 
   // In addition to disabling the watchdog if the command line switch is
   // present, disable it in two other cases. OSMesa is expected to run very
   // slowly.  Also disable the watchdog on valgrind because the code is expected
   // to run slowly in that case.
   bool enable_watchdog =
-      watchdog_timeout != 0 &&
       !command_line.HasSwitch(switches::kDisableGpuWatchdog) &&
       gfx::GetGLImplementation() != gfx::kGLImplementationOSMesaGL &&
       !RunningOnValgrind();
 
   // Disable the watchdog in debug builds because they tend to only be run by
   // developers who will not appreciate the watchdog killing the GPU process.
 #ifndef NDEBUG
   enable_watchdog = false;
 #endif
 
+  // Disable the watchdog for Windows. It tends to abort when the GPU process
+  // is not hung but still taking a long time to do something. Instead, the
+  // browser process displays a dialog when it notices that the child window
+  // is hung giving the user an opportunity to terminate it. This is the
+  // same mechanism used to abort hung plugins.
+#if defined(OS_WIN)
+  enable_watchdog = false;
+#endif
+
   // Start the GPU watchdog only after anything that is expected to be time
   // consuming has completed, otherwise the process is liable to be aborted.
   scoped_refptr<GpuWatchdogThread> watchdog_thread;
   if (enable_watchdog) {
-    watchdog_thread = new GpuWatchdogThread(watchdog_timeout * 1000);
+    watchdog_thread = new GpuWatchdogThread(kGpuTimeout);
     watchdog_thread->Start();
   }
 
   main_message_loop.Run();
 
   if (enable_watchdog)
     watchdog_thread->Stop();
 
   return 0;
 }