Mandoline: Introduce ApplicationConnection::CloseConnection

mojo/application/public/cpp/application_connection.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_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_
 #define MOJO_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_
 
 #include <string>
 
 #include "mojo/application/public/cpp/lib/interface_factory_connector.h"
@@ skipping 22 matching lines @@
 //   connection->AddService<Bar>(&my_foo_and_bar_factory_);
 //
 // The InterfaceFactory must outlive the ApplicationConnection.
 //
 // Additionally you specify a ServiceConnector. If a ServiceConnector has
 // been set and an InterfaceFactory has not been registered for the interface
 // request, than the interface request is sent to the ServiceConnector.
 //
 // Just as with InterfaceFactory, ServiceConnector must outlive
 // ApplicationConnection.
+//
+// An ApplicationConnection's lifetime is managed by an ApplicationImpl. To
+// close a connection, call CloseConnection which will destroy this object.
 class ApplicationConnection {
  public:
-  virtual ~ApplicationConnection();
+  ApplicationConnection();
+
+  // Closes the connection and destroys this object. This is the only valid way
+  // to destroy this object.
+  void CloseConnection();
 
   // See class description for details.
   virtual void SetServiceConnector(ServiceConnector* connector) = 0;
 
   // Makes Interface available as a service to the remote application.
   // |factory| will create implementations of Interface on demand.
   template <typename Interface>
   void AddService(InterfaceFactory<Interface>* factory) {
     SetServiceConnectorForName(
         new internal::InterfaceFactoryConnector<Interface>(factory),
@@ skipping 25 matching lines @@
   virtual const std::string& GetConnectionURL() = 0;
 
   // Returns the URL identifying the remote application on this connection.
   virtual const std::string& GetRemoteApplicationURL() = 0;
 
   // Returns the raw proxy to the remote application's ServiceProvider
   // interface. Most applications will just use ConnectToService() instead.
   // Caller does not take ownership.
   virtual ServiceProvider* GetServiceProvider() = 0;
 
+ protected:
+  virtual ~ApplicationConnection();
+
+  // Called to give the derived type to perform some cleanup before destruction.
+  virtual void OnCloseConnection() = 0;
+
  private:
   virtual void SetServiceConnectorForName(ServiceConnector* service_connector,
                                           const std::string& name) = 0;
+
+  // Ensures that CloseConnection can only be called once and the
+  // ApplicationConnection's destructor can only be called after the connection
+  // is closed.
+  bool connection_closed_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_