Refactored code to allow associating workers with multiple renderers.

chrome/browser/worker_host/worker_service.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_service.h"
 
 #include "base/command_line.h"
 #include "base/singleton.h"
 #include "base/sys_info.h"
 #include "base/thread.h"
@@ skipping 31 matching lines @@
   resource_dispatcher_host_ = rdh;
 }
 
 WorkerService::~WorkerService() {
 }
 
 bool WorkerService::CreateWorker(const GURL &url,
                                  bool is_shared,
                                  bool off_the_record,
                                  const string16& name,
+                                 unsigned long long document_id,
                                  int renderer_id,
                                  int render_view_route_id,
                                  IPC::Message::Sender* sender,
                                  int sender_route_id) {
   // Generate a unique route id for the browser-worker communication that's
   // unique among all worker processes.  That way when the worker process sends
   // a wrapped IPC message through us, we know which WorkerProcessHost to give
   // it to.
   WorkerProcessHost::WorkerInstance instance(url,
                                              is_shared,
                                              off_the_record,
                                              name,
-                                             renderer_id,
-                                             render_view_route_id,
                                              next_worker_route_id());
   instance.AddSender(sender, sender_route_id);
+  instance.worker_document_set()->Add(
+      sender, document_id, renderer_id, render_view_route_id);
 
   WorkerProcessHost* worker = NULL;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kWebWorkerProcessPerCore)) {
     worker = GetProcessToFillUpCores();
   } else if (CommandLine::ForCurrentProcess()->HasSwitch(
                  switches::kWebWorkerShareProcesses)) {
     worker = GetProcessForDomain(url);
   } else {  // One process per worker.
     if (!CanCreateWorkerProcess(instance)) {
       queued_workers_.push_back(instance);
       return true;
     }
   }
 
   // Check to see if this shared worker is already running (two pages may have
   // tried to start up the worker simultaneously).
   if (is_shared) {
     // See if a worker with this name already exists.
     WorkerProcessHost::WorkerInstance* existing_instance =
         FindSharedWorkerInstance(url, name, off_the_record);
     // If this worker is already running, no need to create a new copy. Just
     // inform the caller that the worker has been created.
     if (existing_instance) {
+      // TODO(atwilson): Change this to scan the sender list (crbug.com/29243).
       existing_instance->AddSender(sender, sender_route_id);
       sender->Send(new ViewMsg_WorkerCreated(sender_route_id));
       return true;
     }
 
     // Look to see if there's a pending instance.
     WorkerProcessHost::WorkerInstance* pending = FindPendingInstance(
         url, name, off_the_record);
     // If there's no instance *and* no pending instance, then it means the
     // worker started up and exited already. Log a warning because this should
     // be a very rare occurrence and is probably a bug, but it *can* happen so
     // handle it gracefully.
     if (!pending) {
       DLOG(WARNING) << "Pending worker already exited";
       return false;
     }
 
     // Assign the accumulated document set and sender list for this pending
     // worker to the new instance.
-    DCHECK(!pending->IsDocumentSetEmpty());
-    instance.CopyDocumentSet(*pending);
+    DCHECK(!pending->worker_document_set()->IsEmpty());
+    instance.ShareDocumentSet(*pending);
     RemovePendingInstance(url, name, off_the_record);
   }
 
   if (!worker) {
     worker = new WorkerProcessHost(resource_dispatcher_host_);
     if (!worker->Init()) {
       delete worker;
       return false;
     }
   }
 
   worker->CreateWorker(instance);
   return true;
 }
 
 bool WorkerService::LookupSharedWorker(const GURL &url,
                                        const string16& name,
                                        bool off_the_record,
                                        unsigned long long document_id,
+                                       int renderer_id,
+                                       int render_view_route_id,
                                        IPC::Message::Sender* sender,
                                        int sender_route_id,
                                        bool* url_mismatch) {
   bool found_instance = true;
   WorkerProcessHost::WorkerInstance* instance =
       FindSharedWorkerInstance(url, name, off_the_record);
 
   if (!instance) {
     // If no worker instance currently exists, we need to create a pending
     // instance - this is to make sure that any subsequent lookups passing a
@@ skipping 11 matching lines @@
     return false;
   } else {
     *url_mismatch = false;
   }
 
   // Add our route ID to the existing instance so we can send messages to it.
   if (found_instance)
     instance->AddSender(sender, sender_route_id);
 
   // Add the passed sender/document_id to the worker instance.
-  instance->AddToDocumentSet(sender, document_id);
+  instance->worker_document_set()->Add(
+      sender, document_id, renderer_id, render_view_route_id);
   return found_instance;
 }
 
 void WorkerService::DocumentDetached(IPC::Message::Sender* sender,
                                      unsigned long long document_id) {
   for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     worker->DocumentDetached(sender, document_id);
   }
 
   // Remove any queued shared workers for this document.
   for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin();
        iter != queued_workers_.end();) {
     if (iter->shared()) {
-      iter->RemoveFromDocumentSet(sender, document_id);
-      if (iter->IsDocumentSetEmpty()) {
+      iter->worker_document_set()->Remove(sender, document_id);
+      if (iter->worker_document_set()->IsEmpty()) {
         iter = queued_workers_.erase(iter);
         continue;
       }
     }
     ++iter;
   }
 
   // Remove the document from any pending shared workers.
   for (WorkerProcessHost::Instances::iterator iter =
            pending_shared_workers_.begin();
        iter != pending_shared_workers_.end(); ) {
-    iter->RemoveFromDocumentSet(sender, document_id);
-    if (iter->IsDocumentSetEmpty()) {
+    iter->worker_document_set()->Remove(sender, document_id);
+    if (iter->worker_document_set()->IsEmpty()) {
       iter = pending_shared_workers_.erase(iter);
     } else {
       ++iter;
     }
   }
 
 }
 
 void WorkerService::CancelCreateDedicatedWorker(IPC::Message::Sender* sender,
                                                 int sender_route_id) {
@@ skipping 83 matching lines @@
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     if (!smallest || worker->instances().size() < smallest->instances().size())
       smallest = worker;
   }
 
   return smallest;
 }
 
 bool WorkerService::CanCreateWorkerProcess(
     const WorkerProcessHost::WorkerInstance& instance) {
+  // Worker can be fired off if *any* parent has room.
+  const WorkerDocumentSet::DocumentInfoSet& parents =
+        instance.worker_document_set()->documents();
+
+  for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
+           parents.begin();
+       parent_iter != parents.end(); ++parent_iter) {
+    bool hit_total_worker_limit = false;
+    if (TabCanCreateWorkerProcess(parent_iter->renderer_id(),
+                                  parent_iter->render_view_route_id(),
+                                  &hit_total_worker_limit)) {
+      return true;
+    }
+    // Return false if already at the global worker limit (no need to continue
+    // checking parent tabs).
+    if (hit_total_worker_limit)
+      return false;
+  }
+  // If we've reached here, none of the parent tabs is allowed to create an
+  // instance.
+  return false;
+}
+
+bool WorkerService::TabCanCreateWorkerProcess(int renderer_id,
+                                              int render_view_route_id,
+                                              bool* hit_total_worker_limit) {
   int total_workers = 0;
   int workers_per_tab = 0;
+  *hit_total_worker_limit = false;
   for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     for (WorkerProcessHost::Instances::const_iterator cur_instance =
              worker->instances().begin();
          cur_instance != worker->instances().end(); ++cur_instance) {
       total_workers++;
-      if (total_workers >= kMaxWorkersWhenSeparate)
+      if (total_workers >= kMaxWorkersWhenSeparate) {
+        *hit_total_worker_limit = true;
         return false;
-      if (cur_instance->renderer_id() == instance.renderer_id() &&
-          cur_instance->render_view_route_id() ==
-            instance.render_view_route_id()) {
+      }
+      if (cur_instance->RendererIsParent(renderer_id, render_view_route_id)) {
         workers_per_tab++;
         if (workers_per_tab >= kMaxWorkersPerTabWhenSeparate)
           return false;
       }
     }
   }
 
   return true;
 }
 
