Reduce usage of MessageLoopProxy in base/

base/files/file_path_watcher_linux.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 "base/files/file_path_watcher.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
@@ skipping 10 matching lines @@
 #include "base/containers/hash_tables.h"
 #include "base/debug/trace_event.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/synchronization/lock.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 
 namespace base {
 
 namespace {
 
 class FilePathWatcherImpl;
 
 // Singleton to manage all inotify watches.
 // TODO(tony): It would be nice if this wasn't a singleton.
@@ skipping 66 matching lines @@
  private:
   // Start watching |path| for changes and notify |delegate| on each change.
   // Returns true if watch for |path| has been added successfully.
   virtual bool Watch(const FilePath& path,
                      bool recursive,
                      const FilePathWatcher::Callback& callback) override;
 
   // Cancel the watch. This unregisters the instance with InotifyReader.
   virtual void Cancel() override;
 
-  // Cleans up and stops observing the message_loop() thread.
+  // Cleans up and stops observing the task_runner() thread.
   virtual void CancelOnMessageLoopThread() override;
 
   // Deletion of the FilePathWatcher will call Cancel() to dispose of this
   // object in the right thread. This also observes destruction of the required
   // cleanup thread, in case it quits before Cancel() is called.
   virtual void WillDestroyCurrentMessageLoop() override;
 
   // Inotify watches are installed for all directory components of |target_|. A
   // WatchEntry instance holds the watch descriptor for a component and the
   // subdirectory for that identifies the next component. If a symbolic link
@@ skipping 208 matching lines @@
 
 FilePathWatcherImpl::FilePathWatcherImpl()
     : recursive_(false) {
 }
 
 void FilePathWatcherImpl::OnFilePathChanged(InotifyReader::Watch fired_watch,
                                             const FilePath::StringType& child,
                                             bool created,
                                             bool deleted,
                                             bool is_dir) {
-  if (!message_loop()->BelongsToCurrentThread()) {
-    // Switch to message_loop() to access |watches_| safely.
-    message_loop()->PostTask(
-        FROM_HERE,
-        Bind(&FilePathWatcherImpl::OnFilePathChanged, this,
-             fired_watch, child, created, deleted, is_dir));
+  if (!task_runner()->RunsTasksOnCurrentThread()) {
+    // Switch to task_runner() to access |watches_| safely.
+    task_runner()->PostTask(FROM_HERE,
+                            Bind(&FilePathWatcherImpl::OnFilePathChanged,
+                                 this,
+                                 fired_watch,
+                                 child,
+                                 created,
+                                 deleted,
+                                 is_dir));
     return;
   }
 
   // Check to see if CancelOnMessageLoopThread() has already been called.
   // May happen when code flow reaches here from the PostTask() above.
   if (watches_.empty()) {
     DCHECK(target_.empty());
     return;
   }
 
@@ skipping 57 matching lines @@
     callback_.Run(target_, false /* error */);
   }
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
                                 bool recursive,
                                 const FilePathWatcher::Callback& callback) {
   DCHECK(target_.empty());
   DCHECK(MessageLoopForIO::current());
 
-  set_message_loop(MessageLoopProxy::current());
+  set_task_runner(ThreadTaskRunnerHandle::Get());
   callback_ = callback;
   target_ = path;
   recursive_ = recursive;
   MessageLoop::current()->AddDestructionObserver(this);
 
   std::vector<FilePath::StringType> comps;
   target_.GetComponents(&comps);
   DCHECK(!comps.empty());
   for (size_t i = 1; i < comps.size(); ++i)
     watches_.push_back(WatchEntry(comps[i]));
   watches_.push_back(WatchEntry(FilePath::StringType()));
   UpdateWatches();
   return true;
 }
 
 void FilePathWatcherImpl::Cancel() {
   if (callback_.is_null()) {
-    // Watch was never called, or the message_loop() thread is already gone.
+    // Watch was never called, or the task_runner() thread is already gone.
     set_cancelled();
     return;
   }
 
-  // Switch to the message_loop() if necessary so we can access |watches_|.
-  if (!message_loop()->BelongsToCurrentThread()) {
-    message_loop()->PostTask(FROM_HERE,
-                             Bind(&FilePathWatcher::CancelWatch,
-                                  make_scoped_refptr(this)));
+  // Switch to the task_runner() if necessary so we can access |watches_|.
+  if (!task_runner()->RunsTasksOnCurrentThread()) {
+    task_runner()->PostTask(
+        FROM_HERE,
+        Bind(&FilePathWatcher::CancelWatch, make_scoped_refptr(this)));
   } else {
     CancelOnMessageLoopThread();
   }
 }
 
 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
-  DCHECK(message_loop()->BelongsToCurrentThread());
+  DCHECK(task_runner()->RunsTasksOnCurrentThread());
   set_cancelled();
 
   if (!callback_.is_null()) {
     MessageLoop::current()->RemoveDestructionObserver(this);
     callback_.Reset();
   }
 
   for (size_t i = 0; i < watches_.size(); ++i)
     g_inotify_reader.Get().RemoveWatch(watches_[i].watch, this);
   watches_.clear();
   target_.clear();
 
   if (recursive_)
     RemoveRecursiveWatches();
 }
 
 void FilePathWatcherImpl::WillDestroyCurrentMessageLoop() {
   CancelOnMessageLoopThread();
 }
 
 void FilePathWatcherImpl::UpdateWatches() {
-  // Ensure this runs on the message_loop() exclusively in order to avoid
+  // Ensure this runs on the task_runner() exclusively in order to avoid
   // concurrency issues.
-  DCHECK(message_loop()->BelongsToCurrentThread());
+  DCHECK(task_runner()->RunsTasksOnCurrentThread());
   DCHECK(HasValidWatchVector());
 
   // Walk the list of watches and update them as we go.
   FilePath path(FILE_PATH_LITERAL("/"));
   bool path_valid = true;
   for (size_t i = 0; i < watches_.size(); ++i) {
     WatchEntry& watch_entry = watches_[i];
     InotifyReader::Watch old_watch = watch_entry.watch;
     watch_entry.watch = InotifyReader::kInvalidWatch;
     watch_entry.linkname.clear();
@@ skipping 159 matching lines @@
   return watches_[watches_.size() - 1].subdir.empty();
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base