ServiceWorker: Implement StartWorker by using mojo

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 1e78b20545b3cc5244ac2099cd7d5179a9716d06..0cf1087a866cc5009323d3a8d5f69cb7f15963b6 100644
--- a/content/browser/service_worker/embedded_worker_instance.cc
+++ b/content/browser/service_worker/embedded_worker_instance.cc
@@ -21,10 +21,12 @@
 #include "content/common/service_worker/embedded_worker_settings.h"
 #include "content/common/service_worker/embedded_worker_setup.mojom.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/child_process_host.h"
+#include "content/public/common/content_switches.h"
 #include "ipc/ipc_message.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "services/shell/public/cpp/interface_registry.h"
@@ -115,6 +117,22 @@ void SetupMojoOnUIThread(
       mojo::MakeProxy(std::move(exposed_interfaces)));
 }
 
+void GetRemoteEmbeddededWorkerInstanceClientOnUIThread(
+    int process_id,
+    const base::Callback<void(mojom::EmbeddedWorkerInstanceClientPtr)>&
+        callback_on_io) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
+  // |rph| or its InterfaceProvider may be NULL in unit tests.
+  if (!rph || !rph->GetRemoteInterfaces())
+    return;
+  mojom::EmbeddedWorkerInstanceClientPtr instance_client;
+  rph->GetRemoteInterfaces()->GetInterface(&instance_client);

[Marijn Kruisselbrink, 2016/08/23 18:56:08]

Rather than creating and binding the InterfacePtr here, and then rebinding it on
the IO thread (and having extra thread hops to get back on the IO thread), you
could just have StartTask create the InterfaceRequest for the InterfacePtr, pass
the InterfaceRequest to this method, and then immediately synchronously do what
OnGotRemoteEmbeddedWorkerInstanceClient does in StartTask (as as soon as you
created the InterfaceRequest you can start calling methods on the InterfacePtr).

[shimazu, 2016/08/25 05:14:52]

Thanks, it seems better. Updated.

+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(callback_on_io, base::Passed(&instance_client)));
+}
+
 }  // namespace
 
 // Lives on IO thread, proxies notifications to DevToolsManager that lives on
@@ -366,7 +384,18 @@ class EmbeddedWorkerInstance::StartTask {
 
     params->worker_devtools_agent_route_id = worker_devtools_agent_route_id;
     params->wait_for_debugger = wait_for_debugger;
-    SendStartWorker(std::move(params));
+
+    if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
+      auto callback = base::Bind(
+          &EmbeddedWorkerInstance::OnGotRemoteEmbeddedWorkerInstanceClient,
+          instance_->weak_factory_.GetWeakPtr(), base::Passed(&params));
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&GetRemoteEmbeddededWorkerInstanceClientOnUIThread,
+                     instance_->process_id(), callback));
+    } else {
+      SendStartWorker(std::move(params));
+    }
   }
 
   void SendStartWorker(
@@ -565,6 +594,42 @@ void EmbeddedWorkerInstance::OnRegisteredToDevToolsManager(
   }
 }
 
+void EmbeddedWorkerInstance::OnGotRemoteEmbeddedWorkerInstanceClient(
+    std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
+    mojom::EmbeddedWorkerInstanceClientPtr instance_client) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  // Bind again for thread hop of the mojo interface pointer
+  instance_client_.Bind(instance_client.PassInterface());
+  SendMojoStartWorker(std::move(params));
+}
+
+void EmbeddedWorkerInstance::SendMojoStartWorker(
+    std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params) {
+  auto mojo_params = mojom::EmbeddedWorkerStartWorkerParams::New();
+  mojo_params->embedded_worker_id = params->embedded_worker_id;
+  mojo_params->service_worker_version_id = params->service_worker_version_id;
+  mojo_params->scope = params->scope;
+  mojo_params->script_url = params->script_url;
+  mojo_params->worker_devtools_agent_route_id =
+      params->worker_devtools_agent_route_id;
+  mojo_params->pause_after_download = params->pause_after_download;
+  mojo_params->wait_for_debugger = params->wait_for_debugger;
+  mojo_params->is_installed = params->is_installed;
+
+  mojo_params->settings = mojom::EmbeddedWorkerSettings::New();
+  mojo_params->settings->data_saver_enabled =
+      params->settings.data_saver_enabled;
+  mojo_params->settings->v8_cache_options =
+      static_cast<mojom::V8CacheOptions>(params->settings.v8_cache_options);

[horo, 2016/08/24 04:59:16]

We should have static_assert() for mojo::V8CacheOptions and
content::V8CacheOptions.

[shimazu, 2016/08/25 05:14:52]

Done.

+
+  instance_client_->StartWorker(std::move(mojo_params));
+  registry_->AddWorker(process_id(), embedded_worker_id());
+  TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start",
+                               this, "SendStartWorker", "Status", "mojo");
+  OnStartWorkerMessageSent();
+  return;
+}
+
 void EmbeddedWorkerInstance::OnStartWorkerMessageSent() {
   if (!step_time_.is_null()) {
     base::TimeDelta duration = UpdateStepTime();