Eliminate bind callback that doesn't take a BindSourceInfo parameter.

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 <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 217 matching lines @@
 // RemoterFactory that delegates Create() calls to the ContentBrowserClient.
 //
 // Since Create() could be called at any time, perhaps by a stray task being run
 // after a RenderFrameHost has been destroyed, the RemoterFactoryImpl uses the
 // process/routing IDs as a weak reference to the RenderFrameHostImpl.
 class RemoterFactoryImpl final : public media::mojom::RemoterFactory {
  public:
   RemoterFactoryImpl(int process_id, int routing_id)
       : process_id_(process_id), routing_id_(routing_id) {}
 
-  static void Bind(int process_id, int routing_id,
+  static void Bind(int process_id,
+                   int routing_id,
+                   const service_manager::BindSourceInfo& source_info,
                    media::mojom::RemoterFactoryRequest request) {
     mojo::MakeStrongBinding(
         base::MakeUnique<RemoterFactoryImpl>(process_id, routing_id),
         std::move(request));
   }
 
  private:
   void Create(media::mojom::RemotingSourcePtr source,
               media::mojom::RemoterRequest request) final {
     if (auto* host = RenderFrameHostImpl::FromID(process_id_, routing_id_)) {
       GetContentClient()->browser()->CreateMediaRemoter(
           host, std::move(source), std::move(request));
     }
   }
 
   const int process_id_;
   const int routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoterFactoryImpl);
 };
 #endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING)
 
 template <typename Interface>
-void IgnoreInterfaceRequest(mojo::InterfaceRequest<Interface> request) {
+void IgnoreInterfaceRequest(const service_manager::BindSourceInfo& source_info,
+                            mojo::InterfaceRequest<Interface> request) {
   // Intentionally ignore the interface request.
 }
 
 // The following functions simplify code paths where the UI thread notifies the
 // ResourceDispatcherHostImpl of information pertaining to loading behavior of
 // frame hosts.
 void NotifyRouteChangesOnIO(
     base::Callback<void(ResourceDispatcherHostImpl*,
                         const GlobalFrameRoutingId&)> frame_callback,
     std::unique_ptr<std::set<GlobalFrameRoutingId>> routing_ids) {
@@ skipping 43 matching lines @@
 }
 
 #if defined(OS_ANDROID)
 // static
 void RenderFrameHost::AllowInjectingJavaScriptForAndroidWebView() {
   g_allow_injecting_javascript = true;
 }
 
 void CreateMediaPlayerRenderer(
     content::RenderFrameHost* render_frame_host,
-    mojo::InterfaceRequest<media::mojom::Renderer> request) {
+    const service_manager::BindSourceInfo& source_info,
+    media::mojom::RendererRequest request) {
   std::unique_ptr<MediaPlayerRenderer> renderer =
       base::MakeUnique<MediaPlayerRenderer>(render_frame_host);
 
   // base::Unretained is safe here because the lifetime of the MediaPlayerRender
   // is tied to the lifetime of the MojoRendererService.
   media::MojoRendererService::InitiateSurfaceRequestCB surface_request_cb =
       base::Bind(&MediaPlayerRenderer::InitiateScopedSurfaceRequest,
                  base::Unretained(renderer.get()));
 
   media::MojoRendererService::Create(
@@ skipping 2328 matching lines @@
     // 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.
     GetInterfaceRegistry()->AddInterface(
         base::Bind(&device::GeolocationServiceContext::CreateService,
                    base::Unretained(geolocation_service_context)));
   }
 
-  device::mojom::WakeLockContext* 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.
-    GetInterfaceRegistry()->AddInterface<device::mojom::WakeLockService>(
-        base::Bind(&device::mojom::WakeLockContext::GetWakeLock,
-                   base::Unretained(wake_lock_service_context)));
-  }
+  GetInterfaceRegistry()->AddInterface<device::mojom::WakeLockService>(
+      base::Bind(&RenderFrameHostImpl::BindWakeLockServiceRequest,
+                 base::Unretained(this)));
 
   if (!permission_service_context_)
     permission_service_context_.reset(new PermissionServiceContext(this));
 
   GetInterfaceRegistry()->AddInterface(
       base::Bind(&PermissionServiceContext::CreateService,
                  base::Unretained(permission_service_context_.get())));
 
   GetInterfaceRegistry()->AddInterface(base::Bind(
       &PresentationServiceImpl::CreateMojoService, base::Unretained(this)));
@@ skipping 968 matching lines @@
   FrameTreeNode* focused_frame_tree_node = frame_tree_->GetFocusedFrame();
   if (!focused_frame_tree_node)
     return;
   RenderFrameHostImpl* focused_frame =
       focused_frame_tree_node->current_frame_host();
   DCHECK(focused_frame);
   dst->focused_tree_id = focused_frame->GetAXTreeID();
 }
 
 WebBluetoothServiceImpl* RenderFrameHostImpl::CreateWebBluetoothService(
+    const service_manager::BindSourceInfo& source_info,
     blink::mojom::WebBluetoothServiceRequest request) {
   // RFHI owns |web_bluetooth_services_| and |web_bluetooth_service| owns the
   // |binding_| which may run the error handler. |binding_| can't run the error
   // handler after it's destroyed so it can't run after the RFHI is destroyed.
   auto web_bluetooth_service =
       base::MakeUnique<WebBluetoothServiceImpl>(this, std::move(request));
   web_bluetooth_service->SetClientConnectionErrorHandler(
       base::Bind(&RenderFrameHostImpl::DeleteWebBluetoothService,
                  base::Unretained(this), web_bluetooth_service.get()));
   web_bluetooth_services_.push_back(std::move(web_bluetooth_service));
@@ skipping 30 matching lines @@
       this, std::move(request),
       base::Bind(&RenderFrameHostImpl::OnMediaInterfaceFactoryConnectionError,
                  base::Unretained(this))));
 }
 
 void RenderFrameHostImpl::OnMediaInterfaceFactoryConnectionError() {
   DCHECK(media_interface_proxy_);
   media_interface_proxy_.reset();
 }
 
+void RenderFrameHostImpl::BindWakeLockServiceRequest(
+    const service_manager::BindSourceInfo& source_info,
+    device::mojom::WakeLockServiceRequest request) {
+  device::mojom::WakeLockContext* wake_lock_service_context =
+      delegate_ ? delegate_->GetWakeLockServiceContext() : nullptr;
+  if (wake_lock_service_context)
+    wake_lock_service_context->GetWakeLock(std::move(request));
+}
+
 void RenderFrameHostImpl::GetInterface(
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle interface_pipe) {
   if (interface_registry_.get()) {
     service_manager::BindSourceInfo source_info(
         GetProcess()->GetChildIdentity(), service_manager::CapabilitySet());
     interface_registry_->BindInterface(source_info, interface_name,
                                        std::move(interface_pipe));
   }
 }
@@ skipping 161 matching lines @@
 }
 
 void RenderFrameHostImpl::ForwardGetInterfaceToRenderFrame(
     const std::string& interface_name,
     mojo::ScopedMessagePipeHandle pipe) {
   GetRemoteInterfaces()->GetInterface(interface_name, std::move(pipe));
 }
 #endif
 
 }  // namespace content