Rename ServiceProvider to InterfaceProvider.

mojo/shell/application_instance.cc

 // Copyright 2015 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 "mojo/shell/application_instance.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 59 matching lines @@
 }
 
 void ApplicationInstance::BindPIDReceiver(
     InterfaceRequest<mojom::PIDReceiver> pid_receiver) {
   pid_receiver_binding_.Bind(std::move(pid_receiver));
 }
 
 // Shell implementation:
 void ApplicationInstance::ConnectToApplication(
     URLRequestPtr app_request,
-    InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
+    InterfaceRequest<InterfaceProvider> remote_interfaces,
+    InterfaceProviderPtr local_interfaces,
     mojom::CapabilityFilterPtr filter,
     const ConnectToApplicationCallback& callback) {
   std::string url_string = app_request->url.To<std::string>();
   GURL url(url_string);
   if (!url.is_valid()) {
     LOG(ERROR) << "Error: invalid URL: " << url_string;
     callback.Run(kInvalidApplicationID, kInvalidApplicationID);
     return;
   }
   if (allow_any_application_ ||
       identity_.filter().find(url.spec()) != identity_.filter().end()) {
     CapabilityFilter capability_filter = GetPermissiveCapabilityFilter();
     if (!filter.is_null())
       capability_filter = filter->filter.To<CapabilityFilter>();
 
     scoped_ptr<ConnectToApplicationParams> params(
         new ConnectToApplicationParams);
     params->SetSource(this);
     GURL app_url(app_request->url.get());
     params->SetTargetURLRequest(
         std::move(app_request),
         Identity(app_url, std::string(), capability_filter));
-    params->set_services(std::move(services));
-    params->set_exposed_services(std::move(exposed_services));
+    params->set_remote_interfaces(std::move(remote_interfaces));
+    params->set_local_interfaces(std::move(local_interfaces));
     params->set_connect_callback(callback);
     manager_->ConnectToApplication(std::move(params));
   } else {
     LOG(WARNING) << "CapabilityFilter prevented connection from: " <<
         identity_.url() << " to: " << url.spec();
     callback.Run(kInvalidApplicationID, kInvalidApplicationID);
   }
 }
 
 void ApplicationInstance::QuitApplication() {
@@ skipping 20 matching lines @@
   params->connect_callback().Run(id_, requesting_content_handler_id_);
   AllowedInterfaces interfaces;
   interfaces.insert("*");
   if (!params->source().is_null())
     interfaces = GetAllowedInterfaces(params->source().filter(), identity_);
 
   ApplicationInstance* source =
       manager_->GetApplicationInstance(params->source());
   uint32_t source_id = source ? source->id() : Shell::kInvalidApplicationID;
   shell_client_->AcceptConnection(
-      params->source().url().spec(), source_id, params->TakeServices(),
-      params->TakeExposedServices(), Array<String>::From(interfaces),
+      params->source().url().spec(), source_id, params->TakeRemoteInterfaces(),
+      params->TakeLocalInterfaces(), Array<String>::From(interfaces),
       params->target().url().spec());
 }
 
 void ApplicationInstance::OnConnectionError() {
   std::vector<ConnectToApplicationParams*> queued_client_requests;
   queued_client_requests_.swap(queued_client_requests);
   auto manager = manager_;
   manager_->OnApplicationInstanceError(this);
   //|this| is deleted.
 
@@ skipping 33 matching lines @@
 
   queue_requests_ = false;
   for (auto request : queued_client_requests_)
     CallAcceptConnection(make_scoped_ptr(request));
 
   queued_client_requests_.clear();
 }
 
 }  // namespace shell
 }  // namespace mojo