Some more minor cleanup to ApplicationManager.

mojo/shell/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 "base/run_loop.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_delegate.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/interface_factory.h"
 #include "mojo/application/public/interfaces/content_handler.mojom.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/shell/application_loader.h"
 #include "mojo/shell/application_manager.h"
+#include "mojo/shell/connect_util.h"
 #include "mojo/shell/fetcher.h"
 #include "mojo/shell/test.mojom.h"
 #include "mojo/shell/test_package_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 
 const char kTestURLString[] = "test:testService";
@@ skipping 475 matching lines @@
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(
         make_scoped_ptr(new AMTestPackageManager)));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
-    application_manager_->ConnectToService(GURL(kTestURLString),
-                                           &service_proxy);
+    ConnectToService(application_manager_.get(), GURL(kTestURLString),
+                     &service_proxy);
     test_client_.reset(new TestClient(service_proxy.Pass()));
   }
 
   void TearDown() override {
     test_client_.reset();
     application_manager_.reset();
   }
 
   void AddLoaderForURL(const GURL& url, const std::string& requestor_url) {
     application_manager_->SetLoaderForURL(
@@ skipping 55 matching lines @@
 TEST_F(ApplicationManagerTest, SetLoaders) {
   TestApplicationLoader* default_loader = new TestApplicationLoader;
   TestApplicationLoader* url_loader = new TestApplicationLoader;
   application_manager_->set_default_loader(
       scoped_ptr<ApplicationLoader>(default_loader));
   application_manager_->SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(url_loader), GURL("test:test1"));
 
   // test::test1 should go to url_loader.
   TestServicePtr test_service;
-  application_manager_->ConnectToService(GURL("test:test1"), &test_service);
+  ConnectToService(application_manager_.get(), GURL("test:test1"),
+                   &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(0, default_loader->num_loads());
 
   // http::test1 should go to default loader.
-  application_manager_->ConnectToService(GURL("http:test1"), &test_service);
+  ConnectToService(application_manager_.get(), GURL("http:test1"),
+                   &test_service);
   EXPECT_EQ(1, url_loader->num_loads());
   EXPECT_EQ(1, default_loader->num_loads());
 }
 
 // Confirm that the url of a service is correctly passed to another service that
 // it loads.
 TEST_F(ApplicationManagerTest, ACallB) {
   // Any url can load a.
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // Only a can load b.
   AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
 
   TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
+  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
   a->CallB();
   loop_.Run();
   EXPECT_EQ(1, tester_context_.num_b_calls());
   EXPECT_TRUE(tester_context_.a_called_quit());
 }
 
 // A calls B which calls C.
 TEST_F(ApplicationManagerTest, BCallC) {
   // Any url can load a.
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // Only a can load b.
   AddLoaderForURL(GURL(kTestBURLString), kTestAURLString);
 
   TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
+  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
   a->CallCFromB();
   loop_.Run();
 
   EXPECT_EQ(1, tester_context_.num_b_calls());
   EXPECT_EQ(1, tester_context_.num_c_calls());
   EXPECT_TRUE(tester_context_.a_called_quit());
 }
 
 // Confirm that a service impl will be deleted if the app that connected to
 // it goes away.
 TEST_F(ApplicationManagerTest, BDeleted) {
   AddLoaderForURL(GURL(kTestAURLString), std::string());
   AddLoaderForURL(GURL(kTestBURLString), std::string());
 
   TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
+  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &a);
 
   a->CallB();
   loop_.Run();
 
   // Kills the a app.
   application_manager_->SetLoaderForURL(scoped_ptr<ApplicationLoader>(),
                                         GURL(kTestAURLString));
   loop_.Run();
 
   EXPECT_EQ(1, tester_context_.num_b_deletes());
 }
 
 // Confirm that the url of a service is correctly passed to another service that
 // it loads, and that it can be rejected.
 TEST_F(ApplicationManagerTest, ANoLoadB) {
   // Any url can load a.
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // Only c can load b, so this will fail.
   AddLoaderForURL(GURL(kTestBURLString), "test:TestC");
 
   TestAPtr a;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &a);
+  ConnectToService(application_manager_.get(), 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(ApplicationManagerTest, NoServiceNoLoad) {
   AddLoaderForURL(GURL(kTestAURLString), std::string());
 
   // There is no TestC service implementation registered with
   // ApplicationManager, so this cannot succeed (but also shouldn't crash).
   TestCPtr c;
-  application_manager_->ConnectToService(GURL(kTestAURLString), &c);
+  ConnectToService(application_manager_.get(), GURL(kTestAURLString), &c);
   c.set_connection_error_handler(
       []() { base::MessageLoop::current()->QuitWhenIdle(); });
 
   loop_.Run();
   EXPECT_TRUE(c.encountered_error());
 }
 
 TEST_F(ApplicationManagerTest, TestEndApplicationClosure) {
   ClosingApplicationLoader* loader = new ClosingApplicationLoader();
   application_manager_->SetLoaderForURL(
@@ skipping 42 matching lines @@
 
   ASSERT_EQ(1, loader->num_loads());
   EXPECT_EQ(requestor_url, loader->last_requestor_url());
 }
 
 TEST_F(ApplicationManagerTest, SameIdentityShouldNotCauseDuplicateLoad) {
   // 1 because ApplicationManagerTest connects once at startup.
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
-  application_manager_->ConnectToService(GURL("http://www.example.org/abc?def"),
-                                         &test_service);
+  ConnectToService(application_manager_.get(),
+                   GURL("http://www.example.org/abc?def"), &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // Exactly the same URL as above.
-  application_manager_->ConnectToService(GURL("http://www.example.org/abc?def"),
-                                         &test_service);
+  ConnectToService(application_manager_.get(),
+                   GURL("http://www.example.org/abc?def"), &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // The same identity as the one above because only the query string is
   // different.
-  application_manager_->ConnectToService(GURL("http://www.example.org/abc"),
-                                         &test_service);
+  ConnectToService(application_manager_.get(),
+                   GURL("http://www.example.org/abc"), &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the path is different.
-  application_manager_->ConnectToService(
-      GURL("http://www.example.org/another_path"), &test_service);
+  ConnectToService(application_manager_.get(),
+                   GURL("http://www.example.org/another_path"), &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 
   // A different identity because the domain is different.
-  application_manager_->ConnectToService(
-      GURL("http://www.another_domain.org/abc"), &test_service);
+  ConnectToService(application_manager_.get(),
+                   GURL("http://www.another_domain.org/abc"), &test_service);
   EXPECT_EQ(4, test_loader_->num_loads());
 }
 
 TEST(ApplicationManagerTest2,
      MultipleConnectionsToContentHandlerGetSameContentHandlerId) {
   base::MessageLoop loop;
   const GURL content_handler_url("http://test.content.handler");
   const GURL requestor_url("http://requestor.url");
   TestContext test_context;
   scoped_ptr<AMTestPackageManager> test_package_manager(
@@ skipping 134 matching lines @@
   params->set_filter(GetPermissiveCapabilityFilter());
   params->set_connect_callback(
       [&content_handler_id](uint32_t t) { content_handler_id = t; });
   application_manager_->ConnectToApplication(params.Pass());
   EXPECT_EQ(0u, content_handler_id);
 }
 
 }  // namespace
 }  // namespace shell
 }  // namespace mojo