Wire DevTools agent in the Glue to the Renderer DevTools IPC transport: DevToolsAgent now implements WebDevToolsAgentDelegate, DevToolsClient covers WebDevToolsClientDelegate.

WebDevToolsAgent instance is being created by the WebView early in the init code and belongs to it. WebView exposes interface for accessing the agent; it also extends its delegate interface to pass WebDevToolsAgentDelegate into it.
Note that there is no call overhead unless particular sub-agents are enabled in the WebDevToolsAgent.

WebDevToolsClient instance is being created externally by the DevToolsClient.
Review URL: http://codereview.chromium.org/46032

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@11752 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 84 insertions, 7 deletions

diff --git a/chrome/renderer/dev_tools_agent.cc b/chrome/renderer/dev_tools_agent.cc
index ac453d5..d66881d 100644
--- a/chrome/renderer/dev_tools_agent.cc
+++ b/chrome/renderer/dev_tools_agent.cc
@@ -2,6 +2,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// DevToolsAgent belongs to the inspectable renderer and provides Glue's
+// agents with the communication capabilities. All messages from/to Glue's
+// agents infrastructure are flowing through this comminucation agent.
+//
+// DevToolsAgent is registered as an IPC filter in order to be able to
+// dispatch messages while on the IO thread. The reason for that is that while
+// debugging, Render thread is being held by the v8 and hence no messages
+// are being dispatched there. While holding the thread in a tight loop,
+// v8 provides thread-safe Api for controlling debugger. In our case v8's Api
+// is being used from this communication agent on the IO thread.
+
 #include "chrome/renderer/dev_tools_agent.h"
 
 #include "base/message_loop.h"
@@ -13,10 +24,13 @@
 #endif  // OS_WIN
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_view.h"
+#include "webkit/glue/webdevtoolsagent.h"
 
-DevToolsAgent::DevToolsAgent(RenderView* view, MessageLoop* view_loop)
+DevToolsAgent::DevToolsAgent(int routing_id,
+                             RenderView* view,
+                             MessageLoop* view_loop)
     : debugger_(NULL),
-      routing_id_(view->routing_id()),
+      routing_id_(routing_id),
       view_(view),
       view_loop_(view_loop),
       channel_(NULL),
@@ -72,6 +86,7 @@ bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DebugDetach, OnDebugDetach)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DebugBreak, OnDebugBreak)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DebugCommand, OnDebugCommand)
+    IPC_MESSAGE_HANDLER(DevToolsAgentMsg_RpcMessage, OnRpcMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ -150,3 +165,17 @@ void DevToolsAgent::OnDebugCommand(const std::wstring& cmd) {
     debugger_->Command(cmd);
   }
 }
+
+void DevToolsAgent::SendMessageToClient(const std::string& raw_msg) {
+  Send(DevToolsClientMsg_RpcMessage(raw_msg));
+}
+
+void DevToolsAgent::OnRpcMessage(const std::string& raw_msg) {
+  view_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+      this, &DevToolsAgent::DispatchRpcMessage, raw_msg));
+}
+
+void DevToolsAgent::DispatchRpcMessage(const std::string& raw_msg) {
+  WebDevToolsAgent* web_agent = view_->webview()->GetWebDevToolsAgent();
+  web_agent->DispatchMessageFromClient(raw_msg);
+}
diff --git a/chrome/renderer/dev_tools_agent.h b/chrome/renderer/dev_tools_agent.h
index 86b2d33..8ee1885 100644
--- a/chrome/renderer/dev_tools_agent.h
+++ b/chrome/renderer/dev_tools_agent.h
@@ -11,7 +11,9 @@
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "chrome/common/ipc_channel_proxy.h"
+#include "chrome/renderer/dev_tools_messages.h"
 #include "webkit/glue/debugger_bridge.h"
+#include "webkit/glue/webdevtoolsagent_delegate.h"
 
 class MessageLoop;
 class RenderView;
@@ -21,13 +23,17 @@ class RenderView;
 // go through browser process. On the renderer side of the tools UI there's
 // a corresponding ToolsClient object.
 class DevToolsAgent : public IPC::ChannelProxy::MessageFilter,
