[mojo] Add BrowserInterfaceBroker support for service workers

This change adds BrowserInterfaceBroker plumbing for service workers,
as well as support of task runners for binding interface handlers.
It also converts BackgroundFetchService clients in blink to use
BrowserInterfaceBroker as a use case.

Bug: 985110, 985112, 976962
Change-Id: I5c431f3f862cb3ac10d389f8c7afea3734d5bfd5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1742779
Commit-Queue: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Alex Moshchuk <alexmos@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Peter Beverloo <peter@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#686578}

content/browser/background_fetch/background_fetch_service_impl.cc

@@ -35,10 +35,14 @@ constexpr size_t kMaxDeveloperIdLength = 1024 * 1024;
 
 // static
 void BackgroundFetchServiceImpl::CreateForWorker(
-    blink::mojom::BackgroundFetchServiceRequest request,
-    RenderProcessHost* render_process_host,
-    const url::Origin& origin) {
+    const ServiceWorkerRunningInfo& info,
+    mojo::PendingReceiver<blink::mojom::BackgroundFetchService> receiver) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RenderProcessHost* render_process_host =
+      RenderProcessHost::FromID(info.process_id);
+
+  if (!render_process_host)
+    return;
 
   base::PostTask(
       FROM_HERE, {BrowserThread::IO},
@@ -47,21 +51,19 @@ void BackgroundFetchServiceImpl::CreateForWorker(
           WrapRefCounted(static_cast<StoragePartitionImpl*>(
                              render_process_host->GetStoragePartition())
                              ->GetBackgroundFetchContext()),
-          origin, /* render_frame_tree_node_id= */ 0,
-          /* wc_getter= */ base::NullCallback(), std::move(request)));
+          url::Origin::Create(info.script_url),
+          /* render_frame_tree_node_id= */ 0,
+          /* wc_getter= */ base::NullCallback(), std::move(receiver)));
 }
 
 // static
 void BackgroundFetchServiceImpl::CreateForFrame(
-    RenderProcessHost* render_process_host,
-    int render_frame_id,
-    blink::mojom::BackgroundFetchServiceRequest request) {
+    RenderFrameHost* render_frame_host,
+    mojo::PendingReceiver<blink::mojom::BackgroundFetchService> receiver) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  DCHECK(render_process_host);
-  auto* render_frame_host =
-      RenderFrameHost::FromID(render_process_host->GetID(), render_frame_id);
   DCHECK(render_frame_host);
+  RenderProcessHost* render_process_host = render_frame_host->GetProcess();
+  DCHECK(render_process_host);
 
   WebContents::Getter wc_getter = base::NullCallback();
 
@@ -81,7 +83,7 @@ void BackgroundFetchServiceImpl::CreateForFrame(
                              ->GetBackgroundFetchContext()),
           render_frame_host->GetLastCommittedOrigin(),
           render_frame_host->GetFrameTreeNodeId(), std::move(wc_getter),
-          std::move(request)));
+          std::move(receiver)));
 }
 
 // static

content/browser/background_fetch/background_fetch_service_impl.h

@@ -20,7 +20,6 @@
 namespace content {
 
 class BackgroundFetchContext;
-class RenderProcessHost;
 
 class CONTENT_EXPORT BackgroundFetchServiceImpl
     : public blink::mojom::BackgroundFetchService {
@@ -33,14 +32,12 @@ class CONTENT_EXPORT BackgroundFetchServiceImpl
   ~BackgroundFetchServiceImpl() override;
 
   static void CreateForWorker(
-      blink::mojom::BackgroundFetchServiceRequest request,
-      RenderProcessHost* render_process_host,
-      const url::Origin& origin);
+      const ServiceWorkerRunningInfo& info,
+      mojo::PendingReceiver<blink::mojom::BackgroundFetchService> receiver);
 
   static void CreateForFrame(
-      RenderProcessHost* render_process_host,
-      int render_frame_id,
-      blink::mojom::BackgroundFetchServiceRequest request);
+      RenderFrameHost* render_frame_host,
+      mojo::PendingReceiver<blink::mojom::BackgroundFetchService> receiver);
 
   // blink::mojom::BackgroundFetchService implementation.
   void Fetch(int64_t service_worker_registration_id,

content/browser/browser_interface_binders.cc

@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "content/browser/browser_interface_binders.h"
+#include "content/browser/background_fetch/background_fetch_service_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/worker_host/dedicated_worker_host.h"
 #include "content/browser/worker_host/shared_worker_host.h"
 #include "content/browser/worker_host/shared_worker_instance.h"
@@ -13,67 +15,100 @@
 namespace content {
 namespace internal {
 
-void PopulateFrameBinders(RenderFrameHostImpl* rfhi,
+// Documents/frames
+void PopulateFrameBinders(RenderFrameHostImpl* host,
                           service_manager::BinderMap* map) {
   map->Add<blink::mojom::AudioContextManager>(base::BindRepeating(
-      &RenderFrameHostImpl::GetAudioContextManager, base::Unretained(rfhi)));
+      &RenderFrameHostImpl::GetAudioContextManager, base::Unretained(host)));
 
   map->Add<blink::mojom::FileSystemManager>(base::BindRepeating(
-      &RenderFrameHostImpl::GetFileSystemManager, base::Unretained(rfhi)));
+      &RenderFrameHostImpl::GetFileSystemManager, base::Unretained(host)));
 }
 
 void PopulateBinderMapWithContext(
-    RenderFrameHostImpl* rfhi,
-    service_manager::BinderMapWithContext<RenderFrameHost*>* map) {}
+    RenderFrameHostImpl* host,
+    service_manager::BinderMapWithContext<RenderFrameHost*>* map) {
+  map->Add<blink::mojom::BackgroundFetchService>(
+      base::BindRepeating(&BackgroundFetchServiceImpl::CreateForFrame));
+}
 
