Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/interface_request.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_INTERFACE_REQUEST_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_REQUEST_H_
 
 #include <string>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/optional.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/disconnect_reason.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_proxy.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 
 namespace mojo {
 
 // Represents a request from a remote client for an implementation of Interface
 // over a specified message pipe. The implementor of the interface should
 // remove the message pipe by calling PassMessagePipe() and bind it to the
 // implementation. If this is not done, the InterfaceRequest will automatically
 // close the pipe on destruction. Can also represent the absence of a request
 // if the client did not provide a message pipe.
 template <typename Interface>
 class InterfaceRequest {
  public:
   // Constructs an empty InterfaceRequest, representing that the client is not
   // requesting an implementation of Interface.
   InterfaceRequest() {}
   InterfaceRequest(decltype(nullptr)) {}
 
   // Creates a new message pipe over which Interface is to be served, binding
   // the specified InterfacePtr to one end of the message pipe and this
   // InterfaceRequest to the other. For example usage, see comments on
   // MakeRequest(InterfacePtr*) below.
   explicit InterfaceRequest(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), 0u),
               std::move(runner));
     Bind(std::move(pipe.handle1));
   }
 
   // Takes the message pipe from another InterfaceRequest.
   InterfaceRequest(InterfaceRequest&& other) {
     handle_ = std::move(other.handle_);
   }
@@ skipping 101 matching lines @@
 //
 //   CollectorPtr collector = ...;  // Connect to Collector.
 //   SourcePtr source;
 //   InterfaceRequest<Source> source_request(&source);
 //   collector->RegisterSource(std::move(source));
 //   CreateSource(std::move(source_request));  // Create implementation locally.
 //
 template <typename Interface>
 InterfaceRequest<Interface> MakeRequest(
     InterfacePtr<Interface>* ptr,
-    scoped_refptr<base::SingleThreadTaskRunner> runner =
-        base::ThreadTaskRunnerHandle::Get()) {
+    scoped_refptr<base::SequencedTaskRunner> runner =
+        base::SequencedTaskRunnerHandle::Get()) {
   return InterfaceRequest<Interface>(ptr, runner);
 }
 
 // Fuses an InterfaceRequest<T> endpoint with an InterfacePtrInfo<T> endpoint.
 // Returns |true| on success or |false| on failure.
 template <typename Interface>
 bool FuseInterface(InterfaceRequest<Interface> request,
                    InterfacePtrInfo<Interface> proxy_info) {
   MojoResult result = FuseMessagePipes(request.PassMessagePipe(),
                                        proxy_info.PassHandle());
   return result == MOJO_RESULT_OK;
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_REQUEST_H_