ApplicationConnection lifetime management changes.

mojo/shell/capability_filter_unittest.cc

 // Copyright 2015 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.
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 97 matching lines @@
   WeakBindingSet<Validator> validator_bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionValidator);
 };
 
 // This class models an application who will use the shell to interact with a
 // system service. The shell may limit this application's visibility of the full
 // set of interfaces exposed by that service.
 class TestApplication : public ApplicationDelegate {
  public:
-   TestApplication() : app_(nullptr) {}
-   ~TestApplication() override {}
+  TestApplication() : app_(nullptr) {}
+  ~TestApplication() override {}
 
  private:
   // Overridden from ApplicationDelegate:
   void Initialize(ApplicationImpl* app) override {
     app_ = app;
   }
   bool ConfigureIncomingConnection(ApplicationConnection* connection) override {
     // TestApplications receive their Validator via the inbound connection.
     connection->ConnectToService(&validator_);
 
     URLRequestPtr request(URLRequest::New());
     request->url = String::From("test:service");
-    ApplicationConnection* connection1 =
-        app_->ConnectToApplication(request.Pass());
-    connection1->SetRemoteServiceProviderConnectionErrorHandler(
+    connection1_ = app_->ConnectToApplication(request.Pass());
+    connection1_->SetRemoteServiceProviderConnectionErrorHandler(
         base::Bind(&TestApplication::ConnectionClosed,
                    base::Unretained(this), "test:service"));
 
     URLRequestPtr request2(URLRequest::New());
     request2->url = String::From("test:service2");
-    ApplicationConnection* connection2 =
-        app_->ConnectToApplication(request2.Pass());
-    connection2->SetRemoteServiceProviderConnectionErrorHandler(
+    connection2_ = app_->ConnectToApplication(request2.Pass());
+    connection2_->SetRemoteServiceProviderConnectionErrorHandler(
         base::Bind(&TestApplication::ConnectionClosed,
                     base::Unretained(this), "test:service2"));
     return true;
   }
 
   void ConnectionClosed(const std::string& service_url) {
     validator_->ConnectionClosed(app_->url(), service_url);
   }
 
   ApplicationImpl* app_;
   ValidatorPtr validator_;
+  scoped_ptr<ApplicationConnection> connection1_;
+  scoped_ptr<ApplicationConnection> connection2_;
 
   DISALLOW_COPY_AND_ASSIGN(TestApplication);
 };
 
 class TestContentHandler : public ApplicationDelegate,
                            public InterfaceFactory<ContentHandler>,
                            public ContentHandler {
  public:
   TestContentHandler() : app_(nullptr) {}
   ~TestContentHandler() override {}
@@ skipping 10 matching lines @@
 
   // Overridden from InterfaceFactory<ContentHandler>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<ContentHandler> request) override {
     bindings_.AddBinding(this, request.Pass());
   }
 
   // Overridden from ContentHandler:
   void StartApplication(InterfaceRequest<Application> application,
                         URLResponsePtr response) override {
+    scoped_ptr<ApplicationDelegate> delegate(new TestApplication);
     embedded_apps_.push_back(
-        new ApplicationImpl(new TestApplication, application.Pass()));
+        new ApplicationImpl(delegate.get(), application.Pass()));
+    embedded_app_delegates_.push_back(delegate.Pass());
   }
 
   ApplicationImpl* app_;
   WeakBindingSet<ContentHandler> bindings_;
+  ScopedVector<ApplicationDelegate> embedded_app_delegates_;
   ScopedVector<ApplicationImpl> embedded_apps_;
 
   DISALLOW_COPY_AND_ASSIGN(TestContentHandler);
 };
 
 // This class models a system service that exposes two interfaces, Safe and
 // Unsafe. The interface Unsafe is not to be exposed to untrusted applications.
 class ServiceApplication : public ApplicationDelegate,
                            public InterfaceFactory<Safe>,
                            public InterfaceFactory<Unsafe>,
@@ skipping 342 matching lines @@
   RunTest();
 }
 
 TEST_F(CapabilityFilter_WildcardsTest, ContentHandler) {
   RunContentHandlerTest();
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo