ApplicationConnection lifetime management changes.

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 "base/memory/weak_ptr.h"
 #include "mojo/application/public/cpp/lib/interface_factory_connector.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 
 namespace mojo {
 
 class ServiceConnector;
 
 // Represents a connection to another application. An instance of this class is
 // passed to ApplicationDelegate's ConfigureIncomingConnection() method each
 // time a connection is made to this app, and to ApplicationDelegate's
@@ skipping 18 matching lines @@
 // 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:
-  ApplicationConnection();
+  virtual ~ApplicationConnection() {}
 
-  // Closes the connection and destroys this object. This is the only valid way
-  // to destroy this object.
-  void CloseConnection();
+  class TestApi {
+   public:
+    explicit TestApi(ApplicationConnection* connection)
+        : connection_(connection) {
+    }
+    base::WeakPtr<ApplicationConnection> GetWeakPtr() {
+      return connection_->GetWeakPtr();
+    }
+
+   private:
+    ApplicationConnection* connection_;
+  };
 
   // 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.
   // Returns true if the service was exposed, false if capability filtering
   // from the shell prevented the service from being exposed.
   template <typename Interface>
   bool AddService(InterfaceFactory<Interface>* factory) {
@@ skipping 37 matching lines @@
   // Returns the local application's ServiceProvider interface. The return
   // value is owned by this connection.
   virtual ServiceProvider* GetLocalServiceProvider() = 0;
 
   // Register a handler to receive an error notification on the pipe to the
   // remote application's service provider.
   virtual void SetRemoteServiceProviderConnectionErrorHandler(
       const Closure& handler) = 0;
 
  protected:
-  virtual ~ApplicationConnection();
-
-  // Called to give the derived type to perform some cleanup before destruction.
-  virtual void OnCloseConnection() = 0;
-
- private:
   // Returns true if the connector was set, false if it was not set (e.g. by
   // some filtering policy preventing this interface from being exposed).
   virtual bool 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_;
+  virtual base::WeakPtr<ApplicationConnection> GetWeakPtr() = 0;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_APPLICATION_PUBLIC_CPP_APPLICATION_CONNECTION_H_