Implementations of SharedWorker in the renderer process.

In this CL I introduce 2 classes (EmbeddedSharedWorkerDevToolsAgent, EmbeddedSharedWorkerStub).

EmbeddedSharedWorkerStub and EmbeddedSharedWorkerDevToolsAgent are almost same as WebSharedWorkerStub and SharedWorkerDevToolsAgent which are used in the worker process now.
These classes are not used yet.
EmbeddedSharedWorkerStub will be created when CreateWorker message is received by RenderThreadImpl.

In this CL I move shared_worker_devtools_agent.* from content/worker/ to content/child/ because I want use it from content/renderer/shared_worker.

BUG=327256

Review URL: https://codereview.chromium.org/158953008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251335 0039d316-1c4b-4281-b951-d872f2087c98

content/worker/shared_worker_devtools_agent.cc → content/child/shared_worker_devtools_agent.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright 2014 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/worker/shared_worker_devtools_agent.h"
+#include "content/child/shared_worker_devtools_agent.h"
 
+#include "content/child/child_thread.h"
 #include "content/common/devtools_messages.h"
-#include "content/worker/worker_thread.h"
 #include "third_party/WebKit/public/platform/WebCString.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebSharedWorker.h"
@@ -82,7 +82,7 @@ void SharedWorkerDevToolsAgent::OnResumeWorkerContext() {
 }
 
 bool SharedWorkerDevToolsAgent::Send(IPC::Message* message) {
-  return WorkerThread::current()->Send(message);
+  return ChildThread::current()->Send(message);
 }
 
 }  // namespace content

content/worker/shared_worker_devtools_agent.h → content/child/shared_worker_devtools_agent.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2014 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.
 
-#ifndef CONTENT_WORKER_SHARED_WORKER_DEVTOOLS_AGENT_H_
-#define CONTENT_WORKER_SHARED_WORKER_DEVTOOLS_AGENT_H_
+#ifndef CONTENT_CHILD_SHARED_WORKER_DEVTOOLS_AGENT_H_
+#define CONTENT_CHILD_SHARED_WORKER_DEVTOOLS_AGENT_H_
 
 #include <string>
 
@@ -47,4 +47,4 @@ class SharedWorkerDevToolsAgent {
 
 }  // namespace content
 
-#endif  // CONTENT_WORKER_SHARED_WORKER_DEVTOOLS_AGENT_H_
+#endif  // CONTENT_CHILD_SHARED_WORKER_DEVTOOLS_AGENT_H_

content/content_child.gypi

@@ -139,6 +139,8 @@
     'child/service_worker/web_service_worker_impl.h',
     'child/service_worker/web_service_worker_provider_impl.cc',
     'child/service_worker/web_service_worker_provider_impl.h',
+    'child/shared_worker_devtools_agent.cc',
+    'child/shared_worker_devtools_agent.h',
     'child/simple_webmimeregistry_impl.cc',
     'child/simple_webmimeregistry_impl.h',
     'child/site_isolation_policy.cc',

content/content_renderer.gypi

@@ -492,6 +492,8 @@
     'renderer/shared_memory_seqlock_reader.h',
     'renderer/shared_worker_repository.cc',
     'renderer/shared_worker_repository.h',
+    'renderer/shared_worker/embedded_shared_worker_stub.cc',
+    'renderer/shared_worker/embedded_shared_worker_stub.h',
     'renderer/skia_benchmarking_extension.cc',
     'renderer/skia_benchmarking_extension.h',
     'renderer/speech_recognition_dispatcher.cc',

content/content_worker.gypi

@@ -9,8 +9,6 @@
     '../third_party/WebKit/public/blink.gyp:blink',
   ],
   'sources': [
-    'worker/shared_worker_devtools_agent.cc',
-    'worker/shared_worker_devtools_agent.h',
     'worker/websharedworker_stub.cc',
     'worker/websharedworker_stub.h',
     'worker/websharedworkerclient_proxy.cc',

content/renderer/shared_worker/embedded_shared_worker_stub.cc

+// Copyright 2014 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/scoped_child_process_reference.h"
+#include "content/child/shared_worker_devtools_agent.h"
+#include "content/child/webmessageportchannel_impl.h"
+#include "content/common/worker_messages.h"
+#include "content/renderer/render_thread_impl.h"
+#include "ipc/ipc_message_macros.h"
+#include "third_party/WebKit/public/web/WebSharedWorker.h"
+#include "third_party/WebKit/public/web/WebSharedWorkerClient.h"
+
+namespace content {
+
+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) {
+  RenderThreadImpl::current()->AddRoute(route_id_, this);
+  impl_ = blink::WebSharedWorker::create(this);
+  worker_devtools_agent_.reset(
+      new SharedWorkerDevToolsAgent(route_id, impl_));
+  impl_->startWorkerContext(url, name_,
+                            content_security_policy, security_policy_type);
+}
+
+EmbeddedSharedWorkerStub::~EmbeddedSharedWorkerStub() {
+  RenderThreadImpl::current()->RemoveRoute(route_id_);
+}
+
+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(horo): delete this method if we have no plan to implement this.
+  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();
+}
+
+}  // namespace content

