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

chrome/browser/task_manager/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 "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/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;
-
-// 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 {
- public:
-  TaskManagerSharedWorkerResource(const GURL& url,
-                                  const string16& name,
-                                  int process_id,
-                                  int routing_id,
-                                  base::ProcessHandle process_handle);
-  virtual ~TaskManagerSharedWorkerResource();
-
-  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);
-};
-
-gfx::ImageSkia* TaskManagerSharedWorkerResource::default_icon_ = NULL;
-
-TaskManagerSharedWorkerResource::TaskManagerSharedWorkerResource(
-    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() {
-}
-
-bool TaskManagerSharedWorkerResource::Matches(int process_id,
-                                              int routing_id) const {
-  return process_id_ == process_id && routing_id_ == routing_id;
-}
-
-void TaskManagerSharedWorkerResource::UpdateProcessHandle(
-    base::ProcessHandle handle) {
-  handle_ = handle;
-}
-
-string16 TaskManagerSharedWorkerResource::GetTitle() const {
-  return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_WORKER_PREFIX, title_);
-}
-
-string16 TaskManagerSharedWorkerResource::GetProfileName() const {
-  return string16();
-}
-
-gfx::ImageSkia TaskManagerSharedWorkerResource::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 {
-  return handle_;
-}
-
-int TaskManagerSharedWorkerResource::GetUniqueChildProcessId() const {
-  return process_id_;
-}
-
-TaskManager::Resource::Type TaskManagerSharedWorkerResource::GetType() const {
-  return WORKER;
-}
-
-bool TaskManagerSharedWorkerResource::CanInspect() const {
-  return true;
-}
-
-void TaskManagerSharedWorkerResource::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 {
-  return false;
-}
-
-void TaskManagerSharedWorkerResource::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 {
- public:
-  WorkerResourceListHolder() {
-  }
-
-  ~WorkerResourceListHolder() {
-    STLDeleteElements(&resources_);
-  }
-
-  WorkerResourceList* resources() {
-    return &resources_;
-  }
-
- private:
-  WorkerResourceList resources_;
-};
-
-
-TaskManagerWorkerResourceProvider::
-    TaskManagerWorkerResourceProvider(TaskManager* task_manager)
-    : updating_(false),
-      task_manager_(task_manager) {
-}
-
-TaskManagerWorkerResourceProvider::~TaskManagerWorkerResourceProvider() {
-  DeleteAllResources();
-}
-
-TaskManager::Resource* TaskManagerWorkerResourceProvider::GetResource(
-    int origin_pid,
-    int render_process_host_id,
-    int routing_id) {
-  return NULL;
-}
-
-void TaskManagerWorkerResourceProvider::StartUpdating() {
-  DCHECK(!updating_);
-  updating_ = true;
-  // Get existing workers.
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::StartObservingWorkers,
-          this));
-
-  BrowserChildProcessObserver::Add(this);
-}
-
-void TaskManagerWorkerResourceProvider::StopUpdating() {
-  DCHECK(updating_);
-  updating_ = false;
-  launching_workers_.clear();
-  DeleteAllResources();
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::StopObservingWorkers,
-          this));
-
-  BrowserChildProcessObserver::Remove(this);
-}
-
-void TaskManagerWorkerResourceProvider::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(
-    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(
-    const GURL& url,
-    const string16& name,
-    int process_id,
-    int route_id) {
-  TaskManagerSharedWorkerResource* resource =
-      new TaskManagerSharedWorkerResource(
-          url, name, process_id, route_id, base::kNullProcessHandle);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&TaskManagerWorkerResourceProvider::NotifyWorkerCreated,
-                 this, base::Owned(new WorkerResourceHolder(resource))));
-}
-
-void TaskManagerWorkerResourceProvider::WorkerDestroyed(int process_id,
-                                                        int route_id) {
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE, base::Bind(
-          &TaskManagerWorkerResourceProvider::NotifyWorkerDestroyed,
-          this, process_id, route_id));
-}
-
-void TaskManagerWorkerResourceProvider::NotifyWorkerCreated(
-    WorkerResourceHolder* resource_holder) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!updating_)
-    return;
-  AddResource(resource_holder->release());
-}
-
-void TaskManagerWorkerResourceProvider::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() {
-  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(
-        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,
-          this, base::Owned(holder.release())));
-
-  WorkerService::GetInstance()->AddObserver(this);
-}
-
-void TaskManagerWorkerResourceProvider::StopObservingWorkers() {
-  WorkerService::GetInstance()->RemoveObserver(this);
-}
-
-void TaskManagerWorkerResourceProvider::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) {
-  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() {
-  STLDeleteElements(&resources_);
-}