Mojo: Use InterfaceFactory<Interface> for service registration

mojo/public/cpp/bindings/interface_impl.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_IMPL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_IMPL_H_
 
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/lib/interface_impl_internal.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 // InterfaceImpl<..> is designed to be the base class of an interface
 // implementation. It may be bound to a pipe or a proxy, see BindToPipe and
 // BindToProxy.
 template <typename Interface>
 class InterfaceImpl : public internal::InterfaceImplBase<Interface> {
  public:
   typedef typename Interface::Client Client;
+  typedef Interface Implements;

[jamesr, 2014/07/14 21:21:44]

this is a little bit strange but without it I'm not sure how to specify the type
'Interface' given a type that inherits from InterfaceImpl<Interface> so that
callers don't have to explicitly specify both Impl and Interface in the common
case of a type that inherits from exactly one InterfaceImpl<T>.  You can see one
use of this in ContextInterfaceProvider.  Is there a better syntax for this?

 
   InterfaceImpl() : internal_state_(this) {}
   virtual ~InterfaceImpl() {}
 
   // Returns a proxy to the client interface. This is null upon construction,
   // and becomes non-null after OnClientConnected. NOTE: It remains non-null
   // until this instance is deleted.
   Client* client() { return internal_state_.client(); }
 
   // Blocks the current thread for the first incoming method call, i.e., either
@@ skipping 27 matching lines @@
 // MessagePipe. The instance is returned for convenience in member initializer
 // lists, etc. If the pipe is closed, the instance's OnConnectionError method
 // will be called.
 //
 // The instance is also bound to the current thread. Its methods will only be
 // called on the current thread, and if the current thread exits, then it will
 // also be deleted, and along with it, its end point of the pipe will be closed.
 //
 // Before returning, the instance's OnConnectionEstablished method is called.
 template <typename Impl>
 Impl* BindToPipe(

[darin (slow to review), 2014/07/14 21:34:06]

Instead of exposing the enum (which is a bit awkwardly named), how about
introducing WeakBindToPipe? Then, you can hide the enum completely. I think the
Bind method on internal_state() can just take a bool param, named
delete_on_error.

     Impl* instance,
     ScopedMessagePipeHandle handle,
-    const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
-  instance->internal_state()->Bind(handle.Pass(), waiter);
+    const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter(),
+    OnConnectionErrorBehavior behavior = DELETE_ON_ERROR) {
+  instance->internal_state()->Bind(handle.Pass(), waiter, behavior);
   return instance;
 }
 
 // Takes an instance of an InterfaceImpl<..> subclass and binds it to the given
 // InterfacePtr<..>. The instance is returned for convenience in member
 // initializer lists, etc. If the pipe is closed, the instance's
 // OnConnectionError method will be called.
 //
 // The instance is also bound to the current thread. Its methods will only be
 // called on the current thread, and if the current thread exits, then it will
 // also be deleted, and along with it, its end point of the pipe will be closed.
 //
 // Before returning, the instance's OnConnectionEstablished method is called.
 template <typename Impl, typename Interface>
 Impl* BindToProxy(
     Impl* instance,
     InterfacePtr<Interface>* ptr,
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   instance->internal_state()->BindProxy(ptr, waiter);
   return instance;
 }
 
 // Takes an instance of an InterfaceImpl<..> subclass and binds it to the given
 // InterfaceRequest<..>. The instance is returned for convenience in member
-// initializer lists, etc. If the pipe is closed, the instance's
-// OnConnectionError method will be called.
+// initializer lists, etc.
+//
+// The bind call passes ownership of the instance to the pipe. If the pipe is
+// closed, the instance's OnConnectionError method will be called and then the
+// instance will be deleted.
 //
 // The instance is also bound to the current thread. Its methods will only be
 // called on the current thread, and if the current thread exits, then it will
 // also be deleted, and along with it, its end point of the pipe will be closed.
 //
 // Before returning, the instance will receive a SetClient call, providing it
 // with a proxy to the client on the other end of the pipe.
+//
+// (Aside: If we were using C++11, the type of the first parameter would be
+// std::unique_ptr<Impl>).
 template <typename Impl, typename Interface>
 Impl* BindToRequest(
     Impl* instance,
     InterfaceRequest<Interface>* request,
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
   return BindToPipe(instance, request->PassMessagePipe(), waiter);
 }
 
+// This is the same as BindToRequest except that the lifetime of the instance is
+// not bound to the pipe. If the pipe is closed, the instance's OnChannelError
+// method will be called but the instance will not be deleted.
+template <typename Impl, typename Interface>
+Impl* WeakBindToRequest(
+    Impl* instance,
+    InterfaceRequest<Interface>* request,
+    const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
+  return BindToPipe(instance, request->PassMessagePipe(), waiter, DO_NOTHING);
+}
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_IMPL_H_