Move device service to new service APIs

Migrates device service code and tests from deprecated service APIs to
new ones. Namely this phases out its use of ServiceContext and
ServiceTest in favor of ServiceBinding and plain old unit tests.

Bug: 891780,906239
Change-Id: I7677134b5d11e7297b162bbb532dfabb810504d2
Reviewed-on: https://chromium-review.googlesource.com/c/1345124
Commit-Queue: Ken Rockot <rockot@google.com>
Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Colin Blundell <blundell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#611379}

chrome/browser/chromeos/login/bluetooth_host_pairing_browsertest.cc

@@ -20,7 +20,7 @@
 #include "services/device/public/cpp/hid/fake_input_service_linux.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/input_service.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace chromeos {
 
@@ -75,8 +75,8 @@ class BluetoothHostPairingNoInputTest : public OobeBaseTest {
     fake_input_service_manager_ =
         std::make_unique<device::FakeInputServiceLinux>();
 
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::InputDeviceManager::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&device::FakeInputServiceLinux::Bind,
                    base::Unretained(fake_input_service_manager_.get())));
 
@@ -95,8 +95,8 @@ class BluetoothHostPairingNoInputTest : public OobeBaseTest {
   }
 
   ~BluetoothHostPairingNoInputTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::InputDeviceManager>(device::mojom::kServiceName);
   }
 
   // OobeBaseTest override:

chrome/browser/chromeos/login/hid_detection_browsertest.cc

@@ -17,7 +17,7 @@
 #include "services/device/public/cpp/hid/fake_input_service_linux.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/input_service.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using content::BrowserThread;
@@ -51,15 +51,15 @@ class HidDetectionTest : public OobeBaseTest {
     fake_input_service_manager_ =
         std::make_unique<device::FakeInputServiceLinux>();
 
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::InputDeviceManager::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&device::FakeInputServiceLinux::Bind,
                    base::Unretained(fake_input_service_manager_.get())));
   }
 
   ~HidDetectionTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::InputDeviceManager>(device::mojom::kServiceName);
   }
 
   void SetUpInProcessBrowserTestFixture() override {

chrome/browser/chromeos/login/screens/hid_detection_screen_browsertest.cc

@@ -12,7 +12,7 @@
 #include "services/device/public/cpp/hid/fake_input_service_linux.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/input_service.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace chromeos {
 
@@ -23,15 +23,15 @@ class HIDDetectionScreenTest : public WizardInProcessBrowserTest {
     fake_input_service_manager_ =
         std::make_unique<device::FakeInputServiceLinux>();
 
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::InputDeviceManager::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&device::FakeInputServiceLinux::Bind,
                    base::Unretained(fake_input_service_manager_.get())));
   }
 
   ~HIDDetectionScreenTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::InputDeviceManager>(device::mojom::kServiceName);
   }
 
  protected:

content/browser/battery_monitor_browsertest.cc

@@ -16,7 +16,7 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/device/public/mojom/battery_monitor.mojom.h"
 #include "services/device/public/mojom/constants.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace content {
 
@@ -27,11 +27,9 @@ class MockBatteryMonitor : public device::mojom::BatteryMonitor {
   MockBatteryMonitor() : binding_(this) {}
   ~MockBatteryMonitor() override = default;
 
-  void Bind(const std::string& interface_name,
-            mojo::ScopedMessagePipeHandle handle,
-            const service_manager::BindSourceInfo& source_info) {
+  void Bind(device::mojom::BatteryMonitorRequest request) {
     DCHECK(!binding_.is_bound());
-    binding_.Bind(device::mojom::BatteryMonitorRequest(std::move(handle)));
+    binding_.Bind(std::move(request));
   }
 
   void DidChange(const device::mojom::BatteryStatus& battery_status) {
@@ -76,15 +74,15 @@ class BatteryMonitorTest : public ContentBrowserTest {
     // Because Device Service also runs in this process(browser process), here
     // we can directly set our binder to intercept interface requests against
     // it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::BatteryMonitor::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&MockBatteryMonitor::Bind,
                    base::Unretained(mock_battery_monitor_.get())));
   }
 
   ~BatteryMonitorTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::BatteryMonitor>(device::mojom::kServiceName);
   }
 
  protected:

content/browser/device_sensors/device_sensor_browsertest.cc

@@ -33,7 +33,7 @@
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/sensor.mojom.h"
 #include "services/device/public/mojom/sensor_provider.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace content {
 
