Added suspend/resume detection to the GpuWatchdogThread

content/gpu/gpu_watchdog_thread.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/power_monitor/power_monitor.h"
 #include "base/process/process.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
 namespace content {
 namespace {
 const int64 kCheckPeriodMs = 2000;
 }  // namespace
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
       watched_message_loop_(base::MessageLoop::current()),
       timeout_(base::TimeDelta::FromMilliseconds(timeout)),
       armed_(false),
 #if defined(OS_WIN)
       watched_thread_handle_(0),
       arm_cpu_time_(),
 #endif
       task_observer_(this),
-      weak_factory_(this) {
+      weak_factory_(this),
+      suspended_(false) {
   DCHECK(timeout >= 0);
 
 #if defined(OS_WIN)
   // GetCurrentThread returns a pseudo-handle that cannot be used by one thread
   // to identify another. DuplicateHandle creates a "real" handle that can be
   // used for this purpose.
   BOOL result = DuplicateHandle(GetCurrentProcess(),
                                 GetCurrentThread(),
                                 GetCurrentProcess(),
                                 &watched_thread_handle_,
@@ skipping 51 matching lines @@
 
 GpuWatchdogThread::~GpuWatchdogThread() {
   // Verify that the thread was explicitly stopped. If the thread is stopped
   // implicitly by the destructor, CleanUp() will not be called.
   DCHECK(!weak_factory_.HasWeakPtrs());
 
 #if defined(OS_WIN)
   CloseHandle(watched_thread_handle_);
 #endif
 
+  base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
+  if (power_monitor)
+    power_monitor->RemoveObserver(this);
+
   watched_message_loop_->RemoveTaskObserver(&task_observer_);
 }
 
 void GpuWatchdogThread::OnAcknowledge() {
+  CHECK(base::PlatformThread::CurrentId() == thread_id());
+
   // 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 hang termination.
   weak_factory_.InvalidateWeakPtrs();
   armed_ = false;
 
+  if (suspended_)
+    return;
+
   // If it took a long time for the acknowledgement, assume the computer was
   // recently suspended.
   bool was_suspended = (base::Time::Now() > suspension_timeout_);
 
   // The monitored thread has responded. Post a task to check it again.
   message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GpuWatchdogThread::OnCheck, weak_factory_.GetWeakPtr(),
           was_suspended),
       base::TimeDelta::FromMilliseconds(kCheckPeriodMs));
 }
 
 void GpuWatchdogThread::OnCheck(bool after_suspend) {
-  if (armed_)
+  CHECK(base::PlatformThread::CurrentId() == thread_id());
+
+  // Do not create any new termination tasks if one has already been created
+  // or the system is suspended.
+  if (armed_ || suspended_)
     return;
 
   // Must set armed before posting the task. This task might be the only task
   // that will activate the TaskObserver on the watched thread and it must not
   // miss the false -> true transition.
   armed_ = true;
 
 #if defined(OS_WIN)
   arm_cpu_time_ = GetWatchedThreadTime();
 #endif
@@ skipping 15 matching lines @@
   message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
           weak_factory_.GetWeakPtr()),
       timeout);
 }
 
 // Use the --disable-gpu-watchdog command line switch to disable this.
 void GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang() {
+  // Should not get here while the system is suspended.
+  DCHECK(!suspended_);
+
 #if defined(OS_WIN)
   // Defer termination until a certain amount of CPU time has elapsed on the
   // watched thread.
   base::TimeDelta time_since_arm = GetWatchedThreadTime() - arm_cpu_time_;
   if (time_since_arm < timeout_) {
     message_loop()->PostDelayedTask(
         FROM_HERE,
         base::Bind(
             &GpuWatchdogThread::DeliberatelyTerminateToRecoverFromHang,
             weak_factory_.GetWeakPtr()),
@@ skipping 26 matching lines @@
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_.InMilliseconds() << " ms.";
 
   // Deliberately crash the process to create a crash dump.
   *((volatile int*)0) = 0x1337;
 
   terminated = true;
 }
 
+void GpuWatchdogThread::AddPowerObserver() {
+  message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuWatchdogThread::OnAddPowerObserver, this));
+}
+
+void GpuWatchdogThread::OnAddPowerObserver() {
+  base::PowerMonitor* power_monitor = base::PowerMonitor::Get();
+  DCHECK(power_monitor);
+  power_monitor->AddObserver(this);
+}
+
+void GpuWatchdogThread::OnSuspend() {
+  suspended_ = true;
+
+  // When suspending force an acknowledgement to cancel any pending termination
+  // tasks.
+  OnAcknowledge();
+}
+
+void GpuWatchdogThread::OnResume() {
+  suspended_ = false;
+
+  // After resuming jump-start the watchdog again.
+  armed_ = false;
+  OnCheck(true);
+}
+
 #if defined(OS_WIN)
 base::TimeDelta GpuWatchdogThread::GetWatchedThreadTime() {
   FILETIME creation_time;
   FILETIME exit_time;
   FILETIME user_time;
   FILETIME kernel_time;
   BOOL result = GetThreadTimes(watched_thread_handle_,
                                &creation_time,
                                &exit_time,
                                &kernel_time,
@@ skipping 14 matching lines @@
   // not increasing. The other is where either the kernel hangs and never
   // returns to user level or where user level code
   // calls into kernel level repeatedly, giving up its quanta before it is
   // tracked, for example a loop that repeatedly Sleeps.
   return base::TimeDelta::FromMilliseconds(static_cast<int64>(
       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
 }
 #endif
 
 }  // namespace content