Eliminate outgoing InterfaceProvider

services/shell/service_manager.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/shell/service_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 178 matching lines @@
 
     // The target has specified that sources must request one of its provided
     // classes instead of specifying a wild-card for interfaces.
     if (HasClass(capability_spec_, kCapabilityClass_ExplicitClass) &&
         (request.interfaces.count("*") != 0)) {
       request.interfaces.erase("*");
     }
 
     service_->OnConnect(
         mojom::Identity::From(params->source()), source_id,
-        params->TakeRemoteInterfaces(), params->TakeLocalInterfaces(),
-        mojom::CapabilityRequest::From(request), params->target().name());
+        params->TakeRemoteInterfaces(), mojom::CapabilityRequest::From(request),
+        params->target().name());
 
     return true;
   }
 
   void StartWithService(mojom::ServicePtr service) {
     CHECK(!service_);
     service_ = std::move(service);
     service_.set_connection_error_handler(
         base::Bind(&Instance::OnServiceLost, base::Unretained(this),
                    service_manager_->GetWeakPtr()));
@@ skipping 40 matching lines @@
   // Service:
   bool OnConnect(Connection* connection) override {
     connection->AddInterface<mojom::ServiceManager>(this);
     return true;
   }
 
  private:
   // mojom::Connector implementation:
   void Connect(mojom::IdentityPtr target_ptr,
                mojom::InterfaceProviderRequest remote_interfaces,
-               mojom::InterfaceProviderPtr local_interfaces,
                mojom::ClientProcessConnectionPtr client_process_connection,
                const ConnectCallback& callback) override {
     Identity target = target_ptr.To<Identity>();
     if (target.user_id() == mojom::kInheritUserID)
       target.set_user_id(identity_.user_id());
 
     if (!ValidateIdentity(target, callback))
       return;
     if (!ValidateClientProcessConnection(&client_process_connection, target,
                                          callback)) {
       return;
     }
     if (!ValidateCapabilities(target, callback))
       return;
 
     std::unique_ptr<ConnectParams> params(new ConnectParams);
     params->set_source(identity_);
     params->set_target(target);
     params->set_remote_interfaces(std::move(remote_interfaces));
-    params->set_local_interfaces(std::move(local_interfaces));
     params->set_client_process_connection(std::move(client_process_connection));
     params->set_connect_callback(callback);
     service_manager_->Connect(
         std::move(params), nullptr, weak_factory_.GetWeakPtr());
   }
 
   void Clone(mojom::ConnectorRequest request) override {
     connectors_.AddBinding(this, std::move(request));
   }
 
@@ skipping 517 matching lines @@
   // Now that the instance has a Service, we can connect to it.
   bool connected = instance->ConnectToService(&params);
   DCHECK(connected);
 }
 
 base::WeakPtr<ServiceManager> ServiceManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace shell