Eliminate Connector::Connect(), Connection, etc.

services/service_manager/tests/connect/connect_unittest.cc

Index: services/service_manager/tests/connect/connect_unittest.cc
diff --git a/services/service_manager/tests/connect/connect_unittest.cc b/services/service_manager/tests/connect/connect_unittest.cc
index e4f978cd6d89fbdd74f889991df6bafb517c2d5d..c3b2abf6c483ef8f68aa455fb5ebd6ef4d26e484 100644
--- a/services/service_manager/tests/connect/connect_unittest.cc
+++ b/services/service_manager/tests/connect/connect_unittest.cc
@@ -16,8 +16,8 @@
 #include "base/run_loop.h"
 #include "base/test/test_suite.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
+#include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_factory.h"
-#include "services/service_manager/public/cpp/interface_registry.h"
 #include "services/service_manager/public/cpp/service_test.h"
 #include "services/service_manager/public/interfaces/service_manager.mojom.h"
 #include "services/service_manager/tests/connect/connect_test.mojom.h"
@@ -65,6 +65,19 @@ void ReceiveConnectionResult(mojom::ConnectResult* out_result,
   loop->Quit();
 }
 
+void StartServiceResponse(base::RunLoop* quit_loop,
+                          mojom::ConnectResult* out_result,
+                          Identity* out_resolved_identity,
+                          mojom::ConnectResult result,
+                          const Identity& resolved_identity) {
+  if (quit_loop)
+    quit_loop->Quit();
+  if (out_result)
+    *out_result = result;
+  if (out_resolved_identity)
+    *out_resolved_identity = resolved_identity;
+}
+
 void QuitLoop(base::RunLoop* loop) {
   loop->Quit();
 }
@@ -79,14 +92,6 @@ class ConnectTest : public test::ServiceTest,
   ~ConnectTest() override {}
 
  protected:
-  std::unique_ptr<Connection> ConnectTo(const Identity& target) {
-    std::unique_ptr<Connection> connection = connector()->Connect(target);
-    base::RunLoop loop;
-    connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
-    loop.Run();
-    return connection;
-  }
-
   void CompareConnectionState(
       const std::string& connection_local_name,
       const std::string& connection_remote_name,
@@ -105,18 +110,22 @@ class ConnectTest : public test::ServiceTest,
   class TestService : public test::ServiceTestClient {
    public:
     explicit TestService(ConnectTest* connect_test)
-        : test::ServiceTestClient(connect_test),
-          connect_test_(connect_test) {}
+        : test::ServiceTestClient(connect_test), connect_test_(connect_test) {
+      registry_.AddInterface<test::mojom::ExposedInterface>(connect_test_);
+    }
     ~TestService() override {}
 
    private:
-    bool OnConnect(const ServiceInfo& remote_info,
-                   InterfaceRegistry* registry) override {
-      registry->AddInterface<test::mojom::ExposedInterface>(connect_test_);
-      return true;
+    void OnBindInterface(
+        const ServiceInfo& source_info,
+        const std::string& interface_name,
+        mojo::ScopedMessagePipeHandle interface_pipe) override {
+      registry_.BindInterface(source_info.identity, interface_name,
+                              std::move(interface_pipe));
     }
 
     ConnectTest* connect_test_;
+    BinderRegistry registry_;
 
     DISALLOW_COPY_AND_ASSIGN(TestService);
   };
@@ -129,9 +138,7 @@ class ConnectTest : public test::ServiceTest,
     // package app's manifest and register aliases for the applications it
     // provides.
     test::mojom::ConnectTestServicePtr root_service;
-    std::unique_ptr<Connection> connection =
-        connector()->Connect(kTestPackageName);
-    connection->GetInterface(&root_service);
+    connector()->BindInterface(kTestPackageName, &root_service);
     base::RunLoop run_loop;
     std::string root_name;
     root_service->GetTitle(
@@ -161,34 +168,29 @@ class ConnectTest : public test::ServiceTest,
 
 // Ensure the connection was properly established and that a round trip
 // method call/response is completed.
-TEST_F(ConnectTest, Connect) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
+TEST_F(ConnectTest, BindInterface) {
   test::mojom::ConnectTestServicePtr service;
-  connection->GetInterface(&service);
+  connector()->BindInterface(kTestAppName, &service);
   base::RunLoop run_loop;
   std::string title;
   service->GetTitle(base::Bind(&ReceiveOneString, &title, &run_loop));
   run_loop.Run();
   EXPECT_EQ("APP", title);
-  EXPECT_FALSE(connection->IsPending());
-  EXPECT_EQ(connection->GetRemoteIdentity().name(), kTestAppName);
 }
 
 TEST_F(ConnectTest, Instances) {
   Identity identity_a(kTestAppName, mojom::kInheritUserID, "A");
-  std::unique_ptr<Connection> connection_a1 = ConnectTo(identity_a);
-  std::unique_ptr<Connection> connection_a2 = ConnectTo(identity_a);
   std::string instance_a1, instance_a2;
   test::mojom::ConnectTestServicePtr service_a1;
   {
-    connection_a1->GetInterface(&service_a1);
+    connector()->BindInterface(identity_a, &service_a1);
     base::RunLoop loop;
     service_a1->GetInstance(base::Bind(&ReceiveOneString, &instance_a1, &loop));
     loop.Run();
   }
   test::mojom::ConnectTestServicePtr service_a2;
   {
-    connection_a2->GetInterface(&service_a2);
+    connector()->BindInterface(identity_a, &service_a2);
     base::RunLoop loop;
     service_a2->GetInstance(base::Bind(&ReceiveOneString, &instance_a2, &loop));
     loop.Run();
@@ -196,11 +198,10 @@ TEST_F(ConnectTest, Instances) {
   EXPECT_EQ(instance_a1, instance_a2);
 
   Identity identity_b(kTestAppName, mojom::kInheritUserID, "B");
-  std::unique_ptr<Connection> connection_b = ConnectTo(identity_b);
   std::string instance_b;
   test::mojom::ConnectTestServicePtr service_b;
   {
-    connection_b->GetInterface(&service_b);
+    connector()->BindInterface(identity_b, &service_b);
     base::RunLoop loop;
     service_b->GetInstance(base::Bind(&ReceiveOneString, &instance_b, &loop));
     loop.Run();
@@ -212,10 +213,9 @@ TEST_F(ConnectTest, Instances) {
 // BlockedInterface should not be exposed to this application because it is not
 // in our CapabilityFilter whitelist.
 TEST_F(ConnectTest, BlockedInterface) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
   base::RunLoop run_loop;
   test::mojom::BlockedInterfacePtr blocked;
-  connection->GetInterface(&blocked);
+  connector()->BindInterface(kTestAppName, &blocked);
   blocked.set_connection_error_handler(base::Bind(&QuitLoop, &run_loop));
   std::string title = "unchanged";
   blocked->GetTitleBlocked(base::Bind(&ReceiveOneString, &title, &run_loop));
@@ -225,16 +225,18 @@ TEST_F(ConnectTest, BlockedInterface) {
 
 // Connects to an app provided by a package.
 TEST_F(ConnectTest, PackagedApp) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppAName);
   test::mojom::ConnectTestServicePtr service_a;
-  connection->GetInterface(&service_a);
+  connector()->BindInterface(kTestAppAName, &service_a);
+  Connector::TestApi test_api(connector());
+  Identity resolved_identity;
+  test_api.SetStartServiceCallback(
+      base::Bind(&StartServiceResponse, nullptr, nullptr, &resolved_identity));
   base::RunLoop run_loop;
   std::string a_name;
   service_a->GetTitle(base::Bind(&ReceiveOneString, &a_name, &run_loop));
   run_loop.Run();
   EXPECT_EQ("A", a_name);
-  EXPECT_FALSE(connection->IsPending());
-  EXPECT_EQ(connection->GetRemoteIdentity().name(), kTestAppAName);
+  EXPECT_EQ(resolved_identity.name(), kTestAppAName);
 }
 
 // Ask the target application to attempt to connect to a third application
@@ -243,9 +245,8 @@ TEST_F(ConnectTest, PackagedApp) {
 // allowed regardless of the target's CapabilityFilter with respect to the
 // package.
 TEST_F(ConnectTest, BlockedPackage) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
   test::mojom::StandaloneAppPtr standalone_app;
-  connection->GetInterface(&standalone_app);
+  connector()->BindInterface(kTestAppName, &standalone_app);
   base::RunLoop run_loop;
   std::string title;
   standalone_app->ConnectToAllowedAppInBlockedPackage(
@@ -257,10 +258,9 @@ TEST_F(ConnectTest, BlockedPackage) {
 // BlockedInterface should not be exposed to this application because it is not
 // in our CapabilityFilter whitelist.
 TEST_F(ConnectTest, PackagedApp_BlockedInterface) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppAName);
   base::RunLoop run_loop;
   test::mojom::BlockedInterfacePtr blocked;
-  connection->GetInterface(&blocked);
+  connector()->BindInterface(kTestAppAName, &blocked);
   blocked.set_connection_error_handler(base::Bind(&QuitLoop, &run_loop));
   run_loop.Run();
 }
@@ -268,20 +268,21 @@ TEST_F(ConnectTest, PackagedApp_BlockedInterface) {
 // Connection to another application provided by the same package, blocked
 // because it's not in the capability filter whitelist.
 TEST_F(ConnectTest, BlockedPackagedApplication) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppBName);
   test::mojom::ConnectTestServicePtr service_b;
-  connection->GetInterface(&service_b);
+  connector()->BindInterface(kTestAppBName, &service_b);
+  Connector::TestApi test_api(connector());
+  mojom::ConnectResult result;
+  test_api.SetStartServiceCallback(
+      base::Bind(&StartServiceResponse, nullptr, &result, nullptr));
   base::RunLoop run_loop;
-  connection->SetConnectionLostClosure(base::Bind(&QuitLoop, &run_loop));
+  service_b.set_connection_error_handler(run_loop.QuitClosure());
   run_loop.Run();
-  EXPECT_FALSE(connection->IsPending());
-  EXPECT_EQ(mojom::ConnectResult::ACCESS_DENIED, connection->GetResult());
+  EXPECT_EQ(mojom::ConnectResult::ACCESS_DENIED, result);
 }
 
 TEST_F(ConnectTest, CapabilityClasses) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
   test::mojom::StandaloneAppPtr standalone_app;
-  connection->GetInterface(&standalone_app);
+  connector()->BindInterface(kTestAppName, &standalone_app);
   std::string string1, string2;
   base::RunLoop loop;
   standalone_app->ConnectToClassInterface(
@@ -295,19 +296,16 @@ TEST_F(ConnectTest, ConnectWithoutExplicitClassBlocked) {
   // We not be able to bind a ClassInterfacePtr since the connect_unittest app
   // does not explicitly request the "class" capability from
   // connect_test_class_app. This test will hang if it is bound.
-  std::unique_ptr<Connection> connection =
-      connector()->Connect(kTestClassAppName);
   test::mojom::ClassInterfacePtr class_interface;
-  connection->GetInterface(&class_interface);
+  connector()->BindInterface(kTestClassAppName, &class_interface);
   base::RunLoop loop;
   class_interface.set_connection_error_handler(base::Bind(&QuitLoop, &loop));
   loop.Run();
 }
 
 TEST_F(ConnectTest, ConnectAsDifferentUser_Allowed) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppName);
   test::mojom::UserIdTestPtr user_id_test;
-  connection->GetInterface(&user_id_test);
+  connector()->BindInterface(kTestAppName, &user_id_test);
   mojom::ConnectResult result;
   Identity target(kTestClassAppName, base::GenerateGUID());
   Identity result_identity;
@@ -323,9 +321,8 @@ TEST_F(ConnectTest, ConnectAsDifferentUser_Allowed) {
 }
 
 TEST_F(ConnectTest, ConnectAsDifferentUser_Blocked) {
-  std::unique_ptr<Connection> connection = connector()->Connect(kTestAppAName);
   test::mojom::UserIdTestPtr user_id_test;
-  connection->GetInterface(&user_id_test);
+  connector()->BindInterface(kTestAppAName, &user_id_test);
   mojom::ConnectResult result;
   Identity target(kTestClassAppName, base::GenerateGUID());
   Identity result_identity;
@@ -345,7 +342,7 @@ TEST_F(ConnectTest, ConnectAsDifferentUser_Blocked) {
 // process specifications. This is the only one for blocking.
 TEST_F(ConnectTest, ConnectToClientProcess_Blocked) {
   base::Process process;
-  std::unique_ptr<service_manager::Connection> connection =
+  mojom::ConnectResult result =
       service_manager::test::LaunchAndConnectToProcess(
 #if defined(OS_WIN)
           "connect_test_exe.exe",
@@ -355,7 +352,7 @@ TEST_F(ConnectTest, ConnectToClientProcess_Blocked) {
           service_manager::Identity("connect_test_exe",
                                     service_manager::mojom::kInheritUserID),
           connector(), &process);
-  EXPECT_EQ(connection->GetResult(), mojom::ConnectResult::ACCESS_DENIED);
+  EXPECT_EQ(result, mojom::ConnectResult::ACCESS_DENIED);
 }
 
 // Verifies that a client with the "all_users" capability class can receive
@@ -367,25 +364,28 @@ TEST_F(ConnectTest, AllUsersSingleton) {
   // synthetic user id for all-user singleton instances).
   const std::string singleton_userid = base::GenerateGUID();
   Identity singleton_id(kTestSingletonAppName, singleton_userid);
-  std::unique_ptr<Connection> connection = connector()->Connect(singleton_id);
+  connector()->StartService(singleton_id);
+  Identity first_resolved_identity;
   {
     base::RunLoop loop;
-    connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
+    Connector::TestApi test_api(connector());
+    test_api.SetStartServiceCallback(base::Bind(
+        &StartServiceResponse, &loop, nullptr, &first_resolved_identity));
     loop.Run();
-    EXPECT_NE(connection->GetRemoteIdentity().user_id(), singleton_userid);
+    EXPECT_NE(first_resolved_identity.user_id(), singleton_userid);
   }
   // This connects using the current client's user_id. It should be bound to the
   // same service started above, with the same service manager-generated user
   // id.
-  std::unique_ptr<Connection> inherit_connection =
-      connector()->Connect(kTestSingletonAppName);
+  connector()->StartService(kTestSingletonAppName);
   {
     base::RunLoop loop;
-    inherit_connection->AddConnectionCompletedClosure(
-        base::Bind(&QuitLoop, &loop));
+    Connector::TestApi test_api(connector());
+    Identity resolved_identity;
+    test_api.SetStartServiceCallback(
+        base::Bind(&StartServiceResponse, &loop, nullptr, &resolved_identity));
     loop.Run();
-    EXPECT_EQ(inherit_connection->GetRemoteIdentity().user_id(),
-              connection->GetRemoteIdentity().user_id());
+    EXPECT_EQ(resolved_identity.user_id(), first_resolved_identity.user_id());
   }
 }