@@ -47,15 +47,15 @@ class DeviceSensorBrowserTest : public ContentBrowserTest {
     // Because Device Service also runs in this process (browser process), here
     // we can directly set our binder to intercept interface requests against
     // it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::SensorProvider::Name_,
-        base::BindRepeating(&DeviceSensorBrowserTest::Bind,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
+        base::BindRepeating(&DeviceSensorBrowserTest::BindSensorProvider,
                             base::Unretained(this)));
   }
 
   ~DeviceSensorBrowserTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::SensorProvider>(device::mojom::kServiceName);
   }
 
   void SetUpOnMainThread() override {
@@ -104,11 +104,8 @@ class DeviceSensorBrowserTest : public ContentBrowserTest {
   std::unique_ptr<net::EmbeddedTestServer> https_embedded_test_server_;
 
  private:
-  void Bind(const std::string& interface_name,
-            mojo::ScopedMessagePipeHandle handle,
-            const service_manager::BindSourceInfo& source_info) {
-    sensor_provider_->Bind(
-        device::mojom::SensorProviderRequest(std::move(handle)));
+  void BindSensorProvider(device::mojom::SensorProviderRequest request) {
+    sensor_provider_->Bind(std::move(request));
   }
 };
 

content/browser/generic_sensor/generic_sensor_browsertest.cc

@@ -31,7 +31,7 @@
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/sensor.mojom.h"
 #include "services/device/public/mojom/sensor_provider.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace content {
 
@@ -48,16 +48,16 @@ class GenericSensorBrowserTest : public ContentBrowserTest {
     // Because Device Service also runs in this process (browser process), here
     // we can directly set our binder to intercept interface requests against
     // it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::SensorProvider::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::BindRepeating(
             &GenericSensorBrowserTest::BindSensorProviderRequest,
             base::Unretained(this)));
   }
 
   ~GenericSensorBrowserTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::SensorProvider>(device::mojom::kServiceName);
   }
 
   void SetUpOnMainThread() override {
@@ -78,10 +78,7 @@ class GenericSensorBrowserTest : public ContentBrowserTest {
     command_line->AppendSwitch(switches::kIgnoreCertificateErrors);
   }
 
-  void BindSensorProviderRequest(
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle handle,
-      const service_manager::BindSourceInfo& source_info) {
+  void BindSensorProviderRequest(device::mojom::SensorProviderRequest request) {
     if (!sensor_provider_available_)
       return;
 
@@ -90,8 +87,7 @@ class GenericSensorBrowserTest : public ContentBrowserTest {
       fake_sensor_provider_->SetAmbientLightSensorData(50);
     }
 
-    fake_sensor_provider_->Bind(
-        device::mojom::SensorProviderRequest(std::move(handle)));
+    fake_sensor_provider_->Bind(std::move(request));
   }
 
   void set_sensor_provider_available(bool sensor_provider_available) {

content/browser/power_monitor_browsertest.cc

@@ -26,7 +26,7 @@
 #include "mojo/public/cpp/bindings/interface_ptr_set.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/power_monitor.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace content {
 
@@ -98,20 +98,19 @@ class PowerMonitorTest : public ContentBrowserTest {
   PowerMonitorTest() {
     // Because Device Service also runs in this process(browser process), we can
     // set our binder to intercept requests for PowerMonitor interface to it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::PowerMonitor::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&PowerMonitorTest::BindPowerMonitor,
                    base::Unretained(this)));
   }
 
   ~PowerMonitorTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::PowerMonitor>(device::mojom::kServiceName);
   }
 
-  void BindPowerMonitor(const std::string& interface_name,
-                        mojo::ScopedMessagePipeHandle handle,
-                        const service_manager::BindSourceInfo& source_info) {
+  void BindPowerMonitor(const service_manager::BindSourceInfo& source_info,
+                        device::mojom::PowerMonitorRequest request) {
     if (source_info.identity.name() == mojom::kRendererServiceName) {
       // We can receive binding requests for the spare RenderProcessHost - this
       // might happen before the test has provided the
@@ -144,8 +143,7 @@ class PowerMonitorTest : public ContentBrowserTest {
         std::move(gpu_bound_closure_).Run();
     }
 
-    power_monitor_message_broadcaster_.Bind(
-        device::mojom::PowerMonitorRequest(std::move(handle)));
+    power_monitor_message_broadcaster_.Bind(std::move(request));
   }
 
  protected:

content/browser/service_manager/service_manager_context.cc

@@ -627,46 +627,6 @@ ServiceManagerContext::ServiceManagerContext(
       std::move(root_browser_service), mojo::MakeRequest(&pid_receiver));
   pid_receiver->SetPID(base::GetCurrentProcId());
 
-  service_manager::EmbeddedServiceInfo device_info;
-
-  // This task runner may be used by some device service implementation bits to
-  // interface with dbus client code, which in turn imposes some subtle thread
-  // affinity on the clients. We therefore require a single-thread runner.
-  scoped_refptr<base::SingleThreadTaskRunner> device_blocking_task_runner =
-      base::CreateSingleThreadTaskRunnerWithTraits(
-          {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
-
-#if defined(OS_ANDROID)
-  JNIEnv* env = base::android::AttachCurrentThread();
-  base::android::ScopedJavaGlobalRef<jobject> java_nfc_delegate;
-  java_nfc_delegate.Reset(Java_ContentNfcDelegate_create(env));
-  DCHECK(!java_nfc_delegate.is_null());
-
-  // See the comments on wake_lock_context_host.h, content_browser_client.h and
-  // ContentNfcDelegate.java respectively for comments on those parameters.
-  device_info.factory = base::Bind(
-      &device::CreateDeviceService, device_blocking_task_runner,
-      service_manager_thread_task_runner_,
-      base::MakeRefCounted<DeviceServiceURLLoaderFactory>(),
-      GetContentClient()->browser()->GetGeolocationApiKey(),
-      GetContentClient()->browser()->ShouldUseGmsCoreGeolocationProvider(),
-      base::Bind(&WakeLockContextHost::GetNativeViewForContext),
-      base::Bind(&ContentBrowserClient::OverrideSystemLocationProvider,
-                 base::Unretained(GetContentClient()->browser())),
-      std::move(java_nfc_delegate));
-#else
-  device_info.factory = base::Bind(
-      &device::CreateDeviceService, device_blocking_task_runner,
-      service_manager_thread_task_runner_,
-      base::MakeRefCounted<DeviceServiceURLLoaderFactory>(),
-      GetContentClient()->browser()->GetGeolocationApiKey(),
-      base::Bind(&ContentBrowserClient::OverrideSystemLocationProvider,
-                 base::Unretained(GetContentClient()->browser())));
-#endif
-  device_info.task_runner = base::ThreadTaskRunnerHandle::Get();
-  packaged_services_connection_->AddEmbeddedService(device::mojom::kServiceName,
-                                                    device_info);
-
   service_manager::EmbeddedServiceInfo resource_coordinator_info;
   resource_coordinator_info.factory =
       base::Bind(&resource_coordinator::ResourceCoordinatorService::Create);
@@ -884,6 +844,47 @@ ServiceManagerContext::GetAudioServiceRunner() {
 void ServiceManagerContext::OnUnhandledServiceRequest(
     const std::string& service_name,
     service_manager::mojom::ServiceRequest request) {
+  if (service_name == device::mojom::kServiceName) {
+    // This task runner may be used by some device service implementation bits
+    // to interface with dbus client code, which in turn imposes some subtle
+    // thread affinity on the clients. We therefore require a single-thread
+    // runner.
+    scoped_refptr<base::SingleThreadTaskRunner> device_blocking_task_runner =
+        base::CreateSingleThreadTaskRunnerWithTraits(
+            {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
+#if defined(OS_ANDROID)
+    JNIEnv* env = base::android::AttachCurrentThread();
+    base::android::ScopedJavaGlobalRef<jobject> java_nfc_delegate;
+    java_nfc_delegate.Reset(Java_ContentNfcDelegate_create(env));
+    DCHECK(!java_nfc_delegate.is_null());
+
+    // See the comments on wake_lock_context_host.h, content_browser_client.h
+    // and ContentNfcDelegate.java respectively for comments on those
+    // parameters.
+    auto service = device::CreateDeviceService(
+        device_blocking_task_runner, service_manager_thread_task_runner_,
+        base::MakeRefCounted<DeviceServiceURLLoaderFactory>(),
+        GetContentClient()->browser()->GetGeolocationApiKey(),
+        GetContentClient()->browser()->ShouldUseGmsCoreGeolocationProvider(),
+        base::BindRepeating(&WakeLockContextHost::GetNativeViewForContext),
+        base::BindRepeating(
+            &ContentBrowserClient::OverrideSystemLocationProvider,
+            base::Unretained(GetContentClient()->browser())),
+        std::move(java_nfc_delegate), std::move(request));
+#else
+    auto service = device::CreateDeviceService(
+        device_blocking_task_runner, service_manager_thread_task_runner_,
+        base::MakeRefCounted<DeviceServiceURLLoaderFactory>(),
+        GetContentClient()->browser()->GetGeolocationApiKey(),
+        base::BindRepeating(
+            &ContentBrowserClient::OverrideSystemLocationProvider,
+            base::Unretained(GetContentClient()->browser())),
+        std::move(request));
+#endif
+    service_manager::Service::RunUntilTermination(std::move(service));
+    return;
+  }
+
   GetContentClient()->browser()->HandleServiceRequest(service_name,
                                                       std::move(request));
 }

content/browser/vibration_browsertest.cc

@@ -17,7 +17,7 @@
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/vibration_manager.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace content {
 
@@ -30,22 +30,19 @@ class VibrationTest : public ContentBrowserTest,
     // Because Device Service also runs in this process(browser process), here
     // we can directly set our binder to intercept interface requests against
     // it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::VibrationManager::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&VibrationTest::BindVibrationManager,
                    base::Unretained(this)));
   }
 
   ~VibrationTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::VibrationManager>(device::mojom::kServiceName);
   }
 
-  void BindVibrationManager(
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle handle,
-      const service_manager::BindSourceInfo& source_info) {
-    binding_.Bind(device::mojom::VibrationManagerRequest(std::move(handle)));
+  void BindVibrationManager(device::mojom::VibrationManagerRequest request) {
+    binding_.Bind(std::move(request));
   }
 
  protected:

extensions/browser/api/hid/hid_apitest.cc

@@ -21,7 +21,7 @@
 #include "services/device/public/cpp/hid/hid_report_descriptor.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/hid.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 using base::ThreadTaskRunnerHandle;
 using device::HidReportDescriptor;
@@ -132,11 +132,8 @@ class FakeHidManager : public device::mojom::HidManager {
   FakeHidManager() {}
   ~FakeHidManager() override = default;
 
-  void Bind(const std::string& interface_name,
-            mojo::ScopedMessagePipeHandle handle,
-            const service_manager::BindSourceInfo& source_info) {
-    bindings_.AddBinding(this,
-                         device::mojom::HidManagerRequest(std::move(handle)));
+  void Bind(device::mojom::HidManagerRequest request) {
+    bindings_.AddBinding(this, std::move(request));
   }
 
   // device::mojom::HidManager implementation:
@@ -257,15 +254,15 @@ class HidApiTest : public ShellApiTest {
     // Because Device Service also runs in this process (browser process), we
     // can set our binder to intercept requests for HidManager interface to it.
     fake_hid_manager_ = std::make_unique<FakeHidManager>();
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::HidManager::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::Bind(&FakeHidManager::Bind,
                    base::Unretained(fake_hid_manager_.get())));
   }
 
   ~HidApiTest() override {
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::HidManager>(device::mojom::kServiceName);
   }
 
   void SetUpOnMainThread() override {

extensions/browser/api/serial/serial_apitest.cc

@@ -20,7 +20,7 @@
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/device/public/mojom/serial.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 // Disable SIMULATE_SERIAL_PORTS only if all the following are true:
@@ -197,21 +197,22 @@ class SerialApiTest : public ExtensionApiTest {
     // Because Device Service also runs in this process(browser process), we can
     // set our binder to intercept requests for
     // SerialDeviceEnumerator/SerialIoHandler interfaces to it.
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
         device::mojom::kServiceName,
-        device::mojom::SerialDeviceEnumerator::Name_,
         base::BindRepeating(&SerialApiTest::BindSerialDeviceEnumerator,
                             base::Unretained(this)));
-    service_manager::ServiceContext::SetGlobalBinderForTesting(
-        device::mojom::kServiceName, device::mojom::SerialIoHandler::Name_,
+    service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+        device::mojom::kServiceName,
         base::BindRepeating(&SerialApiTest::BindSerialIoHandler));
 #endif
   }
 
   ~SerialApiTest() override {
 #if SIMULATE_SERIAL_PORTS
-    service_manager::ServiceContext::ClearGlobalBindersForTesting(
-        device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::SerialDeviceEnumerator>(device::mojom::kServiceName);
+    service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+        device::mojom::SerialIoHandler>(device::mojom::kServiceName);
 #endif
   }
 
@@ -229,24 +230,18 @@ class SerialApiTest : public ExtensionApiTest {
 
  protected:
   void BindSerialDeviceEnumerator(
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle handle,
-      const service_manager::BindSourceInfo& source_info) {
+      device::mojom::SerialDeviceEnumeratorRequest request) {
     if (fail_enumerator_request_)
       return;
 
-    mojo::MakeStrongBinding(
-        std::make_unique<FakeSerialDeviceEnumerator>(),
-        device::mojom::SerialDeviceEnumeratorRequest(std::move(handle)));
+    mojo::MakeStrongBinding(std::make_unique<FakeSerialDeviceEnumerator>(),
+                            std::move(request));
   }
 
   static void BindSerialIoHandler(
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle handle,
-      const service_manager::BindSourceInfo& source_info) {
-    mojo::MakeStrongBinding(
-        std::make_unique<FakeSerialIoHandler>(),
-        device::mojom::SerialIoHandlerRequest(std::move(handle)));
+      device::mojom::SerialIoHandlerRequest request) {
+    mojo::MakeStrongBinding(std::make_unique<FakeSerialIoHandler>(),
+                            std::move(request));
   }
 
   bool fail_enumerator_request_ = false;

services/BUILD.gn

@@ -95,7 +95,6 @@ catalog("services_unittests_catalog") {
 
   if (!is_ios) {
     catalog_deps += [
-      "//services/device:tests_catalog",
       "//services/preferences:tests_catalog",
       "//services/resource_coordinator:tests_catalog",
       "//services/tracing:tests_catalog",

services/device/BUILD.gn

@@ -3,8 +3,6 @@
 # found in the LICENSE file.
 
 import("//build/config/features.gni")
-import("//services/catalog/public/tools/catalog.gni")
-import("//services/service_manager/public/cpp/service.gni")
 import("//services/service_manager/public/service_manifest.gni")
 
 if (is_android) {
@@ -219,17 +217,6 @@ service_manifest("manifest") {
   source = "manifest.json"
 }
 
-service_manifest("unittest_manifest") {
-  name = "device_unittests"
-  source = "unittest_manifest.json"
-  packaged_services = [ ":manifest" ]
-}
-
-catalog("tests_catalog") {
-  testonly = true
-  embedded_services = [ ":unittest_manifest" ]
-}
-
 source_set("test_support") {
   testonly = true
 
@@ -249,7 +236,8 @@ source_set("test_support") {
     "//services/device/public/mojom:constants",
     "//services/network:test_support",
     "//services/service_manager/public/cpp",
-    "//services/service_manager/public/cpp:service_test_support",
+    "//services/service_manager/public/cpp/test:test_support",
+    "//testing/gtest",
   ]
 }
 

services/device/OWNERS

@@ -8,5 +8,3 @@ rockot@google.com
 per-file manifest.json=set noparent
 per-file manifest.json=file://ipc/SECURITY_OWNERS
 
-per-file unittest_manifest.json=set noparent
-per-file unittest_manifest.json=file://ipc/SECURITY_OWNERS

services/device/device_service.cc

@@ -47,7 +47,7 @@
 namespace device {
 
 #if defined(OS_ANDROID)
-std::unique_ptr<service_manager::Service> CreateDeviceService(
+std::unique_ptr<DeviceService> CreateDeviceService(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
@@ -55,28 +55,30 @@ std::unique_ptr<service_manager::Service> CreateDeviceService(
     bool use_gms_core_location_provider,
     const WakeLockContextCallback& wake_lock_context_callback,
     const CustomLocationProviderCallback& custom_location_provider_callback,
-    const base::android::JavaRef<jobject>& java_nfc_delegate) {
+    const base::android::JavaRef<jobject>& java_nfc_delegate,
+    service_manager::mojom::ServiceRequest request) {
   GeolocationProviderImpl::SetGeolocationConfiguration(
       url_loader_factory, geolocation_api_key,
       custom_location_provider_callback, use_gms_core_location_provider);
   return std::make_unique<DeviceService>(
       std::move(file_task_runner), std::move(io_task_runner),
       std::move(url_loader_factory), geolocation_api_key,
-      wake_lock_context_callback, java_nfc_delegate);
+      wake_lock_context_callback, java_nfc_delegate, std::move(request));
 }
 #else
-std::unique_ptr<service_manager::Service> CreateDeviceService(
+std::unique_ptr<DeviceService> CreateDeviceService(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     const std::string& geolocation_api_key,
-    const CustomLocationProviderCallback& custom_location_provider_callback) {
+    const CustomLocationProviderCallback& custom_location_provider_callback,
+    service_manager::mojom::ServiceRequest request) {
   GeolocationProviderImpl::SetGeolocationConfiguration(
       url_loader_factory, geolocation_api_key,
       custom_location_provider_callback);
   return std::make_unique<DeviceService>(
       std::move(file_task_runner), std::move(io_task_runner),
-      std::move(url_loader_factory), geolocation_api_key);
+      std::move(url_loader_factory), geolocation_api_key, std::move(request));
 }
 #endif
 
@@ -87,8 +89,10 @@ DeviceService::DeviceService(
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     const std::string& geolocation_api_key,
     const WakeLockContextCallback& wake_lock_context_callback,
-    const base::android::JavaRef<jobject>& java_nfc_delegate)
-    : file_task_runner_(std::move(file_task_runner)),
+    const base::android::JavaRef<jobject>& java_nfc_delegate,
+    service_manager::mojom::ServiceRequest request)
+    : service_binding_(this, std::move(request)),
+      file_task_runner_(std::move(file_task_runner)),
       io_task_runner_(std::move(io_task_runner)),
       url_loader_factory_(std::move(url_loader_factory)),
       geolocation_api_key_(geolocation_api_key),
@@ -101,8 +105,10 @@ DeviceService::DeviceService(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-    const std::string& geolocation_api_key)
-    : file_task_runner_(std::move(file_task_runner)),
+    const std::string& geolocation_api_key,
+    service_manager::mojom::ServiceRequest request)
+    : service_binding_(this, std::move(request)),
+      file_task_runner_(std::move(file_task_runner)),
       io_task_runner_(std::move(io_task_runner)),
       url_loader_factory_(std::move(url_loader_factory)),
       geolocation_api_key_(geolocation_api_key) {}

services/device/device_service.h

@@ -34,6 +34,8 @@
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/cpp/service.h"
+#include "services/service_manager/public/cpp/service_binding.h"
+#include "services/service_manager/public/mojom/service.mojom.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/scoped_java_ref.h"
@@ -64,6 +66,7 @@ namespace device {
 class HidManagerImpl;
 #endif
 
+class DeviceService;
 class PowerMonitorMessageBroadcaster;
 class PublicIpAddressLocationNotifier;
 class TimeZoneMonitor;
@@ -72,7 +75,7 @@ class TimeZoneMonitor;
 // NOTE: See the comments on the definitions of PublicIpAddressLocationNotifier,
 // |WakeLockContextCallback|, |CustomLocationProviderCallback| and
 // NFCDelegate.java to understand the semantics and usage of these parameters.
-std::unique_ptr<service_manager::Service> CreateDeviceService(
+std::unique_ptr<DeviceService> CreateDeviceService(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
@@ -80,14 +83,16 @@ std::unique_ptr<service_manager::Service> CreateDeviceService(
     bool use_gms_core_location_provider,
     const WakeLockContextCallback& wake_lock_context_callback,
     const CustomLocationProviderCallback& custom_location_provider_callback,
-    const base::android::JavaRef<jobject>& java_nfc_delegate);
+    const base::android::JavaRef<jobject>& java_nfc_delegate,
+    service_manager::mojom::ServiceRequest request);
 #else
-std::unique_ptr<service_manager::Service> CreateDeviceService(
+std::unique_ptr<DeviceService> CreateDeviceService(
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     const std::string& geolocation_api_key,
-    const CustomLocationProviderCallback& custom_location_provider_callback);
+    const CustomLocationProviderCallback& custom_location_provider_callback,
+    service_manager::mojom::ServiceRequest request);
 #endif
 
 class DeviceService : public service_manager::Service {
@@ -99,13 +104,15 @@ class DeviceService : public service_manager::Service {
       scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       const std::string& geolocation_api_key,
       const WakeLockContextCallback& wake_lock_context_callback,
-      const base::android::JavaRef<jobject>& java_nfc_delegate);
+      const base::android::JavaRef<jobject>& java_nfc_delegate,
+      service_manager::mojom::ServiceRequest request);
 #else
   DeviceService(
       scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-      const std::string& geolocation_api_key);
+      const std::string& geolocation_api_key,
+      service_manager::mojom::ServiceRequest request);
 #endif
   ~DeviceService() override;
 
@@ -159,6 +166,8 @@ class DeviceService : public service_manager::Service {
 
   void BindUsbDeviceManagerRequest(mojom::UsbDeviceManagerRequest request);
 
+  service_manager::ServiceBinding service_binding_;
+
   std::unique_ptr<PowerMonitorMessageBroadcaster>
       power_monitor_message_broadcaster_;
   std::unique_ptr<PublicIpAddressGeolocationProvider>

services/device/device_service_test_base.cc

@@ -23,98 +23,48 @@ namespace device {
 
 namespace {
 
-const char kTestServiceName[] = "device_unittests";
-
 // Simply return a nullptr which means no CustomLocationProvider from embedder.
 std::unique_ptr<LocationProvider> GetCustomLocationProviderForTest() {
   return nullptr;
 }
 
-// The test service responsible to package Device Service.
-class ServiceTestClient : public service_manager::test::ServiceTestClient,
-                          public service_manager::mojom::ServiceFactory {
- public:
-  explicit ServiceTestClient(
-      service_manager::test::ServiceTest* test,
-      scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-      scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory)
-      : service_manager::test::ServiceTestClient(test),
-        file_task_runner_(std::move(file_task_runner)),
-        io_task_runner_(std::move(io_task_runner)),
-        url_loader_factory_(std::move(url_loader_factory)) {
-    registry_.AddInterface<service_manager::mojom::ServiceFactory>(
-        base::Bind(&ServiceTestClient::Create, base::Unretained(this)));
-  }
-  ~ServiceTestClient() override {}
-
- protected:
-  void OnBindInterface(const service_manager::BindSourceInfo& source_info,
-                       const std::string& interface_name,
-                       mojo::ScopedMessagePipeHandle interface_pipe) override {
-    registry_.BindInterface(interface_name, std::move(interface_pipe));
-  }
-
-  void CreateService(
-      service_manager::mojom::ServiceRequest request,
-      const std::string& name,
-      service_manager::mojom::PIDReceiverPtr pid_receiver) override {
-    if (name == device::mojom::kServiceName) {
+std::unique_ptr<DeviceService> CreateTestDeviceService(
+    scoped_refptr<base::SingleThreadTaskRunner> file_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
+    service_manager::mojom::ServiceRequest request) {
 #if defined(OS_ANDROID)
-      device_service_context_.reset(new service_manager::ServiceContext(
-          CreateDeviceService(
-              file_task_runner_, io_task_runner_, url_loader_factory_,
-              kTestGeolocationApiKey, false, wake_lock_context_callback_,
-              base::BindRepeating(&GetCustomLocationProviderForTest), nullptr),
-          std::move(request)));
+  return CreateDeviceService(
+      file_task_runner, io_task_runner, url_loader_factory,
+      kTestGeolocationApiKey, false, WakeLockContextCallback(),
+      base::BindRepeating(&GetCustomLocationProviderForTest), nullptr,
+      std::move(request));
 #else
-      device_service_context_.reset(new service_manager::ServiceContext(
-          CreateDeviceService(
-              file_task_runner_, io_task_runner_, url_loader_factory_,
-              kTestGeolocationApiKey,
-              base::BindRepeating(&GetCustomLocationProviderForTest)),
-          std::move(request)));
+  return CreateDeviceService(
+      file_task_runner, io_task_runner, url_loader_factory,
+      kTestGeolocationApiKey,
+      base::BindRepeating(&GetCustomLocationProviderForTest),
+      std::move(request));
 #endif
-    }
-  }
-
-  void Create(service_manager::mojom::ServiceFactoryRequest request) {
-    service_factory_bindings_.AddBinding(this, std::move(request));
-  }
-
- private:
-  service_manager::BinderRegistry registry_;
-  mojo::BindingSet<service_manager::mojom::ServiceFactory>
-      service_factory_bindings_;
-  std::unique_ptr<service_manager::ServiceContext> device_service_context_;
-  const scoped_refptr<base::SingleThreadTaskRunner> file_task_runner_;
-  const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
-  const scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
-
-  WakeLockContextCallback wake_lock_context_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(ServiceTestClient);
-};
+}
 
 }  // namespace
 
 DeviceServiceTestBase::DeviceServiceTestBase()
-    : ServiceTest(kTestServiceName),
-      file_thread_("DeviceServiceTestFileThread"),
-      io_thread_("DeviceServiceTestIOThread") {
+    : file_thread_("DeviceServiceTestFileThread"),
+      io_thread_("DeviceServiceTestIOThread"),
+      connector_(test_connector_factory_.CreateConnector()) {
   file_thread_.Start();
   io_thread_.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
-}
 
-DeviceServiceTestBase::~DeviceServiceTestBase() {}
-
-std::unique_ptr<service_manager::Service>
-DeviceServiceTestBase::CreateService() {
-  return std::make_unique<ServiceTestClient>(
-      this, file_thread_.task_runner(), io_thread_.task_runner(),
+  service_ = CreateTestDeviceService(
+      file_thread_.task_runner(), io_thread_.task_runner(),
       base::MakeRefCounted<network::WeakWrapperSharedURLLoaderFactory>(
-          &test_url_loader_factory_));
+          &test_url_loader_factory_),
+      test_connector_factory_.RegisterInstance(mojom::kServiceName));
 }
 
+DeviceServiceTestBase::~DeviceServiceTestBase() = default;
+
 }  // namespace device

services/device/device_service_test_base.h

@@ -6,28 +6,36 @@
 #define SERVICES_DEVICE_DEVICE_SERVICE_TEST_BASE_H_
 
 #include "base/macros.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread.h"
 #include "services/network/test/test_url_loader_factory.h"
-#include "services/service_manager/public/cpp/service_test.h"
+#include "services/service_manager/public/cpp/test/test_connector_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace device {
 
+class DeviceService;
+
 const char kTestGeolocationApiKey[] = "FakeApiKeyForTest";
 
 // Base class responsible to setup Device Service for test.
-class DeviceServiceTestBase : public service_manager::test::ServiceTest {
+class DeviceServiceTestBase : public testing::Test {
  public:
   DeviceServiceTestBase();
   ~DeviceServiceTestBase() override;
 
  protected:
+  service_manager::Connector* connector() { return connector_.get(); }
+
+  base::test::ScopedTaskEnvironment task_environment_;
   base::Thread file_thread_;
   base::Thread io_thread_;
   network::TestURLLoaderFactory test_url_loader_factory_;
 
  private:
-  // service_manager::test::ServiceTest:
-  std::unique_ptr<service_manager::Service> CreateService() override;
+  service_manager::TestConnectorFactory test_connector_factory_;
+  std::unique_ptr<service_manager::Connector> connector_;
+  std::unique_ptr<DeviceService> service_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceServiceTestBase);
 };

services/device/public/cpp/hid/fake_input_service_linux.cc

@@ -32,12 +32,8 @@ void FakeInputServiceLinux::GetDevices(GetDevicesCallback callback) {
   std::move(callback).Run(std::move(devices));
 }
 
-void FakeInputServiceLinux::Bind(
-    const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle handle,
-    const service_manager::BindSourceInfo& source_info) {
-  bindings_.AddBinding(this,
-                       mojom::InputDeviceManagerRequest(std::move(handle)));
+void FakeInputServiceLinux::Bind(mojom::InputDeviceManagerRequest request) {
+  bindings_.AddBinding(this, std::move(request));
 }
 
 void FakeInputServiceLinux::AddDevice(mojom::InputDeviceInfoPtr info) {

services/device/public/cpp/hid/fake_input_service_linux.h

@@ -28,9 +28,7 @@ class FakeInputServiceLinux : public mojom::InputDeviceManager {
       GetDevicesCallback callback) override;
   void GetDevices(GetDevicesCallback callback) override;
 
-  void Bind(const std::string& interface_name,
-            mojo::ScopedMessagePipeHandle handle,
-            const service_manager::BindSourceInfo& source_info);
+  void Bind(mojom::InputDeviceManagerRequest request);
   void AddDevice(mojom::InputDeviceInfoPtr info);
   void RemoveDevice(const std::string& id);
 

services/device/public/cpp/test/scoped_geolocation_overrider.cc

@@ -7,7 +7,7 @@
 #include "services/device/public/cpp/geolocation/geoposition.h"
 #include "services/device/public/cpp/test/scoped_geolocation_overrider.h"
 #include "services/device/public/mojom/constants.mojom.h"
-#include "services/service_manager/public/cpp/service_context.h"
+#include "services/service_manager/public/cpp/service_binding.h"
 
 namespace device {
 
@@ -23,10 +23,7 @@ class ScopedGeolocationOverrider::FakeGeolocationContext
   void UpdateLocation(const mojom::Geoposition& position);
   const mojom::Geoposition& GetGeoposition() const;
 
-  void BindForOverrideService(
-      const std::string& interface_name,
-      mojo::ScopedMessagePipeHandle handle,
-      const service_manager::BindSourceInfo& source_info);
+  void BindForOverrideService(mojom::GeolocationContextRequest request);
 
   // mojom::GeolocationContext implementation:
   void BindGeolocation(mojom::GeolocationRequest request) override;
@@ -77,15 +74,15 @@ ScopedGeolocationOverrider::ScopedGeolocationOverrider(double latitude,
 }
 
 ScopedGeolocationOverrider::~ScopedGeolocationOverrider() {
-  service_manager::ServiceContext::ClearGlobalBindersForTesting(
-      mojom::kServiceName);
+  service_manager::ServiceBinding::ClearInterfaceBinderOverrideForTesting<
+      mojom::GeolocationContext>(mojom::kServiceName);
 }
 
 void ScopedGeolocationOverrider::OverrideGeolocation(
     const mojom::Geoposition& position) {
   geolocation_context_ = std::make_unique<FakeGeolocationContext>(position);
-  service_manager::ServiceContext::SetGlobalBinderForTesting(
-      mojom::kServiceName, mojom::GeolocationContext::Name_,
+  service_manager::ServiceBinding::OverrideInterfaceBinderForTesting(
+      mojom::kServiceName,
       base::BindRepeating(&FakeGeolocationContext::BindForOverrideService,
                           base::Unretained(geolocation_context_.get())));
 }
@@ -139,11 +136,8 @@ ScopedGeolocationOverrider::FakeGeolocationContext::GetGeoposition() const {
 }
 
 void ScopedGeolocationOverrider::FakeGeolocationContext::BindForOverrideService(
-    const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle handle,
-    const service_manager::BindSourceInfo& source_info) {
-  context_bindings_.AddBinding(
-      this, mojom::GeolocationContextRequest(std::move(handle)));
+    mojom::GeolocationContextRequest request) {
+  context_bindings_.AddBinding(this, std::move(request));
 }
 
 void ScopedGeolocationOverrider::FakeGeolocationContext::BindGeolocation(

services/device/unittest_manifest.json

-{
-  "name": "device_unittests",
-  "display_name": "Device Service Unittests",
-  "interface_provider_specs": {
-    "service_manager:connector": {
-      "provides": {
-        "service_manager:service_factory": [
-          "service_manager.mojom.ServiceFactory"
-        ]
-      },
-      "requires": {
-        "device": [
-          "device:bluetooth_system",
-          "device:battery_monitor",
-          "device:generic_sensor",
-          "device:geolocation_config",
-          "device:geolocation_control",
-          "device:geolocation",
-          "device:hid",
-          "device:power_monitor",
-          "device:serial",
-          "device:vibration",
-          "device:wake_lock"
-        ]
-      }
-    }
-  }
-}

services/service_manager/public/cpp/service_binding.cc

@@ -162,7 +162,7 @@ void ServiceBinding::OnBindInterface(
   auto override =
       GetBinderOverrides().GetOverride(identity_.name(), interface_name);
   if (override) {
-    override.Run(std::move(interface_pipe));
+    override.Run(source_info, std::move(interface_pipe));
     return;
   }
 

services/service_manager/public/cpp/service_binding.h

@@ -101,7 +101,8 @@ class COMPONENT_EXPORT(SERVICE_MANAGER_CPP) ServiceBinding
   // targeting any instance of the service |service_name| running in the calling
   // process. Prefer the template helpers for clarity.
   using BinderForTesting =
-      base::RepeatingCallback<void(mojo::ScopedMessagePipeHandle)>;
+      base::RepeatingCallback<void(const BindSourceInfo&,
+                                   mojo::ScopedMessagePipeHandle)>;
   static void OverrideInterfaceBinderForTesting(
       const std::string& service_name,
       const std::string& interface_name,
@@ -111,21 +112,40 @@ class COMPONENT_EXPORT(SERVICE_MANAGER_CPP) ServiceBinding
       const std::string& interface_name);
 
   template <typename Interface>
-  using TypedBinderForTesting =
-      base::RepeatingCallback<void(mojo::InterfaceRequest<Interface>)>;
+  using TypedBinderWithInfoForTesting =
+      base::RepeatingCallback<void(const BindSourceInfo&,
+                                   mojo::InterfaceRequest<Interface>)>;
   template <typename Interface>
   static void OverrideInterfaceBinderForTesting(
       const std::string& service_name,
-      const TypedBinderForTesting<Interface>& binder) {
+      const TypedBinderWithInfoForTesting<Interface>& binder) {
     ServiceBinding::OverrideInterfaceBinderForTesting(
         service_name, Interface::Name_,
         base::BindRepeating(
-            [](const TypedBinderForTesting<Interface>& binder,
-               mojo::ScopedMessagePipeHandle pipe) {
-              binder.Run(mojo::InterfaceRequest<Interface>(std::move(pipe)));
+            [](const TypedBinderWithInfoForTesting<Interface>& binder,
+               const BindSourceInfo& info, mojo::ScopedMessagePipeHandle pipe) {
+              binder.Run(info,
+                         mojo::InterfaceRequest<Interface>(std::move(pipe)));
             },
             binder));
   }
+  template <typename Interface>
+  using TypedBinderForTesting =
+      base::RepeatingCallback<void(mojo::InterfaceRequest<Interface>)>;
+  template <typename Interface>
+  static void OverrideInterfaceBinderForTesting(
+      const std::string& service_name,
+      const TypedBinderForTesting<Interface>& binder) {
+    ServiceBinding::OverrideInterfaceBinderForTesting(
+        service_name, base::BindRepeating(
+                          [](const TypedBinderForTesting<Interface>& binder,
+                             const BindSourceInfo& info,
+                             mojo::InterfaceRequest<Interface> request) {
+                            binder.Run(std::move(request));
+                          },
+                          binder));
+  }
+
   template <typename Interface>
   static void ClearInterfaceBinderOverrideForTesting(
       const std::string& service_name) {

services/service_manager/public/cpp/service_context.cc

@@ -7,7 +7,6 @@
 #include <utility>
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -15,58 +14,6 @@
 
 namespace service_manager {
 
-namespace {
-
-using ServiceNameToBinderRegistryMap =
-    std::map<std::string, BinderRegistryWithArgs<const BindSourceInfo&>>;
-
-base::LazyInstance<std::unique_ptr<ServiceNameToBinderRegistryMap>>::Leaky
-    g_overridden_binder_registries = LAZY_INSTANCE_INITIALIZER;
-
-// Returns the overridden binder registry which intercepts interface bind
-// requests to all |service_name| service instances, returns nullptr if no such
-// one.
-BinderRegistryWithArgs<const BindSourceInfo&>*
-GetGlobalBinderRegistryForService(const std::string& service_name) {
-  const auto& registries = g_overridden_binder_registries.Get();
-  if (registries) {
-    auto it = registries->find(service_name);
-    if (it != registries->end())
-      return &it->second;
-  }
-
-  return nullptr;
-}
-
-}  // namespace
-
-////////////////////////////////////////////////////////////////////////////////
-// ServiceContext, public:
-
-// static
-void ServiceContext::SetGlobalBinderForTesting(
-    const std::string& service_name,
-    const std::string& interface_name,
-    const BinderRegistryWithArgs<const BindSourceInfo&>::Binder& binder,
-    const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
-  if (!g_overridden_binder_registries.Get()) {
-    g_overridden_binder_registries.Get() =
-        std::make_unique<ServiceNameToBinderRegistryMap>();
-  }
-
-  (*g_overridden_binder_registries.Get())[service_name].AddInterface(
-      interface_name, binder, task_runner);
-}
-
-// static
-void ServiceContext::ClearGlobalBindersForTesting(
-    const std::string& service_name) {
-  if (!g_overridden_binder_registries.Get())
-    return;
-
-  g_overridden_binder_registries.Get()->erase(service_name);
-}
-
 ServiceContext::ServiceContext(
     std::unique_ptr<service_manager::Service> service,
     mojom::ServiceRequest request,
@@ -137,14 +84,6 @@ void ServiceContext::OnBindInterface(
     OnBindInterfaceCallback callback) {
   // Acknowledge the request regardless of whether it's accepted.
   std::move(callback).Run();
-
-  BinderRegistryWithArgs<const BindSourceInfo&>* global_registry =
-      GetGlobalBinderRegistryForService(identity_.name());
-  if (global_registry && global_registry->TryBindInterface(
-                             interface_name, &interface_pipe, source_info)) {
-    // Just use the binder overridden globally.
-    return;
-  }
   service_->OnBindInterface(source_info, interface_name,
                             std::move(interface_pipe));
 }

services/service_manager/public/cpp/service_context.h

@@ -109,20 +109,6 @@ class SERVICE_MANAGER_PUBLIC_CPP_EXPORT ServiceContext : public mojom::Service {
   // disconnection from the Service Manager.
   void QuitNow();
 
-  // Overrides the interface binder for |interface_name| of |service_name|.
-  // This is a process-wide override, meaning that |binder| can intercept
-  // requests against only those |service_name| service instances running in the
-  // same process with caller of this function.
-  static void SetGlobalBinderForTesting(
-      const std::string& service_name,
-      const std::string& interface_name,
-      const BinderRegistryWithArgs<const BindSourceInfo&>::Binder& binder,
-      const scoped_refptr<base::SequencedTaskRunner>& task_runner = nullptr);
-
-  // Clears all overridden interface binders for service |service_name| set via
-  // SetGlobalBinderForTesting().
-  static void ClearGlobalBindersForTesting(const std::string& service_name);
-
  private:
   friend class service_manager::Service;