-                      public DebuggerBridge::Delegate {
+                      public DebuggerBridge::Delegate,
+                      public WebDevToolsAgentDelegate {
  public:
   // DevToolsAgent is a field of the RenderView. The view is supposed to remove
   // this agent from message filter list on IO thread before dying.
-  explicit DevToolsAgent(RenderView* view, MessageLoop* view_loop);
+  DevToolsAgent(int routing_id, RenderView* view, MessageLoop* view_loop);
   virtual ~DevToolsAgent();
 
+  // WebDevToolsAgentDelegate implementation
+  virtual void SendMessageToClient(const std::string& raw_msg);
+
   // DevToolsAgent is created by RenderView which is supposed to call this
   // method from its destructor.
   void RenderViewDestroyed();
@@ -48,6 +54,8 @@ class DevToolsAgent : public IPC::ChannelProxy::MessageFilter,
   // Debugger::Delegate callback method to handle debugger output.
   void DebuggerOutput(const std::wstring& out);
 
+  void DispatchRpcMessage(const std::string& raw_msg);
+
   // Evaluate javascript URL in the renderer
   void EvaluateScript(const std::wstring& script);
 
@@ -57,6 +65,7 @@ class DevToolsAgent : public IPC::ChannelProxy::MessageFilter,
   void OnDebugDetach();
   void OnDebugBreak(bool force);
   void OnDebugCommand(const std::wstring& cmd);
+  void OnRpcMessage(const std::string& raw_msg);
 
   scoped_refptr<DebuggerBridge> debugger_;
 
diff --git a/chrome/renderer/dev_tools_client.cc b/chrome/renderer/dev_tools_client.cc
index 502ef39..eb1523d 100644
--- a/chrome/renderer/dev_tools_client.cc
+++ b/chrome/renderer/dev_tools_client.cc
@@ -8,9 +8,12 @@
 #include "chrome/renderer/dev_tools_messages.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
+#include "webkit/glue/webdevtoolsclient.h"
 
 DevToolsClient::DevToolsClient(RenderView* view)
     : render_view_(view) {
+  web_tools_client_.reset(
+      WebDevToolsClient::Create(view->webview(), this));
 }
 
 DevToolsClient::~DevToolsClient() {
@@ -28,6 +31,7 @@ bool DevToolsClient::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DevToolsClient, message)
     IPC_MESSAGE_HANDLER(DevToolsClientMsg_DidDebugAttach, DidDebugAttach)
+    IPC_MESSAGE_HANDLER(DevToolsClientMsg_RpcMessage, OnRpcMessage)
     IPC_MESSAGE_UNHANDLED(handled = false);
   IPC_END_MESSAGE_MAP()
 
@@ -38,3 +42,11 @@ void DevToolsClient::DidDebugAttach() {
   DCHECK(RenderThread::current()->message_loop() == MessageLoop::current());
   // TODO(yurys): delegate to JS frontend.
 }
+
+void DevToolsClient::SendMessageToAgent(const std::string& raw_msg) {
+  Send(DevToolsAgentMsg_RpcMessage(raw_msg));
+}
+
+void DevToolsClient::OnRpcMessage(const std::string& raw_msg) {
+  web_tools_client_->DispatchMessageFromAgent(raw_msg);
+}
diff --git a/chrome/renderer/dev_tools_client.h b/chrome/renderer/dev_tools_client.h
index fd92dcf..4419a4f 100644
--- a/chrome/renderer/dev_tools_client.h
+++ b/chrome/renderer/dev_tools_client.h
@@ -5,13 +5,18 @@
 #ifndef CHROME_RENDERER_DEV_TOOLS_CLIENT_H_
 #define CHROME_RENDERER_DEV_TOOLS_CLIENT_H_
 
-#include "base/basictypes.h"
+#include <string>
+
+#include "base/scoped_ptr.h"
+#include "chrome/renderer/dev_tools_messages.h"
+#include "webkit/glue/webdevtoolsclient_delegate.h"
 
 namespace IPC {
 class Message;
 }
 class MessageLoop;
 class RenderView;
+class WebDevToolsClient;
 
 // Developer tools UI end of communication channel between the render process of
 // the page being inspected and tools UI renderer process. All messages will
@@ -19,7 +24,7 @@ class RenderView;
 // corresponding DevToolsAgent object.
 // TODO(yurys): now the client is almost empty later it will delegate calls to
 // code in glue
-class DevToolsClient {
+class DevToolsClient : public WebDevToolsClientDelegate {
  public:
   explicit DevToolsClient(RenderView* view);
   virtual ~DevToolsClient();
@@ -28,13 +33,18 @@ class DevToolsClient {
   // handled. Called in render thread.
   bool OnMessageReceived(const IPC::Message& message);
 
+  // WebDevToolsClient::Delegate implementation
+  virtual void SendMessageToAgent(const std::string& raw_msg);
+
  private:
   void DidDebugAttach();
+  void OnRpcMessage(const std::string& raw_msg);
 
   // Sends message to DevToolsAgent.
   void Send(const IPC::Message& tools_agent_message);
 
   RenderView* render_view_;  // host render view
+  scoped_ptr<WebDevToolsClient> web_tools_client_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsClient);
 };
diff --git a/chrome/renderer/dev_tools_messages_internal.h b/chrome/renderer/dev_tools_messages_internal.h
index 8922f18..49eee11 100644
--- a/chrome/renderer/dev_tools_messages_internal.h
+++ b/chrome/renderer/dev_tools_messages_internal.h
@@ -53,6 +53,10 @@ IPC_BEGIN_MESSAGES(DevToolsClient)
   IPC_MESSAGE_CONTROL1(DevToolsClientMsg_DebuggerOutput,
                        std::wstring /* msg */)
 
+  // Sends glue-level Rpc message to the client.
+  IPC_MESSAGE_CONTROL1(DevToolsClientMsg_RpcMessage,
+                       std::string  /* raw_msg */)
+
 IPC_END_MESSAGES(DevToolsClient)
 
 
@@ -75,4 +79,8 @@ IPC_BEGIN_MESSAGES(DevToolsAgent)
   IPC_MESSAGE_CONTROL1(DevToolsAgentMsg_DebugCommand,
                        std::wstring  /* cmd */)
 
+  // Sends glue-level Rpc message to the agent.
+  IPC_MESSAGE_CONTROL1(DevToolsAgentMsg_RpcMessage,
+                       std::string  /* raw_msg */)
+
 IPC_END_MESSAGES(DevToolsAgent)
diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc
index 50c98ec..000443e 100644
--- a/chrome/renderer/render_view.cc
+++ b/chrome/renderer/render_view.cc
@@ -51,6 +51,7 @@
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/searchable_form_data.h"
 #include "webkit/glue/webdatasource.h"
+#include "webkit/glue/webdevtoolsagent_delegate.h"
 #include "webkit/glue/webdropdata.h"
 #include "webkit/glue/weberror.h"
 #include "webkit/glue/webframe.h"
@@ -294,6 +295,8 @@ void RenderView::Init(gfx::NativeViewId parent_hwnd,
     decrement_shared_popup_at_destruction_ = false;
   }
 
+  dev_tools_agent_ = new DevToolsAgent(routing_id, this,
+      MessageLoop::current());
   webwidget_ = WebView::Create(this, webkit_prefs);
 
   // Don't let WebCore keep a B/F list - we have our own.
@@ -326,7 +329,6 @@ void RenderView::Init(gfx::NativeViewId parent_hwnd,
   debug_message_handler_ = new DebugMessageHandler(this);
   render_thread_->AddFilter(debug_message_handler_);
 
-  dev_tools_agent_ = new DevToolsAgent(this, MessageLoop::current());
   render_thread_->AddFilter(dev_tools_agent_);
 }
 
@@ -2461,6 +2463,10 @@ void RenderView::DownloadUrl(const GURL& url, const GURL& referrer) {
   Send(new ViewHostMsg_DownloadUrl(routing_id_, url, referrer));
 }
 
+WebDevToolsAgentDelegate* RenderView::GetWebDevToolsAgentDelegate() {
+  return dev_tools_agent_;
+}
+
 WebFrame* RenderView::GetChildFrame(const std::wstring& frame_xpath) const {
   WebFrame* web_frame;
   if (frame_xpath.empty()) {
diff --git a/chrome/renderer/render_view.h b/chrome/renderer/render_view.h
index 8973346..47472db 100644
--- a/chrome/renderer/render_view.h
+++ b/chrome/renderer/render_view.h
@@ -57,6 +57,7 @@ class WebError;
 class WebFrame;
 class WebPluginDelegate;
 class WebPluginDelegateProxy;
+class WebDevToolsAgentDelegate;
 struct AccessibilityInParams;
 struct AccessibilityOutParams;
 struct FindInPageRequest;
@@ -274,6 +275,8 @@ class RenderView : public RenderWidget,
 
   virtual void DownloadUrl(const GURL& url, const GURL& referrer);
 
+  virtual WebDevToolsAgentDelegate* GetWebDevToolsAgentDelegate();
+
   virtual void OnPasswordFormsSeen(WebView* webview,
                                    const std::vector<PasswordForm>& forms);