Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/thread_safe_interface_ptr.h

Index: mojo/public/cpp/bindings/thread_safe_interface_ptr.h
diff --git a/mojo/public/cpp/bindings/thread_safe_interface_ptr.h b/mojo/public/cpp/bindings/thread_safe_interface_ptr.h
index 605bddda1376bb97f2beef559129afe9169342db..9097514de08df61b0eee8fe021064611acd5473b 100644
--- a/mojo/public/cpp/bindings/thread_safe_interface_ptr.h
+++ b/mojo/public/cpp/bindings/thread_safe_interface_ptr.h
@@ -11,7 +11,7 @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/message.h"
@@ -67,7 +67,7 @@ class ThreadSafeInterfacePtrBase
   // methods on the returned interface.
   static scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>
   CreateUnbound(
-      const scoped_refptr<base::SingleThreadTaskRunner>& bind_task_runner) {
+      const scoped_refptr<base::SequencedTaskRunner>& bind_task_runner) {
     scoped_refptr<ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>> ptr =
         new ThreadSafeInterfacePtrBase();
     ptr->interface_ptr_task_runner_ = bind_task_runner;
@@ -80,14 +80,15 @@ class ThreadSafeInterfacePtrBase
   // provided at creation time.
   bool Bind(InterfacePtrType<Interface> interface_ptr) {
     DCHECK(!interface_ptr_task_runner_ ||
-        interface_ptr_task_runner_ == base::ThreadTaskRunnerHandle::Get());
+           interface_ptr_task_runner_ ==
+               base::SequencedTaskRunnerHandle::Get());
     if (!interface_ptr.is_bound()) {
       LOG(ERROR) << "Attempting to bind a ThreadSafe[Associated]InterfacePtr "
                     "from an unbound InterfacePtr.";
       return false;
     }
     interface_ptr_ = std::move(interface_ptr);
-    interface_ptr_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+    interface_ptr_task_runner_ = base::SequencedTaskRunnerHandle::Get();
     return true;
   }
 
@@ -106,7 +107,7 @@ class ThreadSafeInterfacePtrBase
 
   void DeleteOnCorrectThread() const {
     if (interface_ptr_task_runner_ &&
-        !interface_ptr_task_runner_->BelongsToCurrentThread() &&
+        !interface_ptr_task_runner_->RunsTasksOnCurrentThread() &&
         interface_ptr_task_runner_->DeleteSoon(FROM_HERE, this)) {
       return;
     }
@@ -150,8 +151,7 @@ class ThreadSafeInterfacePtrBase
    public:
     explicit ForwardToCallingThread(std::unique_ptr<MessageReceiver> responder)
         : responder_(std::move(responder)),
-          caller_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
-    }
+          caller_task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
 
    private:
     bool Accept(Message* message) {
@@ -172,10 +172,10 @@ class ThreadSafeInterfacePtrBase
     }
 
     std::unique_ptr<MessageReceiver> responder_;
-    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
+    scoped_refptr<base::SequencedTaskRunner> caller_task_runner_;
   };
 
-  scoped_refptr<base::SingleThreadTaskRunner> interface_ptr_task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> interface_ptr_task_runner_;
   ProxyType proxy_;
   InterfacePtrType<Interface> interface_ptr_;
   base::WeakPtrFactory<ThreadSafeInterfacePtrBase> weak_ptr_factory_;