chrome/browser/task_manager/worker_resource_provider.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/task_manager/worker_resource_provider.h"
   6
   7 #include <vector>
   8
   9 #include "base/basictypes.h"
  10 #include "base/strings/string16.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/devtools/devtools_window.h"
  13 #include "chrome/browser/profiles/profile_manager.h"
  14 #include "chrome/browser/task_manager/resource_provider.h"
  15 #include "chrome/browser/task_manager/task_manager.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/browser/child_process_data.h"
  18 #include "content/public/browser/devtools_agent_host.h"
  19 #include "content/public/browser/worker_service.h"
  20 #include "content/public/common/process_type.h"
  21 #include "grit/generated_resources.h"
  22 #include "grit/theme_resources.h"
  23 #include "ui/base/l10n/l10n_util.h"
  24 #include "ui/base/resource/resource_bundle.h"
  25 #include "ui/gfx/image/image_skia.h"
  26
  27 using content::BrowserThread;
  28 using content::DevToolsAgentHost;
  29 using content::WorkerService;
  30
  31 namespace task_manager {
  32
  33 // Objects of this class are created on the IO thread and then passed to the UI
  34 // thread where they are passed to the task manager. All methods must be called
  35 // only on the UI thread. Destructor may be called on any thread.
  36 class SharedWorkerResource : public Resource {
  37  public:
  38   SharedWorkerResource(const GURL& url,
  39                        const base::string16& name,
  40                        int process_id,
  41                        int routing_id,
  42                        base::ProcessHandle process_handle);
  43   virtual ~SharedWorkerResource();
  44
  45   bool Matches(int process_id, int routing_id) const;
  46
  47   void UpdateProcessHandle(base::ProcessHandle handle);
  48   base::ProcessHandle handle() const { return handle_; }
  49   int process_id() const { return process_id_; }
  50
  51  private:
  52   // Resource methods:
  53   virtual base::string16 GetTitle() const OVERRIDE;
  54   virtual base::string16 GetProfileName() const OVERRIDE;
  55   virtual gfx::ImageSkia GetIcon() const OVERRIDE;
  56   virtual base::ProcessHandle GetProcess() const OVERRIDE;
  57   virtual int GetUniqueChildProcessId() const OVERRIDE;
  58   virtual Type GetType() const OVERRIDE;
  59   virtual bool CanInspect() const OVERRIDE;
  60   virtual void Inspect() const OVERRIDE;
  61
  62   virtual bool SupportNetworkUsage() const OVERRIDE;
  63   virtual void SetSupportNetworkUsage() OVERRIDE;
  64
  65   int process_id_;
  66   int routing_id_;
  67   base::string16 title_;
  68   base::ProcessHandle handle_;
  69
  70   static gfx::ImageSkia* default_icon_;
  71
  72   DISALLOW_COPY_AND_ASSIGN(SharedWorkerResource);
  73 };
  74
  75 gfx::ImageSkia* SharedWorkerResource::default_icon_ = NULL;
  76
  77 SharedWorkerResource::SharedWorkerResource(
  78     const GURL& url,
  79     const base::string16& name,
  80     int process_id,
  81     int routing_id,
  82     base::ProcessHandle process_handle)
  83     : process_id_(process_id),
  84       routing_id_(routing_id),
  85       handle_(process_handle) {
  86   title_ = base::UTF8ToUTF16(url.spec());
  87   if (!name.empty())
  88     title_ += base::ASCIIToUTF16(" (") + name + base::ASCIIToUTF16(")");
  89 }
  90
  91 SharedWorkerResource::~SharedWorkerResource() {
  92 }
  93
  94 bool SharedWorkerResource::Matches(int process_id,
  95                                    int routing_id) const {
  96   return process_id_ == process_id && routing_id_ == routing_id;
  97 }
  98
  99 void SharedWorkerResource::UpdateProcessHandle(base::ProcessHandle handle) {
 100   handle_ = handle;
 101 }
 102
 103 base::string16 SharedWorkerResource::GetTitle() const {
 104   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_WORKER_PREFIX, title_);
 105 }
 106
 107 base::string16 SharedWorkerResource::GetProfileName() const {
 108   return base::string16();
 109 }
 110
 111 gfx::ImageSkia SharedWorkerResource::GetIcon() const {
 112   if (!default_icon_) {
 113     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 114     default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGINS_FAVICON);
 115     // TODO(jabdelmalek): use different icon for web workers.
 116   }
 117   return *default_icon_;
 118 }
 119
 120 base::ProcessHandle SharedWorkerResource::GetProcess() const {
 121   return handle_;
 122 }
 123
 124 int SharedWorkerResource::GetUniqueChildProcessId() const {
 125   return process_id_;
 126 }
 127
 128 Resource::Type SharedWorkerResource::GetType() const {
 129   return WORKER;
 130 }
 131
 132 bool SharedWorkerResource::CanInspect() const {
 133   return true;
 134 }
 135
 136 void SharedWorkerResource::Inspect() const {
 137   // TODO(yurys): would be better to get profile from one of the tabs connected
 138   // to the worker.
 139   Profile* profile = ProfileManager::GetLastUsedProfile();
 140   if (!profile)
 141     return;
 142   scoped_refptr<DevToolsAgentHost> agent_host(
 143       DevToolsAgentHost::GetForWorker(process_id_, routing_id_));
 144   DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host.get());
 145 }
 146
 147 bool SharedWorkerResource::SupportNetworkUsage() const {
 148   return false;
 149 }
 150
 151 void SharedWorkerResource::SetSupportNetworkUsage() {
 152 }
 153
 154
 155 // This class is needed to ensure that all resources in WorkerResourceList are
 156 // deleted if corresponding task is posted to but not executed on the UI
 157 // thread.
 158 class WorkerResourceProvider::WorkerResourceListHolder {
 159  public:
 160   WorkerResourceListHolder() {
 161   }
 162
 163   ~WorkerResourceListHolder() {
 164     STLDeleteElements(&resources_);
 165   }
 166
 167   WorkerResourceList* resources() {
 168     return &resources_;
 169   }
 170
 171  private:
 172   WorkerResourceList resources_;
 173 };
 174
 175
 176 WorkerResourceProvider::
 177     WorkerResourceProvider(TaskManager* task_manager)
 178     : updating_(false),
 179       task_manager_(task_manager) {
 180 }
 181
 182 WorkerResourceProvider::~WorkerResourceProvider() {
 183   DeleteAllResources();
 184 }
 185
 186 Resource* WorkerResourceProvider::GetResource(
 187     int origin_pid,
 188     int child_id,
 189     int route_id) {
 190   return NULL;
 191 }
 192
 193 void WorkerResourceProvider::StartUpdating() {
 194   DCHECK(!updating_);
 195   updating_ = true;
 196   // Get existing workers.
 197   BrowserThread::PostTask(
 198       BrowserThread::IO, FROM_HERE, base::Bind(
 199           &WorkerResourceProvider::StartObservingWorkers,
 200           this));
 201
 202   BrowserChildProcessObserver::Add(this);
 203 }
 204
 205 void WorkerResourceProvider::StopUpdating() {
 206   DCHECK(updating_);
 207   updating_ = false;
 208   launching_workers_.clear();
 209   DeleteAllResources();
 210   BrowserThread::PostTask(
 211       BrowserThread::IO, FROM_HERE, base::Bind(
 212           &WorkerResourceProvider::StopObservingWorkers,
 213           this));
 214
 215   BrowserChildProcessObserver::Remove(this);
 216 }
 217
 218 void WorkerResourceProvider::BrowserChildProcessHostConnected(
 219     const content::ChildProcessData& data) {
 220   DCHECK(updating_);
 221
 222   if (data.process_type != content::PROCESS_TYPE_WORKER)
 223     return;
 224
 225   ProcessIdToWorkerResources::iterator it(launching_workers_.find(data.id));
 226   if (it == launching_workers_.end())
 227     return;
 228   WorkerResourceList& resources = it->second;
 229   for (WorkerResourceList::iterator r = resources.begin();
 230        r != resources.end(); ++r) {
 231     (*r)->UpdateProcessHandle(data.handle);
 232     task_manager_->AddResource(*r);
 233   }
 234   launching_workers_.erase(it);
 235 }
 236
 237 void WorkerResourceProvider::BrowserChildProcessHostDisconnected(
 238     const content::ChildProcessData& data) {
 239   DCHECK(updating_);
 240
 241   if (data.process_type != content::PROCESS_TYPE_WORKER)
 242     return;
 243
 244   // Worker process may be destroyed before WorkerMsg_TerminateWorkerContex
 245   // message is handled and WorkerDestroyed is fired. In this case we won't
 246   // get WorkerDestroyed notification and have to clear resources for such
 247   // workers here when the worker process has been destroyed.
 248   for (WorkerResourceList::iterator it = resources_.begin();
 249        it != resources_.end();) {
 250     if ((*it)->process_id() == data.id) {
 251       task_manager_->RemoveResource(*it);
 252       delete *it;
 253       it = resources_.erase(it);
 254     } else {
 255       ++it;
 256     }
 257   }
 258   DCHECK(!ContainsKey(launching_workers_, data.id));
 259 }
 260
 261 void WorkerResourceProvider::WorkerCreated(
 262     const GURL& url,
 263     const base::string16& name,
 264     int process_id,
 265     int route_id) {
 266   SharedWorkerResource* resource = new SharedWorkerResource(
 267       url, name, process_id, route_id, base::kNullProcessHandle);
 268   BrowserThread::PostTask(
 269       BrowserThread::UI, FROM_HERE,
 270       base::Bind(&WorkerResourceProvider::NotifyWorkerCreated,
 271                  this, base::Owned(new WorkerResourceHolder(resource))));
 272 }
 273
 274 void WorkerResourceProvider::WorkerDestroyed(int process_id, int route_id) {
 275   BrowserThread::PostTask(
 276       BrowserThread::UI, FROM_HERE, base::Bind(
 277           &WorkerResourceProvider::NotifyWorkerDestroyed,
 278           this, process_id, route_id));
 279 }
 280
 281 void WorkerResourceProvider::NotifyWorkerCreated(
 282     WorkerResourceHolder* resource_holder) {
 283   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 284   if (!updating_)
 285     return;
 286   AddResource(resource_holder->release());
 287 }
 288
 289 void WorkerResourceProvider::NotifyWorkerDestroyed(
 290     int process_id, int routing_id) {
 291   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 292   if (!updating_)
 293     return;
 294   for (WorkerResourceList::iterator it = resources_.begin();
 295        it !=resources_.end(); ++it) {
 296     if ((*it)->Matches(process_id, routing_id)) {
 297       task_manager_->RemoveResource(*it);
 298       delete *it;
 299       resources_.erase(it);
 300       return;
 301     }
 302   }
 303 }
 304
 305 void WorkerResourceProvider::StartObservingWorkers() {
 306   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 307
 308   scoped_ptr<WorkerResourceListHolder> holder(new WorkerResourceListHolder);
 309   std::vector<WorkerService::WorkerInfo> worker_info =
 310       WorkerService::GetInstance()->GetWorkers();
 311
 312   for (size_t i = 0; i < worker_info.size(); ++i) {
 313     holder->resources()->push_back(new SharedWorkerResource(
 314         worker_info[i].url, worker_info[i].name, worker_info[i].process_id,
 315         worker_info[i].route_id, worker_info[i].handle));
 316   }
 317
 318   BrowserThread::PostTask(
 319       BrowserThread::UI, FROM_HERE,
 320       base::Bind(
 321           &WorkerResourceProvider::AddWorkerResourceList,
 322           this, base::Owned(holder.release())));
 323
 324   WorkerService::GetInstance()->AddObserver(this);
 325 }
 326
 327 void WorkerResourceProvider::StopObservingWorkers() {
 328   WorkerService::GetInstance()->RemoveObserver(this);
 329 }
 330
 331 void WorkerResourceProvider::AddWorkerResourceList(
 332     WorkerResourceListHolder* resource_list_holder) {
 333   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 334   if (!updating_)
 335     return;
 336   WorkerResourceList* resources = resource_list_holder->resources();
 337   for (WorkerResourceList::iterator it = resources->begin();
 338        it !=resources->end(); ++it) {
 339     AddResource(*it);
 340   }
 341   resources->clear();
 342 }
 343
 344 void WorkerResourceProvider::AddResource(SharedWorkerResource* resource) {
 345   DCHECK(updating_);
 346   resources_.push_back(resource);
 347   if (resource->handle() == base::kNullProcessHandle) {
 348     int process_id = resource->process_id();
 349     launching_workers_[process_id].push_back(resource);
 350   } else {
 351     task_manager_->AddResource(resource);
 352   }
 353 }
 354
 355 void WorkerResourceProvider::DeleteAllResources() {
 356   STLDeleteElements(&resources_);
 357 }
 358
 359 }  // namespace task_manager