mojo: allow BackgroundServiceLoader-loaded apps to Quit themselves.

mojo/service_manager/service_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/message_loop/message_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
-#include "mojo/service_manager/background_service_loader.h"
+#include "mojo/service_manager/background_shell_service_loader.h"
 #include "mojo/service_manager/service_loader.h"
 #include "mojo/service_manager/service_manager.h"
 #include "mojo/service_manager/test.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 const char kTestURLString[] = "test:testService";
 const char kTestAURLString[] = "test:TestA";
@@ skipping 220 matching lines @@
   base::MessageLoop* loop_;
 };
 
 // Used to test that the requestor url will be correctly passed.
 class TestAImpl : public InterfaceImpl<TestA> {
  public:
   TestAImpl(ApplicationConnection* connection, TesterContext* test_context)
       : test_context_(test_context) {
     connection->ConnectToApplication(kTestBURLString)->ConnectToService(&b_);
   }
-  virtual ~TestAImpl() { test_context_->IncrementNumADeletes(); }
+  virtual ~TestAImpl() {
+    test_context_->IncrementNumADeletes();
+    if (base::MessageLoop::current()->is_running())
+      Quit();
+  }
 
  private:
   virtual void CallB() OVERRIDE {
     b_->B(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   virtual void CallCFromB() OVERRIDE {
     b_->CallC(base::Bind(&TestAImpl::Quit, base::Unretained(this)));
   }
 
   void Quit() {
+    base::MessageLoop::current()->Quit();
     test_context_->set_a_called_quit();
     test_context_->QuitSoon();
   }
 
   TesterContext* test_context_;
   TestBPtr b_;
 };
 
 class TestBImpl : public InterfaceImpl<TestB> {
  public:
   TestBImpl(ApplicationConnection* connection, TesterContext* test_context)
       : test_context_(test_context) {
     connection->ConnectToService(&c_);
   }
 
   virtual ~TestBImpl() {
     test_context_->IncrementNumBDeletes();
+    if (base::MessageLoop::current()->is_running())
+      base::MessageLoop::current()->Quit();
     test_context_->QuitSoon();
   }
 
  private:
   virtual void B(const mojo::Callback<void()>& callback) OVERRIDE {
     test_context_->IncrementNumBCalls();
     callback.Run();
   }
 
   virtual void CallC(const mojo::Callback<void()>& callback) OVERRIDE {
@@ skipping 41 matching lines @@
 
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {}
 
   virtual bool ConfigureIncomingConnection(
       ApplicationConnection* connection) OVERRIDE {
     if (!requestor_url_.empty() &&
           requestor_url_ != connection->GetRemoteApplicationURL()) {
       context_->set_tester_called_quit();
       context_->QuitSoon();
+      base::MessageLoop::current()->Quit();
       return false;
     }
     // If we're coming from A, then add B, otherwise A.
     if (connection->GetRemoteApplicationURL() == kTestAURLString)
       connection->AddService<TestB>(this);
     else
       connection->AddService<TestA>(this);
     return true;
   }
 
@@ skipping 70 matching lines @@
     TestServicePtr service_proxy;
     service_manager_->ConnectToService(GURL(kTestURLString), &service_proxy);
     test_client_.reset(new TestClientImpl(service_proxy.Pass()));
   }
 
   virtual void TearDown() OVERRIDE {
     test_client_.reset(NULL);
     service_manager_.reset(NULL);
   }
 
-  void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
+  scoped_ptr<BackgroundShellServiceLoader> MakeLoader(
+      const std::string& requestor_url) {
     scoped_ptr<ServiceLoader> real_loader(
         new Tester(&tester_context_, requestor_url));
+    scoped_ptr<BackgroundShellServiceLoader> loader(
+        new BackgroundShellServiceLoader(real_loader.Pass(), std::string(),
+                                         base::MessageLoop::TYPE_DEFAULT));
+    return loader.Pass();
+  }
+
+  void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
     service_manager_->SetLoaderForURL(
-        scoped_ptr<ServiceLoader>(new BackgroundServiceLoader(
-            real_loader.Pass(), "", base::MessageLoop::TYPE_DEFAULT)),
-        url);
+        MakeLoader(requestor_url).PassAs<ServiceLoader>(), url);
   }
 
   bool HasFactoryForTestURL() {
     ServiceManager::TestAPI manager_test_api(service_manager_.get());
     return manager_test_api.HasFactoryForURL(GURL(kTestURLString));
   }
 
  protected:
   base::ShadowingAtExitManager at_exit_;
   TesterContext tester_context_;
@@ skipping 140 matching lines @@
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // Only c can load b, so this will fail.
   AddLoaderForURL(GURL(kTestBURLString), "test:TestC");
 
   TestAPtr a;
   service_manager_->ConnectToService(GURL(kTestAURLString), &a);
   a->CallB();
   loop_.Run();
   EXPECT_EQ(0, tester_context_.num_b_calls());
+
+  EXPECT_FALSE(tester_context_.a_called_quit());
   EXPECT_TRUE(tester_context_.tester_called_quit());
 }
 
 TEST_F(ServiceManagerTest, NoServiceNoLoad) {
-  AddLoaderForURL(GURL(kTestAURLString), std::string());
+  // Because we'll never successfully connect to anything here and apps are not
+  // capable of noticing zero incoming connections and quitting, we need to use
+  // a quittable loader.
+  scoped_ptr<BackgroundShellServiceLoader> loader(MakeLoader(std::string()));
+  loader->set_quit_on_shutdown();
+  service_manager_->SetLoaderForURL(loader.PassAs<ServiceLoader>(),
+                                    GURL(kTestAURLString));
+
 
   // There is no TestC service implementation registered with ServiceManager,
   // so this cannot succeed (but also shouldn't crash).
   TestCPtr c;
   service_manager_->ConnectToService(GURL(kTestAURLString), &c);
   QuitMessageLoopErrorHandler quitter;
   c.set_error_handler(&quitter);
 
   loop_.Run();
   EXPECT_TRUE(c.encountered_error());
 }
 
 TEST_F(ServiceManagerTest, Interceptor) {
   TestServiceInterceptor interceptor;
   TestServiceLoader* default_loader = new TestServiceLoader;
   service_manager_->set_default_loader(
       scoped_ptr<ServiceLoader>(default_loader));
   service_manager_->SetInterceptor(&interceptor);
 
   std::string url("test:test3");
   TestServicePtr test_service;
   service_manager_->ConnectToService(GURL(url), &test_service);
 
   EXPECT_EQ(1, interceptor.call_count());
   EXPECT_EQ(url, interceptor.url_spec());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 }  // namespace mojo