Moved common parts of ChildProcessHost into chrome/common and created a Brows...

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 244 matching lines @@
   instance->AddSender(sender, sender_route_id);
 
   // Add the passed sender/document_id to the worker instance.
   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);
+  for (BrowserChildProcessHost::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->worker_document_set()->Remove(sender, document_id);
@@ skipping 26 matching lines @@
     if (i->HasSender(sender, sender_route_id)) {
       DCHECK(!i->shared());
       queued_workers_.erase(i);
       return;
     }
   }
 
   // There could be a race condition where the WebWorkerProxy told us to cancel
   // the worker right as we sent it a message say it's been created.  Look at
   // the running workers.
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     for (WorkerProcessHost::Instances::const_iterator instance =
              worker->instances().begin();
          instance != worker->instances().end(); ++instance) {
       if (instance->HasSender(sender, sender_route_id)) {
         // Fake a worker destroyed message so that WorkerProcessHost cleans up
         // properly.
         WorkerHostMsg_WorkerContextDestroyed msg(sender_route_id);
         ForwardMessage(msg, sender);
         return;
       }
     }
   }
 
   DCHECK(false) << "Couldn't find worker to cancel";
 }
 
 void WorkerService::ForwardMessage(const IPC::Message& message,
                                    IPC::Message::Sender* sender) {
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     if (worker->FilterMessage(message, sender))
       return;
   }
 
   // TODO(jabdelmalek): tell sender that callee is gone
 }
 
 WorkerProcessHost* WorkerService::GetProcessForDomain(const GURL& url) {
   int num_processes = 0;
   std::string domain =
       net::RegistryControlledDomainService::GetDomainAndRegistry(url);
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     num_processes++;
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     for (WorkerProcessHost::Instances::const_iterator instance =
              worker->instances().begin();
          instance != worker->instances().end(); ++instance) {
       if (net::RegistryControlledDomainService::GetDomainAndRegistry(
               instance->url()) == domain) {
         return worker;
       }
     }
   }
 
   if (num_processes >= kMaxWorkerProcessesWhenSharing)
     return GetLeastLoadedWorker();
 
   return NULL;
 }
 
 WorkerProcessHost* WorkerService::GetProcessToFillUpCores() {
   int num_processes = 0;
-  ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
   for (; !iter.Done(); ++iter)
     num_processes++;
 
   if (num_processes >= base::SysInfo::NumberOfProcessors())
     return GetLeastLoadedWorker();
 
   return NULL;
 }
 
 WorkerProcessHost* WorkerService::GetLeastLoadedWorker() {
   WorkerProcessHost* smallest = NULL;
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     if (!smallest || worker->instances().size() < smallest->instances().size())
       smallest = worker;
   }
 
   return smallest;
 }
 
 bool WorkerService::CanCreateWorkerProcess(
@@ skipping 20 matching lines @@
   // 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);
+  for (BrowserChildProcessHost::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) {
         *hit_total_worker_limit = true;
         return false;
       }
@@ skipping 17 matching lines @@
   } else if (type.value == NotificationType::WORKER_PROCESS_HOST_SHUTDOWN) {
     WorkerProcessHost* sender = Source<WorkerProcessHost>(source).ptr();
     SenderShutdown(sender);
     WorkerProcessDestroyed(sender);
   } else {
     NOTREACHED();
   }
 }
 
 void WorkerService::SenderShutdown(IPC::Message::Sender* sender) {
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     worker->SenderShutdown(sender);
   }
 
   // See if that render process had any queued workers.
   for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin();
        i != queued_workers_.end();) {
     i->RemoveSenders(sender);
     if (i->NumSenders() == 0) {
@@ skipping 34 matching lines @@
       // rare in practice so the list will be small.
       i = queued_workers_.begin();
     } else {
       ++i;
     }
   }
 }
 
 const WorkerProcessHost::WorkerInstance* WorkerService::FindWorkerInstance(
       int worker_process_id) {
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     if (iter->id() != worker_process_id)
         continue;
 
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     WorkerProcessHost::Instances::const_iterator instance =
         worker->instances().begin();
     return instance == worker->instances().end() ? NULL : &*instance;
   }
   return NULL;
 }
 
 WorkerProcessHost::WorkerInstance*
 WorkerService::FindSharedWorkerInstance(const GURL& url, const string16& name,
                                         bool off_the_record) {
-  for (ChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     for (WorkerProcessHost::Instances::iterator instance_iter =
              worker->mutable_instances().begin();
          instance_iter != worker->mutable_instances().end();
          ++instance_iter) {
       if (instance_iter->Matches(url, name, off_the_record))
         return &(*instance_iter);
     }
   }
@@ skipping 40 matching lines @@
       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, MSG_ROUTING_NONE, 0, 0, 0, NULL);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }