Reland of 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/embedded_worker_start_params.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 24 matching lines @@
   ServiceWorkerDevToolsManager::GetInstance()->WorkerVersionInstalled(
       worker_process_id, worker_route_id);
 }
 
 void NotifyWorkerVersionDoomedOnUI(int worker_process_id, int worker_route_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   ServiceWorkerDevToolsManager::GetInstance()->WorkerVersionDoomed(
       worker_process_id, worker_route_id);
 }
 
-void RegisterToWorkerDevToolsManagerOnUI(
+void SetupOnUI(
     int process_id,
     const ServiceWorkerContextCore* service_worker_context,
     const base::WeakPtr<ServiceWorkerContextCore>& service_worker_context_weak,
     int64_t service_worker_version_id,
     const GURL& url,
     const GURL& scope,
     bool is_installed,
+    mojom::EmbeddedWorkerInstanceClientRequest request,
     const base::Callback<void(int worker_devtools_agent_route_id,
                               bool wait_for_debugger)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int worker_devtools_agent_route_id = MSG_ROUTING_NONE;
   bool wait_for_debugger = false;
   if (RenderProcessHost* rph = RenderProcessHost::FromID(process_id)) {
     // |rph| may be NULL in unit tests.
     worker_devtools_agent_route_id = rph->GetNextRoutingID();
     wait_for_debugger =
         ServiceWorkerDevToolsManager::GetInstance()->WorkerCreated(
             process_id, worker_devtools_agent_route_id,
             ServiceWorkerDevToolsManager::ServiceWorkerIdentifier(
                 service_worker_context, service_worker_context_weak,
                 service_worker_version_id, url, scope),
             is_installed);
+    if (request.is_pending())
+      rph->GetRemoteInterfaces()->GetInterface(std::move(request));
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback, worker_devtools_agent_route_id, wait_for_debugger));
 }
 
 void SetupMojoOnUIThread(
     int process_id,
     int thread_id,
@@ skipping 99 matching lines @@
 
 // A task to allocate a worker process and to send a start worker message. This
 // is created on EmbeddedWorkerInstance::Start(), owned by the instance and
 // destroyed on EmbeddedWorkerInstance::OnScriptEvaluated().
 // We can abort starting worker by destroying this task anytime during the
 // sequence.
 class EmbeddedWorkerInstance::StartTask {
  public:
   enum class ProcessAllocationState { NOT_ALLOCATED, ALLOCATING, ALLOCATED };
 
-  StartTask(EmbeddedWorkerInstance* instance, const GURL& script_url)
+  StartTask(EmbeddedWorkerInstance* instance,
+            const GURL& script_url,
+            mojom::EmbeddedWorkerInstanceClientRequest request)
       : instance_(instance),
+        request_(std::move(request)),
         state_(ProcessAllocationState::NOT_ALLOCATED),
         is_installed_(false),
         started_during_browser_startup_(false),
         weak_factory_(this) {
     TRACE_EVENT_ASYNC_BEGIN1("ServiceWorker", "EmbeddedWorkerInstance::Start",
                              this, "Script", script_url.spec());
   }
 
   ~StartTask() {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 21 matching lines @@
     // EmbeddedWorkerInstance::Start(), that is, ServiceWorkerVersion does not
     // expect it when the start worker sequence is canceled by Stop() because
     // the callback, ServiceWorkerVersion::OnStartSentAndScriptEvaluated(),
     // could drain valid start requests queued in the version. After the worker
     // is stopped, the version attempts to restart the worker if there are
     // requests in the queue. See ServiceWorkerVersion::OnStoppedInternal() for
     // details.
     // TODO(nhiroki): Reconsider this bizarre layering.
   }
 
-  void Start(std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
+  void Start(std::unique_ptr<EmbeddedWorkerStartParams> params,
              const StatusCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     state_ = ProcessAllocationState::ALLOCATING;
     start_callback_ = callback;
     is_installed_ = params->is_installed;
 
     if (!GetContentClient()->browser()->IsBrowserStartupComplete())
       started_during_browser_startup_ = true;
 
     GURL scope(params->scope);
@@ skipping 14 matching lines @@
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     StatusCallback callback = task->start_callback_;
     task->start_callback_.Reset();
     callback.Run(status);
     // |task| may be destroyed.
   }
 
   bool is_installed() const { return is_installed_; }
 
  private:
-  void OnProcessAllocated(
-      std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
-      ServiceWorkerStatusCode status,
-      int process_id,
-      bool is_new_process,
-      const EmbeddedWorkerSettings& settings) {
+  void OnProcessAllocated(std::unique_ptr<EmbeddedWorkerStartParams> params,
+                          ServiceWorkerStatusCode status,
+                          int process_id,
+                          bool is_new_process,
+                          const EmbeddedWorkerSettings& settings) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (status != SERVICE_WORKER_OK) {
       TRACE_EVENT_ASYNC_STEP_PAST1(
           "ServiceWorker", "EmbeddedWorkerInstance::Start", this,
           "OnProcessAllocated", "Error", ServiceWorkerStatusToString(status));
       DCHECK_EQ(ChildProcessHost::kInvalidUniqueID, process_id);
       StatusCallback callback = start_callback_;
       start_callback_.Reset();
       instance_->OnStartFailed(callback, status);
@@ skipping 27 matching lines @@
     // TODO(bengr): Support changes to this setting while the worker
     // is running.
     params->settings.data_saver_enabled = settings.data_saver_enabled;
 
     // Register the instance to DevToolsManager on UI thread.
     const int64_t service_worker_version_id = params->service_worker_version_id;
     const GURL& scope = params->scope;
     GURL script_url(params->script_url);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(RegisterToWorkerDevToolsManagerOnUI, process_id,
-                   instance_->context_.get(), instance_->context_,
-                   service_worker_version_id, script_url, scope, is_installed_,
-                   base::Bind(&StartTask::OnRegisteredToDevToolsManager,
+        base::Bind(&SetupOnUI, process_id, instance_->context_.get(),
+                   instance_->context_, service_worker_version_id, script_url,
+                   scope, is_installed_, base::Passed(&request_),
+                   base::Bind(&StartTask::OnSetupOnUICompleted,
                               weak_factory_.GetWeakPtr(), base::Passed(&params),
                               is_new_process)));
   }
 
-  void OnRegisteredToDevToolsManager(
-      std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
-      bool is_new_process,
-      int worker_devtools_agent_route_id,
-      bool wait_for_debugger) {
+  void OnSetupOnUICompleted(std::unique_ptr<EmbeddedWorkerStartParams> params,
+                            bool is_new_process,
+                            int worker_devtools_agent_route_id,
+                            bool wait_for_debugger) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker",
                                  "EmbeddedWorkerInstance::Start", this,
-                                 "OnRegisteredToDevToolsManager");
+                                 "OnSetupOnUICompleted");
 
     // 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())
+      instance_->SendMojoStartWorker(std::move(params));
+    else
+      SendStartWorker(std::move(params));
   }
 
-  void SendStartWorker(
-      std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params) {
+  void SendStartWorker(std::unique_ptr<EmbeddedWorkerStartParams> 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));
     if (status != SERVICE_WORKER_OK) {
       StatusCallback callback = start_callback_;
       start_callback_.Reset();
       instance_->OnStartFailed(callback, status);
       // |this| may be destroyed.
       return;
     }
     instance_->OnStartWorkerMessageSent();
 
     // |start_callback_| will be called via RunStartCallback() when the script
     // is evaluated.
   }
 
   // |instance_| must outlive |this|.
   EmbeddedWorkerInstance* instance_;
 
+  // Ownership is transferred by base::Passed() to a task after process
+  // allocation.
+  mojom::EmbeddedWorkerInstanceClientRequest request_;
+
   StatusCallback start_callback_;
   ProcessAllocationState state_;
 
   // Used for UMA.
   bool is_installed_;
   bool started_during_browser_startup_;
 
   base::WeakPtrFactory<StartTask> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(StartTask);
 };
 
 bool EmbeddedWorkerInstance::Listener::OnMessageReceived(
     const IPC::Message& message) {
   return false;
 }
 
 EmbeddedWorkerInstance::~EmbeddedWorkerInstance() {
   DCHECK(status_ == EmbeddedWorkerStatus::STOPPING ||
          status_ == EmbeddedWorkerStatus::STOPPED)
       << static_cast<int>(status_);
   devtools_proxy_.reset();
   if (registry_->GetWorker(embedded_worker_id_))
     registry_->RemoveWorker(process_id(), embedded_worker_id_);
   process_handle_.reset();
 }
 
 void EmbeddedWorkerInstance::Start(
-    std::unique_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
+    std::unique_ptr<EmbeddedWorkerStartParams> params,
     const StatusCallback& callback) {
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     // |this| may be destroyed by the callback.
     return;
   }
   DCHECK(status_ == EmbeddedWorkerStatus::STOPPED);
 
   DCHECK(!params->pause_after_download || !params->is_installed);
   DCHECK_NE(kInvalidServiceWorkerVersionId, params->service_worker_version_id);
   step_time_ = base::TimeTicks::Now();
   status_ = EmbeddedWorkerStatus::STARTING;
   starting_phase_ = ALLOCATING_PROCESS;
   network_accessed_for_script_ = false;
   interface_registry_.reset(new shell::InterfaceRegistry);
   remote_interfaces_.reset(new shell::InterfaceProvider);
   FOR_EACH_OBSERVER(Listener, listener_list_, OnStarting());
 
   params->embedded_worker_id = embedded_worker_id_;
   params->worker_devtools_agent_route_id = MSG_ROUTING_NONE;
   params->wait_for_debugger = false;
   params->settings.v8_cache_options = GetV8CacheOptions();
 
-  inflight_start_task_.reset(new StartTask(this, params->script_url));
+  mojom::EmbeddedWorkerInstanceClientRequest request;
+  if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled())
+    request = mojo::GetProxy(&client_);
+
+  inflight_start_task_.reset(
+      new StartTask(this, params->script_url, std::move(request)));
   inflight_start_task_->Start(std::move(params), callback);
 }
 
 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() {
   DCHECK(status_ == EmbeddedWorkerStatus::STARTING ||
          status_ == EmbeddedWorkerStatus::RUNNING)
       << static_cast<int>(status_);
 
   // Abort an inflight start task.
   inflight_start_task_.reset();
@@ skipping 99 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::SendMojoStartWorker(
+    std::unique_ptr<EmbeddedWorkerStartParams> params) {
+  client_->StartWorker(*params);
+  registry_->BindWorkerToProcess(process_id(), embedded_worker_id());
+  TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start",
+                               this, "SendStartWorker", "Status", "mojo");
+  OnStartWorkerMessageSent();
+}
+
 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 74 matching lines @@
   if (!step_time_.is_null()) {
     base::TimeDelta duration = UpdateStepTime();
     if (inflight_start_task_->is_installed())
       ServiceWorkerMetrics::RecordTimeToStartThread(duration, start_situation_);
   }
 
   thread_id_ = thread_id;
   FOR_EACH_OBSERVER(Listener, listener_list_, OnThreadStarted());
 
   shell::mojom::InterfaceProviderPtr exposed_interfaces;
-  interface_registry_->Bind(GetProxy(&exposed_interfaces));
+  interface_registry_->Bind(mojo::GetProxy(&exposed_interfaces));
   shell::mojom::InterfaceProviderPtr remote_interfaces;
-  shell::mojom::InterfaceProviderRequest request = GetProxy(&remote_interfaces);
+  shell::mojom::InterfaceProviderRequest request =
+      mojo::GetProxy(&remote_interfaces);
   remote_interfaces_->Bind(std::move(remote_interfaces));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(SetupMojoOnUIThread, process_id(), thread_id_,
                  base::Passed(&request),
                  base::Passed(exposed_interfaces.PassInterface())));
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
   if (!inflight_start_task_)
@@ skipping 210 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content