content/renderer/shared_worker/embedded_shared_worker_stub.h

+// Copyright 2014 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.
+
+#ifndef CONTENT_RENDERER_SHARED_WORKER_EMBEDDED_SHARED_WORKER_STUB_H
+#define CONTENT_RENDERER_SHARED_WORKER_EMBEDDED_SHARED_WORKER_STUB_H
+
+#include "content/child/child_message_filter.h"
+#include "content/child/scoped_child_process_reference.h"
+#include "ipc/ipc_listener.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/web/WebContentSecurityPolicy.h"
+#include "third_party/WebKit/public/web/WebSharedWorkerClient.h"
+#include "url/gurl.h"
+
+namespace blink {
+class WebApplicationCacheHost;
+class WebApplicationCacheHostClient;
+class WebMessagePortChannel;
+class WebNotificationPresenter;
+class WebSecurityOrigin;
+class WebSharedWorker;
+class WebWorkerPermissionClientProxy;
+}
+
+namespace content {
+class SharedWorkerDevToolsAgent;
+class WebMessagePortChannelImpl;
+
+class EmbeddedSharedWorkerStub : public IPC::Listener,
+                                 public blink::WebSharedWorkerClient {
+ public:
+  EmbeddedSharedWorkerStub(
+      const GURL& url,
+      const base::string16& name,
+      const base::string16& content_security_policy,
+      blink::WebContentSecurityPolicyType security_policy_type,
+      int route_id);
+
+  // IPC::Listener implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+  virtual void OnChannelError() OVERRIDE;
+
+  // blink::WebSharedWorkerClient implementation.
+  virtual void workerContextClosed() OVERRIDE;
+  virtual void workerContextDestroyed() OVERRIDE;
+  virtual void workerScriptLoaded() OVERRIDE;
+  virtual void workerScriptLoadFailed() OVERRIDE;
+  virtual void selectAppCacheID(long long) OVERRIDE;
+  virtual blink::WebNotificationPresenter* notificationPresenter() OVERRIDE;
+  virtual blink::WebApplicationCacheHost* createApplicationCacheHost(
+      blink::WebApplicationCacheHostClient*) OVERRIDE;
+  virtual blink::WebWorkerPermissionClientProxy*
+      createWorkerPermissionClientProxy(
+          const blink::WebSecurityOrigin& origin) OVERRIDE;
+  virtual void dispatchDevToolsMessage(
+      const blink::WebString& message) OVERRIDE;
+  virtual void saveDevToolsAgentState(const blink::WebString& state) OVERRIDE;
+
+ private:
+  virtual ~EmbeddedSharedWorkerStub();
+
+  void Shutdown();
+  bool Send(IPC::Message* message);
+
+  void OnConnect(int sent_message_port_id, int routing_id);
+  void OnTerminateWorkerContext();
+
+  int route_id_;
+  base::string16 name_;
+  bool runing_;
+  GURL url_;
+  blink::WebSharedWorker* impl_;
+  scoped_ptr<SharedWorkerDevToolsAgent> worker_devtools_agent_;
+
+  typedef std::vector<WebMessagePortChannelImpl*> PendingChannelList;
+  PendingChannelList pending_channels_;
+
+  ScopedChildProcessReference process_ref_;
+  DISALLOW_COPY_AND_ASSIGN(EmbeddedSharedWorkerStub);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_SHARED_WORKER_EMBEDDED_SHARED_WORKER_STUB_H

content/worker/websharedworker_stub.cc

@@ -8,9 +8,9 @@
 #include "content/child/child_process.h"
 #include "content/child/child_thread.h"
 #include "content/child/fileapi/file_system_dispatcher.h"
+#include "content/child/shared_worker_devtools_agent.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
-#include "content/worker/shared_worker_devtools_agent.h"
 #include "content/worker/worker_thread.h"
 #include "third_party/WebKit/public/web/WebSharedWorker.h"
 #include "third_party/WebKit/public/platform/WebString.h"

content/worker/websharedworkerclient_proxy.cc

@@ -7,10 +7,10 @@
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
+#include "content/child/shared_worker_devtools_agent.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
 #include "content/public/common/content_switches.h"
-#include "content/worker/shared_worker_devtools_agent.h"
 #include "content/worker/shared_worker_permission_client_proxy.h"
 #include "content/worker/websharedworker_stub.h"
 #include "content/worker/worker_thread.h"