Add a Content API around BrowserChildProcessHost, similar to what was done with ChildProcessHost....

content/browser/worker_host/worker_service_impl.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_impl.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/common/view_messages.h"
 #include "content/common/worker_messages.h"
+#include "content/public/browser/child_process_data.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "net/base/registry_controlled_domain.h"
 
 namespace content {
 
 const int WorkerServiceImpl::kMaxWorkerProcessesWhenSharing = 10;
 const int WorkerServiceImpl::kMaxWorkersWhenSeparate = 64;
 const int WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate = 16;
@@ skipping 10 matching lines @@
 WorkerServiceImpl::WorkerServiceImpl() : next_worker_route_id_(0) {
 }
 
 WorkerServiceImpl::~WorkerServiceImpl() {
   // The observers in observers_ can't be used here because they might be
   // gone already.
 }
 
 void WorkerServiceImpl::OnWorkerMessageFilterClosing(
     WorkerMessageFilter* filter) {
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-     !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
-    worker->FilterShutdown(filter);
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    iter->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) {
       i = queued_workers_.erase(i);
     } else {
       ++i;
@@ skipping 87 matching lines @@
 
 void WorkerServiceImpl::CancelCreateDedicatedWorker(
     int route_id,
     WorkerMessageFilter* filter) {
 
   NOTREACHED();
 }
 
 void WorkerServiceImpl::ForwardToWorker(const IPC::Message& message,
                                         WorkerMessageFilter* filter) {
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
-    if (worker->FilterMessage(message, filter))
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (iter->FilterMessage(message, filter))
       return;
   }
 
   // TODO(jabdelmalek): tell filter that callee is gone
 }
 
 void WorkerServiceImpl::DocumentDetached(unsigned long long document_id,
                                          WorkerMessageFilter* filter) {
   // Any associated shared workers can be shut down.
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
-    worker->DocumentDetached(filter, document_id);
-  }
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter)
+    iter->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);
     if (iter->worker_document_set()->IsEmpty()) {
       iter = queued_workers_.erase(iter);
       continue;
     }
@@ skipping 115 matching lines @@
   worker->CreateWorker(instance);
   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
                     WorkerCreated(worker, instance));
   return true;
 }
 
 WorkerProcessHost* WorkerServiceImpl::GetProcessForDomain(const GURL& url) {
   int num_processes = 0;
   std::string domain =
       net::RegistryControlledDomainService::GetDomainAndRegistry(url);
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
+  for (WorkerProcessHostIterator iter; !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) {
+             iter->instances().begin();
+         instance != iter->instances().end(); ++instance) {
       if (net::RegistryControlledDomainService::GetDomainAndRegistry(
               instance->url()) == domain) {
-        return worker;
+        return *iter;
       }
     }
   }
 
   if (num_processes >= kMaxWorkerProcessesWhenSharing)
     return GetLeastLoadedWorker();
 
   return NULL;
 }
 
 WorkerProcessHost* WorkerServiceImpl::GetProcessToFillUpCores() {
   int num_processes = 0;
-  BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-  for (; !iter.Done(); ++iter)
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter)
     num_processes++;
 
   if (num_processes >= base::SysInfo::NumberOfProcessors())
     return GetLeastLoadedWorker();
 
   return NULL;
 }
 
 WorkerProcessHost* WorkerServiceImpl::GetLeastLoadedWorker() {
   WorkerProcessHost* smallest = NULL;
-  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;
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (!smallest || iter->instances().size() < smallest->instances().size())
+      smallest = *iter;
   }
 
   return smallest;
 }
 
 bool WorkerServiceImpl::CanCreateWorkerProcess(
     const WorkerProcessHost::WorkerInstance& instance) {
   // Worker can be fired off if *any* parent has room.
   const WorkerDocumentSet::DocumentInfoSet& parents =
         instance.worker_document_set()->documents();
@@ skipping 17 matching lines @@
   return false;
 }
 
 bool WorkerServiceImpl::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(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
     for (WorkerProcessHost::Instances::const_iterator cur_instance =
-             worker->instances().begin();
-         cur_instance != worker->instances().end(); ++cur_instance) {
+             iter->instances().begin();
+         cur_instance != iter->instances().end(); ++cur_instance) {
       total_workers++;
       if (total_workers >= kMaxWorkersWhenSeparate) {
         *hit_total_worker_limit = true;
         return false;
       }
       if (cur_instance->RendererIsParent(render_process_id, render_view_id)) {
         workers_per_tab++;
         if (workers_per_tab >= kMaxWorkersPerTabWhenSeparate)
           return false;
       }
@@ skipping 22 matching lines @@
       i = queued_workers_.begin();
     } else {
       ++i;
     }
   }
 }
 
 bool WorkerServiceImpl::GetRendererForWorker(int worker_process_id,
                                              int* render_process_id,
                                              int* render_view_id) const {
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    if (iter->data().id != worker_process_id)
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (iter.GetData().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())
+        iter->instances().begin();
+    if (first_instance == iter->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* WorkerServiceImpl::FindWorkerInstance(
       int worker_process_id) {
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    if (iter->data().id != worker_process_id)
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (iter.GetData().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;
+        iter->instances().begin();
+    return instance == iter->instances().end() ? NULL : &*instance;
   }
   return NULL;
 }
 
 void WorkerServiceImpl::AddObserver(WorkerServiceObserver* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   observers_.AddObserver(observer);
 }
 
 void WorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) {
@@ skipping 11 matching lines @@
 void WorkerServiceImpl::NotifyWorkerContextStarted(WorkerProcessHost* process,
                                                    int worker_route_id) {
   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
                     WorkerContextStarted(process, worker_route_id));
 }
 
 WorkerProcessHost::WorkerInstance* WorkerServiceImpl::FindSharedWorkerInstance(
     const GURL& url,
     const string16& name,
     const content::ResourceContext* resource_context) {
-  for (BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-       !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
     for (WorkerProcessHost::Instances::iterator instance_iter =
-             worker->mutable_instances().begin();
-         instance_iter != worker->mutable_instances().end();
+             iter->mutable_instances().begin();
+         instance_iter != iter->mutable_instances().end();
          ++instance_iter) {
       if (instance_iter->Matches(url, name, resource_context))
         return &(*instance_iter);
     }
   }
   return NULL;
 }
 
 WorkerProcessHost::WorkerInstance* WorkerServiceImpl::FindPendingInstance(
     const GURL& url,
@@ skipping 38 matching lines @@
   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();
 }
 
 }  // namespace content