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

chrome/browser/task_manager/task_manager_worker_resource_provider.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 "chrome/browser/task_manager/task_manager_worker_resource_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/profiles/profile_manager.h"
-#include "content/browser/browser_child_process_host.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/worker_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 186 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(
           &TaskManagerWorkerResourceProvider::StopObservingWorkers,
           this));
 }
 
 void TaskManagerWorkerResourceProvider::WorkerCreated(
       WorkerProcessHost* process,
       const WorkerProcessHost::WorkerInstance& instance) {
   TaskManagerSharedWorkerResource* resource =
-      new TaskManagerSharedWorkerResource(process->data(),
+      new TaskManagerSharedWorkerResource(process->GetData(),
                                           instance.worker_route_id(),
                                           instance.url(), instance.name());
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskManagerWorkerResourceProvider::NotifyWorkerCreated,
                  this, base::Owned(new WorkerResourceHolder(resource))));
 }
 
 void TaskManagerWorkerResourceProvider::WorkerDestroyed(
       WorkerProcessHost* process,
       int worker_route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
           &TaskManagerWorkerResourceProvider::NotifyWorkerDestroyed,
-          this, process->data().id, worker_route_id));
+          this, process->GetData().id, worker_route_id));
 }
 
 void TaskManagerWorkerResourceProvider::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   content::ChildProcessData* process_data =
       content::Details<content::ChildProcessData>(details).ptr();
   if (process_data->type != content::PROCESS_TYPE_WORKER)
     return;
@@ skipping 50 matching lines @@
       resources_.erase(it);
       return;
     }
   }
 }
 
 void TaskManagerWorkerResourceProvider::StartObservingWorkers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   scoped_ptr<WorkerResourceListHolder> holder(new WorkerResourceListHolder);
-  BrowserChildProcessHost::Iterator iter(content::PROCESS_TYPE_WORKER);
-  for (; !iter.Done(); ++iter) {
-    WorkerProcessHost* worker = static_cast<WorkerProcessHost*>(*iter);
-    const WorkerProcessHost::Instances& instances = worker->instances();
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    const WorkerProcessHost::Instances& instances = (*iter)->instances();
     for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
          i != instances.end(); ++i) {
        holder->resources()->push_back(new TaskManagerSharedWorkerResource(
-           (*iter)->data(), i->worker_route_id(), i->url(), i->name()));
+           iter.GetData(), i->worker_route_id(), i->url(), i->name()));
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &TaskManagerWorkerResourceProvider::AddWorkerResourceList,
           this, base::Owned(holder.release())));
 
   WorkerService::GetInstance()->AddObserver(this);
@@ skipping 24 matching lines @@
     int process_id = resource->process_data().id;
     launching_workers_[process_id].push_back(resource);
   } else {
     task_manager_->AddResource(resource);
   }
 }
 
 void TaskManagerWorkerResourceProvider::DeleteAllResources() {
   STLDeleteElements(&resources_);
 }