DevTools: add initial support for shared workers debugging

content/worker/worker_devtools_agent.cc

Index: content/worker/worker_devtools_agent.cc
diff --git a/content/worker/worker_devtools_agent.cc b/content/worker/worker_devtools_agent.cc
index af00871357b73326316bec9ac0753e3a5583b4cb..96b50195f4b44fc5330b266739d735cf9f67787f 100644
--- a/content/worker/worker_devtools_agent.cc
+++ b/content/worker/worker_devtools_agent.cc
@@ -7,51 +7,125 @@
 #include "content/common/devtools_messages.h"
 #include "content/worker/worker_thread.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebSharedWorker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebWorker.h"
 
+using WebKit::WebSharedWorker;
 using WebKit::WebString;
 using WebKit::WebWorker;
 
-WorkerDevToolsAgent::WorkerDevToolsAgent(int route_id, WebWorker* webworker)
-    : route_id_(route_id),
-      webworker_(webworker) {
-}
+namespace {
+
+class DedicatedWorkerDevToolsAgent : public WorkerDevToolsAgent {
+ public:
+  DedicatedWorkerDevToolsAgent(int route_id, WebWorker* webworker)
+      : WorkerDevToolsAgent(route_id),
+        webworker_(webworker) {}
+
+ private:
+  virtual ~DedicatedWorkerDevToolsAgent() {}
+
+  // Called on the Worker thread.
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(DedicatedWorkerDevToolsAgent, message)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Attach, OnAttach)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Detach, OnDetach)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_DispatchOnInspectorBackend,
+                          OnDispatchOnInspectorBackend)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+  virtual void SendDevToolsMessage(const WebKit::WebString& message) {
+    Send(new DevToolsAgentMsg_DispatchMessageFromWorker(route_id_,
+                                                        message.utf8()));
+  }
+
+  void OnAttach() {
+    webworker_->attachDevTools();
+  }
+
+  void OnDetach() {
+    webworker_->detachDevTools();
+  }
+
+  void OnDispatchOnInspectorBackend(
+      const std::string& message) {
+    webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+  }
+
+  WebKit::WebWorker* webworker_;
+
+  DISALLOW_COPY_AND_ASSIGN(DedicatedWorkerDevToolsAgent);
+};
 
-WorkerDevToolsAgent::~WorkerDevToolsAgent() {
-}
 
-// Called on the Worker thread.
-bool WorkerDevToolsAgent::OnMessageReceived(const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(WorkerDevToolsAgent, message)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Attach, OnAttach)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Detach, OnDetach)
-    IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_DispatchOnInspectorBackend,
-                        OnDispatchOnInspectorBackend)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
+class SharedWorkerDevToolsAgent : public WorkerDevToolsAgent {

[jam, 2011/07/08 17:49:09]

It's unfortunate that this class is duplicated for both worker types. Why can't
the debugger related methods on We worker and WebSharedWorker derive from a base
class for this purpose? Otherwise a template can be used.

[pfeldman, 2011/07/11 12:07:16]

I think templates won't harm readability of this code.

[yurys, 2011/07/11 15:13:11]

WebWorker and WebSharedWorker don't have common ancestor, otherwise I would have
put these methods there. I tried to avoid a new base class for workers but if
you think that it would be justified, I could do that. But even in that case
OnMessageReceived would have two different implementations as it handles
DevToolsAgentMsg_DispatchOnInspectorBackend in one case and
WorkerDevToolsAgentMsg_DispatchOnInspectorBackend in another. Also
SendDevToolsMessage should be different for shared and dedicated workers. Given
all this I don't think it is worth complicating the code with templates just to
avoid code duplication in 2 one-line methods.

[yurys, 2011/07/11 15:13:11]

See my response to John.

[jam, 2011/07/11 16:53:37]

You can send DevToolsAgentMsg_DispatchOnInspectorBackend in both cases. It's
common for messages that are sent to different child processes to reuse the same
message class, instead of duplicating it.
This one function would be different, but the rest of the 50 line class would be
the same.

[yurys, 2011/07/12 13:58:46]

Done. Converted the class into template and reused
DevToolsAgentMsg_DispatchOnInspectorBackend for both shared and dedicated worker
processes.

+public:
+    SharedWorkerDevToolsAgent(int route_id, WebSharedWorker* webshared_worker)
+        : WorkerDevToolsAgent(route_id),
+          webshared_worker_(webshared_worker) { }
+
+private:
+  // Called on the Worker thread.
+  virtual bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(SharedWorkerDevToolsAgent, message)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Attach, OnAttach)
+      IPC_MESSAGE_HANDLER(WorkerDevToolsAgentMsg_Detach, OnDetach)
+      IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DispatchOnInspectorBackend,
+                          OnDispatchOnInspectorBackend)
+      IPC_MESSAGE_UNHANDLED(handled = false)
+    IPC_END_MESSAGE_MAP()
+    return handled;
+  }
+
+  virtual void SendDevToolsMessage(const WebString& message) {
+    IPC::Message m = DevToolsClientMsg_DispatchOnInspectorFrontend(
+        message.utf8());
+    m.set_routing_id(route_id_);
+    Send(new DevToolsHostMsg_ForwardToClient(route_id_, m));
+  }
+
+  void OnAttach() {
+    webshared_worker_->attachDevTools();
+  }
+  void OnDetach() {
+    webshared_worker_->detachDevTools();
+  }
+  void OnDispatchOnInspectorBackend(const std::string& message) {
+    webshared_worker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+  }
+
+  WebSharedWorker* webshared_worker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsAgent);
+};
+
+}  // namespace
+
+WorkerDevToolsAgent::WorkerDevToolsAgent(int route_id)
+    : route_id_(route_id) {
 }
 
-void WorkerDevToolsAgent::OnAttach() {
-  webworker_->attachDevTools();
+WorkerDevToolsAgent* WorkerDevToolsAgent::CreateForDedicatedWorker(
+    int route_id,
+    WebKit::WebWorker* webworker) {
+  return new DedicatedWorkerDevToolsAgent(route_id, webworker);
 }
 
-void WorkerDevToolsAgent::OnDetach() {
-  webworker_->detachDevTools();
+WorkerDevToolsAgent* WorkerDevToolsAgent::CreateForSharedWorker(
+    int route_id, WebKit::WebSharedWorker* webshared_worker) {
+  return new SharedWorkerDevToolsAgent(route_id, webshared_worker);
 }
 
-void WorkerDevToolsAgent::OnDispatchOnInspectorBackend(
-    const std::string& message) {
-  webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
+
+WorkerDevToolsAgent::~WorkerDevToolsAgent() {
 }
 
 bool WorkerDevToolsAgent::Send(IPC::Message* message) {
   return WorkerThread::current()->Send(message);
 }
-
-void WorkerDevToolsAgent::SendDevToolsMessage(const WebString& message) {
-  Send(new DevToolsAgentMsg_DispatchMessageFromWorker(route_id_,
-                                                      message.utf8()));
-}