chrome: Use base::MessageLoop. (Part 3)

chrome/browser/metrics/thread_watcher.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.
 
 #include "chrome/browser/metrics/thread_watcher.h"
 
 #include <math.h>  // ceil
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 166 matching lines @@
     return;
   watcher->ActivateThreadWatching();
 }
 
 void ThreadWatcher::ActivateThreadWatching() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   if (active_) return;
   active_ = true;
   ping_count_ = unresponsive_threshold_;
   ResetHangCounters();
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::PostPingMessage,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ThreadWatcher::DeActivateThreadWatching() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   active_ = false;
   ping_count_ = 0;
   weak_ptr_factory_.InvalidateWeakPtrs();
@@ skipping 35 matching lines @@
   // Send a ping message to the watched thread. Callback will be called on
   // the WatchDogThread.
   base::Closure callback(
       base::Bind(&ThreadWatcher::OnPongMessage, weak_ptr_factory_.GetWeakPtr(),
                  ping_sequence_number_));
   if (watched_loop_->PostTask(
           FROM_HERE,
           base::Bind(&ThreadWatcher::OnPingMessage, thread_id_,
                      callback))) {
       // Post a task to check the responsiveness of watched thread.
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&ThreadWatcher::OnCheckResponsiveness,
-                     weak_ptr_factory_.GetWeakPtr(), ping_sequence_number_),
-          unresponsive_time_);
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&ThreadWatcher::OnCheckResponsiveness,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   ping_sequence_number_),
+        unresponsive_time_);
   } else {
     // Watched thread might have gone away, stop watching it.
     DeActivateThreadWatching();
   }
 }
 
 void ThreadWatcher::OnPongMessage(uint64 ping_sequence_number) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
   // Record watched thread's response time.
@@ skipping 11 matching lines @@
 
   // Increment sequence number for the next ping message to indicate watched
   // thread is responsive.
   ++ping_sequence_number_;
 
   // If we have stopped watching or if the user is idle, then stop sending
   // ping messages.
   if (!active_ || --ping_count_ <= 0)
     return;
 
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::PostPingMessage,
                  weak_ptr_factory_.GetWeakPtr()),
       sleep_time_);
 }
 
 void ThreadWatcher::OnCheckResponsiveness(uint64 ping_sequence_number) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   // If we have stopped watching then consider thread as responding.
   if (!active_) {
     responsive_ = true;
     return;
   }
   // If the latest ping_sequence_number_ is not same as the ping_sequence_number
   // that is passed in, then we can assume OnPongMessage was called.
   // OnPongMessage increments ping_sequence_number_.
   if (ping_sequence_number_ != ping_sequence_number) {
     // Reset unresponsive_count_ to zero because we got a response from the
     // watched thread.
     ResetHangCounters();
 
     responsive_ = true;
     return;
   }
   // Record that we got no response from watched thread.
   GotNoResponse();
 
   // Post a task to check the responsiveness of watched thread.
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::OnCheckResponsiveness,
-                 weak_ptr_factory_.GetWeakPtr(), ping_sequence_number_),
+                 weak_ptr_factory_.GetWeakPtr(),
+                 ping_sequence_number_),
       unresponsive_time_);
   responsive_ = false;
 }
 
 void ThreadWatcher::Initialize() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   ThreadWatcherList::Register(this);
 
   const std::string response_time_histogram_name =
       "ThreadWatcher.ResponseTime." + thread_name_;
@@ skipping 458 matching lines @@
 }
 
 WatchDogThread::~WatchDogThread() {
   Stop();
 }
 
 // static
 bool WatchDogThread::CurrentlyOnWatchDogThread() {
   base::AutoLock lock(g_watchdog_lock.Get());
   return g_watchdog_thread &&
-    g_watchdog_thread->message_loop() == MessageLoop::current();
+         g_watchdog_thread->message_loop() == base::MessageLoop::current();
 }
 
 // static
 bool WatchDogThread::PostTask(const tracked_objects::Location& from_here,
                               const base::Closure& task) {
   return PostTaskHelper(from_here, task, base::TimeDelta());
 }
 
 // static
 bool WatchDogThread::PostDelayedTask(const tracked_objects::Location& from_here,
                                      const base::Closure& task,
                                      base::TimeDelta delay) {
   return PostTaskHelper(from_here, task, delay);
 }
 
 // static
 bool WatchDogThread::PostTaskHelper(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
   {
     base::AutoLock lock(g_watchdog_lock.Get());
 
-    MessageLoop* message_loop = g_watchdog_thread ?
-        g_watchdog_thread->message_loop() : NULL;
+    base::MessageLoop* message_loop =
+        g_watchdog_thread ? g_watchdog_thread->message_loop() : NULL;
     if (message_loop) {
       message_loop->PostDelayedTask(from_here, task, delay);
       return true;
     }
   }
 
   return false;
 }
 
 void WatchDogThread::Init() {
@@ skipping 100 matching lines @@
 void StartupTimeBomb::DeleteStartupWatchdog() {
   DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
   if (startup_watchdog_->IsJoinable()) {
     // Allow the watchdog thread to shutdown on UI. Watchdog thread shutdowns
     // very fast.
     base::ThreadRestrictions::SetIOAllowed(true);
     delete startup_watchdog_;
     startup_watchdog_ = NULL;
     return;
   }
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&StartupTimeBomb::DeleteStartupWatchdog,
                  base::Unretained(this)),
       base::TimeDelta::FromSeconds(10));
 }
 
 // static
 void StartupTimeBomb::DisarmStartupTimeBomb() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (g_startup_timebomb_)
@@ skipping 33 matching lines @@
 
 #if defined(OS_WIN)
   // On Windows XP, give twice the time for shutdown.
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     actual_duration *= 2;
 #endif
 
   shutdown_watchdog_ = new ShutdownWatchDogThread(actual_duration);
   shutdown_watchdog_->Arm();
 }