Eliminate outgoing InterfaceProvider

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 34 matching lines @@
   if (!BindIfNecessary())
     return nullptr;
 
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(params);
 
   // We allow all interfaces on outgoing connections since we are presumably in
   // 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(
+  std::unique_ptr<internal::ConnectionImpl> connection(
       new internal::ConnectionImpl(
           params->target().name(), params->target(), mojom::kInvalidInstanceID,
           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());
+    connection->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));
+    connection->SetRemoteInterfaces(std::move(remote_interface_provider));
   }
 
   mojom::ServicePtr service;
   mojom::PIDReceiverRequest pid_receiver_request;
   params->TakeClientProcessConnection(&service, &pid_receiver_request);
   mojom::ClientProcessConnectionPtr client_process_connection;
   if (service.is_bound() && pid_receiver_request.is_pending()) {
     client_process_connection = mojom::ClientProcessConnection::New();
     client_process_connection->service =
         service.PassInterface().PassHandle();
     client_process_connection->pid_receiver_request =
         pid_receiver_request.PassMessagePipe();
   } else if (service.is_bound() || pid_receiver_request.is_pending()) {
     NOTREACHED() << "If one of service or pid_receiver_request is valid, "
                  << "both must be valid.";
-    return std::move(registry);
+    return std::move(connection);
   }
   connector_->Connect(mojom::Identity::From(params->target()),
-                      std::move(remote_request), std::move(local_interfaces),
+                      std::move(remote_request),
                       std::move(client_process_connection),
-                      registry->GetConnectCallback());
-  return std::move(registry);
+                      connection->GetConnectCallback());
+  return std::move(connection);
 }
 
 std::unique_ptr<Connector> ConnectorImpl::Clone() {
   if (!BindIfNecessary())
     return nullptr;
 
   mojom::ConnectorPtr connector;
   mojom::ConnectorRequest request = GetProxy(&connector);
   connector_->Clone(std::move(request));
   return base::MakeUnique<ConnectorImpl>(connector.PassInterface());
@@ skipping 21 matching lines @@
   return true;
 }
 
 std::unique_ptr<Connector> Connector::Create(mojom::ConnectorRequest* request) {
   mojom::ConnectorPtr proxy;
   *request = mojo::GetProxy(&proxy);
   return base::MakeUnique<ConnectorImpl>(proxy.PassInterface());
 }
 
 }  // namespace shell