mojo: kill app_thread before unloading main app library and add tests

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 90 matching lines @@
   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.
+// 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());
 
   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.
+TEST_F(ShellTestBaseTest, ConnectBasicNetwork) {
+  InterfacePtr<TestService> service;
+  service.Bind(ConnectToServiceViaNetwork(
+      test_app_url(), TestService::Name_).Pass());
+
+  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.
+  shell_context()->Shutdown();

[tim (not reviewing), 2014/07/19 02:11:37]

Considering moving these two lines to ShellTestBase::TearDown in an
if(connect_to_service_via_network_was_called_)... although it's nice to see it
here as part of the test..

+  message_loop()->Run();
+}
+
+// Tests that trying to connect to a service over network fails preoprly
+// if the service doesn't exist.
+TEST_F(ShellTestBaseTest, ConnectInvalidServiceNetwork) {
+  InterfacePtr<TestService> test_service;
+  test_service.Bind(ConnectToServiceViaNetwork(
+      GURL("mojo:non_existent_service"), TestService::Name_).Pass());
+  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());
+
+  shell_context()->Shutdown();
+  message_loop()->Run();
+}
+
 // 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());
 
     bool was_run1 = false;
     bool was_run2 = false;
@@ skipping 114 matching lines @@
   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