content/browser/devtools/embedded_worker_devtools_manager.cc

   1 // Copyright 2014 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/embedded_worker_devtools_manager.h"
   6
   7 #include "content/browser/devtools/devtools_manager_impl.h"
   8 #include "content/browser/devtools/devtools_protocol.h"
   9 #include "content/browser/devtools/devtools_protocol_constants.h"
  10 #include "content/browser/devtools/ipc_devtools_agent_host.h"
  11 #include "content/browser/shared_worker/shared_worker_instance.h"
  12 #include "content/common/devtools_messages.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "content/public/browser/render_process_host.h"
  15 #include "content/public/browser/worker_service.h"
  16 #include "ipc/ipc_listener.h"
  17
  18 namespace content {
  19
  20 namespace {
  21
  22 bool SendMessageToWorker(
  23     const EmbeddedWorkerDevToolsManager::WorkerId& worker_id,
  24     IPC::Message* message) {
  25   RenderProcessHost* host = RenderProcessHost::FromID(worker_id.first);
  26   if (!host) {
  27     delete message;
  28     return false;
  29   }
  30   message->set_routing_id(worker_id.second);
  31   host->Send(message);
  32   return true;
  33 }
  34
  35 }  // namespace
  36
  37 EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
  38     const ServiceWorkerContextCore* const service_worker_context,
  39     int64 service_worker_version_id)
  40     : service_worker_context_(service_worker_context),
  41       service_worker_version_id_(service_worker_version_id) {
  42 }
  43
  44 EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::ServiceWorkerIdentifier(
  45     const ServiceWorkerIdentifier& other)
  46     : service_worker_context_(other.service_worker_context_),
  47       service_worker_version_id_(other.service_worker_version_id_) {
  48 }
  49
  50 bool EmbeddedWorkerDevToolsManager::ServiceWorkerIdentifier::Matches(
  51     const ServiceWorkerIdentifier& other) const {
  52   return service_worker_context_ == other.service_worker_context_ &&
  53          service_worker_version_id_ == other.service_worker_version_id_;
  54 }
  55
  56 EmbeddedWorkerDevToolsManager::WorkerInfo::WorkerInfo(
  57     const SharedWorkerInstance& instance)
  58     : shared_worker_instance_(new SharedWorkerInstance(instance)),
  59       state_(WORKER_UNINSPECTED),
  60       agent_host_(NULL) {
  61 }
  62
  63 EmbeddedWorkerDevToolsManager::WorkerInfo::WorkerInfo(
  64     const ServiceWorkerIdentifier& service_worker_id)
  65     : service_worker_id_(new ServiceWorkerIdentifier(service_worker_id)),
  66       state_(WORKER_UNINSPECTED),
  67       agent_host_(NULL) {
  68 }
  69
  70 bool EmbeddedWorkerDevToolsManager::WorkerInfo::Matches(
  71     const SharedWorkerInstance& other) {
  72   if (!shared_worker_instance_)
  73     return false;
  74   return shared_worker_instance_->Matches(other);
  75 }
  76
  77 bool EmbeddedWorkerDevToolsManager::WorkerInfo::Matches(
  78     const ServiceWorkerIdentifier& other) {
  79   if (!service_worker_id_)
  80     return false;
  81   return service_worker_id_->Matches(other);
  82 }
  83
  84 EmbeddedWorkerDevToolsManager::WorkerInfo::~WorkerInfo() {
  85 }
  86
  87 class EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsAgentHost
  88     : public IPCDevToolsAgentHost,
  89       public IPC::Listener {
  90  public:
  91   explicit EmbeddedWorkerDevToolsAgentHost(WorkerId worker_id)
  92       : worker_id_(worker_id), worker_attached_(false) {
  93     AttachToWorker();
  94   }
  95
  96   // DevToolsAgentHost override.
  97   virtual bool IsWorker() const OVERRIDE { return true; }
  98
  99   // IPCDevToolsAgentHost implementation.
 100   virtual void SendMessageToAgent(IPC::Message* message) OVERRIDE {
 101     if (worker_attached_)
 102       SendMessageToWorker(worker_id_, message);
 103     else
 104       delete message;
 105   }
 106   virtual void Attach() OVERRIDE {
 107     AttachToWorker();
 108     IPCDevToolsAgentHost::Attach();
 109   }
 110   virtual void OnClientAttached() OVERRIDE {}
 111   virtual void OnClientDetached() OVERRIDE { DetachFromWorker(); }
 112
 113   // IPC::Listener implementation.
 114   virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE {
 115     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 116     bool handled = true;
 117     IPC_BEGIN_MESSAGE_MAP(EmbeddedWorkerDevToolsAgentHost, msg)
 118     IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
 119                         OnDispatchOnInspectorFrontend)
 120     IPC_MESSAGE_HANDLER(DevToolsHostMsg_SaveAgentRuntimeState,
 121                         OnSaveAgentRuntimeState)
 122     IPC_MESSAGE_UNHANDLED(handled = false)
 123     IPC_END_MESSAGE_MAP()
 124     return handled;
 125   }
 126
 127   void ReattachToWorker(WorkerId worker_id) {
 128     CHECK(!worker_attached_);
 129     worker_id_ = worker_id;
 130     if (!IsAttached())
 131       return;
 132     AttachToWorker();
 133     Reattach(state_);
 134   }
 135
 136   void DetachFromWorker() {
 137     if (!worker_attached_)
 138       return;
 139     worker_attached_ = false;
 140     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
 141       host->RemoveRoute(worker_id_.second);
 142     Release();
 143   }
 144
 145   WorkerId worker_id() const { return worker_id_; }
 146
 147  private:
 148   virtual ~EmbeddedWorkerDevToolsAgentHost() {
 149     CHECK(!worker_attached_);
 150     EmbeddedWorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(
 151         this);
 152   }
 153
 154   void OnDispatchOnInspectorFrontend(const std::string& message) {
 155     DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(this,
 156                                                                     message);
 157   }
 158
 159   void OnSaveAgentRuntimeState(const std::string& state) { state_ = state; }
 160
 161   void AttachToWorker() {
 162     if (worker_attached_)
 163       return;
 164     worker_attached_ = true;
 165     AddRef();
 166     if (RenderProcessHost* host = RenderProcessHost::FromID(worker_id_.first))
 167       host->AddRoute(worker_id_.second, this);
 168   }
 169
 170   WorkerId worker_id_;
 171   bool worker_attached_;
 172   std::string state_;
 173   DISALLOW_COPY_AND_ASSIGN(EmbeddedWorkerDevToolsAgentHost);
 174 };
 175
 176 // static
 177 EmbeddedWorkerDevToolsManager* EmbeddedWorkerDevToolsManager::GetInstance() {
 178   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 179   return Singleton<EmbeddedWorkerDevToolsManager>::get();
 180 }
 181
 182 DevToolsAgentHost* EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForWorker(
 183     int worker_process_id,
 184     int worker_route_id) {
 185   WorkerId id(worker_process_id, worker_route_id);
 186
 187   WorkerInfoMap::iterator it = workers_.find(id);
 188   if (it == workers_.end())
 189     return NULL;
 190
 191   WorkerInfo* info = it->second;
 192   if (info->state() != WORKER_UNINSPECTED &&
 193       info->state() != WORKER_PAUSED_FOR_DEBUG_ON_START) {
 194     return info->agent_host();
 195   }
 196
 197   EmbeddedWorkerDevToolsAgentHost* agent_host =
 198       new EmbeddedWorkerDevToolsAgentHost(id);
 199   info->set_agent_host(agent_host);
 200   info->set_state(WORKER_INSPECTED);
 201   return agent_host;
 202 }
 203
 204 DevToolsAgentHost*
 205 EmbeddedWorkerDevToolsManager::GetDevToolsAgentHostForServiceWorker(
 206     const ServiceWorkerIdentifier& service_worker_id) {
 207   WorkerInfoMap::iterator it = FindExistingServiceWorkerInfo(service_worker_id);
 208   if (it == workers_.end())
 209     return NULL;
 210   return GetDevToolsAgentHostForWorker(it->first.first, it->first.second);
 211 }
 212
 213 EmbeddedWorkerDevToolsManager::EmbeddedWorkerDevToolsManager()
 214     : debug_service_worker_on_start_(false) {
 215 }
 216
 217 EmbeddedWorkerDevToolsManager::~EmbeddedWorkerDevToolsManager() {
 218 }
 219
 220 bool EmbeddedWorkerDevToolsManager::SharedWorkerCreated(
 221     int worker_process_id,
 222     int worker_route_id,
 223     const SharedWorkerInstance& instance) {
 224   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 225   const WorkerId id(worker_process_id, worker_route_id);
 226   WorkerInfoMap::iterator it = FindExistingSharedWorkerInfo(instance);
 227   if (it == workers_.end()) {
 228     scoped_ptr<WorkerInfo> info(new WorkerInfo(instance));
 229     workers_.set(id, info.Pass());
 230     return false;
 231   }
 232   MoveToPausedState(id, it);
 233   return true;
 234 }
 235
 236 bool EmbeddedWorkerDevToolsManager::ServiceWorkerCreated(
 237     int worker_process_id,
 238     int worker_route_id,
 239     const ServiceWorkerIdentifier& service_worker_id) {
 240   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 241   const WorkerId id(worker_process_id, worker_route_id);
 242   WorkerInfoMap::iterator it = FindExistingServiceWorkerInfo(service_worker_id);
 243   if (it == workers_.end()) {
 244     scoped_ptr<WorkerInfo> info(new WorkerInfo(service_worker_id));
 245     if (debug_service_worker_on_start_)
 246       info->set_state(WORKER_PAUSED_FOR_DEBUG_ON_START);
 247     workers_.set(id, info.Pass());
 248     return debug_service_worker_on_start_;
 249   }
 250   MoveToPausedState(id, it);
 251   return true;
 252 }
 253
 254 void EmbeddedWorkerDevToolsManager::WorkerDestroyed(int worker_process_id,
 255                                                     int worker_route_id) {
 256   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 257   const WorkerId id(worker_process_id, worker_route_id);
 258   WorkerInfoMap::iterator it = workers_.find(id);
 259   DCHECK(it != workers_.end());
 260   WorkerInfo* info = it->second;
 261   switch (info->state()) {
 262     case WORKER_UNINSPECTED:
 263     case WORKER_PAUSED_FOR_DEBUG_ON_START:
 264       workers_.erase(it);
 265       break;
 266     case WORKER_INSPECTED: {
 267       EmbeddedWorkerDevToolsAgentHost* agent_host = info->agent_host();
 268       info->set_state(WORKER_TERMINATED);
 269       if (!agent_host->IsAttached()) {
 270         agent_host->DetachFromWorker();
 271         return;
 272       }
 273       // Client host is debugging this worker agent host.
 274       std::string notification =
 275           DevToolsProtocol::CreateNotification(
 276               devtools::Worker::disconnectedFromWorker::kName, NULL)
 277               ->Serialize();
 278       DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
 279           agent_host, notification);
 280       agent_host->DetachFromWorker();
 281       break;
 282     }
 283     case WORKER_TERMINATED:
 284       NOTREACHED();
 285       break;
 286     case WORKER_PAUSED_FOR_REATTACH: {
 287       scoped_ptr<WorkerInfo> worker_info = workers_.take_and_erase(it);
 288       worker_info->set_state(WORKER_TERMINATED);
 289       const WorkerId old_id = worker_info->agent_host()->worker_id();
 290       workers_.set(old_id, worker_info.Pass());
 291       break;
 292     }
 293   }
 294 }
 295
 296 void EmbeddedWorkerDevToolsManager::WorkerContextStarted(int worker_process_id,
 297                                                          int worker_route_id) {
 298   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 299   const WorkerId id(worker_process_id, worker_route_id);
 300   WorkerInfoMap::iterator it = workers_.find(id);
 301   DCHECK(it != workers_.end());
 302   WorkerInfo* info = it->second;
 303   if (info->state() == WORKER_PAUSED_FOR_DEBUG_ON_START) {
 304     RenderProcessHost* rph = RenderProcessHost::FromID(worker_process_id);
 305     scoped_refptr<DevToolsAgentHost> agent_host(
 306         GetDevToolsAgentHostForWorker(worker_process_id, worker_route_id));
 307     DevToolsManagerImpl::GetInstance()->Inspect(rph->GetBrowserContext(),
 308                                                 agent_host.get());
 309   } else if (info->state() == WORKER_PAUSED_FOR_REATTACH) {
 310     info->agent_host()->ReattachToWorker(id);
 311     info->set_state(WORKER_INSPECTED);
 312   }
 313 }
 314
 315 void EmbeddedWorkerDevToolsManager::RemoveInspectedWorkerData(
 316     EmbeddedWorkerDevToolsAgentHost* agent_host) {
 317   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 318   const WorkerId id(agent_host->worker_id());
 319   scoped_ptr<WorkerInfo> worker_info = workers_.take_and_erase(id);
 320   if (worker_info) {
 321     DCHECK_EQ(worker_info->agent_host(), agent_host);
 322     if (worker_info->state() == WORKER_TERMINATED)
 323       return;
 324     DCHECK_EQ(worker_info->state(), WORKER_INSPECTED);
 325     worker_info->set_agent_host(NULL);
 326     worker_info->set_state(WORKER_UNINSPECTED);
 327     workers_.set(id, worker_info.Pass());
 328     return;
 329   }
 330   for (WorkerInfoMap::iterator it = workers_.begin(); it != workers_.end();
 331        ++it) {
 332     if (it->second->agent_host() == agent_host) {
 333       DCHECK_EQ(WORKER_PAUSED_FOR_REATTACH, it->second->state());
 334       SendMessageToWorker(
 335           it->first,
 336           new DevToolsAgentMsg_ResumeWorkerContext(it->first.second));
 337       it->second->set_agent_host(NULL);
 338       it->second->set_state(WORKER_UNINSPECTED);
 339       return;
 340     }
 341   }
 342 }
 343
 344 EmbeddedWorkerDevToolsManager::WorkerInfoMap::iterator
 345 EmbeddedWorkerDevToolsManager::FindExistingSharedWorkerInfo(
 346     const SharedWorkerInstance& instance) {
 347   WorkerInfoMap::iterator it = workers_.begin();
 348   for (; it != workers_.end(); ++it) {
 349     if (it->second->Matches(instance))
 350       break;
 351   }
 352   return it;
 353 }
 354
 355 EmbeddedWorkerDevToolsManager::WorkerInfoMap::iterator
 356 EmbeddedWorkerDevToolsManager::FindExistingServiceWorkerInfo(
 357     const ServiceWorkerIdentifier& service_worker_id) {
 358   WorkerInfoMap::iterator it = workers_.begin();
 359   for (; it != workers_.end(); ++it) {
 360     if (it->second->Matches(service_worker_id))
 361       break;
 362   }
 363   return it;
 364 }
 365
 366 void EmbeddedWorkerDevToolsManager::MoveToPausedState(
 367     const WorkerId& id,
 368     const WorkerInfoMap::iterator& it) {
 369   DCHECK_EQ(WORKER_TERMINATED, it->second->state());
 370   scoped_ptr<WorkerInfo> info = workers_.take_and_erase(it);
 371   info->set_state(WORKER_PAUSED_FOR_REATTACH);
 372   workers_.set(id, info.Pass());
 373 }
 374
 375 void EmbeddedWorkerDevToolsManager::ResetForTesting() {
 376   workers_.clear();
 377 }
 378
 379 }  // namespace content