Debug message handler is now called on the render thread

chrome/renderer/devtools_agent.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.
 
 // 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
@@ skipping 14 matching lines @@
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_view.h"
 #include "webkit/glue/webdevtoolsagent.h"
 
 DevToolsAgent::DevToolsAgent(int routing_id,
                              RenderView* view,
                              MessageLoop* view_loop)
     : routing_id_(routing_id),
       view_(view),
       view_loop_(view_loop),
-      channel_(NULL),
       io_loop_(NULL) {
 }
 
 DevToolsAgent::~DevToolsAgent() {
 }
 
 // Called on render thread.
 void DevToolsAgent::RenderViewDestroyed() {
   DCHECK(MessageLoop::current() == view_loop_);
   view_ = NULL;
 }
 
 void DevToolsAgent::Send(const IPC::Message& tools_client_message) {
-  // It's possible that this will get cleared out from under us.
-  MessageLoop* io_loop = io_loop_;
-  if (!io_loop)
+  DCHECK(MessageLoop::current() == view_loop_);
+  if (!view_) {
     return;
+  }
 
   IPC::Message* m = new ViewHostMsg_ForwardToDevToolsClient(
       routing_id_,
       tools_client_message);
-  io_loop->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &DevToolsAgent::SendFromIOThread, m));
-}
-
-void DevToolsAgent::SendFromIOThread(IPC::Message* message) {
-  if (channel_) {
-    channel_->Send(message);
-  } else {
-    delete message;
-  }
+  view_->Send(m);
 }
 
 // Called on the IO thread.
 void DevToolsAgent::OnFilterAdded(IPC::Channel* channel) {
   io_loop_ = MessageLoop::current();
-  channel_ = channel;
 }
 
 // Called on the IO thread.
 bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
   DCHECK(MessageLoop::current() == io_loop_);
 
   if (message.routing_id() != routing_id_)
     return false;
 
+  // TODO(yurys): only DebuggerCommand message is handled on the IO thread
+  // all other messages could be handled in RenderView::OnMessageReceived. With
+  // that approach we wouldn't have to call view_loop_->PostTask for each of the
+  // messages.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DevToolsAgent, message)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_Attach, OnAttach)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_Detach, OnDetach)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_RpcMessage, OnRpcMessage)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DebuggerCommand,
                         OnDebuggerCommand)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_InspectElement, OnInspectElement)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 // Called on the IO thread.
 void DevToolsAgent::OnFilterRemoved() {
   io_loop_ = NULL;
-  channel_ = NULL;
 }
 
 void DevToolsAgent::EvaluateScript(const std::wstring& script) {
   DCHECK(MessageLoop::current() == view_loop_);
   // view_ may have been cleared after this method execution was scheduled.
   if (view_)
     view_->EvaluateScript(L"", script);
 }
 
 void DevToolsAgent::OnAttach() {
@@ skipping 54 matching lines @@
 }
 
 WebDevToolsAgent* DevToolsAgent::GetWebAgent() {
   if (!view_)
     return NULL;
   WebView* web_view = view_->webview();
   if (!web_view)
     return NULL;
   return web_view->GetWebDevToolsAgent();
 }