DevTools: add initial support for shared workers debugging

content/browser/debugger/devtools_manager.cc

 // Copyright (c) 2011 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 "content/browser/debugger/devtools_manager.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/message_loop.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"

[Jói, 2011/07/05 18:00:45]

Please don't add a new dependency on ProfileManager, I am working to remove all
the dependencies on Chrome listed in content/browser/debugger/DEPS.

If you really need the default profile, you could add a method to
ContentBrowserClient to retrieve it.

[pfeldman, 2011/07/06 08:29:39]

Do you have an estimate on when migration is complete?

[jam, 2011/07/06 13:47:40]

if a method is added to ContentBrowserClient to return a profile, it will have
to be removed soon as well since that interface shouldn't know about profiles.
it's probably less work to leave the code as below and then remove it in one
shot when DevToolsWindow doesn't need profile anymore?

On 2011/07/05 18:00:45, Jói wrote:

[yurys, 2011/07/06 14:03:52]

My understanding is that DevToolsWindow is a Chrome-specific implementation of
DevToolsClientHost and as such should live under chrome/ where it shouldn't be a
problem to access ProfileManager.

 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browsing_instance.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/debugger/devtools_client_host.h"
 #include "content/browser/debugger/devtools_netlog_observer.h"
 #include "content/browser/debugger/devtools_window.h"
+#include "content/browser/debugger/worker_devtools_manager.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/notification_service.h"
 #include "googleurl/src/gurl.h"
 
 // static
 DevToolsManager* DevToolsManager::GetInstance() {
   // http://crbug.com/47806 this method may be called when BrowserProcess
   // has already been destroyed.
@@ skipping 16 matching lines @@
   registrar_.Add(this, NotificationType::RENDER_VIEW_HOST_DELETED,
                  NotificationService::AllSources());
 }
 
 DevToolsManager::~DevToolsManager() {
   DCHECK(inspected_rvh_to_client_host_.empty());
   DCHECK(client_host_to_inspected_rvh_.empty());
   // By the time we destroy devtools manager, all orphan client hosts should
   // have been delelted, no need to notify them upon tab closing.
   DCHECK(orphan_client_hosts_.empty());
+  DCHECK(worker_id_to_client_host_.empty());
 }
 
 DevToolsClientHost* DevToolsManager::GetDevToolsClientHostFor(
     RenderViewHost* inspected_rvh) {
   InspectedRvhToClientHostMap::iterator it =
       inspected_rvh_to_client_host_.find(inspected_rvh);
   if (it != inspected_rvh_to_client_host_.end())
     return it->second;
   return NULL;
 }
 
 void DevToolsManager::RegisterDevToolsClientHostFor(
     RenderViewHost* inspected_rvh,
     DevToolsClientHost* client_host) {
   DCHECK(!GetDevToolsClientHostFor(inspected_rvh));
 
   DevToolsRuntimeProperties initial_properties;
   BindClientHost(inspected_rvh, client_host, initial_properties);
   client_host->set_close_listener(this);
   SendAttachToAgent(inspected_rvh);
 }
 
 void DevToolsManager::ForwardToDevToolsAgent(
     RenderViewHost* client_rvh,
     const IPC::Message& message) {
   DevToolsClientHost* client_host = FindOwnerDevToolsClientHost(client_rvh);
-  if (client_host)
+  if (client_host) {
     ForwardToDevToolsAgent(client_host, message);
+    return;
+  }
+  ForwardToWorkerDevToolsAgent(client_rvh, message);
 }
 
 void DevToolsManager::ForwardToDevToolsAgent(DevToolsClientHost* from,
                                              const IPC::Message& message) {
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(from);
   if (!inspected_rvh) {
     // TODO(yurys): notify client that the agent is no longer available
     NOTREACHED();
     return;
   }
 
   IPC::Message* m = new IPC::Message(message);
   m->set_routing_id(inspected_rvh->routing_id());
   inspected_rvh->Send(m);
 }
 
 void DevToolsManager::ForwardToDevToolsClient(RenderViewHost* inspected_rvh,
                                               const IPC::Message& message) {
   DevToolsClientHost* client_host = GetDevToolsClientHostFor(inspected_rvh);
   if (!client_host) {
     // Client window was closed while there were messages
     // being sent to it.
     return;
   }
   client_host->SendMessageToClient(message);
 }
 
