Added beginnings of browser-process support for shared workers.

Refactored WebWorkerClientProxy into two classes - WebWorkerDispatcher which dispatches incoming IPCs for the worker, and WebWorkerClientProxy, which handles outgoing API calls from WebWorkerImpl. This allows WebWorkerClientProxy to be reused by WebSharedWorkerDispatcher.

BUG=26233
TEST=none (will enable layout tests when basic functionality available)

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=31077

Review URL: http://codereview.chromium.org/351004

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

10 files changed, 311 insertions, 91 deletions

diff --git a/chrome/worker/websharedworker_stub.cc b/chrome/worker/websharedworker_stub.cc
new file mode 100644
index 0000000..902f393
--- /dev/null
+++ b/chrome/worker/websharedworker_stub.cc
@@ -0,0 +1,52 @@
+// Copyright (c) 2009 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 "chrome/worker/websharedworker_stub.h"
+
+#include "chrome/common/webmessageportchannel_impl.h"
+#include "chrome/common/worker_messages.h"
+#include "webkit/api/public/WebSharedWorker.h"
+#include "webkit/api/public/WebString.h"
+#include "webkit/api/public/WebURL.h"
+
+WebSharedWorkerStub::WebSharedWorkerStub(
+    const string16& name, int route_id)
+    : WebWorkerStubBase(route_id),
+      name_(name) {
+
+  // TODO(atwilson): Add support for NaCl when they support MessagePorts.
+  impl_ = WebKit::WebSharedWorker::create(client());
+
+}
+
+WebSharedWorkerStub::~WebSharedWorkerStub() {
+  impl_->clientDestroyed();
+}
+
+void WebSharedWorkerStub::OnMessageReceived(const IPC::Message& message) {
+  IPC_BEGIN_MESSAGE_MAP(WebSharedWorkerStub, message)
+    IPC_MESSAGE_HANDLER(WorkerMsg_StartWorkerContext, OnStartWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
+                        OnTerminateWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_Connect, OnConnect)
+  IPC_END_MESSAGE_MAP()
+}
+
+void WebSharedWorkerStub::OnStartWorkerContext(
+    const GURL& url, const string16& user_agent, const string16& source_code) {
+  impl_->startWorkerContext(url, name_, user_agent, source_code);
+}
+
+void WebSharedWorkerStub::OnConnect(int sent_message_port_id, int routing_id) {
+  WebKit::WebMessagePortChannel* channel =
+      new WebMessagePortChannelImpl(routing_id, sent_message_port_id);
+  impl_->connect(channel);
+}
+
+void WebSharedWorkerStub::OnTerminateWorkerContext() {
+  impl_->terminateWorkerContext();
+
+  // Call the client to make sure context exits.
+  EnsureWorkerContextTerminates();
+}
diff --git a/chrome/worker/websharedworker_stub.h b/chrome/worker/websharedworker_stub.h
new file mode 100644
index 0000000..f7a26f3
--- /dev/null
+++ b/chrome/worker/websharedworker_stub.h
@@ -0,0 +1,40 @@
+// Copyright (c) 2009 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 CHROME_WORKER_WEB_SHARED_WORKER_STUB_H_
+#define CHROME_WORKER_WEB_SHARED_WORKER_STUB_H_
+
+#include "chrome/worker/webworker_stub_base.h"
+#include "chrome/worker/webworkerclient_proxy.h"
+#include "googleurl/src/gurl.h"
+
+namespace WebKit {
+class WebSharedWorker;
+}
+
+// This class creates a WebSharedWorker, and translates incoming IPCs to the
+// appropriate WebSharedWorker APIs.
+class WebSharedWorkerStub : public WebWorkerStubBase {
+ public:
+  WebSharedWorkerStub(const string16& name, int route_id);
+
+  // IPC::Channel::Listener implementation.
+  virtual void OnMessageReceived(const IPC::Message& message);
+
+ private:
+  virtual ~WebSharedWorkerStub();
+
+  // Invoked when the WebWorkerClientProxy is shutting down.
+  void OnConnect(int sent_message_port_id, int routing_id);
+  void OnStartWorkerContext(
+      const GURL& url, const string16& user_agent, const string16& source_code);
+  void OnTerminateWorkerContext();
+
+  WebKit::WebSharedWorker* impl_;
+  string16 name_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebSharedWorkerStub);
+};
+
+#endif  // CHROME_WORKER_WEB_SHARED_WORKER_STUB_H_
diff --git a/chrome/worker/webworker_stub.cc b/chrome/worker/webworker_stub.cc
new file mode 100644
index 0000000..37be7ab
--- /dev/null
+++ b/chrome/worker/webworker_stub.cc
@@ -0,0 +1,84 @@
+// Copyright (c) 2009 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 "chrome/worker/webworker_stub.h"
+
+#include "base/command_line.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/webmessageportchannel_impl.h"
+#include "chrome/common/worker_messages.h"
+#include "chrome/worker/nativewebworker_impl.h"
+#include "webkit/api/public/WebString.h"
+#include "webkit/api/public/WebURL.h"
+#include "webkit/api/public/WebWorker.h"
+
+using WebKit::WebWorker;
+
+static bool UrlIsNativeWorker(const GURL& url) {
+  // If the renderer was not passed the switch to enable native workers,
+  // then the URL should be treated as a JavaScript worker.
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+           switches::kEnableNativeWebWorkers)) {
+    return false;
+  }
+  // Based on the suffix, decide whether the url should be considered
+  // a NativeWebWorker (for .nexe) or a WebWorker (for anything else).
+  const std::string kNativeSuffix(".nexe");
+  std::string worker_url = url.path();
+  // Compute the start index of the suffix.
+  std::string::size_type suffix_index =
+      worker_url.length() - kNativeSuffix.length();
+  std::string::size_type pos = worker_url.find(kNativeSuffix, suffix_index);
+  return (suffix_index == pos);
+}
+
+WebWorkerStub::WebWorkerStub(const GURL& url, int route_id)
+    : WebWorkerStubBase(route_id) {
+  if (UrlIsNativeWorker(url)) {
+    // Launch a native worker.
+    impl_ = NativeWebWorkerImpl::create(client());
+  } else {
+    // Launch a JavaScript worker.
+    impl_ = WebKit::WebWorker::create(client());
+  }
+}
+
+WebWorkerStub::~WebWorkerStub() {
+  impl_->clientDestroyed();
+}
+
+void WebWorkerStub::OnMessageReceived(const IPC::Message& message) {
+  if (!impl_)
+    return;
+
+  IPC_BEGIN_MESSAGE_MAP(WebWorkerStub, message)
+    IPC_MESSAGE_FORWARD(WorkerMsg_StartWorkerContext, impl_,
+                        WebWorker::startWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
+                        OnTerminateWorkerContext)
+    IPC_MESSAGE_HANDLER(WorkerMsg_PostMessage, OnPostMessage)
+    IPC_MESSAGE_FORWARD(WorkerMsg_WorkerObjectDestroyed, impl_,
+                        WebWorker::workerObjectDestroyed)
+  IPC_END_MESSAGE_MAP()
+}
+
+void WebWorkerStub::OnTerminateWorkerContext() {
+  impl_->terminateWorkerContext();
+
+  // Call the client to make sure context exits.
+  EnsureWorkerContextTerminates();
+}
+
+void WebWorkerStub::OnPostMessage(
+    const string16& message,
+    const std::vector<int>& sent_message_port_ids,
+    const std::vector<int>& new_routing_ids) {
+  WebKit::WebMessagePortChannelArray channels(sent_message_port_ids.size());
+  for (size_t i = 0; i < sent_message_port_ids.size(); i++) {
+    channels[i] = new WebMessagePortChannelImpl(
+        new_routing_ids[i], sent_message_port_ids[i]);
+  }
+
+  impl_->postMessageToWorkerContext(message, channels);
+}
diff --git a/chrome/worker/webworker_stub.h b/chrome/worker/webworker_stub.h
new file mode 100644
index 0000000..d83a4b7
--- /dev/null
+++ b/chrome/worker/webworker_stub.h
@@ -0,0 +1,38 @@
+// Copyright (c) 2009 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 CHROME_WORKER_WEB_WORKER_STUB_H_
+#define CHROME_WORKER_WEB_WORKER_STUB_H_
+
+#include "chrome/worker/webworker_stub_base.h"
+#include "chrome/worker/webworkerclient_proxy.h"
+#include "googleurl/src/gurl.h"
+
+namespace WebKit {
+class WebWorker;
+}
+
+// This class creates a WebWorker, and translates incoming IPCs to the
+// appropriate WebWorker APIs.
+class WebWorkerStub : public WebWorkerStubBase {
+ public:
+  WebWorkerStub(const GURL& url, int route_id);
+
+  // IPC::Channel::Listener implementation.
+  virtual void OnMessageReceived(const IPC::Message& message);
+
+ private:
+  virtual ~WebWorkerStub();
+
+  void OnTerminateWorkerContext();
+  void OnPostMessage(const string16& message,
+                     const std::vector<int>& sent_message_port_ids,
+                     const std::vector<int>& new_routing_ids);
+
+  WebKit::WebWorker* impl_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebWorkerStub);
+};
+
+#endif  // CHROME_WORKER_WEB_WORKER_STUB_H_
diff --git a/chrome/worker/webworker_stub_base.cc b/chrome/worker/webworker_stub_base.cc
new file mode 100644
index 0000000..8ea2a15
--- /dev/null
+++ b/chrome/worker/webworker_stub_base.cc
@@ -0,0 +1,32 @@
+// Copyright (c) 2009 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 "chrome/worker/webworker_stub_base.h"
+
+#include "base/compiler_specific.h"
+#include "chrome/common/child_process.h"
+#include "chrome/worker/worker_thread.h"
+
+WebWorkerStubBase::WebWorkerStubBase(int route_id)
+    : route_id_(route_id),
+      ALLOW_THIS_IN_INITIALIZER_LIST(client_(route_id, this)) {
+
+  // Start processing incoming IPCs for this worker.
+  WorkerThread::current()->AddRoute(route_id_, this);
+  ChildProcess::current()->AddRefProcess();
+}
+
+WebWorkerStubBase::~WebWorkerStubBase() {
+  WorkerThread::current()->RemoveRoute(route_id_);
+  ChildProcess::current()->ReleaseProcess();
+}
+
+void WebWorkerStubBase::Shutdown() {
+  // The worker has exited - free ourselves and the client.
+  delete this;
+}
+
+void WebWorkerStubBase::EnsureWorkerContextTerminates() {
+  client_.EnsureWorkerContextTerminates();
+}
diff --git a/chrome/worker/webworker_stub_base.h b/chrome/worker/webworker_stub_base.h
new file mode 100644
index 0000000..1e5ec12
--- /dev/null
+++ b/chrome/worker/webworker_stub_base.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2009 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 CHROME_WORKER_WEB_WORKER_STUB_BASE_H_
+#define CHROME_WORKER_WEB_WORKER_STUB_BASE_H_
+
+#include "chrome/worker/webworkerclient_proxy.h"
+#include "ipc/ipc_channel.h"
+
+// This class is the common base class for both WebWorkerStub and
+// WebSharedWorkerStub and contains common setup/teardown functionality.
+class WebWorkerStubBase : public IPC::Channel::Listener {
+ public:
+  WebWorkerStubBase(int route_id);
+  virtual ~WebWorkerStubBase();
+
+  // Invoked when the WebWorkerClientProxy is shutting down.
+  void Shutdown();
+
+  // Called after terminating the worker context to make sure that the worker
+  // actually terminates (is not stuck in an infinite loop).
+  void EnsureWorkerContextTerminates();
+
+  WebWorkerClientProxy* client() { return &client_; }
+
+ private:
+  int route_id_;
+
+  // WebWorkerClient that responds to outgoing API calls from the worker object.
+  WebWorkerClientProxy client_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebWorkerStubBase);
+};
+
+#endif  // CHROME_WORKER_WEB_WORKER_STUB_BASE_H_
diff --git a/chrome/worker/webworkerclient_proxy.cc b/chrome/worker/webworkerclient_proxy.cc
index 9fe0870..baff23c 100644
--- a/chrome/worker/webworkerclient_proxy.cc
+++ b/chrome/worker/webworkerclient_proxy.cc
@@ -5,13 +5,12 @@
 #include "chrome/worker/webworkerclient_proxy.h"
 
 #include "base/command_line.h"
