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

services/service_manager/tests/service_manager/service_manager_unittest.cc

 // Copyright 2015 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>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/scoped_platform_handle.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.h"
 #include "services/service_manager/public/cpp/service_test.h"
 #include "services/service_manager/public/interfaces/constants.mojom.h"
 #include "services/service_manager/public/interfaces/service_manager.mojom.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "services/service_manager/tests/service_manager/service_manager_unittest.mojom.h"
 
 namespace service_manager {
 
 namespace {
 
 class ServiceManagerTestClient
     : public test::ServiceTestClient,
       public InterfaceFactory<test::mojom::CreateInstanceTest>,
       public test::mojom::CreateInstanceTest {
  public:
   explicit ServiceManagerTestClient(test::ServiceTest* test)
-      : test::ServiceTestClient(test), binding_(this) {}
+      : test::ServiceTestClient(test), binding_(this) {
+    registry_.AddInterface<test::mojom::CreateInstanceTest>(this);
+  }
   ~ServiceManagerTestClient() override {}
 
   const Identity& target_identity() const { return target_identity_; }
 
   void WaitForTargetIdentityCall() {
     wait_for_target_identity_loop_ = base::MakeUnique<base::RunLoop>();
     wait_for_target_identity_loop_->Run();
   }
 
  private:
   // test::ServiceTestClient:
-  bool OnConnect(const ServiceInfo& remote_info,
-                 InterfaceRegistry* registry) override {
-    registry->AddInterface<test::mojom::CreateInstanceTest>(this);
-    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));
   }
 
   // InterfaceFactory<test::mojom::CreateInstanceTest>:
   void Create(const Identity& remote_identity,
               test::mojom::CreateInstanceTestRequest request) override {
     binding_.Bind(std::move(request));
   }
 
   // test::mojom::CreateInstanceTest:
   void SetTargetIdentity(const service_manager::Identity& identity) override {
     target_identity_ = identity;
     if (!wait_for_target_identity_loop_)
       LOG(ERROR) << "SetTargetIdentity call received when not waiting for it.";
     else
       wait_for_target_identity_loop_->Quit();
   }
 
   service_manager::Identity target_identity_;
   std::unique_ptr<base::RunLoop> wait_for_target_identity_loop_;
 
+  BinderRegistry registry_;
   mojo::Binding<test::mojom::CreateInstanceTest> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceManagerTestClient);
 };
 
 }  // namespace
 
 class ServiceManagerTest : public test::ServiceTest,
                            public mojom::ServiceManagerListener {
  public:
@@ skipping 88 matching lines @@
     mojo::edk::PendingProcessConnection process_connection;
     service_manager::mojom::ServicePtr client =
         service_manager::PassServiceRequestOnCommandLine(&process_connection,
                                                          &child_command_line);
     service_manager::mojom::PIDReceiverPtr receiver;
 
     service_manager::Identity target("service_manager_unittest_target",
                                      service_manager::mojom::kInheritUserID);
     connector()->StartService(target, std::move(client),
                               MakeRequest(&receiver));
-    std::unique_ptr<service_manager::Connection> connection =
-        connector()->Connect(target);
-    connection->AddConnectionCompletedClosure(
-        base::Bind(&ServiceManagerTest::OnConnectionCompleted,
-                   base::Unretained(this)));
+    Connector::TestApi test_api(connector());
+    test_api.SetStartServiceCallback(base::Bind(
+        &ServiceManagerTest::OnConnectionCompleted, base::Unretained(this)));
 
     base::LaunchOptions options;
 #if defined(OS_WIN)
     options.handles_to_inherit = &handle_passing_info;
 #elif defined(OS_POSIX)
     options.fds_to_remap = &handle_passing_info;
 #endif
     target_ = base::LaunchProcess(child_command_line, options);
     DCHECK(target_.IsValid());
     receiver->SetPID(target_.Pid());
@@ skipping 43 matching lines @@
   void OnServiceStopped(const service_manager::Identity& identity) override {
     for (auto it = instances_.begin(); it != instances_.end(); ++it) {
       auto& instance = *it;
       if (instance.identity == identity) {
         instances_.erase(it);
         break;
       }
     }
   }
 
-  void OnConnectionCompleted() {}
+  void OnConnectionCompleted(mojom::ConnectResult, const Identity&) {}
 
   ServiceManagerTestClient* service_;
   mojo::Binding<mojom::ServiceManagerListener> binding_;
   std::vector<InstanceInfo> instances_;
   std::vector<InstanceInfo> initial_instances_;
   std::unique_ptr<base::RunLoop> wait_for_instances_loop_;
   ServiceStartedCallback service_started_callback_;
   ServiceFailedToStartCallback service_failed_to_start_callback_;
   base::Process target_;
 
@@ skipping 57 matching lines @@
     int start_count = 0;
     std::string service_name;
     set_service_started_callback(base::BindRepeating(
         &OnServiceStartedCallback,
         &start_count, &service_name, loop.QuitClosure()));
     bool failed_to_start = false;
     set_service_failed_to_start_callback(base::BindRepeating(
         &OnServiceFailedToStartCallback,
         &failed_to_start, loop.QuitClosure()));
 
-    std::unique_ptr<Connection> embedder_connection =
-        connector()->Connect("service_manager_unittest_embedder");
+    connector()->StartService("service_manager_unittest_embedder");
     loop.Run();
     EXPECT_FALSE(failed_to_start);
-    EXPECT_FALSE(embedder_connection->IsPending());
     EXPECT_EQ(1, start_count);
     EXPECT_EQ("service_manager_unittest_embedder", service_name);
   }
 
   {
     base::RunLoop loop;
     int start_count = 0;
     std::string service_name;
     set_service_started_callback(base::BindRepeating(
         &OnServiceStartedCallback,
         &start_count, &service_name, loop.QuitClosure()));
     bool failed_to_start = false;
     set_service_failed_to_start_callback(base::BindRepeating(
         &OnServiceFailedToStartCallback,
         &failed_to_start, loop.QuitClosure()));
 
     // Connect to the packaged singleton service.
-    std::unique_ptr<Connection> singleton_connection =
-        connector()->Connect("service_manager_unittest_singleton");
+    connector()->StartService("service_manager_unittest_singleton");
     loop.Run();
     EXPECT_FALSE(failed_to_start);
-    EXPECT_FALSE(singleton_connection->IsPending());
     EXPECT_EQ(1, start_count);
     EXPECT_EQ("service_manager_unittest_singleton", service_name);
   }
 }
 
 }  // namespace service_manager