Add RegisterService, split out of Connect().

services/service_manager/tests/connect/connect_unittest.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 61 matching lines @@
 }  // namespace
 
 class ConnectTest : public test::ServiceTest,
                     public InterfaceFactory<test::mojom::ExposedInterface>,
                     public test::mojom::ExposedInterface {
  public:
   ConnectTest() : ServiceTest("connect_unittests") {}
   ~ConnectTest() override {}
 
  protected:
-  std::unique_ptr<Connection> ConnectTo(Connector::ConnectParams* params) {
-    std::unique_ptr<Connection> connection = connector()->Connect(params);
+  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,
       const std::string& connection_remote_userid,
@@ skipping 74 matching lines @@
   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) {
-  Connector::ConnectParams params_a(
-      Identity(kTestAppName, mojom::kInheritUserID, "A"));
-  std::unique_ptr<Connection> connection_a1 = ConnectTo(&params_a);
-  std::unique_ptr<Connection> connection_a2 = ConnectTo(&params_a);
+  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);
     base::RunLoop loop;
     service_a1->GetInstance(base::Bind(&ReceiveOneString, &instance_a1, &loop));
     loop.Run();
   }
   test::mojom::ConnectTestServicePtr service_a2;
   {
     connection_a2->GetInterface(&service_a2);
     base::RunLoop loop;
     service_a2->GetInstance(base::Bind(&ReceiveOneString, &instance_a2, &loop));
     loop.Run();
   }
   EXPECT_EQ(instance_a1, instance_a2);
 
-  Connector::ConnectParams params_b(
-      Identity(kTestAppName, mojom::kInheritUserID, "B"));
-  std::unique_ptr<Connection> connection_b = ConnectTo(&params_b);
+  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);
     base::RunLoop loop;
     service_b->GetInstance(base::Bind(&ReceiveOneString, &instance_b, &loop));
     loop.Run();
   }
 
   EXPECT_NE(instance_a1, instance_b);
@@ skipping 149 matching lines @@
 }
 
 // Verifies that a client with the "all_users" capability class can receive
 // connections from clients run as other users.
 TEST_F(ConnectTest, AllUsersSingleton) {
   // Connect to an instance with an explicitly different user_id. This supplied
   // user id should be ignored by the service manager (which will generate its
   // own
   // synthetic user id for all-user singleton instances).
   const std::string singleton_userid = base::GenerateGUID();
-  Connector::ConnectParams params(
-      Identity(kTestSingletonAppName, singleton_userid));
-  std::unique_ptr<Connection> connection = connector()->Connect(&params);
+  Identity singleton_id(kTestSingletonAppName, singleton_userid);
+  std::unique_ptr<Connection> connection = connector()->Connect(singleton_id);
   {
     base::RunLoop loop;
     connection->AddConnectionCompletedClosure(base::Bind(&QuitLoop, &loop));
     loop.Run();
     EXPECT_NE(connection->GetRemoteIdentity().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);
   {
     base::RunLoop loop;
     inherit_connection->AddConnectionCompletedClosure(
         base::Bind(&QuitLoop, &loop));
     loop.Run();
     EXPECT_EQ(inherit_connection->GetRemoteIdentity().user_id(),
               connection->GetRemoteIdentity().user_id());
   }
 }
 
 }  // namespace service_manager