Adding support for multiple services to TestConnectorFactory.

Assing support for multiple services to TestConnectorfactory and
changing the API to make that support clearer. Changed all calling sites
to reflect that new API.
Also removed support for custom origin when binding an interface, as it
was not used.

Bug: 800043
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I77eb626b538c9399e636ef381b0dd8d779ced66a
Reviewed-on: https://chromium-review.googlesource.com/854753
Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Reviewed-by: Ken Rockot <rockot@chromium.org>
Commit-Queue: Jay Civelli <jcivelli@chromium.org>
Cr-Commit-Position: refs/heads/master@{#528021}

chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service_unittest.cc

@@ -123,7 +123,7 @@ class ArcVoiceInteractionFrameworkServiceTest : public ash::AshTestBase {
     voice_interaction_controller_client_ =
         std::make_unique<VoiceInteractionControllerClient>();
     connector_factory_ =
-        std::make_unique<service_manager::TestConnectorFactory>(
+        service_manager::TestConnectorFactory::CreateForUniqueService(
             std::move(highlighter_controller_ptr));
     connector_ = connector_factory_->CreateConnector();
     framework_service_ = std::make_unique<ArcVoiceInteractionFrameworkService>(

chrome/browser/chromeos/note_taking_helper_unittest.cc

@@ -309,7 +309,7 @@ class NoteTakingHelperTest : public BrowserWithTestWindowTest,
         std::make_unique<TestNoteTakingController>();
     test_note_taking_controller_ = test_note_taking_controller_ptr.get();
     connector_factory_ =
-        std::make_unique<service_manager::TestConnectorFactory>(
+        service_manager::TestConnectorFactory::CreateForUniqueService(
             std::move(test_note_taking_controller_ptr));
     connector_ = connector_factory_->CreateConnector();
 

chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser_unittest.cc

@@ -97,9 +97,9 @@ class SafeDialAppInfoParserTest : public testing::Test {
  public:
   SafeDialAppInfoParserTest()
       : connector_factory_(
-            std::make_unique<data_decoder::DataDecoderService>()) {
-    connector_ = connector_factory_.CreateConnector();
-  }
+            service_manager::TestConnectorFactory::CreateForUniqueService(
+                std::make_unique<data_decoder::DataDecoderService>())),
+        connector_(connector_factory_->CreateConnector()) {}
 
   std::unique_ptr<ParsedDialAppInfo> Parse(
       const std::string& xml,
@@ -122,8 +122,8 @@ class SafeDialAppInfoParserTest : public testing::Test {
 
  private:
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
-  service_manager::TestConnectorFactory connector_factory_;
   std::unique_ptr<ParsedDialAppInfo> app_info_;
   DISALLOW_COPY_AND_ASSIGN(SafeDialAppInfoParserTest);
 };

chrome/browser/media/router/discovery/dial/safe_dial_device_description_parser_unittest.cc

@@ -80,9 +80,9 @@ class SafeDialDeviceDescriptionParserTest : public testing::Test {
  public:
   SafeDialDeviceDescriptionParserTest()
       : connector_factory_(
-            std::make_unique<data_decoder::DataDecoderService>()) {
-    connector_ = connector_factory_.CreateConnector();
-  }
+            service_manager::TestConnectorFactory::CreateForUniqueService(
+                std::make_unique<data_decoder::DataDecoderService>())),
+        connector_(connector_factory_->CreateConnector()) {}
 
   ParsedDialDeviceDescription Parse(
       const std::string& xml,
@@ -112,8 +112,8 @@ class SafeDialDeviceDescriptionParserTest : public testing::Test {
 
  private:
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
-  service_manager::TestConnectorFactory connector_factory_;
   DISALLOW_COPY_AND_ASSIGN(SafeDialDeviceDescriptionParserTest);
 };
 

chrome/services/file_util/public/cpp/sandboxed_dmg_analyzer_mac_unittest.cc

@@ -28,8 +28,10 @@ class SandboxedDMGAnalyzerTest : public testing::Test {
  public:
   SandboxedDMGAnalyzerTest()
       : browser_thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        test_connector_factory_(std::make_unique<FileUtilService>()),
-        connector_(test_connector_factory_.CreateConnector()) {}
+        test_connector_factory_(
+            service_manager::TestConnectorFactory::CreateForUniqueService(
+                std::make_unique<FileUtilService>())),
+        connector_(test_connector_factory_->CreateConnector()) {}
 
   void AnalyzeFile(const base::FilePath& path,
                    safe_browsing::ArchiveAnalyzerResults* results) {
@@ -77,7 +79,7 @@ class SandboxedDMGAnalyzerTest : public testing::Test {
 
   content::TestBrowserThreadBundle browser_thread_bundle_;
   content::InProcessUtilityThreadHelper utility_thread_helper_;
-  service_manager::TestConnectorFactory test_connector_factory_;
+  std::unique_ptr<service_manager::TestConnectorFactory> test_connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
 };
 

chrome/services/file_util/public/cpp/sandboxed_zip_analyzer_unittest.cc

@@ -74,8 +74,10 @@ class SandboxedZipAnalyzerTest : public ::testing::Test {
 
   SandboxedZipAnalyzerTest()
       : browser_thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
-        test_connector_factory_(std::make_unique<FileUtilService>()),
-        connector_(test_connector_factory_.CreateConnector()) {}
+        test_connector_factory_(
+            service_manager::TestConnectorFactory::CreateForUniqueService(
+                std::make_unique<FileUtilService>())),
+        connector_(test_connector_factory_->CreateConnector()) {}
 
   void SetUp() override {
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data_));
@@ -184,7 +186,8 @@ class SandboxedZipAnalyzerTest : public ::testing::Test {
   base::FilePath dir_test_data_;
   content::TestBrowserThreadBundle browser_thread_bundle_;
   content::InProcessUtilityThreadHelper utility_thread_helper_;
-  service_manager::TestConnectorFactory test_connector_factory_;
+  std::unique_ptr<service_manager::TestConnectorFactory>
+      test_connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
 };
 

components/arc/power/arc_power_bridge_unittest.cc

@@ -40,7 +40,7 @@ class ArcPowerBridgeTest : public testing::Test {
     wake_lock_provider_ = wake_lock_provider_ptr.get();
 
     connector_factory_ =
-        std::make_unique<service_manager::TestConnectorFactory>(
+        service_manager::TestConnectorFactory::CreateForUniqueService(
             std::move(wake_lock_provider_ptr));
     connector_ = connector_factory_->CreateConnector();
 

components/update_client/component_patcher_unittest.cc

@@ -151,10 +151,11 @@ TEST_F(ComponentPatcherOperationTest, CheckCourgetteOperation) {
   command_args->SetString("patch", "binary_courgette_patch.bin");
 
   // The operation needs a connector to access the PatchService.
-  service_manager::TestConnectorFactory connector_factory(
-      std::make_unique<patch::PatchService>());
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory =
+      service_manager::TestConnectorFactory::CreateForUniqueService(
+          std::make_unique<patch::PatchService>());
   std::unique_ptr<service_manager::Connector> connector =
-      connector_factory.CreateConnector();
+      connector_factory->CreateConnector();
 
   TestCallback callback;
   scoped_refptr<DeltaUpdateOp> op =
@@ -190,10 +191,11 @@ TEST_F(ComponentPatcherOperationTest, CheckBsdiffOperation) {
   command_args->SetString("patch", "binary_bsdiff_patch.bin");
 
   // The operation needs a connector to access the PatchService.
-  service_manager::TestConnectorFactory connector_factory(
-      std::make_unique<patch::PatchService>());
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory =
+      service_manager::TestConnectorFactory::CreateForUniqueService(
+          std::make_unique<patch::PatchService>());
   std::unique_ptr<service_manager::Connector> connector =
-      connector_factory.CreateConnector();
+      connector_factory->CreateConnector();
 
   TestCallback callback;
   scoped_refptr<DeltaUpdateOp> op =

components/update_client/test_configurator.cc

@@ -36,8 +36,10 @@ TestConfigurator::TestConfigurator()
       ondemand_time_(0),
       enabled_cup_signing_(false),
       enabled_component_updates_(true),
-      connector_factory_(std::make_unique<patch::PatchService>()),
-      connector_(connector_factory_.CreateConnector()),
+      connector_factory_(
+          service_manager::TestConnectorFactory::CreateForUniqueService(
+              std::make_unique<patch::PatchService>())),
+      connector_(connector_factory_->CreateConnector()),
       context_(base::MakeRefCounted<net::TestURLRequestContextGetter>(
           base::ThreadTaskRunnerHandle::Get())) {}
 

components/update_client/test_configurator.h

@@ -121,7 +121,7 @@ class TestConfigurator : public Configurator {
   GURL update_check_url_;
   GURL ping_url_;
 
-  service_manager::TestConnectorFactory connector_factory_;
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
   scoped_refptr<net::TestURLRequestContextGetter> context_;
 

services/data_decoder/public/cpp/test_data_decoder_service.cc

@@ -9,8 +9,10 @@
 namespace data_decoder {
 
 TestDataDecoderService::TestDataDecoderService()
-    : connector_factory_(std::make_unique<DataDecoderService>()),
-      connector_(connector_factory_.CreateConnector()) {}
+    : connector_factory_(
+          service_manager::TestConnectorFactory::CreateForUniqueService(
+              std::make_unique<DataDecoderService>())),
+      connector_(connector_factory_->CreateConnector()) {}
 
 TestDataDecoderService::~TestDataDecoderService() = default;
 

services/data_decoder/public/cpp/test_data_decoder_service.h

@@ -28,7 +28,7 @@ class TestDataDecoderService {
   service_manager::Connector* connector() const { return connector_.get(); }
 
  private:
-  service_manager::TestConnectorFactory connector_factory_;
+  std::unique_ptr<service_manager::TestConnectorFactory> connector_factory_;
   std::unique_ptr<service_manager::Connector> connector_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDataDecoderService);

services/proxy_resolver/proxy_resolver_service_unittest.cc

@@ -17,7 +17,7 @@ class ProxyResolverServiceTest : public testing::Test {
  public:
   ProxyResolverServiceTest()
       : connector_factory_(
-            std::make_unique<service_manager::TestConnectorFactory>(
+            service_manager::TestConnectorFactory::CreateForUniqueService(
                 std::make_unique<ProxyResolverService>())),
         connector_(connector_factory_->CreateConnector()) {}
 

services/service_manager/public/cpp/test/test_connector_factory.cc

@@ -4,6 +4,8 @@
 
 #include "services/service_manager/public/cpp/test/test_connector_factory.h"
 
+#include <vector>
+
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/public/cpp/service.h"
@@ -14,27 +16,44 @@ namespace service_manager {
 
 namespace {
 
-class TestConnectorImpl : public mojom::Connector {
+class TestConnectorImplBase : public mojom::Connector {
  public:
-  TestConnectorImpl(TestConnectorFactory* factory,
-                    std::unique_ptr<Service> service)
-      : service_context_(std::move(service), mojo::MakeRequest(&service_ptr_)),
-        factory_(factory) {
-    service_ptr_->OnStart(factory_->source_identity(),
-                          base::BindOnce(&TestConnectorImpl::OnStartCallback,
-                                         base::Unretained(this)));
+  TestConnectorImplBase() = default;
+  ~TestConnectorImplBase() override = default;
+
+  void AddService(const std::string& service_name,
+                  std::unique_ptr<Service> service,
+                  mojom::ServicePtr* service_ptr) {
+    service_contexts_.push_back(std::make_unique<ServiceContext>(
+        std::move(service), mojo::MakeRequest(service_ptr)));
+    (*service_ptr)
+        ->OnStart(Identity("TestConnectorFactory"),
+                  base::BindOnce(&TestConnectorImplBase::OnStartCallback,
+                                 base::Unretained(this)));
   }
 
-  ~TestConnectorImpl() override = default;
+ private:
+  virtual mojom::ServicePtr* GetServicePtr(const std::string& service_name) = 0;
+
+  void OnStartCallback(mojom::ConnectorRequest request,
+                       mojom::ServiceControlAssociatedRequest control_request) {
+  }
 
+  // mojom::Connector implementation:
   void BindInterface(const Identity& target,
                      const std::string& interface_name,
                      mojo::ScopedMessagePipeHandle interface_pipe,
                      BindInterfaceCallback callback) override {
-    service_ptr_->OnBindInterface(
-        BindSourceInfo(factory_->source_identity(), CapabilitySet()),
-        interface_name, std::move(interface_pipe),
-        base::Bind(&base::DoNothing));
+    mojom::ServicePtr* service_ptr = GetServicePtr(target.name());
+    // If you hit the DCHECK below, you need to add a call to AddService() in
+    // your test for the reported service.
+    DCHECK(service_ptr) << "Binding interface for unregistered service "
+                        << target.name();
+    (*service_ptr)
+        ->OnBindInterface(
+            BindSourceInfo(Identity("TestConnectorFactory"), CapabilitySet()),
+            interface_name, std::move(interface_pipe),
+            base::BindOnce(&base::DoNothing));
     std::move(callback).Run(mojom::ConnectResult::SUCCEEDED, Identity());
   }
 
@@ -67,28 +86,80 @@ class TestConnectorImpl : public mojom::Connector {
     NOTREACHED();
   }
 
+  std::vector<std::unique_ptr<ServiceContext>> service_contexts_;
+  mojo::BindingSet<mojom::Connector> bindings_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestConnectorImplBase);
+};
+
+class UniqueServiceConnector : public TestConnectorImplBase {
+ public:
+  explicit UniqueServiceConnector(std::unique_ptr<Service> service) {
+    AddService(/*service_name=*/std::string(), std::move(service),
+               &service_ptr_);
+  }
+
  private:
-  void OnStartCallback(
-      service_manager::mojom::ConnectorRequest request,
-      service_manager::mojom::ServiceControlAssociatedRequest control_request) {
+  mojom::ServicePtr* GetServicePtr(const std::string& service_name) override {
+    return &service_ptr_;
   }
 
   mojom::ServicePtr service_ptr_;
-  service_manager::ServiceContext service_context_;
-  TestConnectorFactory* const factory_;
-  mojo::BindingSet<mojom::Connector> bindings_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestConnectorImpl);
+  DISALLOW_COPY_AND_ASSIGN(UniqueServiceConnector);
+};
+
+class MultipleServiceConnector : public TestConnectorImplBase {
+ public:
+  explicit MultipleServiceConnector(
+      TestConnectorFactory::NameToServiceMap services) {
+    for (auto& name_and_service : services) {
+      mojom::ServicePtr service_ptr;
+      const std::string& service_name = name_and_service.first;
+      AddService(service_name, std::move(name_and_service.second),
+                 &service_ptr);
+      service_ptrs_.insert(
+          std::make_pair(service_name, std::move(service_ptr)));
+    }
+  }
+
+ private:
+  using NameToServicePtrMap = std::map<std::string, mojom::ServicePtr>;
+
+  mojom::ServicePtr* GetServicePtr(const std::string& service_name) override {
+    NameToServicePtrMap::iterator it = service_ptrs_.find(service_name);
+    return it == service_ptrs_.end() ? nullptr : &(it->second);
+  }
+
+  NameToServicePtrMap service_ptrs_;
+
+  DISALLOW_COPY_AND_ASSIGN(MultipleServiceConnector);
 };
 
 }  // namespace
 
-TestConnectorFactory::TestConnectorFactory(std::unique_ptr<Service> service)
-    : source_identity_("TestConnectorFactory"),
-      impl_(std::make_unique<TestConnectorImpl>(this, std::move(service))) {}
+TestConnectorFactory::TestConnectorFactory(
+    std::unique_ptr<mojom::Connector> impl)
+    : impl_(std::move(impl)) {}
 
 TestConnectorFactory::~TestConnectorFactory() = default;
 
+// static
+std::unique_ptr<TestConnectorFactory>
+TestConnectorFactory::CreateForUniqueService(std::unique_ptr<Service> service) {
+  // Note that we are not using std::make_unique below so TestConnectorFactory's
+  // constructor can be kept private.
+  return std::unique_ptr<TestConnectorFactory>(new TestConnectorFactory(
+      std::make_unique<UniqueServiceConnector>(std::move(service))));
+}
+
+// static
+std::unique_ptr<TestConnectorFactory> TestConnectorFactory::CreateForServices(
+    NameToServiceMap services) {
+  return std::unique_ptr<TestConnectorFactory>(new TestConnectorFactory(
+      std::make_unique<MultipleServiceConnector>(std::move(services))));
+}
+
 std::unique_ptr<Connector> TestConnectorFactory::CreateConnector() {
   mojom::ConnectorPtr proxy;
   impl_->Clone(mojo::MakeRequest(&proxy));