Move the ProcessType enum out to its own file. This is in preparation for getting rid of ChildPro...

content/browser/worker_host/worker_service.cc

 // Copyright (c) 2011 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 "content/browser/worker_host/worker_service.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "content/browser/resource_context.h"
 #include "content/browser/worker_host/worker_message_filter.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/browser/worker_host/worker_service_observer.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/process_type.h"
 #include "net/base/registry_controlled_domain.h"
 
 using content::BrowserThread;
 
 const int WorkerService::kMaxWorkerProcessesWhenSharing = 10;
 const int WorkerService::kMaxWorkersWhenSeparate = 64;
 const int WorkerService::kMaxWorkersPerTabWhenSeparate = 16;
 
 WorkerService* WorkerService::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<WorkerService>::get();
 }
 
 WorkerService::WorkerService() : next_worker_route_id_(0) {
 }
 
 WorkerService::~WorkerService() {
   // The observers in observers_ can't be used here because they might be
   // gone already.
 }
 
 void WorkerService::OnWorkerMessageFilterClosing(WorkerMessageFilter* filter) {
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
      !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     worker->FilterShutdown(filter);
   }
 
   // See if that process had any queued workers.
   for (WorkerProcessHost::Instances::iterator i = queued_workers_.begin();
        i != queued_workers_.end();) {
     i->RemoveFilters(filter);
     if (i->NumFilters() == 0) {
@@ skipping 90 matching lines @@
 
 void WorkerService::CancelCreateDedicatedWorker(
     int route_id,
     WorkerMessageFilter* filter) {
 
   NOTREACHED();
 }
 
 void WorkerService::ForwardToWorker(const IPC::Message& message,
                                     WorkerMessageFilter* filter) {
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     if (worker->FilterMessage(message, filter))
       return;
   }
 
   // TODO(jabdelmalek): tell filter that callee is gone
 }
 
 void WorkerService::DocumentDetached(unsigned long long document_id,
                                      WorkerMessageFilter* filter) {
   // Any associated shared workers can be shut down.
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !iter.Done(); ++iter) {
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     worker->DocumentDetached(filter, document_id);
   }
 
   // Remove any queued shared workers for this document.
   for (WorkerProcessHost::Instances::iterator iter = queued_workers_.begin();
        iter != queued_workers_.end();) {
 
     iter->worker_document_set()->Remove(filter, document_id);
@@ skipping 121 matching lines @@
   worker->CreateWorker(instance);
   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
                     WorkerCreated(worker, instance));
   return true;
 }
 
 WorkerProcessHost* WorkerService::GetProcessForDomain(const GURL& url) {
   int num_processes = 0;
   std::string domain =
       net::RegistryControlledDomainService::GetDomainAndRegistry(url);
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !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;
-  BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
   for (; !iter.Done(); ++iter)
     num_processes++;
 
   if (num_processes >= base::SysInfo::NumberOfProcessors())
     return GetLeastLoadedWorker();
 
   return NULL;
 }
 
 WorkerProcessHost* WorkerService::GetLeastLoadedWorker() {
   WorkerProcessHost* smallest = NULL;
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !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 render_process_id,
                                               int render_view_id,
                                               bool* hit_total_worker_limit) {
   int total_workers = 0;
   int workers_per_tab = 0;
   *hit_total_worker_limit = false;
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !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 27 matching lines @@
       i = queued_workers_.begin();
     } else {
       ++i;
     }
   }
 }
 
 bool WorkerService::GetRendererForWorker(int worker_process_id,
                                          int* render_process_id,
                                          int* render_view_id) const {
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !iter.Done(); ++iter) {
     if (iter->id() != worker_process_id)
         continue;
 
     // This code assumes one worker per process, see function comment in header!
     WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
     WorkerProcessHost::Instances::const_iterator first_instance =
         worker->instances().begin();
     if (first_instance == worker->instances().end())
       return false;
 
     WorkerDocumentSet::DocumentInfoSet::const_iterator info =
         first_instance->worker_document_set()->documents().begin();
     *render_process_id = info->render_process_id();
     *render_view_id = info->render_view_id();
     return true;
   }
   return false;
 }
 
 const WorkerProcessHost::WorkerInstance* WorkerService::FindWorkerInstance(
       int worker_process_id) {
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !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;
@@ skipping 20 matching lines @@
                                                int worker_route_id) {
   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
                     WorkerContextStarted(process, worker_route_id));
 }
 
 WorkerProcessHost::WorkerInstance*
 WorkerService::FindSharedWorkerInstance(
     const GURL& url,
     const string16& name,
     const content::ResourceContext* resource_context) {
-  for (BrowserChildProcessHost::Iterator iter(ChildProcessInfo::WORKER_PROCESS);
+  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
        !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, resource_context))
         return &(*instance_iter);
     }
   }
@@ skipping 43 matching lines @@
   WorkerProcessHost::WorkerInstance* instance =
       FindPendingInstance(url, name, resource_context);
   if (instance)
     return instance;
 
   // No existing pending worker - create a new one.
   WorkerProcessHost::WorkerInstance pending(url, true, name, resource_context);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }