ServiceWorker: Implement StartWorker by using mojo

content/browser/service_worker/embedded_worker_instance.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/service_worker/embedded_worker_instance.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #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"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 // When a service worker version's failure count exceeds
@@ skipping 70 matching lines @@
   // |rph| or its InterfaceProvider may be NULL in unit tests.
   if (!rph || !rph->GetRemoteInterfaces())
     return;
   mojom::EmbeddedWorkerSetupPtr setup;
   rph->GetRemoteInterfaces()->GetInterface(&setup);
   setup->ExchangeInterfaceProviders(
       thread_id, std::move(remote_interfaces),
       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
 // UI thread. Owned by EmbeddedWorkerInstance.
 class EmbeddedWorkerInstance::DevToolsProxy : public base::NonThreadSafe {
  public:
   DevToolsProxy(int process_id, int agent_route_id)
       : process_id_(process_id),
         agent_route_id_(agent_route_id) {}
 
@@ skipping 231 matching lines @@
     TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker",
                                  "EmbeddedWorkerInstance::Start", this,
                                  "OnRegisteredToDevToolsManager");
 
     // Notify the instance that it is registered to the devtools manager.
     instance_->OnRegisteredToDevToolsManager(
         is_new_process, worker_devtools_agent_route_id, wait_for_debugger);
 
     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(
       std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     ServiceWorkerStatusCode status = instance_->registry_->SendStartWorker(
         std::move(params), instance_->process_id());
     TRACE_EVENT_ASYNC_STEP_PAST1(
         "ServiceWorker", "EmbeddedWorkerInstance::Start", this,
         "SendStartWorker", "Status", ServiceWorkerStatusToString(status));
@@ skipping 178 matching lines @@
     devtools_proxy_.reset(
         new DevToolsProxy(process_id(), worker_devtools_agent_route_id));
   }
   if (wait_for_debugger) {
     // We don't measure the start time when wait_for_debugger flag is set. So
     // we set the NULL time here.
     step_time_ = base::TimeTicks();
   }
 }
 
+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();
     if (inflight_start_task_->is_installed()) {
       ServiceWorkerMetrics::RecordTimeToSendStartWorker(duration,
                                                         start_situation_);
     }
   }
 
   starting_phase_ = SENT_START_WORKER;
@@ skipping 307 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content