-void PopulateBinderMap(RenderFrameHostImpl* rfhi,
+void PopulateBinderMap(RenderFrameHostImpl* host,
                        service_manager::BinderMap* map) {
-  PopulateFrameBinders(rfhi, map);
+  PopulateFrameBinders(host, map);
 }
 
-RenderFrameHost* GetContextForHost(RenderFrameHostImpl* rfhi) {
-  return rfhi;
+RenderFrameHost* GetContextForHost(RenderFrameHostImpl* host) {
+  return host;
 }
 
-void PopulateDedicatedWorkerBinders(DedicatedWorkerHost* dwh,
-                                    service_manager::BinderMap* map) {}
-
-const url::Origin& GetContextForHost(DedicatedWorkerHost* dwh) {
-  return dwh->GetOrigin();
+// Dedicated workers
+const url::Origin& GetContextForHost(DedicatedWorkerHost* host) {
+  return host->GetOrigin();
 }
 
+void PopulateDedicatedWorkerBinders(DedicatedWorkerHost* host,
+                                    service_manager::BinderMap* map) {}
+
 void PopulateBinderMapWithContext(
-    DedicatedWorkerHost* dwh,
+    DedicatedWorkerHost* host,
     service_manager::BinderMapWithContext<const url::Origin&>* map) {
   // TODO(https://crbug.com/873661): Pass origin to FileSystemManager.
   map->Add<blink::mojom::FileSystemManager>(
       base::BindRepeating(&RenderProcessHost::BindFileSystemManager,
-                          base::Unretained(dwh->GetProcessHost())));
+                          base::Unretained(host->GetProcessHost())));
 }
 
-void PopulateBinderMap(DedicatedWorkerHost* dwh,
+void PopulateBinderMap(DedicatedWorkerHost* host,
                        service_manager::BinderMap* map) {
-  PopulateDedicatedWorkerBinders(dwh, map);
+  PopulateDedicatedWorkerBinders(host, map);
 }
 
-url::Origin GetContextForHost(SharedWorkerHost* swh) {
-  return url::Origin::Create(swh->instance()->url());
+// Shared workers
+url::Origin GetContextForHost(SharedWorkerHost* host) {
+  return url::Origin::Create(host->instance()->url());
 }
 
-void PopulateSharedWorkerBinders(SharedWorkerHost* swh,
+void PopulateSharedWorkerBinders(SharedWorkerHost* host,
                                  service_manager::BinderMap* map) {}
 
 void PopulateBinderMapWithContext(
-    SharedWorkerHost* swh,
+    SharedWorkerHost* host,
     service_manager::BinderMapWithContext<const url::Origin&>* map) {
   // TODO(https://crbug.com/873661): Pass origin to FileSystemManager.
   map->Add<blink::mojom::FileSystemManager>(
       base::BindRepeating(&RenderProcessHost::BindFileSystemManager,
-                          base::Unretained(swh->GetProcessHost())));
+                          base::Unretained(host->GetProcessHost())));
+}
+
+void PopulateBinderMap(SharedWorkerHost* host,
+                       service_manager::BinderMap* map) {
+  PopulateSharedWorkerBinders(host, map);
 }
 
-void PopulateBinderMap(SharedWorkerHost* swh, service_manager::BinderMap* map) {
-  PopulateSharedWorkerBinders(swh, map);
+// Service workers
+ServiceWorkerRunningInfo GetContextForHost(ServiceWorkerProviderHost* host) {
+  // TODO(crbug.com/993409): pass Origin instead of GURL
+  return {host->running_hosted_version()->script_origin().GetURL(),
+          host->running_hosted_version()->version_id(), host->process_id()};
+}
+
+void PopulateServiceWorkerBinders(ServiceWorkerProviderHost* host,
+                                  service_manager::BinderMap* map) {}
+
+void PopulateBinderMapWithContext(
+    ServiceWorkerProviderHost* host,
+    service_manager::BinderMapWithContext<const ServiceWorkerRunningInfo&>*
+        map) {
+  // Using a task runner since ServiceWorkerProviderHost lives on the IO thread,
+  // and CreateForWorker() needs to be called on the UI thread.
+  map->Add<blink::mojom::BackgroundFetchService>(
+      base::BindRepeating(&BackgroundFetchServiceImpl::CreateForWorker),
+      base::CreateSingleThreadTaskRunnerWithTraits(BrowserThread::UI));
+}
+
+void PopulateBinderMap(ServiceWorkerProviderHost* host,
+                       service_manager::BinderMap* map) {
+  PopulateServiceWorkerBinders(host, map);
 }
 
 }  // namespace internal

content/browser/browser_interface_binders.h

@@ -5,6 +5,7 @@
 #ifndef CONTENT_BROWSER_BROWSER_INTERFACE_BINDERS_H_
 #define CONTENT_BROWSER_BROWSER_INTERFACE_BINDERS_H_
 
+#include "content/public/browser/service_worker_running_info.h"
 #include "services/service_manager/public/cpp/binder_map.h"
 #include "url/origin.h"
 
@@ -14,6 +15,7 @@ class RenderFrameHost;
 class RenderFrameHostImpl;
 class DedicatedWorkerHost;
 class SharedWorkerHost;
+class ServiceWorkerProviderHost;
 
 namespace internal {
 
@@ -27,27 +29,36 @@ namespace internal {
 // handling InterfaceProvider's GetInterface() calls (see crbug.com/718652).
 
 // Registers the handlers for interfaces requested by frames.
-void PopulateBinderMap(RenderFrameHostImpl* rfhi,
+void PopulateBinderMap(RenderFrameHostImpl* host,
                        service_manager::BinderMap* map);
 void PopulateBinderMapWithContext(
-    RenderFrameHostImpl* rfhi,
+    RenderFrameHostImpl* host,
     service_manager::BinderMapWithContext<RenderFrameHost*>* map);
-RenderFrameHost* GetContextForHost(RenderFrameHostImpl* rfhi);
+RenderFrameHost* GetContextForHost(RenderFrameHostImpl* host);
 
 // Registers the handlers for interfaces requested by dedicated workers.
-void PopulateBinderMap(DedicatedWorkerHost* dwh,
+void PopulateBinderMap(DedicatedWorkerHost* host,
                        service_manager::BinderMap* map);
 void PopulateBinderMapWithContext(
-    DedicatedWorkerHost* dwh,
+    DedicatedWorkerHost* host,
     service_manager::BinderMapWithContext<const url::Origin&>* map);
-const url::Origin& GetContextForHost(DedicatedWorkerHost* dwh);
+const url::Origin& GetContextForHost(DedicatedWorkerHost* host);
 
 // Registers the handlers for interfaces requested by shared workers.
-void PopulateBinderMap(SharedWorkerHost* swh, service_manager::BinderMap* map);
+void PopulateBinderMap(SharedWorkerHost* host, service_manager::BinderMap* map);
 void PopulateBinderMapWithContext(
-    SharedWorkerHost* swh,
+    SharedWorkerHost* host,
     service_manager::BinderMapWithContext<const url::Origin&>* map);
-url::Origin GetContextForHost(SharedWorkerHost* swh);
+url::Origin GetContextForHost(SharedWorkerHost* host);
+
+// Registers the handlers for interfaces requested by service workers.
+void PopulateBinderMap(ServiceWorkerProviderHost* host,
+                       service_manager::BinderMap* map);
+void PopulateBinderMapWithContext(
+    ServiceWorkerProviderHost* host,
+    service_manager::BinderMapWithContext<const ServiceWorkerRunningInfo&>*
+        map);
+ServiceWorkerRunningInfo GetContextForHost(ServiceWorkerProviderHost* host);
 
 }  // namespace internal
 }  // namespace content

content/browser/frame_host/render_frame_host_impl.cc

@@ -36,7 +36,6 @@
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
-#include "content/browser/background_fetch/background_fetch_service_impl.h"
 #include "content/browser/bluetooth/web_bluetooth_service_impl.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/child_process_security_policy_impl.h"
@@ -4344,9 +4343,6 @@ void RenderFrameHostImpl::RegisterMojoInterfaces() {
       GetProcess()->GetStoragePartition()->GetFileSystemContext(),
       ChromeBlobStorageContext::GetFor(GetProcess()->GetBrowserContext())));
 
-  registry_->AddInterface(base::BindRepeating(
-      &BackgroundFetchServiceImpl::CreateForFrame, GetProcess(), routing_id_));
-
   registry_->AddInterface(base::BindRepeating(&ContactsManagerImpl::Create,
                                               base::Unretained(this)));
 

content/browser/renderer_interface_binders.cc

@@ -10,7 +10,6 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/no_destructor.h"
-#include "content/browser/background_fetch/background_fetch_service_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/content_index/content_index_service_impl.h"
 #include "content/browser/cookie_store/cookie_store_context.h"
@@ -203,8 +202,6 @@ void RendererInterfaceBinders::InitializeParameterizedBinderRegistry() {
             ->GetPlatformNotificationContext()
             ->CreateService(origin, std::move(request));
       }));
-  parameterized_binder_registry_.AddInterface(
-      base::BindRepeating(&BackgroundFetchServiceImpl::CreateForWorker));
   parameterized_binder_registry_.AddInterface(
       base::BindRepeating(&QuotaDispatcherHost::CreateForWorker));
   parameterized_binder_registry_.AddInterface(base::BindRepeating(

content/browser/service_worker/embedded_worker_instance.cc

@@ -794,7 +794,9 @@ void EmbeddedWorkerInstance::SendStartWorker(
 
   // The host must be alive as long as |params->provider_info| is alive.
   owner_version_->provider_host()->CompleteStartWorkerPreparation(
-      process_id(), MakeRequest(&params->provider_info->interface_provider));
+      process_id(), MakeRequest(&params->provider_info->interface_provider),
+      params->provider_info->browser_interface_broker
+          .InitWithNewPipeAndPassReceiver());
   client_->StartWorker(std::move(params));
 
   starting_phase_ = is_script_streaming ? SCRIPT_STREAMING : SENT_START_WORKER;

content/browser/service_worker/service_worker_provider_host.cc

@@ -664,8 +664,9 @@ void ServiceWorkerProviderHost::OnBeginNavigationCommit(int render_process_id,
 
 void ServiceWorkerProviderHost::CompleteStartWorkerPreparation(
     int process_id,
-    service_manager::mojom::InterfaceProviderRequest
-        interface_provider_request) {
+    service_manager::mojom::InterfaceProviderRequest interface_provider_request,
+    mojo::PendingReceiver<blink::mojom::BrowserInterfaceBroker>
+        broker_receiver) {
   DCHECK(context_);
   DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, render_process_id_);
   DCHECK_NE(ChildProcessHost::kInvalidUniqueID, process_id);
@@ -676,6 +677,8 @@ void ServiceWorkerProviderHost::CompleteStartWorkerPreparation(
   interface_provider_binding_.Bind(FilterRendererExposedInterfaces(
       blink::mojom::kNavigation_ServiceWorkerSpec, process_id,
       std::move(interface_provider_request)));
+
+  broker_receiver_.Bind(std::move(broker_receiver));
 }
 
 void ServiceWorkerProviderHost::CompleteWebWorkerPreparation() {

content/browser/service_worker/service_worker_provider_host.h

@@ -20,6 +20,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "base/unguessable_token.h"
+#include "content/browser/browser_interface_broker_impl.h"
 #include "content/browser/service_worker/service_worker_object_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/common/content_export.h"
@@ -324,7 +325,9 @@ class CONTENT_EXPORT ServiceWorkerProviderHost
   void CompleteStartWorkerPreparation(
       int process_id,
       service_manager::mojom::InterfaceProviderRequest
-          interface_provider_request);
+          interface_provider_request,
+      mojo::PendingReceiver<blink::mojom::BrowserInterfaceBroker>
+          broker_receiver);
 
   // Called when the web worker main script resource has finished loading.
   // After this is called, is_response_committed() and is_execution_ready()
@@ -685,6 +688,11 @@ class CONTENT_EXPORT ServiceWorkerProviderHost
   // For service worker execution contexts.
   mojo::Binding<service_manager::mojom::InterfaceProvider>
       interface_provider_binding_;
+  BrowserInterfaceBrokerImpl<ServiceWorkerProviderHost,
+                             const ServiceWorkerRunningInfo&>
+      broker_{this};
+  mojo::Receiver<blink::mojom::BrowserInterfaceBroker> broker_receiver_{
+      &broker_};
 
   // For service worker clients.
   ClientPhase client_phase_ = ClientPhase::kInitial;

content/browser/service_worker/service_worker_test_utils.cc

@@ -307,7 +307,8 @@ CreateProviderHostForServiceWorkerContext(
           &provider_info);
 
   host->CompleteStartWorkerPreparation(
-      process_id, mojo::MakeRequest(&provider_info->interface_provider));
+      process_id, mojo::MakeRequest(&provider_info->interface_provider),
+      provider_info->browser_interface_broker.InitWithNewPipeAndPassReceiver());
   output_endpoint->BindForServiceWorker(std::move(provider_info));
   return host;
 }