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

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 2012 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 433 matching lines @@
   }
 
  private:
   std::unique_ptr<std::map<int, SessionStorageNamespaceMap>>
       session_storage_namespaces_awaiting_close_;
   DISALLOW_COPY_AND_ASSIGN(SessionStorageHolder);
 };
 
 void CreateMemoryCoordinatorHandle(
     int render_process_id,
+    const service_manager::BindSourceInfo& source_info,
     mojom::MemoryCoordinatorHandleRequest request) {
   MemoryCoordinatorImpl::GetInstance()->CreateHandle(render_process_id,
                                                      std::move(request));
 }
 
 // Forwards service requests to Service Manager since the renderer cannot launch
 // out-of-process services on is own.
 template <typename R>
-void ForwardShapeDetectionRequest(R request) {
+void ForwardShapeDetectionRequest(const service_manager::BindSourceInfo&,
+                                  R request) {
+  // TODO(beng): This should really be using the per-profile connector.
   service_manager::Connector* connector =
       ServiceManagerConnection::GetForProcess()->GetConnector();
   connector->BindInterface(shape_detection::mojom::kServiceName,
                            std::move(request));
 }
 
 class WorkerURLLoaderFactoryProviderImpl
     : public mojom::WorkerURLLoaderFactoryProvider {
  public:
   static void Create(
       int render_process_id,
       scoped_refptr<ResourceMessageFilter> resource_message_filter,
       scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      const service_manager::BindSourceInfo& source_info,
       mojom::WorkerURLLoaderFactoryProviderRequest request) {
     DCHECK(base::FeatureList::IsEnabled(features::kOffMainThreadFetch));
     mojo::MakeStrongBinding(
         base::MakeUnique<WorkerURLLoaderFactoryProviderImpl>(
             render_process_id, resource_message_filter->GetWeakPtr(),
             std::move(service_worker_context)),
         std::move(request));
   }
   WorkerURLLoaderFactoryProviderImpl(
       int render_process_id,
@@ skipping 843 matching lines @@
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context(
         static_cast<ServiceWorkerContextWrapper*>(
             storage_partition_impl_->GetServiceWorkerContext()));
     registry->AddInterface(
         base::Bind(&WorkerURLLoaderFactoryProviderImpl::Create, GetID(),
                    resource_message_filter_, service_worker_context));
   }
 
   // This is to support usage of WebSockets in cases in which there is no
   // associated RenderFrame (e.g., Shared Workers).
-  AddUIThreadInterface(
-      registry.get(), base::Bind(&WebSocketManager::CreateWebSocket, GetID(),
-                                 MSG_ROUTING_NONE));
+  AddUIThreadInterface(registry.get(),
+                       base::Bind(&WebSocketManager::CreateWebSocket, GetID(),
+                                  MSG_ROUTING_NONE));
 
   // Chrome browser process only provides DiscardableSharedMemory service when
   // Chrome is not running in mus+ash.
   if (!service_manager::ServiceManagerIsRemote()) {
     discardable_memory::DiscardableSharedMemoryManager* manager =
         BrowserMainLoop::GetInstance()->discardable_shared_memory_manager();
     registry->AddInterface(
         base::Bind(&discardable_memory::DiscardableSharedMemoryManager::Bind,
                    base::Unretained(manager)));
   }
@@ skipping 42 matching lines @@
 void RenderProcessHostImpl::GetAssociatedInterface(
     const std::string& name,
     mojom::AssociatedInterfaceAssociatedRequest request) {
   int32_t routing_id =
       associated_interface_provider_bindings_.dispatch_context();
   IPC::Listener* listener = listeners_.Lookup(routing_id);
   if (listener)
     listener->OnAssociatedInterfaceRequest(name, request.PassHandle());
 }
 
-void RenderProcessHostImpl::CreateMusGpuRequest(ui::mojom::GpuRequest request) {
+void RenderProcessHostImpl::CreateMusGpuRequest(
+    const service_manager::BindSourceInfo& source_info,
+    ui::mojom::GpuRequest request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!gpu_client_)
     gpu_client_.reset(new GpuClient(GetID()));
   gpu_client_->Add(std::move(request));
 }
 
 void RenderProcessHostImpl::CreateOffscreenCanvasProvider(
+    const service_manager::BindSourceInfo& source_info,
     blink::mojom::OffscreenCanvasProviderRequest request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!offscreen_canvas_provider_) {
     // The client id gets converted to a uint32_t in FrameSinkId.
     uint32_t renderer_client_id = base::checked_cast<uint32_t>(id_);
     offscreen_canvas_provider_ =
         base::MakeUnique<OffscreenCanvasProviderImpl>(renderer_client_id);
   }
   offscreen_canvas_provider_->Add(std::move(request));
 }
 
 void RenderProcessHostImpl::BindFrameSinkProvider(
+    const service_manager::BindSourceInfo& source_info,
     mojom::FrameSinkProviderRequest request) {
   frame_sink_provider_.Bind(std::move(request));
 }
 
 void RenderProcessHostImpl::CreateStoragePartitionService(
-    mojo::InterfaceRequest<mojom::StoragePartitionService> request) {
+    const service_manager::BindSourceInfo& source_info,
+    mojom::StoragePartitionServiceRequest request) {
   // DO NOT REMOVE THIS COMMAND LINE CHECK WITHOUT SECURITY REVIEW!
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoLocalStorage)) {
     storage_partition_impl_->Bind(std::move(request));
   }
 }
 
 int RenderProcessHostImpl::GetNextRoutingID() {
   return widget_helper_->GetNextRoutingID();
 }
@@ skipping 1692 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing.
   // Capture the error message in a crash key value.
   base::debug::ScopedCrashKey error_key_value("mojo-message-error", error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content