Implementations of SharedWorker in the renderer process.

content/renderer/shared_worker/embedded_shared_worker_stub.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/renderer/shared_worker/embedded_shared_worker_stub.h"
+
+#include "base/message_loop/message_loop_proxy.h"
+#include "content/child/child_thread.h"
+#include "content/child/scoped_child_process_reference.h"
+#include "content/child/thread_safe_sender.h"
+#include "content/child/webmessageportchannel_impl.h"
+#include "content/child/worker_thread_task_runner.h"
+#include "content/common/worker_messages.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/shared_worker/embedded_shared_worker_devtools_agent.h"
+#include "ipc/ipc_message_macros.h"
+

[kinuko, 2014/02/12 11:49:33]

nit: extra empty line

[horo, 2014/02/13 05:30:01]

Done.

+#include "third_party/WebKit/public/web/WebSharedWorker.h"
+#include "third_party/WebKit/public/web/WebSharedWorkerClient.h"
+
+namespace blink {
+class WebNotificationPresenter;
+class WebApplicationCacheHost;
+}

[kinuko, 2014/02/12 11:49:33]

Do we need this in .cc?

[horo, 2014/02/13 05:30:01]

Done.

+
+namespace content {

[kinuko, 2014/02/12 11:49:33]

nit: have empty line after namespace {

[horo, 2014/02/13 05:30:01]

Done.

+EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
+    const GURL& url,
+    const base::string16& name,
+    const base::string16& content_security_policy,
+    blink::WebContentSecurityPolicyType security_policy_type,
+    int route_id)
+    : route_id_(route_id),
+      name_(name),
+      runing_(false),
+      url_(url) {

[kinuko, 2014/02/12 11:49:33]

Will we call RenderThreadImpl::current()->AddRoute() here (and RemoveRoute in
the dtor)?

[horo, 2014/02/13 05:30:01]

Done.

+  impl_ = blink::WebSharedWorker::create(this);
+  worker_devtools_agent_.reset(
+      new EmbeddedSharedWorkerDevToolsAgent(route_id, impl_));
+  impl_->startWorkerContext(url, name_,
+                            content_security_policy, security_policy_type);
+}
+
+EmbeddedSharedWorkerStub::~EmbeddedSharedWorkerStub() {
+}
+
+bool EmbeddedSharedWorkerStub::OnMessageReceived(
+    const IPC::Message& message) {
+  if (worker_devtools_agent_->OnMessageReceived(message))
+    return true;
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(EmbeddedSharedWorkerStub, message)
+    IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
+                        OnTerminateWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void EmbeddedSharedWorkerStub::OnChannelError() {
+  OnTerminateWorkerContext();
+}
+
+void EmbeddedSharedWorkerStub::workerScriptLoaded() {
+  Send(new WorkerHostMsg_WorkerScriptLoaded(route_id_));
+  runing_ = true;
+  // Process any pending connections.
+  for (PendingChannelList::const_iterator iter = pending_channels_.begin();
+       iter != pending_channels_.end();
+       ++iter) {
+    impl_->connect(*iter);
+    Send(new WorkerHostMsg_WorkerConnected((*iter)->message_port_id(),
+                                           route_id_));
+  }
+  pending_channels_.clear();
+}
+
+void EmbeddedSharedWorkerStub::workerScriptLoadFailed() {
+  Send(new WorkerHostMsg_WorkerScriptLoadFailed(route_id_));
+  for (PendingChannelList::const_iterator iter = pending_channels_.begin();
+       iter != pending_channels_.end();
+       ++iter) {
+    blink::WebMessagePortChannel* channel = *iter;
+    channel->destroy();
+  }
+  pending_channels_.clear();
+  Shutdown();
+}
+
+void EmbeddedSharedWorkerStub::workerContextClosed() {
+  Send(new WorkerHostMsg_WorkerContextClosed(route_id_));
+}
+
+void EmbeddedSharedWorkerStub::workerContextDestroyed() {
+  Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
+  Shutdown();
+}
+
+void EmbeddedSharedWorkerStub::selectAppCacheID(long long) {
+  //TODO(horo): implement this.
+}
+
+blink::WebNotificationPresenter*
+EmbeddedSharedWorkerStub::notificationPresenter() {
+  // TODO(johnnyg): Notifications are not yet hooked up to workers.
+  // Coming soon.

[kinuko, 2014/02/12 11:49:33]

Is this TODO still applicable / do we need this?

[horo, 2014/02/13 05:30:01]

This is copied from websharedworkerclient_proxy.cc.
I will ask johnnyg@ whether there is still a plan to implement
WebSharedWorkerClientProxy::notificationPresenter().

[kinuko, 2014/02/13 06:09:36]

Afaik johnny's transferred to another team (youtube), and this method doesn't
seem to be called by anyone.

We can probably have a better different TODO comment for this?  (E.g. delete
this method if we have no plan to implement this, etc)

[horo, 2014/02/13 08:54:20]

Done.

+  NOTREACHED();
+  return NULL;
+}
+
+blink::WebApplicationCacheHost*
+    EmbeddedSharedWorkerStub::createApplicationCacheHost(
+        blink::WebApplicationCacheHostClient*) {
+  //TODO(horo): implement this.
+  return NULL;
+}
+
+blink::WebWorkerPermissionClientProxy*
+    EmbeddedSharedWorkerStub::createWorkerPermissionClientProxy(
+    const blink::WebSecurityOrigin& origin) {
+  //TODO(horo): implement this.
+  return NULL;
+}
+
+void EmbeddedSharedWorkerStub::dispatchDevToolsMessage(
+      const blink::WebString& message) {
+  worker_devtools_agent_->SendDevToolsMessage(message);
+}
+
+void EmbeddedSharedWorkerStub::saveDevToolsAgentState(
+      const blink::WebString& state) {
+  worker_devtools_agent_->SaveDevToolsAgentState(state);
+}
+
+void EmbeddedSharedWorkerStub::Shutdown() {
+  delete this;
+}
+
+bool EmbeddedSharedWorkerStub::Send(IPC::Message* message) {
+  return RenderThreadImpl::current()->Send(message);
+}
+
+void EmbeddedSharedWorkerStub::OnConnect(int sent_message_port_id,
+                                         int routing_id) {
+  WebMessagePortChannelImpl* channel =
+      new WebMessagePortChannelImpl(routing_id,
+                                    sent_message_port_id,
+                                    base::MessageLoopProxy::current().get());
+  if (runing_) {
+    impl_->connect(channel);
+  } else {
+    // If two documents try to load a SharedWorker at the same time, the
+    // WorkerMsg_Connect for one of the documents can come in before the
+    // worker is started. Just queue up the connect and deliver it once the
+    // worker starts.
+    pending_channels_.push_back(channel);
+  }
+}
+
+void EmbeddedSharedWorkerStub::OnTerminateWorkerContext() {
+  runing_ = false;
+  impl_->terminateWorkerContext();

[kinuko, 2014/02/12 11:49:33]

Will we have 'ensure worker context terminates' part here?

[horo, 2014/02/13 05:30:01]

I think we don't need to call EnsureWorkerContextTerminates like
WebSharedWorkerClientProxy::EnsureWorkerContextTerminates.

This code has been introduced in order to prevent a worker that loops forever
from preventing shutdown of the worker process in
https://codereview.chromium.org/112049.
But in current code, even if "while(1){}" is being evaluated by
script->evaluate() in WorkerThread::workerThread(),
WebSharedWorkerImpl::terminateWorkerContext() will call
v8::V8::TerminateExecution() and then script->evaluate() will stop evaluation.

Is my understanding incorrect?

[kinuko, 2014/02/13 06:09:36]

I don't know, just wondered why you didn't copy this.

v8::V8::TerminateExecution change seems to have made after the addition of
EnsureWorkerContextTerminates, so probably you're right. (Does that mean we
don't need it in WebSharedWorkerClientProxy either, right?)
https://bugs.webkit.org/show_bug.cgi?id=35137

[horo, 2014/02/13 08:54:20]

I think we don't need WebSharedWorkerClientProxy::EnsureWorkerContextTerminates
either.

+}
+
+}  // namespace content