Revert "Added beginnings of browser-process support for shared workers."

This reverts commit 31077.

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

10 files changed, 91 insertions, 311 deletions

diff --git a/chrome/worker/websharedworker_stub.cc b/chrome/worker/websharedworker_stub.cc
deleted file mode 100644
index 902f393..0000000
--- a/chrome/worker/websharedworker_stub.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// 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
deleted file mode 100644
index f7a26f3..0000000
--- a/chrome/worker/websharedworker_stub.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// 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
deleted file mode 100644
index 37be7ab..0000000
--- a/chrome/worker/webworker_stub.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// 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
deleted file mode 100644
index d83a4b7..0000000
--- a/chrome/worker/webworker_stub.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// 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
deleted file mode 100644
index 8ea2a15..0000000
--- a/chrome/worker/webworker_stub_base.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-// 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
deleted file mode 100644
index 1e5ec12..0000000
--- a/chrome/worker/webworker_stub_base.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// 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 baff23c..9fe0870 100644
--- a/chrome/worker/webworkerclient_proxy.cc
+++ b/chrome/worker/webworkerclient_proxy.cc
@@ -5,12 +5,13 @@
 #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"
@@ -25,14 +26,43 @@ using WebKit::WebWorkerClient;
 // How long to wait for worker to finish after it's been told to terminate.
 #define kMaxTimeForRunawayWorkerMs 3000
 
-WebWorkerClientProxy::WebWorkerClientProxy(int route_id,
-                                           WebWorkerStubBase* stub)
-    : route_id_(route_id),
-      stub_(stub),
+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),
       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(
@@ -93,9 +123,8 @@ void WebWorkerClientProxy::reportPendingActivity(bool has_pending_activity) {
 
 void WebWorkerClientProxy::workerContextDestroyed() {
   Send(new WorkerHostMsg_WorkerContextDestroyed(route_id_));
-  // Tell the stub that the worker has shutdown - frees this object.
-  if (stub_)
-    stub_->Shutdown();
+
+  delete this;
 }
 
 WebKit::WebWorker* WebWorkerClientProxy::createWorker(
@@ -107,7 +136,24 @@ bool WebWorkerClientProxy::Send(IPC::Message* message) {
   return WorkerThread::current()->Send(message);
 }
 
-void WebWorkerClientProxy::EnsureWorkerContextTerminates() {
+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();
+
   // Avoid a worker doing a while(1) from never exiting.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWebWorkerShareProcesses)) {
@@ -126,3 +172,15 @@ void WebWorkerClientProxy::EnsureWorkerContextTerminates() {
           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 b422912..456ecb0 100644
--- a/chrome/worker/webworkerclient_proxy.h
+++ b/chrome/worker/webworkerclient_proxy.h
@@ -9,6 +9,7 @@
 
 #include "base/basictypes.h"
 #include "base/task.h"
+#include "googleurl/src/gurl.h"
 #include "ipc/ipc_channel.h"
 #include "webkit/api/public/WebWorkerClient.h"
 
@@ -16,17 +17,15 @@ 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 {
+class WebWorkerClientProxy : public WebKit::WebWorkerClient,
+                             public IPC::Channel::Listener {
  public:
-  WebWorkerClientProxy(int route_id, WebWorkerStubBase* stub);
-  ~WebWorkerClientProxy();
+  WebWorkerClientProxy(const GURL& url, int route_id);
 
   // WebWorkerClient implementation.
   virtual void postMessageToWorkerObject(
@@ -56,13 +55,26 @@ class WebWorkerClientProxy : public WebKit::WebWorkerClient {
     return NULL;
   }
 
-  void EnsureWorkerContextTerminates();
+  // IPC::Channel::Listener implementation.
+  virtual void OnMessageReceived(const IPC::Message& message);
 
  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_;
-  WebWorkerStubBase* stub_;
+
+  WebKit::WebWorker* impl_;
+
   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 8ffc92b..e4be0b9 100644
--- a/chrome/worker/worker_thread.cc
+++ b/chrome/worker/worker_thread.cc
@@ -7,8 +7,7 @@
 #include "base/lazy_instance.h"
 #include "base/thread_local.h"
 #include "chrome/common/worker_messages.h"
-#include "chrome/worker/webworker_stub.h"
-#include "chrome/worker/websharedworker_stub.h"
+#include "chrome/worker/webworkerclient_proxy.h"
 #include "chrome/worker/worker_webkitclient_impl.h"
 #include "webkit/api/public/WebKit.h"
 
@@ -38,13 +37,7 @@ void WorkerThread::OnControlMessageReceived(const IPC::Message& msg) {
   IPC_END_MESSAGE_MAP()
 }
 
-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);
+void WorkerThread::OnCreateWorker(const GURL& url, int route_id) {
+  // WebWorkerClientProxy owns itself.
+  new WebWorkerClientProxy(url, route_id);
 }
diff --git a/chrome/worker/worker_thread.h b/chrome/worker/worker_thread.h
index 040f0db..27d0abf 100644
--- a/chrome/worker/worker_thread.h
+++ b/chrome/worker/worker_thread.h
@@ -21,8 +21,7 @@ class WorkerThread : public ChildThread {
  private:
   virtual void OnControlMessageReceived(const IPC::Message& msg);
 
-  void OnCreateWorker(
-      const GURL& url, bool is_shared, const string16& name, int route_id);
+  void OnCreateWorker(const GURL& url, int route_id);
 
   scoped_ptr<WorkerWebKitClientImpl> webkit_client_;