Rename ServiceProvider to InterfaceProvider.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1480 matching lines @@
   // showing, then WebKit will never send a commit and we'll be left spinning.
   // Set the is_swapped_out_ bit to true, so IPC filtering is in effect and
   // the navigation to swappedout:// is not announced to the browser side.
   is_swapped_out_ = true;
   GURL swappedOutURL(kSwappedOutURL);
   WebURLRequest request(swappedOutURL);
   frame_->loadRequest(request);
 }
 
 void RenderFrameImpl::BindServiceRegistry(
-    mojo::InterfaceRequest<mojo::ServiceProvider> services,
-    mojo::ServiceProviderPtr exposed_services) {
+    mojo::InterfaceRequest<mojo::InterfaceProvider> services,
+    mojo::InterfaceProviderPtr exposed_services) {
   service_registry_.Bind(std::move(services));
   service_registry_.BindRemoteServiceProvider(std::move(exposed_services));
 }
 
 ManifestManager* RenderFrameImpl::manifest_manager() {
   return manifest_manager_;
 }
 
 void RenderFrameImpl::SetPendingNavigationParams(
     scoped_ptr<NavigationParams> navigation_params) {
@@ skipping 4486 matching lines @@
     media_permission_dispatcher_.reset(new MediaPermissionDispatcher(
         base::Bind(&RenderFrameImpl::ConnectToService<PermissionService>,
                    base::Unretained(this))));
   }
   return media_permission_dispatcher_.get();
 }
 
 #if defined(ENABLE_MOJO_MEDIA)
 media::interfaces::ServiceFactory* RenderFrameImpl::GetMediaServiceFactory() {
   if (!media_service_factory_) {
-    mojo::ServiceProviderPtr service_provider =
+    mojo::InterfaceProviderPtr service_provider =
         ConnectToApplication(GURL("mojo:media"));
     mojo::ConnectToService(service_provider.get(), &media_service_factory_);
     media_service_factory_.set_connection_error_handler(
         base::Bind(&RenderFrameImpl::OnMediaServiceFactoryConnectionError,
                    base::Unretained(this)));
   }
 
   return media_service_factory_.get();
 }
 
@@ skipping 49 matching lines @@
                    base::Unretained(this)));
   }
 }
 
 template <typename Interface>
 void RenderFrameImpl::ConnectToService(
     mojo::InterfaceRequest<Interface> request) {
   GetServiceRegistry()->ConnectToRemoteService(std::move(request));
 }
 
-mojo::ServiceProviderPtr RenderFrameImpl::ConnectToApplication(
+mojo::InterfaceProviderPtr RenderFrameImpl::ConnectToApplication(
     const GURL& url) {
   if (!mojo_shell_)
     GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&mojo_shell_));
-  mojo::ServiceProviderPtr service_provider;
+  mojo::InterfaceProviderPtr service_provider;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo::shell::mojom::CapabilityFilterPtr filter(
       mojo::shell::mojom::CapabilityFilter::New());
   mojo::Array<mojo::String> all_interfaces;
   all_interfaces.push_back("*");
   filter->filter.insert("*", std::move(all_interfaces));
   mojo_shell_->ConnectToApplication(
       std::move(request), GetProxy(&service_provider), nullptr,
       std::move(filter), base::Bind(&OnGotRemoteIDs));
@@ skipping 40 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content