Allow FilePathWatcher to be used from sequenced tasks.

base/files/file_path_watcher_kqueue.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_kqueue.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/param.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 
 // On some platforms these are not defined.
 #if !defined(EV_RECEIPT)
 #define EV_RECEIPT 0
 #endif
 #if !defined(O_EVTONLY)
 #define O_EVTONLY O_RDONLY
 #endif
 
 namespace base {
@@ skipping 208 matching lines @@
                                   const FilePathWatcher::Callback& callback) {
   DCHECK(target_.value().empty());  // Can only watch one path.
   DCHECK(!callback.is_null());
   DCHECK_EQ(kqueue_, -1);
   // Recursive watch is not supported using kqueue.
   DCHECK(!recursive);
 
   callback_ = callback;
   target_ = path;
 
-  set_task_runner(ThreadTaskRunnerHandle::Get());
+  set_task_runner(SequencedTaskRunnerHandle::Get());
 
   kqueue_ = kqueue();
   if (kqueue_ == -1) {
     DPLOG(ERROR) << "kqueue";
     return false;
   }
 
   int last_entry = EventsForPath(target_, &events_);
   DCHECK_NE(last_entry, 0);
 
@@ skipping 17 matching lines @@
       kqueue_, Bind(&FilePathWatcherKQueue::OnKQueueReadable, this));
   return true;
 }
 
 void FilePathWatcherKQueue::Cancel() {
   if (!task_runner()) {
     set_cancelled();
     return;
   }
 
-  DCHECK(task_runner()->BelongsToCurrentThread());
+  DCHECK(task_runner()->RunsTasksOnCurrentThread());
   if (!is_cancelled()) {
     set_cancelled();
     kqueue_watch_controller_.reset();
     if (IGNORE_EINTR(close(kqueue_)) != 0) {
       DPLOG(ERROR) << "close kqueue";
     }
     kqueue_ = -1;
     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
     events_.clear();
     callback_.Reset();
   }
 }
 
 void FilePathWatcherKQueue::OnKQueueReadable() {
-  DCHECK(task_runner()->BelongsToCurrentThread());
+  DCHECK(task_runner()->RunsTasksOnCurrentThread());
   DCHECK(events_.size());
 
   // Request the file system update notifications that have occurred and return
   // them in |updates|. |count| will contain the number of updates that have
   // occurred.
   EventVector updates(events_.size());
   struct timespec timeout = {0, 0};
   int count = HANDLE_EINTR(kevent(kqueue_, NULL, 0, &updates[0], updates.size(),
                                   &timeout));
 
@@ skipping 51 matching lines @@
       Cancel();
     }
   }
 
   if (send_notification) {
     callback_.Run(target_, false);
   }
 }
 
 }  // namespace base