Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/associated_interface_ptr.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_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/logging.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/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/connection_error_callback.h"
 #include "mojo/public/cpp/bindings/lib/associated_interface_ptr_state.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
 namespace mojo {
 
@@ skipping 31 matching lines @@
   //
   // |runner| must belong to the same thread. It will be used to dispatch all
   // callbacks and connection error notification. It is useful when you attach
   // multiple task runners to a single thread for the purposes of task
   // scheduling.
   //
   // NOTE: Please see the comments of
   // AssociatedGroup.CreateAssociatedInterface() about when you can use this
   // object to make calls.
   void Bind(AssociatedInterfacePtrInfo<Interface> info,
-            scoped_refptr<base::SingleThreadTaskRunner> runner =
-                base::ThreadTaskRunnerHandle::Get()) {
+            scoped_refptr<base::SequencedTaskRunner> runner =
+                base::SequencedTaskRunnerHandle::Get()) {
     reset();
 
     bool is_local = info.handle().is_local();
 
     DCHECK(is_local) << "The AssociatedInterfacePtrInfo is supposed to be used "
                         "at the other side of the message pipe.";
 
     if (info.is_valid() && is_local)
       internal_state_.Bind(std::move(info), std::move(runner));
   }
@@ skipping 126 matching lines @@
 // interface implementation at the remote side.
 //
 // NOTE: |ptr| should NOT be used to make calls before the request is sent.
 // Violating that will cause the message pipe to be closed. On the other hand,
 // as soon as the request is sent, |ptr| is usable. There is no need to wait
 // until the request is bound to an implementation at the remote side.
 template <typename Interface>
 AssociatedInterfaceRequest<Interface> MakeRequest(
     AssociatedInterfacePtr<Interface>* ptr,
     AssociatedGroup* group,
-    scoped_refptr<base::SingleThreadTaskRunner> runner =
-        base::ThreadTaskRunnerHandle::Get()) {
+    scoped_refptr<base::SequencedTaskRunner> runner =
+        base::SequencedTaskRunnerHandle::Get()) {
   AssociatedInterfaceRequest<Interface> request;
   AssociatedInterfacePtrInfo<Interface> ptr_info;
   group->CreateAssociatedInterface(AssociatedGroup::WILL_PASS_REQUEST,
                                    &ptr_info, &request);
 
   ptr->Bind(std::move(ptr_info), std::move(runner));
   return request;
 }
 
 // Creates an associated interface proxy in its own AssociatedGroup.
 template <typename Interface>
 AssociatedInterfaceRequest<Interface> MakeRequestForTesting(
     AssociatedInterfacePtr<Interface>* ptr,
-    scoped_refptr<base::SingleThreadTaskRunner> runner =
-        base::ThreadTaskRunnerHandle::Get()) {
+    scoped_refptr<base::SequencedTaskRunner> runner =
+        base::SequencedTaskRunnerHandle::Get()) {
   MessagePipe pipe;
   using internal::MultiplexRouter;
   scoped_refptr<MultiplexRouter> router0 = new MultiplexRouter(
       std::move(pipe.handle0), MultiplexRouter::MULTI_INTERFACE, true, runner);
   scoped_refptr<MultiplexRouter> router1 = new MultiplexRouter(
       std::move(pipe.handle1), MultiplexRouter::MULTI_INTERFACE, false, runner);
 
   AssociatedInterfacePtrInfo<Interface> ptr_info;
   AssociatedInterfaceRequest<Interface> request;
   router1->CreateAssociatedGroup()->CreateAssociatedInterface(
@@ skipping 20 matching lines @@
 //  * In testing, where the returned request is bound to e.g. a mock and there
 //    are no other interfaces involved.
 //
 //  * When discarding messages sent on an interface, which can be done by
 //    discarding the returned request.
 template <typename Interface>
 AssociatedInterfaceRequest<Interface> GetIsolatedProxy(
     AssociatedInterfacePtr<Interface>* ptr) {
   MessagePipe pipe;
   scoped_refptr<internal::MultiplexRouter> router0 =
-      new internal::MultiplexRouter(std::move(pipe.handle0),
-                                    internal::MultiplexRouter::MULTI_INTERFACE,
-                                    false, base::ThreadTaskRunnerHandle::Get());
+      new internal::MultiplexRouter(
+          std::move(pipe.handle0), internal::MultiplexRouter::MULTI_INTERFACE,
+          false, base::SequencedTaskRunnerHandle::Get());
   scoped_refptr<internal::MultiplexRouter> router1 =
-      new internal::MultiplexRouter(std::move(pipe.handle1),
-                                    internal::MultiplexRouter::MULTI_INTERFACE,
-                                    true, base::ThreadTaskRunnerHandle::Get());
+      new internal::MultiplexRouter(
+          std::move(pipe.handle1), internal::MultiplexRouter::MULTI_INTERFACE,
+          true, base::SequencedTaskRunnerHandle::Get());
 
   ScopedInterfaceEndpointHandle endpoint0, endpoint1;
   router0->CreateEndpointHandlePair(&endpoint0, &endpoint1);
   endpoint1 = router1->CreateLocalEndpointHandle(endpoint1.release());
 
   ptr->Bind(AssociatedInterfacePtrInfo<Interface>(std::move(endpoint0),
                                                   Interface::Version_));
 
   AssociatedInterfaceRequest<Interface> request;
   request.Bind(std::move(endpoint1));
   return request;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_INTERFACE_PTR_H_