ApplicationManager: Use callback to get notified on application shutdown.

shell/application_manager/application_manager_unittest.cc

 // 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.
 
 #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 "mojo/public/cpp/application/application_connection.h"
@@ skipping 15 matching lines @@
 const char kTestAURLString[] = "test:TestA";
 const char kTestBURLString[] = "test:TestB";
 
 struct TestContext {
   TestContext() : num_impls(0), num_loader_deletes(0) {}
   std::string last_test_string;
   int num_impls;
   int num_loader_deletes;
 };
 
+void QuitClosure(bool* value) {
+  *value = true;
+  base::MessageLoop::current()->QuitWhenIdle();
+}
+
 class QuitMessageLoopErrorHandler : public ErrorHandler {
  public:
   QuitMessageLoopErrorHandler() {}
   ~QuitMessageLoopErrorHandler() override {}
 
   // |ErrorHandler| implementation:
   void OnConnectionError() override {
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
@@ skipping 84 matching lines @@
               InterfaceRequest<TestService> request) override {
     new TestServiceImpl(context_, request.Pass());
   }
 
   scoped_ptr<ApplicationImpl> test_app_;
   TestContext* context_;
   int num_loads_;
   DISALLOW_COPY_AND_ASSIGN(TestApplicationLoader);
 };
 
+class ClosingApplicationLoader : public ApplicationLoader {
+ private:
+  // ApplicationLoader implementation.
+  void Load(const GURL& url,
+            InterfaceRequest<Application> application_request) override {}
+};
+
 class TesterContext {
  public:
   explicit TesterContext(base::MessageLoop* loop)
       : num_b_calls_(0),
         num_c_calls_(0),
         num_a_deletes_(0),
         num_b_deletes_(0),
         num_c_deletes_(0),
         tester_called_quit_(false),
         a_called_quit_(false),
@@ skipping 246 matching lines @@
     GURL mapped_url = ResolveMappings(url);
     // The shell automatically map mojo URLs.
     if (mapped_url.scheme() == "mojo") {
       url::Replacements<char> replacements;
       replacements.SetScheme("file", url::Component(0, 4));
       mapped_url = mapped_url.ReplaceComponents(replacements);
     }
     return mapped_url;
   }
 
-  void OnApplicationError(const GURL& url) override {}
-
  private:
   std::map<GURL, GURL> mappings_;
 };
 
 class TestExternal : public ApplicationDelegate {
  public:
   TestExternal() : configure_incoming_connection_called_(false) {}
 
   void Initialize(ApplicationImpl* app) override {
     initialize_args_ = app->args();
@@ skipping 376 matching lines @@
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(0, scheme_loader->num_loads());
 
   // test::test2 should go to scheme loader.
   application_manager_->ConnectToService(GURL("test:test2?foo=bar"),
                                          &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(1, scheme_loader->num_loads());
 }
 
+TEST_F(ApplicationManagerTest, TestEndApplicationClosure) {
+  ClosingApplicationLoader* loader = new ClosingApplicationLoader();
+  application_manager_->SetLoaderForScheme(
+      scoped_ptr<ApplicationLoader>(loader), "test");
+
+  bool called = false;
+  application_manager_->ConnectToApplication(
+      GURL("test:test"), GURL(), nullptr, nullptr,
+      base::Bind(&QuitClosure, base::Unretained(&called)));
+  loop_.Run();
+  EXPECT_TRUE(called);
+}
+
 }  // namespace
 }  // namespace shell
 }  // namespace mojo