Reduce usage of MessageLoopProxy in base/

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 <sys/param.h>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
+#include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_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 296 matching lines @@
   if (recursive) {
     // Recursive watch is not supported using kqueue.
     NOTIMPLEMENTED();
     return false;
   }
 
   callback_ = callback;
   target_ = path;
 
   MessageLoop::current()->AddDestructionObserver(this);
-  io_message_loop_ = base::MessageLoopProxy::current();
+  io_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   kqueue_ = kqueue();
   if (kqueue_ == -1) {
     DPLOG(ERROR) << "kqueue";
     return false;
   }
 
   int last_entry = EventsForPath(target_, &events_);
   DCHECK_NE(last_entry, 0);
 
   EventVector responses(last_entry);
 
   int count = HANDLE_EINTR(kevent(kqueue_, &events_[0], last_entry,
                                   &responses[0], last_entry, NULL));
   if (!AreKeventValuesValid(&responses[0], count)) {
     // Calling Cancel() here to close any file descriptors that were opened.
     // This would happen in the destructor anyways, but FilePathWatchers tend to
     // be long lived, and if an error has occurred, there is no reason to waste
     // the file descriptors.
     Cancel();
     return false;
   }
 
   return MessageLoopForIO::current()->WatchFileDescriptor(
       kqueue_, true, MessageLoopForIO::WATCH_READ, &kqueue_watcher_, this);
 }
 
 void FilePathWatcherKQueue::Cancel() {
-  base::MessageLoopProxy* proxy = io_message_loop_.get();
-  if (!proxy) {
+  base::SequencedTaskRunner* task_runner = io_task_runner_.get();
+  if (!task_runner) {
     set_cancelled();
     return;
   }
-  if (!proxy->BelongsToCurrentThread()) {
-    proxy->PostTask(FROM_HERE,
-                    base::Bind(&FilePathWatcherKQueue::Cancel, this));
+  if (!task_runner->RunsTasksOnCurrentThread()) {
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(&FilePathWatcherKQueue::Cancel, this));
     return;
   }
   CancelOnMessageLoopThread();
 }
 
 void FilePathWatcherKQueue::CancelOnMessageLoopThread() {
   DCHECK(MessageLoopForIO::current());
   if (!is_cancelled()) {
     set_cancelled();
     kqueue_watcher_.StopWatchingFileDescriptor();
     if (IGNORE_EINTR(close(kqueue_)) != 0) {
       DPLOG(ERROR) << "close kqueue";
     }
     kqueue_ = -1;
     std::for_each(events_.begin(), events_.end(), ReleaseEvent);
     events_.clear();
-    io_message_loop_ = NULL;
+    io_task_runner_ = NULL;
     MessageLoop::current()->RemoveDestructionObserver(this);
     callback_.Reset();
   }
 }
 
 }  // namespace base