Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/binding.h

 // Copyright 2014 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_BINDING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_
 
 #include <string>
 #include <utility>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/sequenced_task_runner.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "mojo/public/cpp/bindings/connection_error_callback.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/lib/binding_state.h"
 #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
 #include "mojo/public/cpp/system/core.h"
 
 namespace mojo {
 
@@ skipping 28 matching lines @@
 //       // delete FooImpl on connection errors.
 //     }
 //   };
 //
 // This class is thread hostile while bound to a message pipe. All calls to this
 // class must be from the thread that bound it. The interface implementation's
 // methods will be called from the thread that bound this. If a Binding is not
 // bound to a message pipe, it may be bound or destroyed on any thread.
 //
 // When you bind this class to a message pipe, optionally you can specify a
-// base::SingleThreadTaskRunner. This task runner must belong to the same
+// base::SequencedTaskRunner. This task runner must belong to the same
 // thread. It will be used to dispatch incoming method calls and connection
 // error notification. It is useful when you attach multiple task runners to a
 // single thread for the purposes of task scheduling. Please note that incoming
 // synchrounous method calls may not be run from this task runner, when they
 // reenter outgoing synchrounous calls on the same thread.
 template <typename Interface,
           typename ImplRefTraits = RawPtrImplRefTraits<Interface>>
 class Binding {
  public:
   using ImplPointerType = typename ImplRefTraits::PointerType;
 
   // Constructs an incomplete binding that will use the implementation |impl|.
   // The binding may be completed with a subsequent call to the |Bind| method.
   // Does not take ownership of |impl|, which must outlive the binding.
   explicit Binding(ImplPointerType impl) : internal_state_(std::move(impl)) {}
 
   // Constructs a completed binding of message pipe |handle| to implementation
   // |impl|. Does not take ownership of |impl|, which must outlive the binding.
   Binding(ImplPointerType impl,
           ScopedMessagePipeHandle handle,
-          scoped_refptr<base::SingleThreadTaskRunner> runner =
-              base::ThreadTaskRunnerHandle::Get())
+          scoped_refptr<base::SequencedTaskRunner> runner =
+              base::SequencedTaskRunnerHandle::Get())
       : Binding(std::move(impl)) {
     Bind(std::move(handle), std::move(runner));
   }
 
   // Constructs a completed binding of |impl| to a new message pipe, passing the
   // client end to |ptr|, which takes ownership of it. The caller is expected to
   // pass |ptr| on to the client of the service. Does not take ownership of any
   // of the parameters. |impl| must outlive the binding. |ptr| only needs to
   // last until the constructor returns.
   Binding(ImplPointerType impl,
           InterfacePtr<Interface>* ptr,
-          scoped_refptr<base::SingleThreadTaskRunner> runner =
-              base::ThreadTaskRunnerHandle::Get())
+          scoped_refptr<base::SequencedTaskRunner> runner =
+              base::SequencedTaskRunnerHandle::Get())
       : Binding(std::move(impl)) {
     Bind(ptr, std::move(runner));
   }
 
   // Constructs a completed binding of |impl| to the message pipe endpoint in
   // |request|, taking ownership of the endpoint. Does not take ownership of
   // |impl|, which must outlive the binding.
   Binding(ImplPointerType impl,
           InterfaceRequest<Interface> request,
-          scoped_refptr<base::SingleThreadTaskRunner> runner =
-              base::ThreadTaskRunnerHandle::Get())
+          scoped_refptr<base::SequencedTaskRunner> runner =
+              base::SequencedTaskRunnerHandle::Get())
       : Binding(std::move(impl)) {
     Bind(request.PassMessagePipe(), std::move(runner));
   }
 
   // Tears down the binding, closing the message pipe and leaving the interface
   // implementation unbound.
   ~Binding() {}
 
   // Returns an InterfacePtr bound to one end of a pipe whose other end is
   // bound to |this|.
   InterfacePtr<Interface> CreateInterfacePtrAndBind(
-      scoped_refptr<base::SingleThreadTaskRunner> runner =
-          base::ThreadTaskRunnerHandle::Get()) {
+      scoped_refptr<base::SequencedTaskRunner> runner =
+          base::SequencedTaskRunnerHandle::Get()) {
     InterfacePtr<Interface> interface_ptr;
     Bind(&interface_ptr, std::move(runner));
     return interface_ptr;
   }
 
   // Completes a binding that was constructed with only an interface
   // implementation. Takes ownership of |handle| and binds it to the previously
   // specified implementation.
   void Bind(ScopedMessagePipeHandle handle,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     internal_state_.Bind(std::move(handle), std::move(runner));
   }
 
   // Completes a binding that was constructed with only an interface
   // implementation by creating a new message pipe, binding one end of it to the
   // previously specified implementation, and passing the other to |ptr|, which
   // takes ownership of it. The caller is expected to pass |ptr| on to the
   // eventual client of the service. Does not take ownership of |ptr|.
   void Bind(InterfacePtr<Interface>* ptr,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     MessagePipe pipe;
     ptr->Bind(InterfacePtrInfo<Interface>(std::move(pipe.handle0),
                                           Interface::Version_),
               runner);
     Bind(std::move(pipe.handle1), std::move(runner));
   }
 
   // Completes a binding that was constructed with only an interface
   // implementation by removing the message pipe endpoint from |request| and
   // binding it to the previously specified implementation.
   void Bind(InterfaceRequest<Interface> request,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     Bind(request.PassMessagePipe(), std::move(runner));
   }
 
   // Adds a message filter to be notified of each incoming message before
   // dispatch. If a filter returns |false| from Accept(), the message is not
   // dispatched and the pipe is closed. Filters cannot be removed.
   void AddFilter(std::unique_ptr<MessageReceiver> filter) {
     DCHECK(is_bound());
     internal_state_.AddFilter(std::move(filter));
   }
@@ skipping 107 matching lines @@
 
  private:
   internal::BindingState<Interface, ImplRefTraits> internal_state_;
 
   DISALLOW_COPY_AND_ASSIGN(Binding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_