Use public Service Manager Connector API in Blink

services/service_manager/public/cpp/lib/connector_impl.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 "services/service_manager/public/cpp/lib/connector_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "services/service_manager/public/cpp/lib/connection_impl.h"
 
@@ skipping 58 matching lines @@
   return std::move(connection);
 }
 
 void ConnectorImpl::BindInterface(
     const Identity& target,
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   if (!BindConnectorIfNecessary())
     return;
 
-  if (!local_binder_overrides_.empty() &&
-      local_binder_overrides_.count(interface_name)) {
-    local_binder_overrides_[interface_name].Run(std::move(interface_pipe));
-    return;
+  auto service_overrides_iter = local_binder_overrides_.find(target.name());
+  if (service_overrides_iter != local_binder_overrides_.end()) {
+    auto override_iter = service_overrides_iter->second.find(interface_name);
+    if (override_iter != service_overrides_iter->second.end()) {
+      override_iter->second.Run(std::move(interface_pipe));
+      return;
+    }
   }
 
   connector_->BindInterface(target, interface_name, std::move(interface_pipe),
                             base::Bind(&EmptyBindCallback));
 }
 
 std::unique_ptr<Connector> ConnectorImpl::Clone() {
   if (!BindConnectorIfNecessary())
     return nullptr;
 
   mojom::ConnectorPtr connector;
   mojom::ConnectorRequest request(&connector);
   connector_->Clone(std::move(request));
   return base::MakeUnique<ConnectorImpl>(connector.PassInterface());
 }
 
 void ConnectorImpl::BindConnectorRequest(mojom::ConnectorRequest request) {
   if (!BindConnectorIfNecessary())
     return;
   connector_->Clone(std::move(request));
 }
 
 base::WeakPtr<Connector> ConnectorImpl::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
-void ConnectorImpl::OverrideBinderForTesting(const std::string& interface_name,
+void ConnectorImpl::OverrideBinderForTesting(const std::string& service_name,
+                                             const std::string& interface_name,
                                              const TestApi::Binder& binder) {
-  local_binder_overrides_[interface_name] = binder;
+  local_binder_overrides_[service_name][interface_name] = binder;
 }
 
 void ConnectorImpl::ClearBinderOverrides() {
   local_binder_overrides_.clear();
 }
 
 bool ConnectorImpl::BindConnectorIfNecessary() {
   // Bind this object to the current thread the first time it is used to
   // connect.
   if (!connector_.is_bound()) {
@@ skipping 16 matching lines @@
   return true;
 }
 
 std::unique_ptr<Connector> Connector::Create(mojom::ConnectorRequest* request) {
   mojom::ConnectorPtr proxy;
   *request = mojo::MakeRequest(&proxy);
   return base::MakeUnique<ConnectorImpl>(proxy.PassInterface());
 }
 
 }  // namespace service_manager