components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/timers/alarm_timer_chromeos.cc

 // Copyright 2014 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 "components/timers/alarm_timer_chromeos.h"
 
 #include <sys/timerfd.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/pending_task.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 
 namespace timers {
 namespace {
 // This class represents the IO thread that the AlarmTimer::Delegate may use for
 // watching file descriptors if it gets called from a thread that does not have
 // a MessageLoopForIO.  It is a lazy global instance because it may not always
 // be necessary.
 class RtcAlarmIOThread : public base::Thread {
  public:
@@ skipping 73 matching lines @@
 
   // Resets the timer to fire after |delay| has passed.  Cancels any
   // pre-existing delay.
   void Reset(base::TimeDelta delay);
 
   // Stops the currently running timer.  It should be safe to call this even if
   // the timer is not running.
   void Stop();
 
   // Sets a hook that will be called when the timer fires and a task has been
-  // queued on |origin_message_loop_|.  Used by tests to wait until a task is
+  // queued on |origin_task_runner_|.  Used by tests to wait until a task is
   // pending in the MessageLoop.
   void SetTimerFiredCallbackForTest(base::Closure test_callback);
 
   // base::MessageLoopForIO::Watcher overrides.
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
  private:
   friend class base::RefCountedThreadSafe<Delegate>;
   ~Delegate() override;
 
   // Actually performs the system calls to set up the timer.  This must be
   // called on a MessageLoopForIO.
   void ResetImpl(base::TimeDelta delay, int reset_sequence_number);
 
   // Callback that is run when the timer fires.  Must be run on
-  // |origin_message_loop_|.
+  // |origin_task_runner_|.
   void OnTimerFired(int reset_sequence_number);
 
   // File descriptor associated with the alarm timer.
   int alarm_fd_;
 
-  // Message loop which initially started the timer.
-  scoped_refptr<base::MessageLoopProxy> origin_message_loop_;
+  // Task runner which initially started the timer.
+  scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
 
   // Callback that should be run when the timer fires.
   base::Closure on_timer_fired_callback_;
 
   // Hook used by tests to be notified when the timer has fired and a task has
   // been queued in the MessageLoop.
   base::Closure on_timer_fired_callback_for_test_;
 
   // Manages watching file descriptors.
   scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> fd_watcher_;
 
   // The sequence numbers of the last Reset() call handled respectively on
-  // |origin_message_loop_| and on the MessageLoopForIO used for watching the
+  // |origin_task_runner_| and on the MessageLoopForIO used for watching the
   // timer file descriptor.  Note that these can be the same MessageLoop.
   // OnTimerFired() runs |on_timer_fired_callback_| only if the sequence number
   // it receives from the MessageLoopForIO matches
   // |origin_reset_sequence_number_|.
   int origin_reset_sequence_number_;
   int io_reset_sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
@@ skipping 11 matching lines @@
 AlarmTimer::Delegate::~Delegate() {
   if (alarm_fd_ != -1)
     close(alarm_fd_);
 }
 
 bool AlarmTimer::Delegate::CanWakeFromSuspend() {
   return alarm_fd_ != -1;
 }
 
 void AlarmTimer::Delegate::Reset(base::TimeDelta delay) {
-  // Get a proxy for the current message loop.  When the timer fires, we will
+  // Get a task runner for the current message loop.  When the timer fires, we
+  // will
   // post tasks to this proxy to let the parent timer know.
-  origin_message_loop_ = base::MessageLoopProxy::current();
+  origin_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   // Increment the sequence number.  Used to invalidate any events that have
   // been queued but not yet run since the last time Reset() was called.
   origin_reset_sequence_number_++;
 
   // Calling timerfd_settime with a zero delay actually clears the timer so if
   // the user has requested a zero delay timer, we need to handle it
   // differently.  We queue the task here but we still go ahead and call
   // timerfd_settime with the zero delay anyway to cancel any previous delay
   // that might have been programmed.
   if (delay <= base::TimeDelta::FromMicroseconds(0)) {
     // The timerfd_settime documentation is vague on what happens when it is
     // passed a negative delay.  We can sidestep the issue by ensuring that
     // the delay is 0.
     delay = base::TimeDelta::FromMicroseconds(0);
-    origin_message_loop_->PostTask(
+    origin_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this),
                    origin_reset_sequence_number_));
   }
 
   // Run ResetImpl() on a MessageLoopForIO.
   if (base::MessageLoopForIO::IsCurrent()) {
     ResetImpl(delay, origin_reset_sequence_number_);
   } else {
     g_io_thread.Pointer()->task_runner()->PostTask(
@@ skipping 23 matching lines @@
 
 void AlarmTimer::Delegate::OnFileCanReadWithoutBlocking(int fd) {
   DCHECK_EQ(alarm_fd_, fd);
 
   // Read from the fd to ack the event.
   char val[sizeof(uint64_t)];
   if (!base::ReadFromFD(alarm_fd_, val, sizeof(uint64_t)))
     PLOG(DFATAL) << "Unable to read from timer file descriptor.";
 
   // Make sure that the parent timer is informed on the proper message loop.
-  if (origin_message_loop_->RunsTasksOnCurrentThread()) {
+  if (origin_task_runner_->RunsTasksOnCurrentThread()) {
     OnTimerFired(io_reset_sequence_number_);
   } else {
-    origin_message_loop_->PostTask(
+    origin_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this),
                    io_reset_sequence_number_));
   }
 }
 
 void AlarmTimer::Delegate::OnFileCanWriteWithoutBlocking(int fd) {
   NOTREACHED();
 }
 
@@ skipping 28 matching lines @@
   itimerspec alarm_time = {};
   alarm_time.it_value.tv_sec = delay.InSeconds();
   alarm_time.it_value.tv_nsec =
       (delay.InMicroseconds() % base::Time::kMicrosecondsPerSecond) *
       base::Time::kNanosecondsPerMicrosecond;
   if (timerfd_settime(alarm_fd_, 0, &alarm_time, NULL) < 0)
     PLOG(ERROR) << "Error while setting alarm time.  Timer will not fire";
 }
 
 void AlarmTimer::Delegate::OnTimerFired(int reset_sequence_number) {
-  DCHECK(origin_message_loop_->RunsTasksOnCurrentThread());
+  DCHECK(origin_task_runner_->RunsTasksOnCurrentThread());
 
   // If a test wants to be notified when this function is about to run, then
   // re-queue this task in the MessageLoop and run the test's callback.
   if (!on_timer_fired_callback_for_test_.is_null()) {
-    origin_message_loop_->PostTask(
+    origin_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Delegate::OnTimerFired, scoped_refptr<Delegate>(this),
                    reset_sequence_number));
 
     on_timer_fired_callback_for_test_.Run();
     on_timer_fired_callback_for_test_.Reset();
     return;
   }
 
   // Check to make sure that the timer was not reset in the time between when
@@ skipping 147 matching lines @@
 SimpleAlarmTimer::SimpleAlarmTimer(const tracked_objects::Location& posted_from,
                                    base::TimeDelta delay,
                                    const base::Closure& user_task)
     : AlarmTimer(posted_from, delay, user_task, false) {
 }
 
 SimpleAlarmTimer::~SimpleAlarmTimer() {
 }
 
 }  // namespace timers