GPU process terminates rather than crashing on hang.

content/gpu/gpu_watchdog_thread.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/gpu/gpu_watchdog_thread.h"
 
 #include "base/compiler_specific.h"
+#include "base/process.h"
+#include "base/process_util.h"
 #include "build/build_config.h"
+#include "content/common/result_codes.h"
 
 namespace {
 const int64 kCheckPeriod = 2000;
 
 void DoNothing() {
 }
 }
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
@@ skipping 156 matching lines @@
   // also wake up the observer. This simply ensures there is at least one.
   watched_message_loop_->PostTask(
       FROM_HERE,
       NewRunnableFunction(DoNothing));
 
   // Post a task to the watchdog thread to exit if the monitored thread does
   // not respond in time.
   message_loop()->PostDelayedTask(
       FROM_HERE,
       method_factory_->NewRunnableMethod(
-          &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
+          &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang),
       timeout_);
 }
 
 // Use the --disable-gpu-watchdog command line switch to disable this.
-void GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang() {
+void GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang() {
 #if defined(OS_WIN)
   // Defer termination until a certain amount of CPU time has elapsed on the
   // watched thread.
   int64 time_since_arm = GetWatchedThreadTime() - arm_cpu_time_;
   if (time_since_arm < timeout_) {
     message_loop()->PostDelayedTask(
         FROM_HERE,
         method_factory_->NewRunnableMethod(
-            &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
+            &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang),
         timeout_ - time_since_arm);
     return;
   }
 #endif
 
   // If the watchdog woke up significantly behind schedule, disarm and reset
   // the watchdog check. This is to prevent the watchdog thread from terminating
   // when a machine wakes up from sleep or hibernation, which would otherwise
   // appear to be a hang.
   if ((base::Time::Now() - arm_absolute_time_).InMilliseconds() >
       timeout_ * 2) {
     armed_ = false;
     OnCheck();
     return;
   }
 
-  // Make sure the timeout period is on the stack before crashing.
-  volatile int timeout = timeout_;
-
-  // For minimal developer annoyance, don't keep crashing.
-  static bool crashed = false;
-  if (crashed)
+  // For minimal developer annoyance, don't keep terminating. You need to skip
+  // the call to base::Process::Terminate below in a debugger for this to be
+  // useful.
+  static bool terminated = false;
+  if (terminated)
     return;
 
 #if defined(OS_WIN)
   if (IsDebuggerPresent())
     return;
 #endif
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_ << " ms.";
 
-  volatile int* null_pointer = NULL;
-  *null_pointer = timeout;
+  base::Process current_process(base::GetCurrentProcessHandle());
+  current_process.Terminate(content::RESULT_CODE_HUNG);
 
-  crashed = true;
+  terminated = true;
 }