WIP attempt to replace StartWorker/StopWorker IPCs with a new mojo EmbeddedWorker service.

content/renderer/service_worker/embedded_worker_impl.cc

+// Copyright 2015 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/renderer/service_worker/embedded_worker_impl.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "content/child/scoped_child_process_reference.h"
+#include "content/child/thread_safe_sender.h"
+#include "content/common/service_worker/embedded_worker_messages.h"
+#include "content/public/common/content_client.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/service_worker/embedded_worker_devtools_agent.h"
+#include "content/renderer/service_worker/service_worker_context_client.h"
+#include "mojo/common/url_type_converters.h"
+#include "third_party/WebKit/public/web/WebEmbeddedWorker.h"
+#include "third_party/WebKit/public/web/WebEmbeddedWorkerStartData.h"
+
+namespace content {
+
+namespace {
+static const int kInvalidEmbeddedWorkerId = -1;
+}  // namespace
+
+// A thin wrapper of WebEmbeddedWorker which also adds and releases process
+// references automatically.
+class EmbeddedWorkerImpl::WorkerWrapper {
+ public:
+  WorkerWrapper(blink::WebEmbeddedWorker* worker, int devtools_agent_route_id)
+      : worker_(worker),
+        dev_tools_agent_(
+            new EmbeddedWorkerDevToolsAgent(worker, devtools_agent_route_id)) {}
+  ~WorkerWrapper() {}
+
+  blink::WebEmbeddedWorker* worker() { return worker_.get(); }
+
+ private:
+  ScopedChildProcessReference process_ref_;
+  scoped_ptr<blink::WebEmbeddedWorker> worker_;
+  scoped_ptr<EmbeddedWorkerDevToolsAgent> dev_tools_agent_;
+};
+
+// static
+void EmbeddedWorkerImpl::Create(
+    ThreadSafeSender* thread_safe_sender,
+    mojo::InterfaceRequest<EmbeddedWorker> request) {
+  new EmbeddedWorkerImpl(thread_safe_sender, request.Pass());
+}
+
+EmbeddedWorkerImpl::EmbeddedWorkerImpl(
+    ThreadSafeSender* thread_safe_sender,
+    mojo::InterfaceRequest<EmbeddedWorker> request)
+    : binding_(this, request.Pass()),
+      embedded_worker_id_(kInvalidEmbeddedWorkerId),
+      thread_safe_sender_(thread_safe_sender),
+      main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()) {
+  binding_.set_connection_error_handler([this]() { ConnectionLost(); });
+}
+
+EmbeddedWorkerImpl::~EmbeddedWorkerImpl() {
+}
+
+void EmbeddedWorkerImpl::ConnectionLost() {
+  // This should eventually call WorkerContextDestroyed. (We may need to post
+  // a delayed task to forcibly abort the worker context if we find it
+  // necessary)
+  if (wrapper_) {
+    TRACE_EVENT0("ServiceWorker", "EmbeddedWorkerImpl::StopWorker");
+    wrapper_->worker()->terminateWorkerContext();
+  } else {
+    delete this;
+  }
+}
+
+void EmbeddedWorkerImpl::WorkerContextDestroyed() {
+  thread_safe_sender_->Send(
+      new EmbeddedWorkerHostMsg_WorkerStopped(embedded_worker_id_));
+  main_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&EmbeddedWorkerImpl::DeleteOnMainThread,
+                            base::Unretained(this)));
+}
+
+void EmbeddedWorkerImpl::Initialize(EmbeddedWorkerStartWorkerParamsPtr params) {
+  DCHECK_EQ(embedded_worker_id_, kInvalidEmbeddedWorkerId);
+  DCHECK(!wrapper_);
+  TRACE_EVENT0("ServiceWorker", "EmbeddedWorkerImpl::Initialize");
+  RenderThread::Get()->EnsureWebKitInitialized();
+  wrapper_.reset((new WorkerWrapper(
+      blink::WebEmbeddedWorker::create(
+          new ServiceWorkerContextClient(
+              params->embedded_worker_id, this,
+              params->service_worker_version_id, params->scope.To<GURL>(),
+              params->script_url.To<GURL>(),
+              params->worker_devtools_agent_route_id),
+          NULL),
+      params->worker_devtools_agent_route_id)));
+  embedded_worker_id_ = params->embedded_worker_id;
+
+  blink::WebEmbeddedWorkerStartData start_data;
+  start_data.scriptURL = params->script_url.To<GURL>();
+  start_data.userAgent = base::UTF8ToUTF16(GetContentClient()->GetUserAgent());
+  start_data.pauseAfterDownloadMode =
+      params->pause_after_download
+          ? blink::WebEmbeddedWorkerStartData::PauseAfterDownload
+          : blink::WebEmbeddedWorkerStartData::DontPauseAfterDownload;
+  start_data.waitForDebuggerMode =
+      params->wait_for_debugger
+          ? blink::WebEmbeddedWorkerStartData::WaitForDebugger
+          : blink::WebEmbeddedWorkerStartData::DontWaitForDebugger;
+  start_data.v8CacheOptions =
+      static_cast<blink::WebSettings::V8CacheOptions>(params->v8_cache_options);
+
+  wrapper_->worker()->startWorkerContext(start_data);
+}
+
+void EmbeddedWorkerImpl::DeleteOnMainThread() {
+  delete this;
+}
+
+}  // namespace content