Add support for base::Closure in the MessageLoop.

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 "build/build_config.h"
 
 namespace {
 const int64 kCheckPeriod = 2000;
 
 void DoNothing() {
 }
 }
 
 GpuWatchdogThread::GpuWatchdogThread(int timeout)
     : base::Thread("Watchdog"),
       watched_message_loop_(MessageLoop::current()),
       timeout_(timeout),
       armed_(false),
 #if defined(OS_WIN)
       watched_thread_handle_(0),
       arm_cpu_time_(0),
 #endif
-      ALLOW_THIS_IN_INITIALIZER_LIST(task_observer_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(closure_observer_(this)) {
   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_,
                                 THREAD_QUERY_INFORMATION,
                                 FALSE,
                                 0);
   DCHECK(result);
 #endif
 
-  watched_message_loop_->AddTaskObserver(&task_observer_);
+  watched_message_loop_->AddClosureObserver(&closure_observer_);
 }
 
 GpuWatchdogThread::~GpuWatchdogThread() {
   // Verify that the thread was explicitly stopped. If the thread is stopped
   // implicitly by the destructor, CleanUp() will not be called.
   DCHECK(!method_factory_.get());
 
 #if defined(OS_WIN)
   CloseHandle(watched_thread_handle_);
 #endif
 
-  watched_message_loop_->RemoveTaskObserver(&task_observer_);
+  watched_message_loop_->RemoveClosureObserver(&closure_observer_);
 }
 
 void GpuWatchdogThread::PostAcknowledge() {
   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
   // the method factory. Rely on reference counting instead.
   message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(this, &GpuWatchdogThread::OnAcknowledge));
 }
 
 void GpuWatchdogThread::Init() {
   // The method factory must be created on the watchdog thread.
   method_factory_.reset(new MethodFactory(this));
 
   // Schedule the first check.
   OnCheck();
 }
 
 void GpuWatchdogThread::CleanUp() {
   // The method factory must be destroyed on the watchdog thread.
   method_factory_->RevokeAll();
   method_factory_.reset();
 }
 
-GpuWatchdogThread::GpuWatchdogTaskObserver::GpuWatchdogTaskObserver(
+GpuWatchdogThread::GpuWatchdogClosureObserver::GpuWatchdogClosureObserver(
     GpuWatchdogThread* watchdog)
-  : watchdog_(watchdog) {
+    : watchdog_(watchdog) {
 }
 
-GpuWatchdogThread::GpuWatchdogTaskObserver::~GpuWatchdogTaskObserver() {
+GpuWatchdogThread::GpuWatchdogClosureObserver::~GpuWatchdogClosureObserver() {
 }
 
-void GpuWatchdogThread::GpuWatchdogTaskObserver::WillProcessTask(
-    const Task* task)
-{
+void GpuWatchdogThread::GpuWatchdogClosureObserver::WillProcessClosure(
+    base::TimeTicks time_posted) {
   CheckArmed();
 }
 
-void GpuWatchdogThread::GpuWatchdogTaskObserver::DidProcessTask(
-    const Task* task)
-{
+void GpuWatchdogThread::GpuWatchdogClosureObserver::DidProcessClosure(
+    base::TimeTicks time_posted) {
   CheckArmed();
 }
 
-void GpuWatchdogThread::GpuWatchdogTaskObserver::CheckArmed()
-{
+void GpuWatchdogThread::GpuWatchdogClosureObserver::CheckArmed() {
   // Acknowledge the watchdog if it has armed itself. The watchdog will not
   // change its armed state until it is acknowledged.
   if (watchdog_->armed()) {
     watchdog_->PostAcknowledge();
   }
 }
 
 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
@@ skipping 44 matching lines @@
   return static_cast<int64>(
       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000);
 }
 #endif
 
 void GpuWatchdogThread::OnCheck() {
   if (armed_)
     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.
+  // that will activate the ClosureObserver on the watched thread and it must
+  // not miss the false -> true transition.
   armed_ = true;
 
 #if defined(OS_WIN)
   arm_cpu_time_ = GetWatchedThreadTime();
 #endif
 
   arm_absolute_time_ = base::Time::Now();
 
   // Post a task to the monitored thread that does nothing but wake up the
-  // 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.
+  // ClosureObserver. 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::DeliberatelyCrashingToRecoverFromHang),
@@ skipping 41 matching lines @@
 #endif
 
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_ << " ms.";
 
   volatile int* null_pointer = NULL;
   *null_pointer = timeout;
 
   crashed = true;
 }