Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/thread_safe_interface_ptr.h

 // Copyright 2016 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #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"
 
 namespace mojo {
 
 struct ThreadSafeInterfacePtrDeleter;
 
 // ThreadSafeInterfacePtr and ThreadSafeAssociatedInterfacePtr are versions of
 // InterfacePtr and AssociatedInterfacePtr that let callers invoke
@@ skipping 35 matching lines @@
   }
 
   // Creates a ThreadSafeInterfacePtrBase with no associated InterfacePtr.
   // Call Bind() with the InterfacePtr once available, which must be called on
   // the |bind_task_runner|.
   // Providing the TaskRunner here allows you to post a task to
   // |bind_task_runner| to do the bind and then immediately start calling
   // 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;
     return ptr;
   }
 
   // Binds a ThreadSafeInterfacePtrBase previously created with CreateUnbound().
   // This must be called on the thread that |interface_ptr| should be used.
   // If created with CreateUnbound() that thread should be the same as the one
   // 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;
   }
 
   ~ThreadSafeInterfacePtrBase() override {}
 
   Interface* get() { return &proxy_; }
   Interface* operator->() { return get(); }
   Interface& operator*() { return *get(); }
 
  private:
   friend class base::RefCountedThreadSafe<
       ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>>;
   friend struct ThreadSafeInterfacePtrDeleter;
 
   ThreadSafeInterfacePtrBase() : proxy_(this), weak_ptr_factory_(this) {}
 
   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;
     }
     delete this;
   }
 
   // MessageReceiverWithResponder implementation:
   bool Accept(Message* message) override {
     interface_ptr_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 23 matching lines @@
       Message message,
       std::unique_ptr<MessageReceiver> responder) {
     interface_ptr_.internal_state()->ForwardMessageWithResponder(
         std::move(message), std::move(responder));
   }
 
   class ForwardToCallingThread : public MessageReceiver {
    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) {
       // The current instance will be deleted when this method returns, so we
       // have to relinquish the responder's ownership so it does not get
       // deleted.
       caller_task_runner_->PostTask(FROM_HERE,
           base::Bind(&ForwardToCallingThread::CallAcceptAndDeleteResponder,
                      base::Passed(std::move(responder_)),
                      base::Passed(std::move(*message))));
       return true;
     }
 
     static void CallAcceptAndDeleteResponder(
         std::unique_ptr<MessageReceiver> responder,
         Message message) {
       ignore_result(responder->Accept(&message));
     }
 
     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_;
 };
 
 struct ThreadSafeInterfacePtrDeleter {
   template <typename Interface, template <typename> class InterfacePtrType>
   static void Destruct(
       const ThreadSafeInterfacePtrBase<Interface, InterfacePtrType>*
           interface_ptr) {
     interface_ptr->DeleteOnCorrectThread();
   }
 };
 
 template <typename Interface>
 using ThreadSafeAssociatedInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, AssociatedInterfacePtr>;
 
 template <typename Interface>
 using ThreadSafeInterfacePtr =
     ThreadSafeInterfacePtrBase<Interface, InterfacePtr>;
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_THREAD_SAFE_INTERFACE_PTR_H_