ServiceWorker: remove EmbeddedWorkerMsg_StartWorker

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 "url/gurl.h"
@@ skipping 63 matching lines @@
             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 SetupEventDispatcherOnUIThread(
-    int process_id,
-    int thread_id,
-    mojom::ServiceWorkerEventDispatcherRequest request) {
-  DCHECK(!ServiceWorkerUtils::IsMojoForServiceWorkerEnabled());
-  RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
-  // |rph| or its InterfaceProvider may be NULL in unit tests.
-  if (!rph || !rph->GetRemoteInterfaces())
-    return;
-  mojom::EmbeddedWorkerSetupPtr setup;
-  rph->GetRemoteInterfaces()->GetInterface(&setup);
-  setup->AttachServiceWorkerEventDispatcher(thread_id, std::move(request));
-}
-
 void CallDetach(EmbeddedWorkerInstance* instance) {
   // This could be called on the UI thread if |client_| still be valid when the
   // message loop on the UI thread gets destructed.
   // TODO(shimazu): Remove this after https://crbug.com/604762 is fixed
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     DCHECK(ServiceWorkerUtils::IsMojoForServiceWorkerEnabled());
     return;
   }
   instance->Detach();
 }
@@ skipping 264 matching lines @@
                                  "EmbeddedWorkerInstance::Start", this,
                                  "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;
 
-    if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled())
-      SendMojoStartWorker(std::move(params));
-    else
-      SendStartWorker(std::move(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));
+    ServiceWorkerStatusCode status =
+        instance_->SendStartWorker(std::move(params));
     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.
-  }
-
-  void SendMojoStartWorker(std::unique_ptr<EmbeddedWorkerStartParams> params) {
-    ServiceWorkerStatusCode status =
-        instance_->SendMojoStartWorker(std::move(params));
-    if (status != SERVICE_WORKER_OK) {
-      StatusCallback callback = start_callback_;
-      start_callback_.Reset();
-      instance_->OnStartFailed(callback, status);
-      // |this| may be destroyed.
-      return;
     }
   }
 
   // |instance_| must outlive |this|.
   EmbeddedWorkerInstance* instance_;
 
   // Ownership is transferred by base::Passed() to a task after process
   // allocation.
   mojom::EmbeddedWorkerInstanceClientRequest request_;
 
@@ skipping 43 matching lines @@
   starting_phase_ = ALLOCATING_PROCESS;
   network_accessed_for_script_ = false;
   for (auto& observer : listener_list_)
     observer.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();
 
-  mojom::EmbeddedWorkerInstanceClientRequest request;
-  if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
-    request = mojo::MakeRequest(&client_);
-    client_.set_connection_error_handler(
-        base::Bind(&CallDetach, base::Unretained(this)));
-  }
+  mojom::EmbeddedWorkerInstanceClientRequest request =
+      mojo::MakeRequest(&client_);
+  client_.set_connection_error_handler(
+      base::Bind(&CallDetach, base::Unretained(this)));
 
   pending_dispatcher_request_ = std::move(dispatcher_request);
 
   inflight_start_task_.reset(
       new StartTask(this, params->script_url, std::move(request)));
   inflight_start_task_->Start(std::move(params), callback);
 }
 
 bool EmbeddedWorkerInstance::Stop() {
   DCHECK(status_ == EmbeddedWorkerStatus::STARTING ||
@@ skipping 110 matching lines @@
   }
   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();
   }
   for (auto& observer : listener_list_)
     observer.OnRegisteredToDevToolsManager();
 }
 
-ServiceWorkerStatusCode EmbeddedWorkerInstance::SendMojoStartWorker(
+ServiceWorkerStatusCode EmbeddedWorkerInstance::SendStartWorker(
     std::unique_ptr<EmbeddedWorkerStartParams> params) {
   if (!context_)
     return SERVICE_WORKER_ERROR_ABORT;
   DCHECK(pending_dispatcher_request_.is_pending());
   client_->StartWorker(*params, std::move(pending_dispatcher_request_));
   registry_->BindWorkerToProcess(process_id(), embedded_worker_id());
-  TRACE_EVENT_ASYNC_STEP_PAST1("ServiceWorker", "EmbeddedWorkerInstance::Start",
-                               this, "SendStartWorker", "Status", "mojo");
+  TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start",
+                               this, "SendStartWorker");
   OnStartWorkerMessageSent();
   return SERVICE_WORKER_OK;
 }
 
 void EmbeddedWorkerInstance::OnStartWorkerMessageSent() {
   if (!step_time_.is_null()) {
     base::TimeDelta duration = UpdateStepTime();
     if (inflight_start_task_->is_installed()) {
       ServiceWorkerMetrics::RecordTimeToSendStartWorker(duration,
                                                         start_situation_);
@@ skipping 79 matching lines @@
   starting_phase_ = THREAD_STARTED;
   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 (auto& observer : listener_list_)
     observer.OnThreadStarted();
-
-  // The pending request is sent at StartWorker if mojo for the service worker
-  // is enabled.
-  if (!ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
-    DCHECK(pending_dispatcher_request_.is_pending());
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(SetupEventDispatcherOnUIThread, process_id(), thread_id_,
-                   base::Passed(&pending_dispatcher_request_)));
-  }
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
   if (!inflight_start_task_)
     return;
   TRACE_EVENT_ASYNC_STEP_PAST0("ServiceWorker", "EmbeddedWorkerInstance::Start",
                                inflight_start_task_.get(),
                                "OnScriptLoadFailed");
   for (auto& observer : listener_list_)
     observer.OnScriptLoadFailed();
@@ skipping 207 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content