Cleanup Service<> and ServiceFactory<> when clients go away.

mojo/public/shell/service.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_SHELL_SERVICE_H_
 #define MOJO_PUBLIC_SHELL_SERVICE_H_
 
 #include <vector>
 
 #include "mojo/public/bindings/error_handler.h"
@@ skipping 40 matching lines @@
 // Context: Optional type of shared context.v
 namespace mojo {
 
 class ServiceFactoryBase : public ShellClient {
  public:
   virtual ~ServiceFactoryBase();
 
  protected:
   ServiceFactoryBase(ScopedMessagePipeHandle shell_handle);
   Shell* shell() { return shell_.get(); }
+  // Destroys connection to Shell.
+  void DisconnectFromShell();
 
  private:
   RemotePtr<Shell> shell_;
 };
 
 template <class ServiceImpl, typename Context=void>
 class ServiceFactory : public ServiceFactoryBase {
  public:
   ServiceFactory(ScopedMessagePipeHandle shell_handle, Context* context = NULL)
       : ServiceFactoryBase(shell_handle.Pass()),
@@ skipping 10 matching lines @@
     ServiceImpl* service = new ServiceImpl();
     service->Initialize(this, client_handle.Pass());
     services_.push_back(service);
   }
 
   void RemoveService(ServiceImpl* service) {
     for (typename ServiceList::iterator it = services_.begin();
          it != services_.end(); ++it) {
       if (*it == service) {
         services_.erase(it);
+        if (services_.empty())
+          DisconnectFromShell();
         return;
       }
     }
   }
 
   Context* context() const {
     return context_;
   }
 
  private:
   typedef std::vector<ServiceImpl*> ServiceList;
   ServiceList services_;
   Context* context_;
 };
 
 // Specialization of ServiceFactory.
 // ServiceInterface: Service interface.
 // ServiceImpl: Implementation of Service interface.
 // Context: Optional type of shared context.
 template <class ServiceInterface, class ServiceImpl, typename Context=void>
 class Service : public ServiceInterface {
  public:
   virtual ~Service() {
     service_factory_->RemoveService(static_cast<ServiceImpl*>(this));
   }
 
  protected:
   friend class ServiceFactory<ServiceImpl, Context>;
-  Service() {}
+  Service() : reaper_(this) {}
 
   void Initialize(ServiceFactory<ServiceImpl, Context>* service_factory,
                   ScopedMessagePipeHandle client_handle) {
     service_factory_ = service_factory;
-    client_.reset(client_handle.Pass(), this);
+    client_.reset(client_handle.Pass(), this, &reaper_);
   }
 
   Context* context() const {
     return service_factory_->context();
   }
 
   typename ServiceInterface::_Peer* client() { return client_.get(); }
 
  private:
+  // The Reaper class allows us to handle errors on the client proxy without
+  // polluting the name space of the Service<> class.
+  class Reaper : public ErrorHandler {
+   public:
+    Reaper(Service<ServiceInterface, ServiceImpl, Context>* service)
+        : service_(service) {}
+    virtual void OnError() {
+      delete service_;
+    }
+   private:
+    Service<ServiceInterface, ServiceImpl, Context>* service_;
+  };
+  Reaper reaper_;
   ServiceFactory<ServiceImpl, Context>* service_factory_;
   RemotePtr<typename ServiceInterface::_Peer> client_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_SHELL_SERVICE_H_