-#include "chrome/common/child_process.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/webmessageportchannel_impl.h"
 #include "chrome/common/worker_messages.h"
 #include "chrome/renderer/webworker_proxy.h"
+#include "chrome/worker/webworker_stub_base.h"
 #include "chrome/worker/worker_thread.h"
-#include "chrome/worker/nativewebworker_impl.h"
 #include "ipc/ipc_logging.h"
 #include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebURL.h"
@@ -26,43 +25,14 @@ using WebKit::WebWorkerClient;
 // How long to wait for worker to finish after it's been told to terminate.
 #define kMaxTimeForRunawayWorkerMs 3000
 
-static bool UrlIsNativeWorker(const GURL& url) {
-  // If the renderer was not passed the switch to enable native workers,
-  // then the URL should be treated as a JavaScript worker.
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-           switches::kEnableNativeWebWorkers)) {
-    return false;
-  }
-  // Based on the suffix, decide whether the url should be considered
-  // a NativeWebWorker (for .nexe) or a WebWorker (for anything else).
-  const std::string kNativeSuffix(".nexe");
-  std::string worker_url = url.path();
-  // Compute the start index of the suffix.
-  std::string::size_type suffix_index =
-      worker_url.length() - kNativeSuffix.length();
-  std::string::size_type pos = worker_url.find(kNativeSuffix, suffix_index);
-  return (suffix_index == pos);
-}
-
-WebWorkerClientProxy::WebWorkerClientProxy(const GURL& url, int route_id)
-    : url_(url),
-      route_id_(route_id),
+WebWorkerClientProxy::WebWorkerClientProxy(int route_id,
+                                           WebWorkerStubBase* stub)
+    : route_id_(route_id),
+      stub_(stub),
       ALLOW_THIS_IN_INITIALIZER_LIST(kill_process_factory_(this)) {
-  if (UrlIsNativeWorker(url)) {
-    // Launch a native worker.
-    impl_ = NativeWebWorkerImpl::create(this);
-  } else {
-    // Launch a JavaScript worker.
-    impl_ = WebWorker::create(this);
-  }
-  WorkerThread::current()->AddRoute(route_id_, this);
-  ChildProcess::current()->AddRefProcess();
 }
 
 WebWorkerClientProxy::~WebWorkerClientProxy() {
-  impl_->clientDestroyed();
-  WorkerThread::current()->RemoveRoute(route_id_);
-  ChildProcess::current()->ReleaseProcess();
 }
 
 void WebWorkerClientProxy::postMessageToWorkerObject(
@@ -123,8 +93,9 @@ void WebWorkerClientProxy::reportPendingActivity(bool has_pending_activity) {
 
 void WebWorkerClientProxy::workerContextDestroyed() {
   Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
-
-  delete this;
+  // Tell the stub that the worker has shutdown - frees this object.
+  if (stub_)
+    stub_->Shutdown();
 }
 
 WebKit::WebWorker* WebWorkerClientProxy::createWorker(
@@ -136,24 +107,7 @@ bool WebWorkerClientProxy::Send(IPC::Message* message) {
   return WorkerThread::current()->Send(message);
 }
 
-void WebWorkerClientProxy::OnMessageReceived(const IPC::Message& message) {
-  if (!impl_)
-    return;
-
-  IPC_BEGIN_MESSAGE_MAP(WebWorkerClientProxy, message)
-    IPC_MESSAGE_FORWARD(WorkerMsg_StartWorkerContext, impl_,
-                        WebWorker::startWorkerContext)
-    IPC_MESSAGE_HANDLER(WorkerMsg_TerminateWorkerContext,
-                        OnTerminateWorkerContext)
-    IPC_MESSAGE_HANDLER(WorkerMsg_PostMessage, OnPostMessage)
-    IPC_MESSAGE_FORWARD(WorkerMsg_WorkerObjectDestroyed, impl_,
-                        WebWorker::workerObjectDestroyed)
-  IPC_END_MESSAGE_MAP()
-}
-
-void WebWorkerClientProxy::OnTerminateWorkerContext() {
-  impl_->terminateWorkerContext();
-
+void WebWorkerClientProxy::EnsureWorkerContextTerminates() {
   // Avoid a worker doing a while(1) from never exiting.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWebWorkerShareProcesses)) {
@@ -172,15 +126,3 @@ void WebWorkerClientProxy::OnTerminateWorkerContext() {
           kMaxTimeForRunawayWorkerMs);
 }
 
-void WebWorkerClientProxy::OnPostMessage(
-    const string16& message,
-    const std::vector<int>& sent_message_port_ids,
-    const std::vector<int>& new_routing_ids) {
-  WebMessagePortChannelArray channels(sent_message_port_ids.size());
-  for (size_t i = 0; i < sent_message_port_ids.size(); i++) {
-    channels[i] = new WebMessagePortChannelImpl(
-        new_routing_ids[i], sent_message_port_ids[i]);
-  }
-
-  impl_->postMessageToWorkerContext(message, channels);
-}
diff --git a/chrome/worker/webworkerclient_proxy.h b/chrome/worker/webworkerclient_proxy.h
index 456ecb0..b422912 100644
--- a/chrome/worker/webworkerclient_proxy.h
+++ b/chrome/worker/webworkerclient_proxy.h
@@ -9,7 +9,6 @@
 
 #include "base/basictypes.h"
 #include "base/task.h"
-#include "googleurl/src/gurl.h"
 #include "ipc/ipc_channel.h"
 #include "webkit/api/public/WebWorkerClient.h"
 
@@ -17,15 +16,17 @@ namespace WebKit {
 class WebWorker;
 }
 
+class WebWorkerStubBase;
+
 // This class receives IPCs from the renderer and calls the WebCore::Worker
 // implementation (after the data types have been converted by glue code).  It
 // is also called by the worker code and converts these function calls into
 // IPCs that are sent to the renderer, where they're converted back to function
 // calls by WebWorkerProxy.
-class WebWorkerClientProxy : public WebKit::WebWorkerClient,
-                             public IPC::Channel::Listener {
+class WebWorkerClientProxy : public WebKit::WebWorkerClient {
  public:
-  WebWorkerClientProxy(const GURL& url, int route_id);
+  WebWorkerClientProxy(int route_id, WebWorkerStubBase* stub);
+  ~WebWorkerClientProxy();
 
   // WebWorkerClient implementation.
   virtual void postMessageToWorkerObject(
@@ -55,26 +56,13 @@ class WebWorkerClientProxy : public WebKit::WebWorkerClient,
     return NULL;
   }
 
-  // IPC::Channel::Listener implementation.
-  virtual void OnMessageReceived(const IPC::Message& message);
+  void EnsureWorkerContextTerminates();
 
  private:
-  ~WebWorkerClientProxy();
-
   bool Send(IPC::Message* message);
 
-  void OnTerminateWorkerContext();
-  void OnPostMessage(const string16& message,
-                     const std::vector<int>& sent_message_port_ids,
-                     const std::vector<int>& new_routing_ids);
-
-  // The source url for this worker.
-  GURL url_;
-
   int route_id_;
-
-  WebKit::WebWorker* impl_;
-
+  WebWorkerStubBase* stub_;
   ScopedRunnableMethodFactory<WebWorkerClientProxy> kill_process_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebWorkerClientProxy);
diff --git a/chrome/worker/worker_thread.cc b/chrome/worker/worker_thread.cc
index e4be0b9..8ffc92b 100644
--- a/chrome/worker/worker_thread.cc
+++ b/chrome/worker/worker_thread.cc
@@ -7,7 +7,8 @@
 #include "base/lazy_instance.h"
 #include "base/thread_local.h"
 #include "chrome/common/worker_messages.h"
-#include "chrome/worker/webworkerclient_proxy.h"
+#include "chrome/worker/webworker_stub.h"
+#include "chrome/worker/websharedworker_stub.h"
 #include "chrome/worker/worker_webkitclient_impl.h"
 #include "webkit/api/public/WebKit.h"
 
@@ -37,7 +38,13 @@ void WorkerThread::OnControlMessageReceived(const IPC::Message& msg) {
   IPC_END_MESSAGE_MAP()
 }
 
-void WorkerThread::OnCreateWorker(const GURL& url, int route_id) {
-  // WebWorkerClientProxy owns itself.
-  new WebWorkerClientProxy(url, route_id);
+void WorkerThread::OnCreateWorker(const GURL& url,
+                                  bool is_shared,
+                                  const string16& name,
+                                  int route_id) {
+  // WebWorkerStub and WebSharedWorkerStub own themselves.
+  if (is_shared)
+    new WebSharedWorkerStub(name, route_id);
+  else
+    new WebWorkerStub(url, route_id);
 }
diff --git a/chrome/worker/worker_thread.h b/chrome/worker/worker_thread.h
index 27d0abf..040f0db 100644
--- a/chrome/worker/worker_thread.h
+++ b/chrome/worker/worker_thread.h
@@ -21,7 +21,8 @@ class WorkerThread : public ChildThread {
  private:
   virtual void OnControlMessageReceived(const IPC::Message& msg);
 
-  void OnCreateWorker(const GURL& url, int route_id);
+  void OnCreateWorker(
+      const GURL& url, bool is_shared, const string16& name, int route_id);
 
   scoped_ptr<WorkerWebKitClientImpl> webkit_client_;