Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/associated_binding.h

 // Copyright 2015 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_ASSOCIATED_BINDING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_group_controller.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/connection_error_callback.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/lib/control_message_proxy.h"
 #include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
 #include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 
 namespace mojo {
 
 class MessageReceiver;
 
 // Represents the implementation side of an associated interface. It is similar
 // to Binding, except that it doesn't own a message pipe handle.
 //
 // When you bind this class to a request, 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 AssociatedBinding {
  public:
   using ImplPointerType = typename ImplRefTraits::PointerType;
 
   // Constructs an incomplete associated binding that will use the
   // implementation |impl|. It may be completed with a subsequent call to the
   // |Bind| method. Does not take ownership of |impl|, which must outlive this
   // object.
   explicit AssociatedBinding(ImplPointerType impl) { stub_.set_sink(impl); }
 
   // Constructs a completed associated binding of |impl|. The output |ptr_info|
   // should be passed through the message pipe endpoint referred to by
   // |associated_group| to setup the corresponding asssociated interface
   // pointer. |impl| must outlive this object.
   AssociatedBinding(ImplPointerType impl,
                     AssociatedInterfacePtrInfo<Interface>* ptr_info,
                     AssociatedGroup* associated_group,
-                    scoped_refptr<base::SingleThreadTaskRunner> runner =
-                        base::ThreadTaskRunnerHandle::Get())
+                    scoped_refptr<base::SequencedTaskRunner> runner =
+                        base::SequencedTaskRunnerHandle::Get())
       : AssociatedBinding(std::move(impl)) {
     Bind(ptr_info, associated_group, std::move(runner));
   }
 
   // Constructs a completed associated binding of |impl|. |impl| must outlive
   // the binding.
   AssociatedBinding(ImplPointerType impl,
                     AssociatedInterfaceRequest<Interface> request,
-                    scoped_refptr<base::SingleThreadTaskRunner> runner =
-                        base::ThreadTaskRunnerHandle::Get())
+                    scoped_refptr<base::SequencedTaskRunner> runner =
+                        base::SequencedTaskRunnerHandle::Get())
       : AssociatedBinding(std::move(impl)) {
     Bind(std::move(request), std::move(runner));
   }
 
   ~AssociatedBinding() {}
 
   // Creates an associated inteface and sets up this object as the
   // implementation side. The output |ptr_info| should be passed through the
   // message pipe endpoint referred to by |associated_group| to setup the
   // corresponding asssociated interface pointer.
   void Bind(AssociatedInterfacePtrInfo<Interface>* ptr_info,
             AssociatedGroup* associated_group,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     AssociatedInterfaceRequest<Interface> request;
     associated_group->CreateAssociatedInterface(AssociatedGroup::WILL_PASS_PTR,
                                                 ptr_info, &request);
     Bind(std::move(request), std::move(runner));
   }
 
   // Sets up this object as the implementation side of an associated interface.
   void Bind(AssociatedInterfaceRequest<Interface> request,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     ScopedInterfaceEndpointHandle handle = request.PassHandle();
 
     DCHECK(handle.is_local())
         << "The AssociatedInterfaceRequest is supposed to be used at the "
         << "other side of the message pipe.";
 
     if (!handle.is_valid() || !handle.is_local()) {
       endpoint_client_.reset();
       return;
     }
@@ skipping 83 matching lines @@
  private:
   std::unique_ptr<InterfaceEndpointClient> endpoint_client_;
   typename Interface::template Stub_<ImplRefTraits> stub_;
 
   DISALLOW_COPY_AND_ASSIGN(AssociatedBinding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_