Eliminate ShellClientFactoryConnection & just have the ApplicationManager do it.

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 "mojo/shell/application_manager.h"
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 380 matching lines @@
   ~ApplicationManagerTest() override {}
 
   void SetUp() override {
     application_manager_.reset(new ApplicationManager(true));
     test_loader_ = new TestApplicationLoader;
     test_loader_->set_context(&context_);
     application_manager_->set_default_loader(
         scoped_ptr<ApplicationLoader>(test_loader_));
 
     TestServicePtr service_proxy;
-    ConnectToInterface(application_manager_.get(), GURL(kTestURLString),
-                     &service_proxy);
+    ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                       GURL(kTestURLString), &service_proxy);
     test_client_.reset(new TestClient(std::move(service_proxy)));
   }
 
   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;
-  ConnectToInterface(application_manager_.get(), GURL("test:test1"),
-                     &test_service);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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.
-  ConnectToInterface(application_manager_.get(), GURL("http:test1"),
-                     &test_service);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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;
-  ConnectToInterface(application_manager_.get(), GURL(kTestAURLString), &a);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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;
-  ConnectToInterface(application_manager_.get(), GURL(kTestAURLString), &a);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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;
-  ConnectToInterface(application_manager_.get(), GURL(kTestAURLString), &a);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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;
-  ConnectToInterface(application_manager_.get(), GURL(kTestAURLString), &a);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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;
-  ConnectToInterface(application_manager_.get(), GURL(kTestAURLString), &c);
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
+                     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(
       scoped_ptr<ApplicationLoader>(loader), GURL("test:test"));
 
   bool called = false;
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->SetTargetURL(GURL("test:test"));
   params->set_on_application_end(
       base::Bind(&QuitClosure, base::Unretained(&called)));
   application_manager_->ConnectToApplication(std::move(params));
   loop_.Run();
   EXPECT_TRUE(called);
 }
 
 TEST_F(ApplicationManagerTest, SameIdentityShouldNotCauseDuplicateLoad) {
   // 1 because ApplicationManagerTest connects once at startup.
   EXPECT_EQ(1, test_loader_->num_loads());
 
   TestServicePtr test_service;
-  ConnectToInterface(application_manager_.get(),
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
                      GURL("mojo:foo"), &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // Exactly the same URL as above.
-  ConnectToInterface(application_manager_.get(),
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
                      GURL("mojo:foo"), &test_service);
   EXPECT_EQ(2, test_loader_->num_loads());
 
   // A different identity because the domain is different.
-  ConnectToInterface(application_manager_.get(),
+  ConnectToInterface(application_manager_.get(), CreateShellIdentity(),
                      GURL("mojo:bar"), &test_service);
   EXPECT_EQ(3, test_loader_->num_loads());
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo