Remove FilePathWatcher::PlatformDelegate::CancelOnMessageLoopThread().

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 <stddef.h>
 #include <string.h>
 #include <sys/inotify.h>
@@ skipping 102 matching lines @@
 
  private:
   // Start watching |path| for changes and notify |delegate| on each change.
   // Returns true if watch for |path| has been added successfully.
   bool Watch(const FilePath& path,
              bool recursive,
              const FilePathWatcher::Callback& callback) override;
 
   // Cancel the watch. This unregisters the instance with InotifyReader.
   void Cancel() override;
-  void CancelOnMessageLoopThread() override;
   void CancelOnMessageLoopThreadOrInDestructor();
 
   // Inotify watches are installed for all directory components of |target_|.
   // A WatchEntry instance holds:
   // - |watch|: the watch descriptor for a component.
   // - |subdir|: the subdirectory that identifies the next component.
   //   - For the last component, there is no next component, so it is empty.
   // - |linkname|: the target of the symlink.
   //   - Only if the target being watched is a symbolic link.
   struct WatchEntry {
@@ skipping 188 matching lines @@
                                             bool deleted,
                                             bool is_dir) {
   if (!task_runner()->BelongsToCurrentThread()) {
     // 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.
+  // Check to see if CancelOnMessageLoopThreadOrInDestructor() has already been
+  // called. May happen when code flow reaches here from the PostTask() above.
   if (watches_.empty()) {
     DCHECK(target_.empty());
     return;
   }
 
   DCHECK(MessageLoopForIO::current());
   DCHECK(HasValidWatchVector());
 
   // Used below to avoid multiple recursive updates.
   bool did_update = false;
@@ skipping 94 matching lines @@
   return true;
 }
 
 void FilePathWatcherImpl::Cancel() {
   if (callback_.is_null()) {
     // Watch was never called, or the message_loop() thread is already gone.
     set_cancelled();
     return;
   }
 
-  // Switch to the message_loop() if necessary so we can access |watches_|.
+  // Switch to the task_runner() if necessary so we can access |watches_|.
   if (!task_runner()->BelongsToCurrentThread()) {
-    task_runner()->PostTask(FROM_HERE, Bind(&FilePathWatcher::CancelWatch,
-                                            make_scoped_refptr(this)));
+    task_runner()->PostTask(
+        FROM_HERE,
+        Bind(&FilePathWatcherImpl::CancelOnMessageLoopThreadOrInDestructor,
+             this));
   } else {
-    CancelOnMessageLoopThread();
+    CancelOnMessageLoopThreadOrInDestructor();
   }
 }
 
-void FilePathWatcherImpl::CancelOnMessageLoopThread() {
-  CancelOnMessageLoopThreadOrInDestructor();
-}
-
 void FilePathWatcherImpl::CancelOnMessageLoopThreadOrInDestructor() {
   DCHECK(in_destructor_ || task_runner()->BelongsToCurrentThread());
 
   if (is_cancelled())
     return;
 
   set_cancelled();
 
   if (!callback_.is_null())
     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::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(task_runner()->BelongsToCurrentThread());
   DCHECK(HasValidWatchVector());
 
   // Walk the list of watches and update them as we go.
   FilePath path(FILE_PATH_LITERAL("/"));
   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;
@@ skipping 164 matching lines @@
   return watches_.back().subdir.empty();
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base