Initial pass of shared workers renderer-side code

chrome/browser/worker_host/worker_process_host.cc

 // 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/browser/worker_host/worker_process_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 126 matching lines @@
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
   ChildProcessSecurityPolicy::GetInstance()->GrantRequestURL(
       id(), instance.url);
 
   instances_.push_back(instance);
   Send(new WorkerProcessMsg_CreateWorker(
       instance.url, instance.worker_route_id));
 
   UpdateTitle();
   instances_.back().sender->Send(
-      new ViewMsg_DedicatedWorkerCreated(instance.sender_route_id));
+      new ViewMsg_WorkerCreated(instance.sender_route_id));
 }
 
 bool WorkerProcessHost::FilterMessage(const IPC::Message& message,
                                       int sender_pid) {
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
     if (i->sender_id == sender_pid &&
         i->sender_route_id == message.routing_id()) {
       RelayMessage(
           message, this, i->worker_route_id, next_route_id_callback_.get());
       return true;
@@ skipping 64 matching lines @@
 
   // Must be a ResourceMessageFilter.
   return static_cast<ResourceMessageFilter*>(sender)->next_route_id_callback();
 }
 
 void WorkerProcessHost::RelayMessage(
     const IPC::Message& message,
     IPC::Message::Sender* sender,
     int route_id,
     CallbackWithReturnValue<int>::Type* next_route_id) {
-  if (message.type() != WorkerMsg_PostMessage::ID) {
+
+  if (message.type() == WorkerMsg_PostMessage::ID) {
+    // We want to send the receiver a routing id for the new channel, so
+    // crack the message first.
+    string16 msg;
+    std::vector<int> sent_message_port_ids;
+    std::vector<int> new_routing_ids;
+    if (!WorkerMsg_PostMessage::Read(
+            &message, &msg, &sent_message_port_ids, &new_routing_ids)) {
+      return;
+    }
+    DCHECK(sent_message_port_ids.size() == new_routing_ids.size());
+
+    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
+      new_routing_ids[i] = next_route_id->Run();
+      MessagePortDispatcher::GetInstance()->UpdateMessagePort(
+          sent_message_port_ids[i], sender, new_routing_ids[i], next_route_id);
+    }
+
+    sender->Send(new WorkerMsg_PostMessage(
+        route_id, msg, sent_message_port_ids, new_routing_ids));
+
+    // Send any queued messages to the sent message ports.  We can only do this
+    // after sending the above message, since it's the one that sets up the
+    // message port route which the queued messages are sent to.
+    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
+      MessagePortDispatcher::GetInstance()->
+          SendQueuedMessagesIfPossible(sent_message_port_ids[i]);
+    }
+  } else if (message.type() == WorkerMsg_Connect::ID) {
+    // Crack the SharedWorker Connect message to setup routing for the port.
+    int sent_message_port_id;
+    int new_routing_id;
+    if (!WorkerMsg_Connect::Read(
+            &message, &sent_message_port_id, &new_routing_id)) {
+      return;
+    }
+    new_routing_id = next_route_id->Run();
+    MessagePortDispatcher::GetInstance()->UpdateMessagePort(
+        sent_message_port_id, sender, new_routing_id, next_route_id);
+
+    // Resend the message with the new routing id.
+    sender->Send(new WorkerMsg_Connect(
+        route_id, sent_message_port_id, new_routing_id));
+
+    // Send any queued messages for the sent port.
+    MessagePortDispatcher::GetInstance()->SendQueuedMessagesIfPossible(
+        sent_message_port_id);
+  } else {
     IPC::Message* new_message = new IPC::Message(message);
     new_message->set_routing_id(route_id);
     sender->Send(new_message);
     return;
   }
-
-  // We want to send the receiver a routing id for the new channel, so
-  // crack the message first.
-  string16 msg;
-  std::vector<int> sent_message_port_ids;
-  std::vector<int> new_routing_ids;
-  if (!WorkerMsg_PostMessage::Read(
-          &message, &msg, &sent_message_port_ids, &new_routing_ids)) {
-    return;
-  }
-  DCHECK(sent_message_port_ids.size() == new_routing_ids.size());
-
-  for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-    new_routing_ids[i] = next_route_id->Run();
-    MessagePortDispatcher::GetInstance()->UpdateMessagePort(
-        sent_message_port_ids[i], sender, new_routing_ids[i], next_route_id);
-  }
-
-  sender->Send(new WorkerMsg_PostMessage(
-      route_id, msg, sent_message_port_ids, new_routing_ids));
-
-  // Send any queued messages to the sent message ports.  We can only do this
-  // after sending the above message, since it's the one that sets up the
-  // message port route which the queued messages are sent to.
-  for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-    MessagePortDispatcher::GetInstance()->
-        SendQueuedMessagesIfPossible(sent_message_port_ids[i]);
-  }
 }
 
 void WorkerProcessHost::SenderShutdown(IPC::Message::Sender* sender) {
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     if (i->sender == sender) {
       Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id));
       i = instances_.erase(i);
     } else {
       ++i;
     }
@@ skipping 35 matching lines @@
       instances_.front().render_view_route_id, this, id(), *route_id);
 }
 
 void WorkerProcessHost::OnCancelCreateDedicatedWorker(int route_id) {
   WorkerService::GetInstance()->CancelCreateDedicatedWorker(id(), route_id);
 }
 
 void WorkerProcessHost::OnForwardToWorker(const IPC::Message& message) {
   WorkerService::GetInstance()->ForwardMessage(message, id());
 }