chrome/browser: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

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"
 #include "base/debug/dump_without_crashing.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/metrics/thread_watcher_report_hang.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "content/public/browser/notification_service.h"
 
 #if defined(OS_WIN)
@@ skipping 56 matching lines @@
     return;
   watcher->ActivateThreadWatching();
 }
 
 void ThreadWatcher::ActivateThreadWatching() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   if (active_) return;
   active_ = true;
   ping_count_ = unresponsive_threshold_;
   ResetHangCounters();
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&ThreadWatcher::PostPingMessage,
-                 weak_ptr_factory_.GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->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();
 }
 
 void ThreadWatcher::WakeUp() {
@@ skipping 68 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;
 
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ThreadWatcher::PostPingMessage,
-                 weak_ptr_factory_.GetWeakPtr()),
+  base::ThreadTaskRunnerHandle::Get()->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.
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::OnCheckResponsiveness,
                  weak_ptr_factory_.GetWeakPtr(), ping_sequence_number_),
       unresponsive_time_);
   responsive_ = false;
 }
 
 void ThreadWatcher::Initialize() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   ThreadWatcherList::Register(this);
@@ skipping 531 matching lines @@
 bool WatchDogThread::PostTaskHelper(
     const tracked_objects::Location& from_here,
     const base::Closure& task,
     base::TimeDelta delay) {
   {
     base::AutoLock lock(g_watchdog_lock.Get());
 
     base::MessageLoop* message_loop = g_watchdog_thread ?
         g_watchdog_thread->message_loop() : NULL;
     if (message_loop) {
-      message_loop->PostDelayedTask(from_here, task, delay);
+      message_loop->task_runner()->PostDelayedTask(from_here, task, delay);
       return true;
     }
   }
 
   return false;
 }
 
 void WatchDogThread::Init() {
   // This thread shouldn't be allowed to perform any blocking disk I/O.
   base::ThreadRestrictions::SetIOAllowed(false);
@@ 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;
   }
-  base::MessageLoop::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&StartupTimeBomb::DeleteStartupWatchdog,
-                 base::Unretained(this)),
+  base::ThreadTaskRunnerHandle::Get()->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_)
     g_startup_timebomb_->Disarm();
 }
 
@@ skipping 30 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();
 }