Revert "content: Remove use of MessageLoopProxy and deprecated MessageLoop APIs"

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/files/file_util.h"
-#include "base/location.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/process/process.h"
-#include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
 namespace content {
 namespace {
 #if defined(OS_CHROMEOS)
 const base::FilePath::CharType
     kTtyFilePath[] = FILE_PATH_LITERAL("/sys/class/tty/tty0/active");
 #endif
@@ skipping 40 matching lines @@
 #endif
 #if defined(USE_X11)
   SetupXServer();
 #endif
   watched_message_loop_->AddTaskObserver(&task_observer_);
 }
 
 void GpuWatchdogThread::PostAcknowledge() {
   // Called on the monitored thread. Responds with OnAcknowledge. Cannot use
   // the method factory. Rely on reference counting instead.
-  task_runner()->PostTask(FROM_HERE,
-                          base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
+  message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&GpuWatchdogThread::OnAcknowledge, this));
 }
 
 void GpuWatchdogThread::CheckArmed() {
   // Acknowledge the watchdog if it has armed itself. The watchdog will not
   // change its armed state until it is acknowledged.
   if (armed()) {
     PostAcknowledge();
   }
 }
 
@@ skipping 64 matching lines @@
   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.
-  task_runner()->PostDelayedTask(
-      FROM_HERE, base::Bind(&GpuWatchdogThread::OnCheck,
-                            weak_factory_.GetWeakPtr(), was_suspended),
+  message_loop()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&GpuWatchdogThread::OnCheck, weak_factory_.GetWeakPtr(),
+          was_suspended),
       0.5 * timeout_);
 }
 
 void GpuWatchdogThread::OnCheck(bool after_suspend) {
   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
 
   // Immediately after the computer is woken up from being suspended it might
   // be pretty sluggish, so allow some extra time before the next timeout.
   base::TimeDelta timeout = timeout_ * (after_suspend ? 3 : 1);
   suspension_timeout_ = base::Time::Now() + timeout * 2;
 
   // 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.
-  watched_message_loop_->task_runner()->PostTask(FROM_HERE,
-                                                 base::Bind(&base::DoNothing));
+  watched_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&base::DoNothing));
 
   // Post a task to the watchdog thread to exit if the monitored thread does
   // not respond in time.
-  task_runner()->PostDelayedTask(
+  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_);
@@ skipping 120 matching lines @@
 bool GpuWatchdogThread::MatchXEventAtom(XEvent* event) {
   if (event->xproperty.window == window_ && event->type == PropertyNotify &&
       event->xproperty.atom == atom_)
     return true;
 
   return false;
 }
 
 #endif
 void GpuWatchdogThread::AddPowerObserver() {
-  task_runner()->PostTask(
-      FROM_HERE, base::Bind(&GpuWatchdogThread::OnAddPowerObserver, this));
+  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;
@@ skipping 38 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