mojo:: Introduce InterfaceRequest ctor that takes in InterfacePtr*

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>
 
@@ skipping 13 matching lines @@
 // 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()) {
+    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_);
   }
   InterfaceRequest& operator=(InterfaceRequest&& other) {
     handle_ = std::move(other.handle_);
     return *this;
   }
 
   // Assigning to nullptr resets the InterfaceRequest to an empty state,
@@ skipping 85 matching lines @@
 //
 // Given the following interface
 //   interface Collector {
 //     RegisterSource(Source source);
 //   }
 //
 // The client would have code similar to the following:
 //
 //   CollectorPtr collector = ...;  // Connect to Collector.
 //   SourcePtr source;
-//   InterfaceRequest<Source> source_request = MakeRequest(&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()) {
-  MessagePipe pipe;
-  ptr->Bind(InterfacePtrInfo<Interface>(std::move(pipe.handle0), 0u),
-            std::move(runner));
-  return MakeRequest<Interface>(std::move(pipe.handle1));
+  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_