+void DevToolsManager::OpenDevToolsForWorker(int worker_devtools_id) {
+  Profile* profile = ProfileManager::GetDefaultProfile();
+  if (!profile)
+    return;
+  DevToolsWindow* window = new DevToolsWindow(profile, NULL, false);
+  window->set_close_listener(this);
+  window->Show(DEVTOOLS_TOGGLE_ACTION_NONE);
+  worker_id_to_client_host_[worker_devtools_id] = window;
+}
+
+void DevToolsManager::ForwardToWorkerDevToolsClient(
+    int worker_devtools_id,
+    const IPC::Message& message) {
+  WorkerIdToClientHostMap::iterator it =
+      worker_id_to_client_host_.find(worker_devtools_id);
+  if (it == worker_id_to_client_host_.end())
+    return;
+  it->second->SendMessageToClient(message);
+}
+
+static void ForwardToWorkerDevToolsAgentOnIOThread(
+    int worker_devtools_id,
+    const IPC::Message& message) {
+  WorkerDevToolsManager::GetInstance()->ForwardToWorkerDevToolsAgent(
+      worker_devtools_id, message);
+}
+
+void DevToolsManager::ForwardToWorkerDevToolsAgent(
+    RenderViewHost* client_rvh,
+    const IPC::Message& message) {
+  int worker_devtools_id = FindWorkerDevToolsId(client_rvh);
+  if (worker_devtools_id == -1)
+    return;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableFunction(
+          ForwardToWorkerDevToolsAgentOnIOThread,
+          worker_devtools_id,
+          IPC::Message(message)));
+}
+
+int DevToolsManager::FindWorkerDevToolsId(RenderViewHost* client_rvh) {
+  for (WorkerIdToClientHostMap::const_iterator it =
+           worker_id_to_client_host_.begin();
+       it != worker_id_to_client_host_.end(); ++it) {
+    DevToolsWindow* window = it->second->AsDevToolsWindow();
+    if (!window)
+      continue;
+    if (window->GetRenderViewHost() != client_rvh)
+      continue;
+    return it->first;
+  }
+  return -1;
+}
+
+static void NotifyWorkerDevToolsClientClosingOnIOThread(
+    int worker_devtools_id) {
+  WorkerDevToolsManager::GetInstance()->WorkerDevToolsClientClosing(
+      worker_devtools_id);
+}
+
+void DevToolsManager::MaybeWorkerDevToolsClientHostClosing(
+    DevToolsClientHost* host) {
+  WorkerIdToClientHostMap::iterator it = worker_id_to_client_host_.begin();
+  for (; it != worker_id_to_client_host_.end(); ++it) {
+    if (it->second == host) {
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          NewRunnableFunction(NotifyWorkerDevToolsClientClosingOnIOThread,
+                              it->first));
+      worker_id_to_client_host_.erase(it);
+      return;
+    }
+  }
+}
+
 void DevToolsManager::ActivateWindow(RenderViewHost* client_rvh) {
   DevToolsClientHost* client_host = FindOwnerDevToolsClientHost(client_rvh);
   if (!client_host)
     return;
 
   DevToolsWindow* window = client_host->AsDevToolsWindow();
   DCHECK(window);
   window->Activate();
 }
 
@@ skipping 56 matching lines @@
   RenderViewHost* inspected_rvh = GetInspectedRenderViewHost(host);
   if (!inspected_rvh) {
     // It might be in the list of orphan client hosts, remove it from there.
     for (OrphanClientHosts::iterator it = orphan_client_hosts_.begin();
          it != orphan_client_hosts_.end(); ++it) {
       if (it->second.first == host) {
         orphan_client_hosts_.erase(it->first);
         return;
       }
     }
+
+    // Worker DevTools clients don't have inspected RVHs. Check if one of them
+    // is closing.
+    MaybeWorkerDevToolsClientHostClosing(host);
     return;
   }
 
   NotificationService::current()->Notify(
       NotificationType::DEVTOOLS_WINDOW_CLOSING,
       Source<Profile>(inspected_rvh->site_instance()->GetProcess()->profile()),
       Details<RenderViewHost>(inspected_rvh));
 
   UnbindClientHost(inspected_rvh, host);
 }
@@ skipping 258 matching lines @@
   for (InspectedRvhToClientHostMap::iterator it =
            inspected_rvh_to_client_host_.begin();
        it != inspected_rvh_to_client_host_.end(); ++it) {
     rhvs.push_back(it->first);
   }
   for (std::vector<RenderViewHost*>::iterator it = rhvs.begin();
        it != rhvs.end(); ++it) {
     UnregisterDevToolsClientHostFor(*it);
   }
 }