@@ skipping 27 matching lines @@
       i = queued_workers_.erase(i);
     } else {
       ++i;
     }
   }
 
   // Also, see if that render process had any pending shared workers.
   for (WorkerProcessHost::Instances::iterator iter =
            pending_shared_workers_.begin();
        iter != pending_shared_workers_.end(); ) {
-    iter->RemoveAllAssociatedDocuments(sender);
-    if (iter->IsDocumentSetEmpty()) {
+    iter->worker_document_set()->RemoveAll(sender);
+    if (iter->worker_document_set()->IsEmpty()) {
       iter = pending_shared_workers_.erase(iter);
     } else {
       ++iter;
     }
   }
 }
 
 void WorkerService::WorkerProcessDestroyed(WorkerProcessHost* process) {
   if (queued_workers_.empty())
     return;
@@ skipping 84 matching lines @@
                                      const string16& name,
                                      bool off_the_record) {
   // Look for an existing pending worker.
   WorkerProcessHost::WorkerInstance* instance =
       FindPendingInstance(url, name, off_the_record);
   if (instance)
     return instance;
 
   // No existing pending worker - create a new one.
   WorkerProcessHost::WorkerInstance pending(
-      url, true, off_the_record, name, 0, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
+      url, true, off_the_record, name, MSG_ROUTING_NONE);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }