Refactored code to allow associating workers with multiple renderers.

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 47 matching lines @@
       WorkerService::GetInstance(), &WorkerService::next_worker_route_id));
 }
 
 WorkerProcessHost::~WorkerProcessHost() {
   // Let interested observers know we are being deleted.
   NotificationService::current()->Notify(
       NotificationType::WORKER_PROCESS_HOST_SHUTDOWN,
       Source<WorkerProcessHost>(this),
       NotificationService::NoDetails());
 
-  // If we crashed, tell the RenderViewHost.
+  // If we crashed, tell the RenderViewHosts.
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
-    ChromeThread::PostTask(
-        ChromeThread::UI, FROM_HERE,
-        new WorkerCrashTask(i->renderer_id(), i->render_view_route_id()));
+    const WorkerDocumentSet::DocumentInfoSet& parents =
+        i->worker_document_set()->documents();
+    for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
+             parents.begin(); parent_iter != parents.end(); ++parent_iter) {
+      ChromeThread::PostTask(
+          ChromeThread::UI, FROM_HERE,
+          new WorkerCrashTask(parent_iter->renderer_id(),
+                              parent_iter->render_view_route_id()));
+    }
   }
 
   ChildProcessSecurityPolicy::GetInstance()->Remove(id());
 }
 
 bool WorkerProcessHost::Init() {
   if (!CreateChannel())
     return false;
 
   FilePath exe_path = GetChildPath();
@@ skipping 240 matching lines @@
     sender->Send(new_message);
     return;
   }
 }
 
 void WorkerProcessHost::SenderShutdown(IPC::Message::Sender* sender) {
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     bool shutdown = false;
     i->RemoveSenders(sender);
     if (i->shared()) {
-      i->RemoveAllAssociatedDocuments(sender);
-      if (i->IsDocumentSetEmpty()) {
+      i->worker_document_set()->RemoveAll(sender);
+      if (i->worker_document_set()->IsEmpty()) {
         shutdown = true;
       }
     } else if (i->NumSenders() == 0) {
       shutdown = true;
     }
     if (shutdown) {
       Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
       i = instances_.erase(i);
     } else {
       ++i;
@@ skipping 22 matching lines @@
       display_title += ", ";
     display_title += *i;
   }
 
   set_name(ASCIIToWide(display_title));
 }
 
 void WorkerProcessHost::OnLookupSharedWorker(const GURL& url,
                                              const string16& name,
                                              unsigned long long document_id,
+                                             int render_view_route_id,
                                              int* route_id,
                                              bool* url_mismatch) {
   int new_route_id = WorkerService::GetInstance()->next_worker_route_id();
-  // TODO(atwilson): Add code to merge document sets for nested shared workers.
+  // TODO(atwilson): Add code to pass in the current worker's document set for
+  // these nested workers. Code below will not work for SharedWorkers as it
+  // only looks at a single parent.
+  DCHECK(instances_.front().worker_document_set()->documents().size() == 1);
+  WorkerDocumentSet::DocumentInfoSet::const_iterator first_parent =
+      instances_.front().worker_document_set()->documents().begin();
   bool worker_found = WorkerService::GetInstance()->LookupSharedWorker(
-      url, name, instances_.front().off_the_record(), document_id, this,
+      url, name, instances_.front().off_the_record(), document_id,
+      first_parent->renderer_id(), first_parent->render_view_route_id(), this,
       new_route_id, url_mismatch);
   *route_id = worker_found ? new_route_id : MSG_ROUTING_NONE;
 }
 
-void WorkerProcessHost::OnCreateWorker(const GURL& url,
-                                       bool shared,
-                                       const string16& name,
-                                       int render_view_route_id,
-                                       int* route_id) {
+void WorkerProcessHost::OnCreateWorker(
+    const ViewHostMsg_CreateWorker_Params& params, int* route_id) {
   DCHECK(instances_.size() == 1);  // Only called when one process per worker.
+  // TODO(atwilson): Add code to pass in the current worker's document set for
+  // these nested workers. Code below will not work for SharedWorkers as it
+  // only looks at a single parent.
+  DCHECK(instances_.front().worker_document_set()->documents().size() == 1);
+  WorkerDocumentSet::DocumentInfoSet::const_iterator first_parent =
+      instances_.front().worker_document_set()->documents().begin();
   *route_id = WorkerService::GetInstance()->next_worker_route_id();
   WorkerService::GetInstance()->CreateWorker(
-      url, shared, instances_.front().off_the_record(), name,
-      instances_.front().renderer_id(),
-      instances_.front().render_view_route_id(), this, *route_id);
-  // TODO(atwilson): Add code to merge document sets for nested shared workers.
+      params.url, params.is_shared, instances_.front().off_the_record(),
+      params.name, params.document_id, first_parent->renderer_id(),
+      first_parent->render_view_route_id(), this, *route_id);
 }
 
 void WorkerProcessHost::OnCancelCreateDedicatedWorker(int route_id) {
   WorkerService::GetInstance()->CancelCreateDedicatedWorker(this, route_id);
 }
 
 void WorkerProcessHost::OnForwardToWorker(const IPC::Message& message) {
   WorkerService::GetInstance()->ForwardMessage(message, this);
 }
 
 void WorkerProcessHost::DocumentDetached(IPC::Message::Sender* parent,
                                          unsigned long long document_id)
 {
   // Walk all instances and remove the document from their document set.
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     if (!i->shared()) {
       ++i;
     } else {
-      i->RemoveFromDocumentSet(parent, document_id);
-      if (i->IsDocumentSetEmpty()) {
+      i->worker_document_set()->Remove(parent, document_id);
+      if (i->worker_document_set()->IsEmpty()) {
         // This worker has no more associated documents - shut it down.
         Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
         i = instances_.erase(i);
       } else {
         ++i;
       }
     }
   }
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(const GURL& url,
                                                   bool shared,
                                                   bool off_the_record,
                                                   const string16& name,
-                                                  int renderer_id,
-                                                  int render_view_route_id,
                                                   int worker_route_id)
     : url_(url),
       shared_(shared),
       off_the_record_(off_the_record),
       closed_(false),
       name_(name),
-      renderer_id_(renderer_id),
-      render_view_route_id_(render_view_route_id),
-      worker_route_id_(worker_route_id) {
+      worker_route_id_(worker_route_id),
+      worker_document_set_(new WorkerDocumentSet()) {
 }
 
 // Compares an instance based on the algorithm in the WebWorkers spec - an
 // instance matches if the origins of the URLs match, and:
 // a) the names are non-empty and equal
 // -or-
 // b) the names are both empty, and the urls are equal
 bool WorkerProcessHost::WorkerInstance::Matches(
     const GURL& match_url, const string16& match_name,
     bool off_the_record) const {
   // Only match open shared workers.
   if (!shared_ || closed_)
     return false;
 
   // Incognito workers don't match non-incognito workers.
   if (off_the_record_ != off_the_record)
     return false;
 
   if (url_.GetOrigin() != match_url.GetOrigin())
     return false;
 
   if (name_.empty() && match_name.empty())
     return url_ == match_url;
 
   return name_ == match_name;
 }
 
-void WorkerProcessHost::WorkerInstance::AddToDocumentSet(
-    IPC::Message::Sender* parent, unsigned long long document_id) {
-  if (!IsInDocumentSet(parent, document_id)) {
-    DocumentInfo info(parent, document_id);
-    document_set_.push_back(info);
-  }
-}
-
-bool WorkerProcessHost::WorkerInstance::IsInDocumentSet(
-    IPC::Message::Sender* parent, unsigned long long document_id) const {
-  for (DocumentSet::const_iterator i = document_set_.begin();
-       i != document_set_.end(); ++i) {
-    if (i->first == parent && i->second == document_id)
-      return true;
-  }
-  return false;
-}
-
-void WorkerProcessHost::WorkerInstance::RemoveFromDocumentSet(
-    IPC::Message::Sender* parent, unsigned long long document_id) {
-  for (DocumentSet::iterator i = document_set_.begin();
-       i != document_set_.end(); i++) {
-    if (i->first == parent && i->second == document_id) {
-      document_set_.erase(i);
-      break;
-    }
-  }
-  // Should not be duplicate copies in the document set.
-  DCHECK(!IsInDocumentSet(parent, document_id));
-}
-
-void WorkerProcessHost::WorkerInstance::RemoveAllAssociatedDocuments(
-    IPC::Message::Sender* parent) {
-  for (DocumentSet::iterator i = document_set_.begin();
-       i != document_set_.end();) {
-    if (i->first == parent)
-      i = document_set_.erase(i);
-    else
-      ++i;
-  }
-}
-
 void WorkerProcessHost::WorkerInstance::AddSender(IPC::Message::Sender* sender,
                                                   int sender_route_id) {
   if (!HasSender(sender, sender_route_id)) {
     SenderInfo info(sender, sender_route_id);
     senders_.push_back(info);
   }
   // Only shared workers can have more than one associated sender.
   DCHECK(shared_ || senders_.size() == 1);
 }
 
@@ skipping 22 matching lines @@
 bool WorkerProcessHost::WorkerInstance::HasSender(
     IPC::Message::Sender* sender, int sender_route_id) const {
   for (SenderList::const_iterator i = senders_.begin(); i != senders_.end();
        ++i) {
     if (i->first == sender && i->second == sender_route_id)
       return true;
   }
   return false;
 }
 
+bool WorkerProcessHost::WorkerInstance::RendererIsParent(
+    int renderer_id, int render_view_route_id) const {
+  const WorkerDocumentSet::DocumentInfoSet& parents =
+      worker_document_set()->documents();
+  for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
+           parents.begin();
+       parent_iter != parents.end(); ++parent_iter) {
+    if (parent_iter->renderer_id() == renderer_id &&
+        parent_iter->render_view_route_id() == render_view_route_id) {
+      return true;
+    }
+  }
+  return false;
+}
+
 WorkerProcessHost::WorkerInstance::SenderInfo
 WorkerProcessHost::WorkerInstance::GetSender() const {
   DCHECK(NumSenders() == 1);
   return *senders_.begin();
 }