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 360