Renamed GpuWatchdogThread::OnExit to make it clear it is crashing deliberatel...

chrome/gpu/gpu_watchdog_thread.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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "chrome/gpu/gpu_watchdog_thread.h"
 
@@ skipping 100 matching lines @@
 }
 
 void GpuWatchdogThread::OnAcknowledge() {
   // The check has already been acknowledged and another has already been
   // scheduled by a previous call to OnAcknowledge. It is normal for a
   // watched thread to see armed_ being true multiple times before
   // the OnAcknowledge task is run on the watchdog thread.
   if (!armed_)
     return;
 
-  // Revoke any pending OnExit.
+  // Revoke any pending hang termination.
   method_factory_->RevokeAll();
   armed_ = false;
 
   // The monitored thread has responded. Post a task to check it again.
   message_loop()->PostDelayedTask(
       FROM_HERE,
       method_factory_->NewRunnableMethod(&GpuWatchdogThread::OnCheck),
       kCheckPeriod);
 }
 
@@ skipping 49 matching lines @@
   // TaskObserver. Any other tasks that are pending on the watched thread will
   // 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::OnExit),
+      method_factory_->NewRunnableMethod(
+          &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
       timeout_);
 }
 
 // Use the --disable-gpu-watchdog command line switch to disable this.
-void GpuWatchdogThread::OnExit() {
+void GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang() {
 #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::OnExit),
+        method_factory_->NewRunnableMethod(
+            &GpuWatchdogThread::DeliberatelyCrashingToRecoverFromHang),
         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() >
@@ skipping 17 matching lines @@
 #endif
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_ << " ms.";
 
   volatile int* null_pointer = NULL;
   *null_pointer = timeout;
 
   crashed = true;
 }