Change RenderFrame to use InterfaceRegistry et al.

content/browser/frame_host/render_frame_host_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/browser/frame_host/render_frame_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 63 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/file_chooser_file_info.h"
 #include "content/public/common/file_chooser_params.h"
 #include "content/public/common/isolated_world_ids.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "device/vibration/vibration_manager_impl.h"
+#include "services/shell/public/cpp/interface_provider.h"
 #include "ui/accessibility/ax_tree.h"
 #include "ui/accessibility/ax_tree_update.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "content/browser/mojo/service_registrar_android.h"
 #endif
 
 #if defined(OS_MACOSX)
@@ skipping 370 matching lines @@
 }
 
 void RenderFrameHostImpl::SaveImageAt(int x, int y) {
   Send(new FrameMsg_SaveImageAt(routing_id_, x, y));
 }
 
 RenderViewHost* RenderFrameHostImpl::GetRenderViewHost() {
   return render_view_host_;
 }
 
-ServiceRegistry* RenderFrameHostImpl::GetServiceRegistry() {
-  return service_registry_.get();
+shell::InterfaceRegistry* RenderFrameHostImpl::GetInterfaceRegistry() {
+  return interface_registry_.get();
+}
+
+shell::InterfaceProvider* RenderFrameHostImpl::GetRemoteInterfaces() {
+  return remote_interfaces_.get();
 }
 
 blink::WebPageVisibilityState RenderFrameHostImpl::GetVisibilityState() {
   // Works around the crashes seen in https://crbug.com/501863, where the
   // active WebContents from a browser iterator may contain a render frame
   // detached from the frame tree. This tries to find a RenderWidgetHost
   // attached to an ancestor frame, and defaults to visibility hidden if
   // it fails.
   // TODO(yfriedman, peter): Ideally this would never be called on an
   // unattached frame and we could omit this check. See
@@ skipping 1499 matching lines @@
 }
 
 void RenderFrameHostImpl::OnHidePopup() {
   RenderViewHostDelegateView* view =
       render_view_host_->delegate_->GetDelegateView();
   if (view)
     view->HidePopupMenu();
 }
 #endif
 
-void RenderFrameHostImpl::RegisterMojoServices() {
+void RenderFrameHostImpl::RegisterMojoInterfaces() {
   GeolocationServiceContext* geolocation_service_context =
       delegate_ ? delegate_->GetGeolocationServiceContext() : NULL;
   if (geolocation_service_context) {
     // TODO(creis): Bind process ID here so that GeolocationServiceImpl
     // can perform permissions checks once site isolation is complete.
     // crbug.com/426384
     // NOTE: At shutdown, there is no guaranteed ordering between destruction of
     // this object and destruction of any GeolocationServicesImpls created via
     // the below service registry, the reason being that the destruction of the
     // latter is triggered by receiving a message that the pipe was closed from
     // the renderer side. Hence, supply the reference to this object as a weak
     // pointer.
-    GetServiceRegistry()->AddService(
+    GetInterfaceRegistry()->AddInterface(
         base::Bind(&GeolocationServiceContext::CreateService,
                    base::Unretained(geolocation_service_context),
                    base::Bind(&RenderFrameHostImpl::DidUseGeolocationPermission,
                               weak_ptr_factory_.GetWeakPtr())));
   }
 
   WakeLockServiceContext* wake_lock_service_context =
       delegate_ ? delegate_->GetWakeLockServiceContext() : nullptr;
   if (wake_lock_service_context) {
     // WakeLockServiceContext is owned by WebContentsImpl so it will outlive
     // this RenderFrameHostImpl, hence a raw pointer can be bound to service
     // factory callback.
-    GetServiceRegistry()->AddService<blink::mojom::WakeLockService>(
+    GetInterfaceRegistry()->AddInterface<blink::mojom::WakeLockService>(
         base::Bind(&WakeLockServiceContext::CreateService,
                    base::Unretained(wake_lock_service_context),
                    GetProcess()->GetID(), GetRoutingID()));
   }
 
   if (!permission_service_context_)
     permission_service_context_.reset(new PermissionServiceContext(this));
 
-  GetServiceRegistry()->AddService(
+  GetInterfaceRegistry()->AddInterface(
       base::Bind(&PermissionServiceContext::CreateService,
                  base::Unretained(permission_service_context_.get())));
 
-  GetServiceRegistry()->AddService(base::Bind(
+  GetInterfaceRegistry()->AddInterface(base::Bind(
       &PresentationServiceImpl::CreateMojoService, base::Unretained(this)));
 
 #if !defined(OS_ANDROID)
-  GetServiceRegistry()->AddService(
+  GetInterfaceRegistry()->AddInterface(
       base::Bind(&device::VibrationManagerImpl::Create));
 #endif
 
   bool enable_web_bluetooth = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableWebBluetooth);
 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
   enable_web_bluetooth = true;
 #endif
 
   if (enable_web_bluetooth) {
-    GetServiceRegistry()->AddService(
+    GetInterfaceRegistry()->AddInterface(
         base::Bind(&RenderFrameHostImpl::CreateWebBluetoothService,
                    base::Unretained(this)));
   }
 
   if (!frame_mojo_shell_)
     frame_mojo_shell_.reset(new FrameMojoShell(this));
 
-  GetServiceRegistry()->AddService<shell::mojom::Connector>(base::Bind(
+  GetInterfaceRegistry()->AddInterface<shell::mojom::Connector>(base::Bind(
       &FrameMojoShell::BindRequest, base::Unretained(frame_mojo_shell_.get())));
 
 #if defined(ENABLE_WEBVR)
   const base::CommandLine& browser_command_line =
       *base::CommandLine::ForCurrentProcess();
 
   if (browser_command_line.HasSwitch(switches::kEnableWebVR)) {
-    GetServiceRegistry()->AddService<device::VRService>(
+    GetInterfaceRegistry()->AddInterface<device::VRService>(
         base::Bind(&device::VRDeviceManager::BindRequest));
   }
 #endif
 
-  GetContentClient()->browser()->RegisterRenderFrameMojoServices(
-      GetServiceRegistry(), this);
+  GetContentClient()->browser()->RegisterRenderFrameMojoInterfaces(
+      GetInterfaceRegistry(), this);
 }
 
 void RenderFrameHostImpl::ResetWaitingState() {
   DCHECK(is_active());
 
   // The active state of the RVH is determined by its main frame, since
   // subframes should have their own widgets.
   if (frame_tree_node_->IsMainFrame()) {
     render_view_host_->set_is_active(true);
     render_view_host_->set_is_swapped_out(false);
@@ skipping 295 matching lines @@
 
   Send(new FrameMsg_FailedNavigation(routing_id_, common_params, request_params,
                                      has_stale_copy_in_cache, error_code));
 
   // An error page is expected to commit, hence why is_loading_ is set to true.
   is_loading_ = true;
   frame_tree_node_->ResetNavigationRequest(true);
 }
 
 void RenderFrameHostImpl::SetUpMojoIfNeeded() {
-  if (service_registry_.get())
+  if (interface_registry_.get())
     return;
 
-  service_registry_.reset(new ServiceRegistryImpl());
+  interface_registry_.reset(new shell::InterfaceRegistry(nullptr));
   if (!GetProcess()->GetServiceRegistry())
     return;
 
-  RegisterMojoServices();
+  RegisterMojoInterfaces();
   mojom::FrameFactoryPtr frame_factory;
   GetProcess()->GetServiceRegistry()->ConnectToRemoteService(
       mojo::GetProxy(&frame_factory));
 
   frame_factory->CreateFrame(routing_id_, GetProxy(&frame_),
                              frame_host_binding_.CreateInterfacePtrAndBind());
-  frame_->GetInterfaceProvider(service_registry_->TakeRemoteRequest());
+
+
+  shell::mojom::InterfaceProviderPtr remote_interfaces;
+  shell::mojom::InterfaceProviderRequest remote_interfaces_request =
+      GetProxy(&remote_interfaces);
+  remote_interfaces_.reset(
+      new shell::InterfaceProvider(std::move(remote_interfaces)));
+  frame_->GetInterfaceProvider(std::move(remote_interfaces_request));
 
 #if defined(OS_ANDROID)
   service_registry_android_ =
-      ServiceRegistryAndroid::Create(service_registry_.get());
+      ServiceRegistryAndroid::Create(interface_registry_.get(),
+                                     remote_interfaces_.get());
   ServiceRegistrarAndroid::RegisterFrameHostServices(
       service_registry_android_.get());
 #endif
 }
 
 void RenderFrameHostImpl::InvalidateMojoConnection() {
 #if defined(OS_ANDROID)
   // The Android-specific service registry has a reference to
   // |service_registry_| and thus must be torn down first.
   service_registry_android_.reset();
 #endif
 
-  service_registry_.reset();
+  interface_registry_.reset();
   frame_.reset();
   frame_host_binding_.Close();
 
   // Disconnect with ImageDownloader Mojo service in RenderFrame.
   mojo_image_downloader_.reset();
 }
 
 bool RenderFrameHostImpl::IsFocused() {
   return GetRenderWidgetHost()->is_focused() &&
          frame_tree_->GetFocusedFrame() &&
@@ skipping 87 matching lines @@
 }
 
 void RenderFrameHostImpl::ClearAllWebUI() {
   ClearPendingWebUI();
   web_ui_type_ = WebUI::kNoWebUI;
   web_ui_.reset();
 }
 
 const content::mojom::ImageDownloaderPtr&
 RenderFrameHostImpl::GetMojoImageDownloader() {
-  if (!mojo_image_downloader_.get() && GetServiceRegistry()) {
-    GetServiceRegistry()->ConnectToRemoteService(
-        mojo::GetProxy(&mojo_image_downloader_));
-  }
+  if (!mojo_image_downloader_.get() && GetRemoteInterfaces())
+    GetRemoteInterfaces()->GetInterface(&mojo_image_downloader_);
   return mojo_image_downloader_;
 }
 
 void RenderFrameHostImpl::ResetLoadingState() {
   if (is_loading()) {
     // When pending deletion, just set the loading state to not loading.
     // Otherwise, OnDidStopLoading will take care of that, as well as sending
     // notification to the FrameTreeNode about the change in loading state.
     if (!is_active())
       is_loading_ = false;
@@ skipping 135 matching lines @@
           file_system_context->CrackURL(file.file_system_url)
               .mount_filesystem_id());
     }
   }
 
   Send(new FrameMsg_RunFileChooserResponse(routing_id_, files));
 }
 
 void RenderFrameHostImpl::GetInterfaceProvider(
     shell::mojom::InterfaceProviderRequest interfaces) {
-  service_registry_->Bind(std::move(interfaces));
+  interface_registry_->Bind(std::move(interfaces));
 }
 
 #if defined(USE_EXTERNAL_POPUP_MENU)
 #if defined(OS_MACOSX)
 
 void RenderFrameHostImpl::DidSelectPopupMenuItem(int selected_index) {
   Send(new FrameMsg_SelectPopupMenuItem(routing_id_, selected_index));
 }
 
 void RenderFrameHostImpl::DidCancelPopupMenu() {
@@ skipping 252 matching lines @@
   // handler after it's destroyed so it can't run after the RFHI is destroyed.
   web_bluetooth_service_->SetClientConnectionErrorHandler(base::Bind(
       &RenderFrameHostImpl::DeleteWebBluetoothService, base::Unretained(this)));
 }
 
 void RenderFrameHostImpl::DeleteWebBluetoothService() {
   web_bluetooth_service_.reset();
 }
 
 }  // namespace content