content/browser/devtools/worker_devtools_manager.cc

   1 // Copyright (c) 2011 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 "content/browser/devtools/worker_devtools_manager.h"
   6
   7 #include <list>
   8 #include <map>
   9
  10 #include "base/bind.h"
  11 #include "base/lazy_instance.h"
  12 #include "content/browser/devtools/devtools_manager_impl.h"
  13 #include "content/browser/devtools/devtools_protocol.h"
  14 #include "content/browser/devtools/devtools_protocol_constants.h"
  15 #include "content/browser/devtools/embedded_worker_devtools_manager.h"
  16 #include "content/browser/devtools/ipc_devtools_agent_host.h"
  17 #include "content/browser/devtools/worker_devtools_message_filter.h"
  18 #include "content/browser/worker_host/worker_service_impl.h"
  19 #include "content/common/devtools_messages.h"
  20 #include "content/public/browser/browser_thread.h"
  21 #include "content/public/browser/child_process_data.h"
  22 #include "content/public/common/process_type.h"
  23
  24 namespace content {
  25
  26 // Called on the UI thread.
  27 // static
  28 scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::GetForWorker(
  29     int worker_process_id,
  30     int worker_route_id) {
  31   if (WorkerService::EmbeddedSharedWorkerEnabled()) {
  32     return EmbeddedWorkerDevToolsManager::GetInstance()
  33         ->GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id);
  34   } else {
  35     return WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
  36         worker_process_id, worker_route_id);
  37   }
  38 }
  39
  40 namespace {
  41
  42 typedef std::map<WorkerDevToolsManager::WorkerId,
  43                  WorkerDevToolsManager::WorkerDevToolsAgentHost*> AgentHosts;
  44 base::LazyInstance<AgentHosts>::Leaky g_agent_map = LAZY_INSTANCE_INITIALIZER;
  45 base::LazyInstance<AgentHosts>::Leaky g_orphan_map = LAZY_INSTANCE_INITIALIZER;
  46
  47 }  // namespace
  48
  49 struct WorkerDevToolsManager::TerminatedInspectedWorker {
  50   TerminatedInspectedWorker(WorkerId id,
  51                             const GURL& url,
  52                             const base::string16& name)
  53       : old_worker_id(id),
  54         worker_url(url),
  55         worker_name(name) {}
  56   WorkerId old_worker_id;
  57   GURL worker_url;
  58   base::string16 worker_name;
  59 };
  60
  61
  62 class WorkerDevToolsManager::WorkerDevToolsAgentHost
  63     : public IPCDevToolsAgentHost {
  64  public:
  65   explicit WorkerDevToolsAgentHost(WorkerId worker_id)
  66       : has_worker_id_(false) {
  67     SetWorkerId(worker_id, false);
  68   }
  69
  70   void SetWorkerId(WorkerId worker_id, bool reattach) {
  71     worker_id_ = worker_id;
  72     if (!has_worker_id_)
  73       AddRef();  //  Balanced in ResetWorkerId.
  74     has_worker_id_ = true;
  75     g_agent_map.Get()[worker_id_] = this;
  76
  77     BrowserThread::PostTask(
  78         BrowserThread::IO,
  79         FROM_HERE,
  80         base::Bind(
  81             &ConnectToWorker,
  82             worker_id.first,
  83             worker_id.second));
  84
  85     if (reattach)
  86       Reattach(state_);
  87   }
  88
  89   void ResetWorkerId() {
  90     g_agent_map.Get().erase(worker_id_);
  91     has_worker_id_ = false;
  92     Release();  //  Balanced in SetWorkerId.
  93   }
  94
  95   void SaveAgentRuntimeState(const std::string& state) {
  96     state_ = state;
  97   }
  98
  99   void ConnectionFailed() {
 100     NotifyCloseListener();
 101     // Object can be deleted here.
 102   }
 103
 104  private:
 105   virtual ~WorkerDevToolsAgentHost();
 106
 107   static void ConnectToWorker(
 108       int worker_process_id,
 109       int worker_route_id) {
 110     WorkerDevToolsManager::GetInstance()->ConnectDevToolsAgentHostToWorker(
 111         worker_process_id, worker_route_id);
 112   }
 113
 114   static void ForwardToWorkerDevToolsAgent(
 115       int worker_process_id,
 116       int worker_route_id,
 117       IPC::Message* message) {
 118     WorkerDevToolsManager::GetInstance()->ForwardToWorkerDevToolsAgent(
 119         worker_process_id, worker_route_id, *message);
 120   }
 121
 122   // IPCDevToolsAgentHost implementation.
 123   virtual void SendMessageToAgent(IPC::Message* message) OVERRIDE {
 124     if (!has_worker_id_) {
 125       delete message;
 126       return;
 127     }
 128     BrowserThread::PostTask(
 129         BrowserThread::IO, FROM_HERE,
 130         base::Bind(
 131             &WorkerDevToolsAgentHost::ForwardToWorkerDevToolsAgent,
 132             worker_id_.first,
 133             worker_id_.second,
 134             base::Owned(message)));
 135   }
 136
 137   virtual void OnClientAttached() OVERRIDE {}
 138   virtual void OnClientDetached() OVERRIDE {}
 139
 140   bool has_worker_id_;
 141   WorkerId worker_id_;
 142   std::string state_;
 143
 144   DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgentHost);
 145 };
 146
 147
 148 class WorkerDevToolsManager::DetachedClientHosts {
 149  public:
 150   static void WorkerReloaded(WorkerId old_id, WorkerId new_id) {
 151     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 152     AgentHosts::iterator it = g_orphan_map.Get().find(old_id);
 153     if (it != g_orphan_map.Get().end()) {
 154       it->second->SetWorkerId(new_id, true);
 155       g_orphan_map.Get().erase(old_id);
 156       return;
 157     }
 158     RemovePendingWorkerData(old_id);
 159   }
 160
 161   static void WorkerDestroyed(WorkerId id) {
 162     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 163     AgentHosts::iterator it = g_agent_map.Get().find(id);
 164     if (it == g_agent_map.Get().end()) {
 165       RemovePendingWorkerData(id);
 166       return;
 167     }
 168
 169     WorkerDevToolsAgentHost* agent = it->second;
 170     DevToolsManagerImpl* devtools_manager = DevToolsManagerImpl::GetInstance();
 171     if (!agent->IsAttached()) {
 172       // Agent has no client hosts -> delete it.
 173       RemovePendingWorkerData(id);
 174       return;
 175     }
 176
 177     // Client host is debugging this worker agent host.
 178     std::string notification = DevToolsProtocol::CreateNotification(
 179         devtools::Worker::disconnectedFromWorker::kName, NULL)->Serialize();
 180     devtools_manager->DispatchOnInspectorFrontend(agent, notification);
 181     g_orphan_map.Get()[id] = agent;
 182     agent->ResetWorkerId();
 183   }
 184
 185   static void RemovePendingWorkerData(WorkerId id) {
 186     BrowserThread::PostTask(
 187         BrowserThread::IO, FROM_HERE,
 188         base::Bind(&RemoveInspectedWorkerDataOnIOThread, id));
 189   }
 190
 191  private:
 192   DetachedClientHosts() {}
 193   ~DetachedClientHosts() {}
 194
 195   static void RemoveInspectedWorkerDataOnIOThread(WorkerId id) {
 196     WorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(id);
 197   }
 198 };
 199
 200 struct WorkerDevToolsManager::InspectedWorker {
 201   InspectedWorker(WorkerProcessHost* host, int route_id, const GURL& url,
 202                   const base::string16& name)
 203       : host(host),
 204         route_id(route_id),
 205         worker_url(url),
 206         worker_name(name) {}
 207   WorkerProcessHost* const host;
 208   int const route_id;
 209   GURL worker_url;
 210   base::string16 worker_name;
 211 };
 212
 213 // static
 214 WorkerDevToolsManager* WorkerDevToolsManager::GetInstance() {
 215   DCHECK(!WorkerService::EmbeddedSharedWorkerEnabled());
 216   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 217   return Singleton<WorkerDevToolsManager>::get();
 218 }
 219
 220 // static
 221 DevToolsAgentHost* WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
 222     int worker_process_id,
 223     int worker_route_id) {
 224   DCHECK(!WorkerService::EmbeddedSharedWorkerEnabled());
 225   WorkerId id(worker_process_id, worker_route_id);
 226   AgentHosts::iterator it = g_agent_map.Get().find(id);
 227   if (it == g_agent_map.Get().end())
 228     return new WorkerDevToolsAgentHost(id);
 229   return it->second;
 230 }
 231
 232 WorkerDevToolsManager::WorkerDevToolsManager() {
 233 }
 234
 235 WorkerDevToolsManager::~WorkerDevToolsManager() {
 236 }
 237
 238 bool WorkerDevToolsManager::WorkerCreated(
 239     WorkerProcessHost* worker,
 240     const WorkerProcessHost::WorkerInstance& instance) {
 241   for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
 242        it != terminated_workers_.end(); ++it) {
 243     if (instance.Matches(it->worker_url, it->worker_name,
 244                          instance.partition(),
 245                          instance.resource_context())) {
 246       WorkerId new_worker_id(worker->GetData().id, instance.worker_route_id());
 247       paused_workers_[new_worker_id] = it->old_worker_id;
 248       terminated_workers_.erase(it);
 249       return true;
 250     }
 251   }
 252   return false;
 253 }
 254
 255 void WorkerDevToolsManager::WorkerDestroyed(
 256     WorkerProcessHost* worker,
 257     int worker_route_id) {
 258   InspectedWorkersList::iterator it = FindInspectedWorker(
 259       worker->GetData().id,
 260       worker_route_id);
 261   if (it == inspected_workers_.end())
 262     return;
 263
 264   WorkerId worker_id(worker->GetData().id, worker_route_id);
 265   terminated_workers_.push_back(TerminatedInspectedWorker(
 266       worker_id,
 267       it->worker_url,
 268       it->worker_name));
 269   inspected_workers_.erase(it);
 270   BrowserThread::PostTask(
 271       BrowserThread::UI, FROM_HERE,
 272       base::Bind(&DetachedClientHosts::WorkerDestroyed, worker_id));
 273 }
 274
 275 void WorkerDevToolsManager::WorkerContextStarted(WorkerProcessHost* process,
 276                                                  int worker_route_id) {
 277   WorkerId new_worker_id(process->GetData().id, worker_route_id);
 278   PausedWorkers::iterator it = paused_workers_.find(new_worker_id);
 279   if (it == paused_workers_.end())
 280     return;
 281
 282   BrowserThread::PostTask(
 283       BrowserThread::UI, FROM_HERE,
 284       base::Bind(
 285           &DetachedClientHosts::WorkerReloaded,
 286           it->second,
 287           new_worker_id));
 288   paused_workers_.erase(it);
 289 }
 290
 291 void WorkerDevToolsManager::RemoveInspectedWorkerData(
 292     const WorkerId& id) {
 293   for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
 294        it != terminated_workers_.end(); ++it) {
 295     if (it->old_worker_id == id) {
 296       terminated_workers_.erase(it);
 297       return;
 298     }
 299   }
 300
 301   for (PausedWorkers::iterator it = paused_workers_.begin();
 302        it != paused_workers_.end(); ++it) {
 303     if (it->second == id) {
 304       SendResumeToWorker(it->first);
 305       paused_workers_.erase(it);
 306       return;
 307     }
 308   }
 309 }
 310
 311 WorkerDevToolsManager::InspectedWorkersList::iterator
 312 WorkerDevToolsManager::FindInspectedWorker(
 313     int host_id, int route_id) {
 314   InspectedWorkersList::iterator it = inspected_workers_.begin();
 315   while (it != inspected_workers_.end()) {
 316     if (it->host->GetData().id == host_id && it->route_id == route_id)
 317       break;
 318     ++it;
 319   }
 320   return it;
 321 }
 322
 323 static WorkerProcessHost* FindWorkerProcess(int worker_process_id) {
 324   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
 325     if (iter.GetData().id == worker_process_id)
 326       return *iter;
 327   }
 328   return NULL;
 329 }
 330
 331 void WorkerDevToolsManager::ConnectDevToolsAgentHostToWorker(
 332     int worker_process_id,
 333     int worker_route_id) {
 334   if (WorkerProcessHost* process = FindWorkerProcess(worker_process_id)) {
 335     const WorkerProcessHost::Instances& instances = process->instances();
 336     for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
 337          i != instances.end(); ++i) {
 338       if (i->worker_route_id() == worker_route_id) {
 339         DCHECK(FindInspectedWorker(worker_process_id, worker_route_id) ==
 340                inspected_workers_.end());
 341         inspected_workers_.push_back(
 342             InspectedWorker(process, worker_route_id, i->url(), i->name()));
 343         return;
 344       }
 345     }
 346   }
 347   NotifyConnectionFailedOnIOThread(worker_process_id, worker_route_id);
 348 }
 349
 350 void WorkerDevToolsManager::ForwardToDevToolsClient(
 351     int worker_process_id,
 352     int worker_route_id,
 353     const std::string& message) {
 354   if (FindInspectedWorker(worker_process_id, worker_route_id) ==
 355           inspected_workers_.end()) {
 356       NOTREACHED();
 357       return;
 358   }
 359   BrowserThread::PostTask(
 360       BrowserThread::UI, FROM_HERE,
 361       base::Bind(
 362           &ForwardToDevToolsClientOnUIThread,
 363           worker_process_id,
 364           worker_route_id,
 365           message));
 366 }
 367
 368 void WorkerDevToolsManager::SaveAgentRuntimeState(int worker_process_id,
 369                                                   int worker_route_id,
 370                                                   const std::string& state) {
 371   BrowserThread::PostTask(
 372       BrowserThread::UI, FROM_HERE,
 373       base::Bind(
 374           &SaveAgentRuntimeStateOnUIThread,
 375           worker_process_id,
 376           worker_route_id,
 377           state));
 378 }
 379
 380 void WorkerDevToolsManager::ForwardToWorkerDevToolsAgent(
 381     int worker_process_id,
 382     int worker_route_id,
 383     const IPC::Message& message) {
 384   InspectedWorkersList::iterator it = FindInspectedWorker(
 385       worker_process_id,
 386       worker_route_id);
 387   if (it == inspected_workers_.end())
 388     return;
 389   IPC::Message* msg = new IPC::Message(message);
 390   msg->set_routing_id(worker_route_id);
 391   it->host->Send(msg);
 392 }
 393
 394 // static
 395 void WorkerDevToolsManager::ForwardToDevToolsClientOnUIThread(
 396     int worker_process_id,
 397     int worker_route_id,
 398     const std::string& message) {
 399   AgentHosts::iterator it = g_agent_map.Get().find(WorkerId(worker_process_id,
 400                                                             worker_route_id));
 401   if (it == g_agent_map.Get().end())
 402     return;
 403   DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(it->second,
 404                                                                   message);
 405 }
 406
 407 // static
 408 void WorkerDevToolsManager::SaveAgentRuntimeStateOnUIThread(
 409     int worker_process_id,
 410     int worker_route_id,
 411     const std::string& state) {
 412   AgentHosts::iterator it = g_agent_map.Get().find(WorkerId(worker_process_id,
 413                                                             worker_route_id));
 414   if (it == g_agent_map.Get().end())
 415     return;
 416   it->second->SaveAgentRuntimeState(state);
 417 }
 418
 419 // static
 420 void WorkerDevToolsManager::NotifyConnectionFailedOnIOThread(
 421     int worker_process_id,
 422     int worker_route_id) {
 423   BrowserThread::PostTask(
 424       BrowserThread::UI, FROM_HERE,
 425       base::Bind(
 426           &WorkerDevToolsManager::NotifyConnectionFailedOnUIThread,
 427           worker_process_id,
 428           worker_route_id));
 429 }
 430
 431 // static
 432 void WorkerDevToolsManager::NotifyConnectionFailedOnUIThread(
 433     int worker_process_id,
 434     int worker_route_id) {
 435   AgentHosts::iterator it = g_agent_map.Get().find(WorkerId(worker_process_id,
 436                                                             worker_route_id));
 437   if (it != g_agent_map.Get().end())
 438     it->second->ConnectionFailed();
 439 }
 440
 441 // static
 442 void WorkerDevToolsManager::SendResumeToWorker(const WorkerId& id) {
 443   if (WorkerProcessHost* process = FindWorkerProcess(id.first))
 444     process->Send(new DevToolsAgentMsg_ResumeWorkerContext(id.second));
 445 }
 446
 447 WorkerDevToolsManager::WorkerDevToolsAgentHost::~WorkerDevToolsAgentHost() {
 448   DetachedClientHosts::RemovePendingWorkerData(worker_id_);
 449   g_agent_map.Get().erase(worker_id_);
 450   g_orphan_map.Get().erase(worker_id_);
 451 }
 452
 453 }  // namespace content