Get rid of KeepAlive. Quit shell when all urls run directly by Context are closed.

mojo/shell/shell_test_base_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 "mojo/shell/shell_test_base.h"
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 26 matching lines @@
   for (size_t i = 0; i < report.size(); i++)
     reports_out->push_back(*report[i]);
   loop->QuitWhenIdle();
 }
 
 class ShellTestBaseTest : public ShellTestBase {
  public:
   // Convenience helpers for use as callbacks in tests.
   template <typename T>
   base::Callback<void()> SetAndQuit(T* val, T result) {
-      return base::Bind(&ShellTestBaseTest::SetAndQuitImpl<T>,
-          base::Unretained(this), val, result);
+    return base::Bind(&ShellTestBaseTest::SetAndQuitImpl<T>,
+        base::Unretained(this), val, result);
   }
   template <typename T>
   base::Callback<void(T result)> SetAndQuit(T* val) {
       return base::Bind(&ShellTestBaseTest::SetAndQuitImpl<T>,
           base::Unretained(this), val);
   }
   static GURL test_app_url() {
     return GURL("mojo:mojo_test_app");
   }
 
   void GetReport(std::vector<ServiceReport>* report) {
-    request_tracking_.Bind(
-        ConnectToService(GURL("mojo:mojo_test_request_tracker_app"),
-        TestTrackedRequestService::Name_).Pass());
+    ConnectToService(GURL("mojo:mojo_test_request_tracker_app"),
+                     &request_tracking_);
     request_tracking_->GetReport(base::Bind(&GetReportCallback,
         base::Unretained(message_loop()),
         base::Unretained(report)));
     message_loop()->Run();
   }
 
  private:
   template<typename T>
   void SetAndQuitImpl(T* val, T result) {
     *val = result;
@@ skipping 12 matching lines @@
     base::MessageLoop::current()->QuitWhenIdle();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitMessageLoopErrorHandler);
 };
 
 // Tests that we can connect to a single service within a single app.
 TEST_F(ShellTestBaseTest, ConnectBasic) {
   InterfacePtr<TestService> service;
-  service.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
 
   bool was_run = false;
   service->Ping(SetAndQuit<bool>(&was_run, true));
   message_loop()->Run();
   EXPECT_TRUE(was_run);
   EXPECT_FALSE(service.encountered_error());
 
   service.reset();
 
   // This will run until the test app has actually quit (which it will,
   // since we killed the only connection to it).
   message_loop()->Run();
 }
 
 // Tests that trying to connect to a service fails properly if the service
 // doesn't exist. Implicit in this test is verification that the shell
 // terminates if no services are running.
 TEST_F(ShellTestBaseTest, ConnectInvalidService) {
   InterfacePtr<TestService> test_service;
-  test_service.Bind(ConnectToService(GURL("mojo:non_existent_service"),
-                                     TestService::Name_).Pass());
+  ConnectToService(GURL("mojo:non_existent_service"), &test_service);
 
   bool was_run = false;
   test_service->Ping(SetAndQuit<bool>(&was_run, true));
 
   // This will quit because there's nothing running.
   message_loop()->Run();
   EXPECT_FALSE(was_run);
 
   // It may have quit before an error was processed.
   if (!test_service.encountered_error()) {
     QuitMessageLoopErrorHandler quitter;
     test_service.set_error_handler(&quitter);
     message_loop()->Run();
     EXPECT_TRUE(test_service.encountered_error());
   }
 
   test_service.reset();
 }
 
 // Tests that we can connect to a single service within a single app using
 // a network based loader instead of local files.
 // TODO(tim): Disabled because network service leaks NSS at exit, meaning
 // subsequent tests can't init properly.
 TEST_F(ShellTestBaseTest, DISABLED_ConnectBasicNetwork) {
   InterfacePtr<TestService> service;
-  service.Bind(ConnectToServiceViaNetwork(
-      test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
 
   bool was_run = false;
   service->Ping(SetAndQuit<bool>(&was_run, true));
   message_loop()->Run();
   EXPECT_TRUE(was_run);
   EXPECT_FALSE(service.encountered_error());
 
   // Note that use of the network service is implicit in this test.
   // Since TestService is not the only service in use, the shell won't auto
   // magically exit when TestService is destroyed (unlike ConnectBasic).
   // Tearing down the shell context will kill connections. The shell loop will
   // exit as soon as no more apps are connected.
   // TODO(tim): crbug.com/392685.  Calling this explicitly shouldn't be
   // necessary once the shell terminates if the primordial app exits, which
   // we could enforce here by resetting |service|.
   shell_context()->application_manager()->TerminateShellConnections();
   message_loop()->Run();  // Waits for all connections to die.
 }
 
 // Tests that trying to connect to a service over network fails preoprly
 // if the service doesn't exist.
 // TODO(tim): Disabled because network service leaks NSS at exit, meaning
 // subsequent tests can't init properly.
 TEST_F(ShellTestBaseTest, DISABLED_ConnectInvalidServiceNetwork) {
   InterfacePtr<TestService> test_service;
-  test_service.Bind(ConnectToServiceViaNetwork(
-      GURL("mojo:non_existent_service"), TestService::Name_).Pass());
+  ConnectToService(GURL("mojo:non_existent_service"), &test_service);
   QuitMessageLoopErrorHandler quitter;
   test_service.set_error_handler(&quitter);
   bool was_run = false;
   test_service->Ping(SetAndQuit<bool>(&was_run, true));
   message_loop()->Run();
   EXPECT_TRUE(test_service.encountered_error());
 
   // TODO(tim): crbug.com/392685.  Calling this explicitly shouldn't be
   // necessary once the shell terminates if the primordial app exits, which
   // we could enforce here by resetting |service|.
   shell_context()->application_manager()->TerminateShellConnections();
   message_loop()->Run();  // Waits for all connections to die.
 }
 
 // Similar to ConnectBasic, but causes the app to instantiate multiple
 // service implementation objects and verifies the shell can reach both.
 TEST_F(ShellTestBaseTest, ConnectMultipleInstancesPerApp) {
   {
     TestServicePtr service1, service2;
-    service1.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
-    service2.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+    ConnectToService(test_app_url(), &service1);
+    ConnectToService(test_app_url(), &service2);
 
     bool was_run1 = false;
     bool was_run2 = false;
     service1->Ping(SetAndQuit<bool>(&was_run1, true));
     message_loop()->Run();
     service2->Ping(SetAndQuit<bool>(&was_run2, true));
     message_loop()->Run();
     EXPECT_TRUE(was_run1);
     EXPECT_TRUE(was_run2);
     EXPECT_FALSE(service1.encountered_error());
     EXPECT_FALSE(service2.encountered_error());
   }
   message_loop()->Run();
 }
 
 // Tests that service A and service B, both in App 1, can talk to each other
 // and parameters are passed around properly.
 TEST_F(ShellTestBaseTest, ConnectDifferentServicesInSingleApp) {
   // Have a TestService GetPartyTime on a TestTimeService in the same app.
   int64 time_message;
   TestServicePtr service;
-  service.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
   service->ConnectToAppAndGetTime(test_app_url().spec(),
                                   SetAndQuit<int64>(&time_message));
   message_loop()->Run();
 
   // Verify by hitting the TimeService directly.
   TestTimeServicePtr time_service;
-  time_service.Bind(
-      ConnectToService(test_app_url(), TestTimeService::Name_).Pass());
+  ConnectToService(test_app_url(), &time_service);
   int64 party_time;
   time_service->GetPartyTime(SetAndQuit<int64>(&party_time));
   message_loop()->Run();
 
   EXPECT_EQ(time_message, party_time);
 }
 
 // Tests that a service A in App 1 can talk to service B in App 2 and
 // parameters are passed around properly.
 TEST_F(ShellTestBaseTest, ConnectDifferentServicesInDifferentApps) {
   int64 time_message;
   TestServicePtr service;
-  service.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
   service->ConnectToAppAndGetTime("mojo:mojo_test_request_tracker_app",
                                   SetAndQuit<int64>(&time_message));
   message_loop()->Run();
 
   // Verify by hitting the TimeService in the request tracker app directly.
   TestTimeServicePtr time_service;
-  time_service.Bind(ConnectToService(GURL("mojo:mojo_test_request_tracker_app"),
-                    TestTimeService::Name_).Pass());
+  ConnectToService(GURL("mojo:mojo_test_request_tracker_app"), &time_service);
   int64 party_time;
   time_service->GetPartyTime(SetAndQuit<int64>(&party_time));
   message_loop()->Run();
 
   EXPECT_EQ(time_message, party_time);
 }
 
 // Tests that service A in App 1 can be a client of service B in App 2.
 TEST_F(ShellTestBaseTest, ConnectServiceAsClientOfSeparateApp) {
   TestServicePtr service;
-  service.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
   service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure());
   service->Ping(mojo::Callback<void()>());
   message_loop()->Run();
 
   for (int i = 0; i < 8; i++)
     service->Ping(mojo::Callback<void()>());
   service->Ping(message_loop()->QuitWhenIdleClosure());
   message_loop()->Run();
 
   // If everything worked properly, the tracking service should report
   // 10 pings to TestService.
   std::vector<ServiceReport> reports;
   GetReport(&reports);
   ASSERT_EQ(1U, reports.size());
   EXPECT_EQ(TestService::Name_, reports[0].service_name);
   EXPECT_EQ(10U, reports[0].total_requests);
 }
 
 // Connect several services together and use the tracking service to verify
 // communication.
 TEST_F(ShellTestBaseTest, ConnectManyClientsAndServices) {
   TestServicePtr service;
   TestTimeServicePtr time_service;
 
   // Make a request to the TestService and have it contact TimeService in the
   // tracking app. Do all this with tracking enabled, meaning both services
   // are connected as clients of the TrackedRequestService.
-  service.Bind(ConnectToService(test_app_url(), TestService::Name_).Pass());
+  ConnectToService(test_app_url(), &service);
   service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure());
   message_loop()->Run();
   for (int i = 0; i < 5; i++)
     service->Ping(mojo::Callback<void()>());
   int64 time_result;
   service->ConnectToAppAndGetTime("mojo:mojo_test_request_tracker_app",
                                   SetAndQuit<int64>(&time_result));
   message_loop()->Run();
 
   // Also make a few requests to the TimeService in the test_app.
-  time_service.Bind(
-      ConnectToService(test_app_url(), TestTimeService::Name_).Pass());
+  ConnectToService(test_app_url(), &time_service);
   time_service->StartTrackingRequests(message_loop()->QuitWhenIdleClosure());
   time_service->GetPartyTime(mojo::Callback<void(uint64_t)>());
   message_loop()->Run();
   for (int i = 0; i < 18; i++)
     time_service->GetPartyTime(mojo::Callback<void(uint64_t)>());
   // Flush the tasks with one more to quit.
   int64 party_time = 0;
   time_service->GetPartyTime(SetAndQuit<int64>(&party_time));
   message_loop()->Run();
 
   std::vector<ServiceReport> reports;
   GetReport(&reports);
   ASSERT_EQ(3U, reports.size());
   EXPECT_EQ(TestService::Name_, reports[0].service_name);
   EXPECT_EQ(6U, reports[0].total_requests);
   EXPECT_EQ(TestTimeService::Name_, reports[1].service_name);
   EXPECT_EQ(1U, reports[1].total_requests);
   EXPECT_EQ(TestTimeService::Name_, reports[2].service_name);
   EXPECT_EQ(20U, reports[2].total_requests);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo