DevTools: devtools message plumbing between worker and page processes

content/renderer/webworker_proxy.cc

 // Copyright (c) 2009 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/renderer/webworker_proxy.h"
 
 #include "content/common/child_thread.h"
+#include "content/common/content_client.h"
 #include "content/common/view_messages.h"
 #include "content/common/webmessageportchannel_impl.h"
 #include "content/common/worker_messages.h"
+#include "content/worker/content_worker_client.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebWorkerClient.h"
 
 using WebKit::WebCommonWorkerClient;
 using WebKit::WebMessagePortChannel;
 using WebKit::WebMessagePortChannelArray;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebWorkerClient;
 
 WebWorkerProxy::WebWorkerProxy(
     WebWorkerClient* client,
     ChildThread* child_thread,
     int render_view_route_id,
     int parent_appcache_host_id)
     : WebWorkerBase(child_thread, 0, MSG_ROUTING_NONE, render_view_route_id,
                     parent_appcache_host_id),
       client_(client) {
   // TODO(atwilson): Change to pass in a real document_id when we support nested
   // workers.
+  content::GetContentClient()->worker()->WebWorkerProxyCreated(this, route_id_,
+                                                               client_);
 }
 
 WebWorkerProxy::~WebWorkerProxy() {
   // If we're midway through starting a worker, cancel it.
   CancelCreation();
 }
 
 void WebWorkerProxy::CancelCreation() {
   if (route_id_ == MSG_ROUTING_NONE)
     return;
@@ skipping 36 matching lines @@
 }
 
 void WebWorkerProxy::workerObjectDestroyed() {
   Send(new WorkerMsg_WorkerObjectDestroyed(route_id_));
   delete this;
 }
 
 void WebWorkerProxy::clientDestroyed() {
 }
 
+void WebWorkerProxy::attachDevTools()
+{
+  if (devtools_delegate_)
+    devtools_delegate_->AttachDevTools();
+}
+
+void WebWorkerProxy::detachDevTools()
+{
+  if (devtools_delegate_)
+    devtools_delegate_->DetachDevTools();
+}
+
+void WebWorkerProxy::dispatchDevToolsMessage(const WebString& message)
+{
+  if (devtools_delegate_)
+    devtools_delegate_->SendDevToolsMessage(message.utf8());
+}
+
 bool WebWorkerProxy::OnMessageReceived(const IPC::Message& message) {
   if (!client_)
     return false;
 
+  if (devtools_delegate_ &&
+    devtools_delegate_->OnMessageReceived(message))
+    return true;
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebWorkerProxy, message)
     IPC_MESSAGE_HANDLER(ViewMsg_WorkerCreated, OnWorkerCreated)
     IPC_MESSAGE_HANDLER(WorkerMsg_PostMessage, OnPostMessage)
     IPC_MESSAGE_FORWARD(WorkerHostMsg_PostExceptionToWorkerObject,
                         client_,
                         WebWorkerClient::postExceptionToWorkerObject)
     IPC_MESSAGE_HANDLER(WorkerHostMsg_PostConsoleMessageToWorkerObject,
                         OnPostConsoleMessageToWorkerObject)
     IPC_MESSAGE_FORWARD(WorkerHostMsg_ConfirmMessageFromWorkerObject,
@@ skipping 30 matching lines @@
   client_->postMessageToWorkerObject(message, channels);
 }
 
 void WebWorkerProxy::OnPostConsoleMessageToWorkerObject(
       const WorkerHostMsg_PostConsoleMessageToWorkerObject_Params& params) {
   client_->postConsoleMessageToWorkerObject(params.source_identifier,
       params.message_type, params.message_level,
       params.message, params.line_number, params.source_url);
 }