Initial pass of shared workers renderer-side code

chrome/renderer/webworker_proxy.cc

Index: chrome/renderer/webworker_proxy.cc
diff --git a/chrome/renderer/webworker_proxy.cc b/chrome/renderer/webworker_proxy.cc
index 3932d6e9c3bb2487082b16a822b514976145b41c..5a24c41aa223ac60a6e36f330b6a9d1e8e952811 100644
--- a/chrome/renderer/webworker_proxy.cc
+++ b/chrome/renderer/webworker_proxy.cc
@@ -21,51 +21,29 @@ WebWorkerProxy::WebWorkerProxy(
     WebWorkerClient* client,
     ChildThread* child_thread,
     int render_view_route_id)
-    : route_id_(MSG_ROUTING_NONE),
-      child_thread_(child_thread),
-      render_view_route_id_(render_view_route_id),
+    : WebWorkerBase(child_thread, MSG_ROUTING_NONE, render_view_route_id),
       client_(client) {
 }
 
-WebWorkerProxy::~WebWorkerProxy() {
-  Disconnect();
-
-  for (size_t i = 0; i < queued_messages_.size(); ++i)
-    delete queued_messages_[i];
-}
-
 void WebWorkerProxy::Disconnect() {
   if (route_id_ == MSG_ROUTING_NONE)
     return;
 
-  // So the messages from WorkerContext (like WorkerContextDestroyed) do not
-  // come after nobody is listening. Since Worker and WorkerContext can
-  // terminate independently, already sent messages may still be in the pipe.
-  child_thread_->RemoveRoute(route_id_);
-
   // Tell the browser to not start our queued worker.
-  if (!queued_messages_.empty())
+  if (!IsStarted())
     child_thread_->Send(new ViewHostMsg_CancelCreateDedicatedWorker(route_id_));
 
-  route_id_ = MSG_ROUTING_NONE;
+  // Call our superclass to shutdown the routing
+  WebWorkerBase::Disconnect();
 }
 
 void WebWorkerProxy::startWorkerContext(
     const WebURL& script_url,
     const WebString& user_agent,
     const WebString& source_code) {
-  child_thread_->Send(new ViewHostMsg_CreateDedicatedWorker(
-      script_url, render_view_route_id_, &route_id_));
-  if (route_id_ == MSG_ROUTING_NONE)
-    return;
-
-  child_thread_->AddRoute(route_id_, this);
-
-  // We make sure that the start message is the first, since postMessage might
-  // have already been called.
-  queued_messages_.insert(queued_messages_.begin(),
-      new WorkerMsg_StartWorkerContext(
-          route_id_, script_url, user_agent, source_code));
+  IPC::Message* create_message = new ViewHostMsg_CreateDedicatedWorker(
+      script_url, render_view_route_id_, &route_id_);
+  CreateWorkerContext(create_message, script_url, user_agent, source_code);
 }
 
 void WebWorkerProxy::terminateWorkerContext() {
@@ -100,31 +78,12 @@ void WebWorkerProxy::workerObjectDestroyed() {
 void WebWorkerProxy::clientDestroyed() {
 }
 
-bool WebWorkerProxy::Send(IPC::Message* message) {
-  // It's possible that postMessage is called before the worker is created, in
-  // which case route_id_ will be none.  Or the worker object can be interacted
-  // with before the browser process told us that it started, in which case we
-  // also want to queue the message.
-  if (route_id_ == MSG_ROUTING_NONE || !queued_messages_.empty()) {
-    queued_messages_.push_back(message);
-    return true;
-  }
-
-  // For now we proxy all messages to the worker process through the browser.
-  // Revisit if we find this slow.
-  // TODO(jabdelmalek): handle sync messages if we need them.
-  IPC::Message* wrapped_msg = new ViewHostMsg_ForwardToWorker(*message);
-  delete message;
-  return child_thread_->Send(wrapped_msg);
-}
-
 void WebWorkerProxy::OnMessageReceived(const IPC::Message& message) {
   if (!client_)
     return;
 
   IPC_BEGIN_MESSAGE_MAP(WebWorkerProxy, message)
-    IPC_MESSAGE_HANDLER(ViewMsg_DedicatedWorkerCreated,
-                        OnDedicatedWorkerCreated)
+    IPC_MESSAGE_HANDLER(ViewMsg_WorkerCreated, OnWorkerCreated)
     IPC_MESSAGE_HANDLER(WorkerMsg_PostMessage, OnPostMessage)
     IPC_MESSAGE_FORWARD(WorkerHostMsg_PostExceptionToWorkerObject,
                         client_,
@@ -143,14 +102,10 @@ void WebWorkerProxy::OnMessageReceived(const IPC::Message& message) {
   IPC_END_MESSAGE_MAP()
 }
 
-void WebWorkerProxy::OnDedicatedWorkerCreated() {
-  DCHECK(queued_messages_.size());
-  std::vector<IPC::Message*> queued_messages = queued_messages_;
-  queued_messages_.clear();
-  for (size_t i = 0; i < queued_messages.size(); ++i) {
-    queued_messages[i]->set_routing_id(route_id_);
-    Send(queued_messages[i]);
-  }
+void WebWorkerProxy::OnWorkerCreated() {
+  // The worker is created - now send off the CreateWorkerContext message and
+  // any other queued messages
+  SendQueuedMessages();
 }
 
 void WebWorkerProxy::OnPostMessage(