Enable overriding interface binders for any services running in current process.

services/service_manager/public/cpp/service_context.cc

 // Copyright 2014 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 "services/service_manager/public/cpp/service_context.h"
 
 #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"
 #include "services/service_manager/public/cpp/service.h"
 
 namespace service_manager {
 
+namespace {
+
+using ServiceNameToBinderRegistryMap = std::map<std::string, BinderRegistry>;
+
+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.
+BinderRegistry* 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 BinderRegistry::Binder& binder,
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+  if (!g_overridden_binder_registries.Get()) {
+    g_overridden_binder_registries.Get() =
+        base::MakeUnique<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()) {

[Ken Rockot(use gerrit already), 2017/05/11 02:32:08]

nit: no {} necessary

[leonhsl(Using Gerrit), 2017/05/11 03:10:04]

Done.

+    return;
+  }
+
+  g_overridden_binder_registries.Get()->erase(service_name);
+}
+
 ServiceContext::ServiceContext(
     std::unique_ptr<service_manager::Service> service,
     mojom::ServiceRequest request,
     std::unique_ptr<Connector> connector,
     mojom::ConnectorRequest connector_request)
     : pending_connector_request_(std::move(connector_request)),
       service_(std::move(service)),
       binding_(this, std::move(request)),
       connector_(std::move(connector)),
       weak_factory_(this) {
@@ skipping 46 matching lines @@
 }
 
 void ServiceContext::OnBindInterface(
     const BindSourceInfo& source_info,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe,
     const OnBindInterfaceCallback& callback) {
   // Acknowledge the request regardless of whether it's accepted.
   callback.Run();
 
+  BinderRegistry* global_registry =
+      GetGlobalBinderRegistryForService(identity_.name());
+  if (global_registry && global_registry->CanBindInterface(interface_name)) {
+    // Just use the binder overridden globally.
+    global_registry->BindInterface(source_info, interface_name,
+                                   std::move(interface_pipe));
+    return;
+  }
   service_->OnBindInterface(source_info, interface_name,
                             std::move(interface_pipe));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ServiceContext, private:
 
 void ServiceContext::OnConnectionError() {
   if (service_->OnServiceManagerConnectionLost()) {
     // CAUTION: May delete |this|.
     QuitNow();
   }
 }
 
 }  // namespace service_manager