Mojo: Expose untyped associated endpoints through public API

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 <utility>
 
 #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 "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/lib/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
-#include "mojo/public/cpp/bindings/lib/scoped_interface_endpoint_handle.h"
+#include "mojo/public/cpp/bindings/scoped_interface_endpoint_handle.h"
 
 namespace mojo {
 
 // 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
 // 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
@@ skipping 47 matching lines @@
     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()) {
-    internal::ScopedInterfaceEndpointHandle handle =
-        internal::AssociatedInterfaceRequestHelper::PassHandle(&request);
+    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 15 matching lines @@
     connection_error_handler_.reset();
   }
 
   // Unbinds and returns the associated interface request so it can be
   // used in another context, such as on another thread or with a different
   // implementation. Puts this object into a state where it can be rebound.
   AssociatedInterfaceRequest<Interface> Unbind() {
     DCHECK(endpoint_client_);
 
     AssociatedInterfaceRequest<Interface> request;
-    internal::AssociatedInterfaceRequestHelper::SetHandle(
-        &request, endpoint_client_->PassHandle());
+    request.Bind(endpoint_client_->PassHandle());
 
     endpoint_client_.reset();
     connection_error_handler_.reset();
 
     return request;
   }
 
   // Sets an error handler that will be called if a connection error occurs.
   //
   // This method may only be called after this AssociatedBinding has been bound
@@ skipping 22 matching lines @@
   typename Interface::Stub_ stub_;
   Interface* impl_;
   Closure connection_error_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(AssociatedBinding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ASSOCIATED_BINDING_H_