Add a mojo ServiceRegistry to embedded workers.

content/browser/service_worker/embedded_worker_instance.cc

Index: content/browser/service_worker/embedded_worker_instance.cc
diff --git a/content/browser/service_worker/embedded_worker_instance.cc b/content/browser/service_worker/embedded_worker_instance.cc
index d2a1ab81e105a7b5840b4676cf3d1d188d955174..22f6f10f827f8ace0456e78ae2d5dcac2455b91d 100644
--- a/content/browser/service_worker/embedded_worker_instance.cc
+++ b/content/browser/service_worker/embedded_worker_instance.cc
@@ -15,7 +15,9 @@
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/common/content_switches_internal.h"
+#include "content/common/mojo/service_registry_impl.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
+#include "content/common/service_worker/embedded_worker_setup.mojom.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
@@ -83,6 +85,20 @@ void RegisterToWorkerDevToolsManagerOnUI(
       base::Bind(callback, worker_devtools_agent_route_id, wait_for_debugger));
 }
 
+void SetupMojoOnUIThread(int process_id,
+                         int thread_id,
+                         mojo::InterfaceRequest<mojo::ServiceProvider> services,
+                         mojo::ServiceProviderPtr exposed_services) {
+  RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
+  // |rph| may be NULL in unit tests.
+  if (!rph)
+    return;
+  EmbeddedWorkerSetupPtr setup;
+  rph->GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&setup));
+  setup->ExchangeServiceProviders(thread_id, services.Pass(),

[michaeln, 2015/07/07 22:15:09]

I'm not familiar enough to know what happens at runtime but am curious.

How expensive is a connection to a remote service, what happens under the covers
here to establish the connection? Are these super liteweight? Is there a round
trip handshake that has to happen prior to remote service calls being sent?

And then once setup, when code on the IO thread invokes a method of a remote
service, what happens with regard to thread context switching? I'm wondering if
tasks get bounced to the UI thread first, then back to the IO thread for real
sending since the RPH's mojo registry service is tied to the UI thread? I have
the same questions about what happens on the remote side under the convers.

+                                  exposed_services.Pass());
+}
+
 }  // namespace
 
 // Lives on IO thread, proxies notifications to DevToolsManager that lives on
@@ -211,6 +227,10 @@ ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMessage(
                              thread_id_, embedded_worker_id_, message));
 }
 
+ServiceRegistry* EmbeddedWorkerInstance::GetServiceRegistry() {
+  return service_registry_.get();
+}
+
 EmbeddedWorkerInstance::EmbeddedWorkerInstance(
     base::WeakPtr<ServiceWorkerContextCore> context,
     int embedded_worker_id)
@@ -353,6 +373,19 @@ void EmbeddedWorkerInstance::OnScriptLoaded(int thread_id) {
   }
   thread_id_ = thread_id;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoaded());
+
+  service_registry_.reset(new ServiceRegistryImpl());
+  mojo::ServiceProviderPtr exposed_services;
+  service_registry_->Bind(GetProxy(&exposed_services));
+  mojo::ServiceProviderPtr services;
+  mojo::InterfaceRequest<mojo::ServiceProvider> services_request =
+      GetProxy(&services);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(SetupMojoOnUIThread, process_id_, thread_id_,
+                 base::Passed(&services_request),
+                 base::Passed(&exposed_services)));
+  service_registry_->BindRemoteServiceProvider(services.Pass());
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
@@ -385,6 +418,7 @@ void EmbeddedWorkerInstance::OnStarted() {
 void EmbeddedWorkerInstance::OnStopped() {
   Status old_status = status_;
   ReleaseProcess();
+  service_registry_.reset();
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStopped(old_status));
 }