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;

[darin (slow to review), 2014/07/15 06:10:38]

The name of this typedef bugs me a bit. Interface is a noun, but Implements is a
verb. A more verbose choice might be ImplementedInterface. Given how
infrequently this is used, maybe that is the way to go?

Another option is to just rename the template arg and let the typedef be
Interface. "The interface of the InterfaceImpl is InterfaceImpl::Interface."
That sort of works too.

[jamesr, 2014/07/15 18:07:22]

yeah, it's used in two places total so I went with ImplementedInterface.  I like
having the template arg be called 'Interface' since that's what most folks will
see.

 
   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 31 matching lines @@
 // 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(
     Impl* instance,
     ScopedMessagePipeHandle handle,
     const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
-  instance->internal_state()->Bind(handle.Pass(), waiter);
+  instance->internal_state()->Bind(
+      handle.Pass(), waiter, true /* delete_on_error */);
   return instance;
 }
 
+template <typename Impl>
+Impl* WeakBindToPipe(
+    Impl* instance,
+    ScopedMessagePipeHandle handle,
+    const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
+  instance->internal_state()->Bind(
+      handle.Pass(), waiter, false /* delete_on_error */);
+  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(

[darin (slow to review), 2014/07/15 06:10:38]

I guess this should be renamed WeakBindToProxy. Maybe we should have both
BindToProxy (strong ownership of instance) and WeakBindToProxy?

[jamesr, 2014/07/15 18:07:22]

Turns out I do need a WeakBindToProxy so I made this version strong and added
that

     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.
 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

[darin (slow to review), 2014/07/15 06:10:38]

nit: OnChannelError -> OnConnectionError

+// 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 WeakBindToPipe(instance, request->PassMessagePipe(), waiter);
+}
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_IMPL_H_