Begin to wean child processes off reliance on a persistent service_manager::Connection to the brows…

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"
 
 namespace service_manager {
 
 namespace {
 void EmptyBindCallback(mojom::ConnectResult, const std::string&) {}
 }
 
 ConnectorImpl::ConnectorImpl(mojom::ConnectorPtrInfo unbound_state)
-    : unbound_state_(std::move(unbound_state)) {
+    : unbound_state_(std::move(unbound_state)), weak_factory_(this) {
   thread_checker_.DetachFromThread();
 }
 
 ConnectorImpl::ConnectorImpl(mojom::ConnectorPtr connector)
-    : connector_(std::move(connector)) {
+    : connector_(std::move(connector)), weak_factory_(this) {
   connector_.set_connection_error_handler(
       base::Bind(&ConnectorImpl::OnConnectionError, base::Unretained(this)));
 }
 
 ConnectorImpl::~ConnectorImpl() {}
 
 void ConnectorImpl::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   connector_.reset();
 }
@@ skipping 35 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;
+  }
+
   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,
+                                             const TestApi::Binder& binder) {
+  local_binder_overrides_[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()) {
     if (!unbound_state_.is_valid()) {
       // It's possible to get here when the link to the service manager has been
       // severed
       // (and so the connector pipe has been closed) but the app has chosen not
       // to quit.
       return false;
@@ skipping 10 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