Create task_manager namespace and wrap classes related to TaskManager with it.

chrome/browser/task_manager/worker_resource_provider.cc

 // Copyright (c) 2012 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 "chrome/browser/task_manager/worker_resource_provider.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_process_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/worker_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::BrowserThread;
 using content::DevToolsAgentHost;
 using content::WorkerService;
 
-////////////////////////////////////////////////////////////////////////////////
-// TaskManagerSharedWorkerResource class
-////////////////////////////////////////////////////////////////////////////////
+namespace task_manager {
 
 // Objects of this class are created on the IO thread and then passed to the UI
 // thread where they are passed to the task manager. All methods must be called
 // only on the UI thread. Destructor may be called on any thread.
-class TaskManagerSharedWorkerResource : public TaskManager::Resource {
+class SharedWorkerResource : public TaskManager::Resource {
  public:
-  TaskManagerSharedWorkerResource(const GURL& url,
-                                  const string16& name,
-                                  int process_id,
-                                  int routing_id,
-                                  base::ProcessHandle process_handle);
-  virtual ~TaskManagerSharedWorkerResource();
+  SharedWorkerResource(const GURL& url,
+                       const string16& name,
+                       int process_id,
+                       int routing_id,
+                       base::ProcessHandle process_handle);
+  virtual ~SharedWorkerResource();
 
   bool Matches(int process_id, int routing_id) const;
 
   void UpdateProcessHandle(base::ProcessHandle handle);
   base::ProcessHandle handle() const { return handle_; }
   int process_id() const { return process_id_; }
 
  private:
   // TaskManager::Resource methods:
   virtual string16 GetTitle() const OVERRIDE;
   virtual string16 GetProfileName() const OVERRIDE;
   virtual gfx::ImageSkia GetIcon() const OVERRIDE;
   virtual base::ProcessHandle GetProcess() const OVERRIDE;
   virtual int GetUniqueChildProcessId() const OVERRIDE;
   virtual Type GetType() const OVERRIDE;
   virtual bool CanInspect() const OVERRIDE;
   virtual void Inspect() const OVERRIDE;
 
   virtual bool SupportNetworkUsage() const OVERRIDE;
   virtual void SetSupportNetworkUsage() OVERRIDE;
 
   int process_id_;
   int routing_id_;
   string16 title_;
   base::ProcessHandle handle_;
 
   static gfx::ImageSkia* default_icon_;
 
-  DISALLOW_COPY_AND_ASSIGN(TaskManagerSharedWorkerResource);
+  DISALLOW_COPY_AND_ASSIGN(SharedWorkerResource);
 };
 
-gfx::ImageSkia* TaskManagerSharedWorkerResource::default_icon_ = NULL;
+gfx::ImageSkia* SharedWorkerResource::default_icon_ = NULL;
 
-TaskManagerSharedWorkerResource::TaskManagerSharedWorkerResource(
+SharedWorkerResource::SharedWorkerResource(
     const GURL& url,
     const string16& name,
     int process_id,
     int routing_id,
     base::ProcessHandle process_handle)
     : process_id_(process_id),
       routing_id_(routing_id),
       handle_(process_handle) {
   title_ = UTF8ToUTF16(url.spec());
   if (!name.empty())
     title_ += ASCIIToUTF16(" (") + name + ASCIIToUTF16(")");
 }
 
-TaskManagerSharedWorkerResource::~TaskManagerSharedWorkerResource() {
+SharedWorkerResource::~SharedWorkerResource() {
 }
 
-bool TaskManagerSharedWorkerResource::Matches(int process_id,
-                                              int routing_id) const {
+bool SharedWorkerResource::Matches(int process_id,
+                                   int routing_id) const {
   return process_id_ == process_id && routing_id_ == routing_id;
 }
 
-void TaskManagerSharedWorkerResource::UpdateProcessHandle(
-    base::ProcessHandle handle) {
+void SharedWorkerResource::UpdateProcessHandle(base::ProcessHandle handle) {
   handle_ = handle;
 }
 
-string16 TaskManagerSharedWorkerResource::GetTitle() const {
+string16 SharedWorkerResource::GetTitle() const {
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_WORKER_PREFIX, title_);
 }
 
-string16 TaskManagerSharedWorkerResource::GetProfileName() const {
+string16 SharedWorkerResource::GetProfileName() const {
   return string16();
 }
 
-gfx::ImageSkia TaskManagerSharedWorkerResource::GetIcon() const {
+gfx::ImageSkia SharedWorkerResource::GetIcon() const {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGINS_FAVICON);
     // TODO(jabdelmalek): use different icon for web workers.
   }
   return *default_icon_;
 }
 
-base::ProcessHandle TaskManagerSharedWorkerResource::GetProcess() const {
+base::ProcessHandle SharedWorkerResource::GetProcess() const {
   return handle_;
 }
 
-int TaskManagerSharedWorkerResource::GetUniqueChildProcessId() const {
+int SharedWorkerResource::GetUniqueChildProcessId() const {
   return process_id_;
 }
 
-TaskManager::Resource::Type TaskManagerSharedWorkerResource::GetType() const {
+TaskManager::Resource::Type SharedWorkerResource::GetType() const {
   return WORKER;
 }
 
-bool TaskManagerSharedWorkerResource::CanInspect() const {
+bool SharedWorkerResource::CanInspect() const {
   return true;
 }
 
-void TaskManagerSharedWorkerResource::Inspect() const {
+void SharedWorkerResource::Inspect() const {
   // TODO(yurys): would be better to get profile from one of the tabs connected
   // to the worker.
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile)
     return;
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForWorker(process_id_, routing_id_));
   DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
 }
 
-bool TaskManagerSharedWorkerResource::SupportNetworkUsage() const {
+bool SharedWorkerResource::SupportNetworkUsage() const {
   return false;
 }
 
-void TaskManagerSharedWorkerResource::SetSupportNetworkUsage() {
+void SharedWorkerResource::SetSupportNetworkUsage() {
 }
 
 
 // This class is needed to ensure that all resources in WorkerResourceList are
 // deleted if corresponding task is posted to but not executed on the UI
 // thread.
-class TaskManagerWorkerResourceProvider::WorkerResourceListHolder {
+class WorkerResourceProvider::WorkerResourceListHolder {
  public:
   WorkerResourceListHolder() {
   }
 
   ~WorkerResourceListHolder() {
     STLDeleteElements(&resources_);
   }
 
   WorkerResourceList* resources() {
     return &resources_;
   }
 
  private:
   WorkerResourceList resources_;
 };
 
 
-TaskManagerWorkerResourceProvider::
-    TaskManagerWorkerResourceProvider(TaskManager* task_manager)
+WorkerResourceProvider::
+    WorkerResourceProvider(TaskManager* task_manager)
     : updating_(false),
       task_manager_(task_manager) {
 }
 
-TaskManagerWorkerResourceProvider::~TaskManagerWorkerResourceProvider() {
+WorkerResourceProvider::~WorkerResourceProvider() {
   DeleteAllResources();
 }
 
-TaskManager::Resource* TaskManagerWorkerResourceProvider::GetResource(
+TaskManager::Resource* WorkerResourceProvider::GetResource(
     int origin_pid,
     int render_process_host_id,
     int routing_id) {
   return NULL;
 }
 
-void TaskManagerWorkerResourceProvider::StartUpdating() {
+void WorkerResourceProvider::StartUpdating() {
   DCHECK(!updating_);
   updating_ = true;
   // Get existing workers.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::StartObservingWorkers,
+          &WorkerResourceProvider::StartObservingWorkers,
           this));
 
   BrowserChildProcessObserver::Add(this);
 }
 
-void TaskManagerWorkerResourceProvider::StopUpdating() {
+void WorkerResourceProvider::StopUpdating() {
   DCHECK(updating_);
   updating_ = false;
   launching_workers_.clear();
   DeleteAllResources();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::StopObservingWorkers,
+          &WorkerResourceProvider::StopObservingWorkers,
           this));
 
   BrowserChildProcessObserver::Remove(this);
 }
 
-void TaskManagerWorkerResourceProvider::BrowserChildProcessHostConnected(
+void WorkerResourceProvider::BrowserChildProcessHostConnected(
     const content::ChildProcessData& data) {
   DCHECK(updating_);
 
   if (data.process_type != content::PROCESS_TYPE_WORKER)
     return;
 
   ProcessIdToWorkerResources::iterator it(launching_workers_.find(data.id));
   if (it == launching_workers_.end())
     return;
   WorkerResourceList& resources = it->second;
   for (WorkerResourceList::iterator r = resources.begin();
        r != resources.end(); ++r) {
     (*r)->UpdateProcessHandle(data.handle);
     task_manager_->AddResource(*r);
   }
   launching_workers_.erase(it);
 }
 
-void TaskManagerWorkerResourceProvider::BrowserChildProcessHostDisconnected(
+void WorkerResourceProvider::BrowserChildProcessHostDisconnected(
     const content::ChildProcessData& data) {
   DCHECK(updating_);
 
   if (data.process_type != content::PROCESS_TYPE_WORKER)
     return;
 
   // Worker process may be destroyed before WorkerMsg_TerminateWorkerContex
   // message is handled and WorkerDestroyed is fired. In this case we won't
   // get WorkerDestroyed notification and have to clear resources for such
   // workers here when the worker process has been destroyed.
   for (WorkerResourceList::iterator it = resources_.begin();
        it != resources_.end();) {
     if ((*it)->process_id() == data.id) {
       task_manager_->RemoveResource(*it);
       delete *it;
       it = resources_.erase(it);
     } else {
       ++it;
     }
   }
   DCHECK(!ContainsKey(launching_workers_, data.id));
 }
 
-void TaskManagerWorkerResourceProvider::WorkerCreated(
+void WorkerResourceProvider::WorkerCreated(
     const GURL& url,
     const string16& name,
     int process_id,
     int route_id) {
-  TaskManagerSharedWorkerResource* resource =
-      new TaskManagerSharedWorkerResource(
-          url, name, process_id, route_id, base::kNullProcessHandle);
+  SharedWorkerResource* resource = new SharedWorkerResource(
+      url, name, process_id, route_id, base::kNullProcessHandle);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&TaskManagerWorkerResourceProvider::NotifyWorkerCreated,
+      base::Bind(&WorkerResourceProvider::NotifyWorkerCreated,
                  this, base::Owned(new WorkerResourceHolder(resource))));
 }
 
-void TaskManagerWorkerResourceProvider::WorkerDestroyed(int process_id,
-                                                        int route_id) {
+void WorkerResourceProvider::WorkerDestroyed(int process_id, int route_id) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::NotifyWorkerDestroyed,
+          &WorkerResourceProvider::NotifyWorkerDestroyed,
           this, process_id, route_id));
 }
 
-void TaskManagerWorkerResourceProvider::NotifyWorkerCreated(
+void WorkerResourceProvider::NotifyWorkerCreated(
     WorkerResourceHolder* resource_holder) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!updating_)
     return;
   AddResource(resource_holder->release());
 }
 
-void TaskManagerWorkerResourceProvider::NotifyWorkerDestroyed(
+void WorkerResourceProvider::NotifyWorkerDestroyed(
     int process_id, int routing_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!updating_)
     return;
   for (WorkerResourceList::iterator it = resources_.begin();
        it !=resources_.end(); ++it) {
     if ((*it)->Matches(process_id, routing_id)) {
       task_manager_->RemoveResource(*it);
       delete *it;
       resources_.erase(it);
       return;
     }
   }
 }
 
-void TaskManagerWorkerResourceProvider::StartObservingWorkers() {
+void WorkerResourceProvider::StartObservingWorkers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   scoped_ptr<WorkerResourceListHolder> holder(new WorkerResourceListHolder);
   std::vector<WorkerService::WorkerInfo> worker_info =
       WorkerService::GetInstance()->GetWorkers();
 
   for (size_t i = 0; i < worker_info.size(); ++i) {
-    holder->resources()->push_back(new TaskManagerSharedWorkerResource(
+    holder->resources()->push_back(new SharedWorkerResource(
         worker_info[i].url, worker_info[i].name, worker_info[i].process_id,
         worker_info[i].route_id, worker_info[i].handle));
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
-          &TaskManagerWorkerResourceProvider::AddWorkerResourceList,
+          &WorkerResourceProvider::AddWorkerResourceList,
           this, base::Owned(holder.release())));
 
   WorkerService::GetInstance()->AddObserver(this);
 }
 
-void TaskManagerWorkerResourceProvider::StopObservingWorkers() {
+void WorkerResourceProvider::StopObservingWorkers() {
   WorkerService::GetInstance()->RemoveObserver(this);
 }
 
-void TaskManagerWorkerResourceProvider::AddWorkerResourceList(
+void WorkerResourceProvider::AddWorkerResourceList(
     WorkerResourceListHolder* resource_list_holder) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!updating_)
     return;
   WorkerResourceList* resources = resource_list_holder->resources();
   for (WorkerResourceList::iterator it = resources->begin();
        it !=resources->end(); ++it) {
     AddResource(*it);
   }
   resources->clear();
 }
 
-void TaskManagerWorkerResourceProvider::AddResource(
-    TaskManagerSharedWorkerResource* resource) {
+void WorkerResourceProvider::AddResource(SharedWorkerResource* resource) {
   DCHECK(updating_);
   resources_.push_back(resource);
   if (resource->handle() == base::kNullProcessHandle) {
     int process_id = resource->process_id();
     launching_workers_[process_id].push_back(resource);
   } else {
     task_manager_->AddResource(resource);
   }
 }
 
-void TaskManagerWorkerResourceProvider::DeleteAllResources() {
+void WorkerResourceProvider::DeleteAllResources() {
   STLDeleteElements(&resources_);
 }
+
+}  // namespace task_manager