Add ability to bind a different InterfaceRegistry/InterfaceProvider to an incoming Connection.

services/shell/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/shell/public/cpp/lib/connector_impl.h"
 
 #include "base/memory/ptr_util.h"
 #include "services/shell/public/cpp/identity.h"
 #include "services/shell/public/cpp/lib/connection_impl.h"
 
@@ skipping 42 matching lines @@
   // a position to know who we're talking to.
   CapabilityRequest request;
   request.interfaces.insert("*");
   mojom::InterfaceProviderPtr local_interfaces;
   mojom::InterfaceProviderRequest local_request = GetProxy(&local_interfaces);
   mojom::InterfaceProviderPtr remote_interfaces;
   mojom::InterfaceProviderRequest remote_request = GetProxy(&remote_interfaces);
   std::unique_ptr<internal::ConnectionImpl> registry(
       new internal::ConnectionImpl(
           params->target().name(), params->target(), mojom::kInvalidInstanceID,
-          std::move(remote_interfaces), std::move(local_request), request,
-          Connection::State::PENDING));
+          request, Connection::State::PENDING));
+  if (params->exposed_interfaces()) {
+    params->exposed_interfaces()->Bind(std::move(local_request));
+    registry->set_exposed_interfaces(params->exposed_interfaces());
+  } else {
+    std::unique_ptr<InterfaceRegistry> exposed_interfaces(
+        new InterfaceRegistry(registry.get()));
+    exposed_interfaces->Bind(std::move(local_request));
+    registry->SetExposedInterfaces(std::move(exposed_interfaces));
+  }
+  if (params->remote_interfaces()) {
+    params->remote_interfaces()->Bind(std::move(remote_interfaces));
+    registry->set_remote_interfaces(params->remote_interfaces());
+  } else {
+    std::unique_ptr<InterfaceProvider> remote_interface_provider(
+        new InterfaceProvider);
+    remote_interface_provider->Bind(std::move(remote_interfaces));
+    registry->SetRemoteInterfaces(std::move(remote_interface_provider));
+  }
 
   mojom::ShellClientPtr shell_client;
   mojom::PIDReceiverRequest pid_receiver_request;
   params->TakeClientProcessConnection(&shell_client, &pid_receiver_request);
   mojom::ClientProcessConnectionPtr client_process_connection;
   if (shell_client.is_bound() && pid_receiver_request.is_pending()) {
     client_process_connection = mojom::ClientProcessConnection::New();
     client_process_connection->shell_client =
         shell_client.PassInterface().PassHandle();
     client_process_connection->pid_receiver_request =
@@ skipping 10 matching lines @@
   return std::move(registry);
 }
 
 std::unique_ptr<Connector> ConnectorImpl::Clone() {
   mojom::ConnectorPtr connector;
   connector_->Clone(GetProxy(&connector));
   return base::WrapUnique(new ConnectorImpl(connector.PassInterface()));
 }
 
 }  // namespace shell