Reduce usage of MessageLoopProxy in base/

base/files/file_path_watcher_fsevents.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 "base/files/file_path_watcher_fsevents.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/mac/libdispatch_task_runner.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/message_loop/message_loop.h"
+#include "base/sequenced_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 
 namespace base {
 
 namespace {
 
 // The latency parameter passed to FSEventsStreamCreate().
 const CFAbsoluteTime kEventLatencySeconds = 0.3;
 
 class FSEventsTaskRunner : public mac::LibDispatchTaskRunner {
  public:
@@ skipping 85 matching lines @@
   watcher->OnFilePathsChanged(paths);
 }
 
 }  // namespace
 
 FilePathWatcherFSEvents::FilePathWatcherFSEvents() : fsevent_stream_(NULL) {
 }
 
 void FilePathWatcherFSEvents::OnFilePathsChanged(
     const std::vector<FilePath>& paths) {
-  if (!message_loop()->BelongsToCurrentThread()) {
-    message_loop()->PostTask(
+  if (!task_runner()->RunsTasksOnCurrentThread()) {
+    task_runner()->PostTask(
         FROM_HERE,
         Bind(&FilePathWatcherFSEvents::OnFilePathsChanged, this, paths));
     return;
   }
 
-  DCHECK(message_loop()->BelongsToCurrentThread());
+  DCHECK(task_runner()->RunsTasksOnCurrentThread());
   if (resolved_target_.empty())
     return;
 
   for (size_t i = 0; i < paths.size(); i++) {
     if (resolved_target_.IsParent(paths[i]) || resolved_target_ == paths[i]) {
       callback_.Run(target_, false);
       return;
     }
   }
 }
 
 bool FilePathWatcherFSEvents::Watch(const FilePath& path,
                                     bool recursive,
                                     const FilePathWatcher::Callback& callback) {
   DCHECK(resolved_target_.empty());
   DCHECK(MessageLoopForIO::current());
   DCHECK(!callback.is_null());
 
   // This class could support non-recursive watches, but that is currently
   // left to FilePathWatcherKQueue.
   if (!recursive)
     return false;
 
-  set_message_loop(MessageLoopProxy::current());
+  set_task_runner(ThreadTaskRunnerHandle::Get());
   callback_ = callback;
   target_ = path;
 
   FSEventStreamEventId start_event = FSEventsGetCurrentEventId();
   g_task_runner.Get().PostTask(
       FROM_HERE,
       Bind(&FilePathWatcherFSEvents::StartEventStream, this, start_event));
   return true;
 }
 
@@ skipping 10 matching lines @@
     g_task_runner.Get().PostTask(
         FROM_HERE,
         Bind(&FilePathWatcherFSEvents::CancelOnMessageLoopThread, this));
   } else {
     CancelOnMessageLoopThread();
   }
 }
 
 void FilePathWatcherFSEvents::CancelOnMessageLoopThread() {
   // For all other implementations, the "message loop thread" is the IO thread,
-  // as returned by message_loop(). This implementation, however, needs to
+  // as returned by task_runner(). This implementation, however, needs to
   // cancel pending work on the Dipatch Queue thread.
   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
 
   set_cancelled();
   if (fsevent_stream_) {
     DestroyEventStream();
     callback_.Reset();
     target_.clear();
     resolved_target_.clear();
   }
@@ skipping 30 matching lines @@
 
   fsevent_stream_ = FSEventStreamCreate(NULL, &FSEventsCallback, &context,
                                         watched_paths,
                                         start_event,
                                         kEventLatencySeconds,
                                         kFSEventStreamCreateFlagWatchRoot);
   FSEventStreamSetDispatchQueue(fsevent_stream_,
                                 g_task_runner.Get().GetDispatchQueue());
 
   if (!FSEventStreamStart(fsevent_stream_))
-    message_loop()->PostTask(FROM_HERE, Bind(callback_, target_, true));
+    task_runner()->PostTask(FROM_HERE, Bind(callback_, target_, true));
 }
 
 bool FilePathWatcherFSEvents::ResolveTargetPath() {
   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
   FilePath resolved = ResolvePath(target_).StripTrailingSeparators();
   bool changed = resolved != resolved_target_;
   resolved_target_ = resolved;
   if (resolved_target_.empty())
-    message_loop()->PostTask(FROM_HERE, Bind(callback_, target_, true));
+    task_runner()->PostTask(FROM_HERE, Bind(callback_, target_, true));
   return changed;
 }
 
 void FilePathWatcherFSEvents::DestroyEventStream() {
   FSEventStreamStop(fsevent_stream_);
   FSEventStreamInvalidate(fsevent_stream_);
   FSEventStreamRelease(fsevent_stream_);
   fsevent_stream_ = NULL;
 }
 
 void FilePathWatcherFSEvents::StartEventStream(
     FSEventStreamEventId start_event) {
   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
   ResolveTargetPath();
   UpdateEventStream(start_event);
 }
 
 FilePathWatcherFSEvents::~FilePathWatcherFSEvents() {}
 
 }  // namespace base