DevTools: Remove base/values dependency from devtools.

Review URL: http://codereview.chromium.org/173480

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

30 files changed, 235 insertions, 635 deletions

diff --git a/chrome/browser/debugger/inspectable_tab_proxy.cc b/chrome/browser/debugger/inspectable_tab_proxy.cc
index 7d584dc..29e5d32 100644
--- a/chrome/browser/debugger/inspectable_tab_proxy.cc
+++ b/chrome/browser/debugger/inspectable_tab_proxy.cc
@@ -4,9 +4,7 @@
 
 #include "chrome/browser/debugger/inspectable_tab_proxy.h"
 
-#include "base/json_reader.h"
 #include "base/string_util.h"
-#include "base/values.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/debugger/debugger_remote_service.h"
@@ -38,31 +36,19 @@ void DevToolsClientHostImpl::SendMessageToClient(
 
 void DevToolsClientHostImpl::OnRpcMessage(const std::string& class_name,
                                           const std::string& message_name,
-                                          const std::string& msg) {
+                                          const std::string& param1,
+                                          const std::string& param2,
+                                          const std::string& param3) {
   static const std::string kDebuggerAgentDelegate = "DebuggerAgentDelegate";
   static const std::string kToolsAgentDelegate = "ToolsAgentDelegate";
   static const std::string kDebuggerOutput = "DebuggerOutput";
   static const std::string kFrameNavigate = "FrameNavigate";
 
-  scoped_ptr<Value> message(JSONReader::Read(msg, false));
-  if (!message->IsType(Value::TYPE_LIST)) {
-    NOTREACHED();  // The RPC protocol has changed :(
-    return;
-  }
-  ListValue* list_msg = static_cast<ListValue*>(message.get());
   if (class_name == kDebuggerAgentDelegate && message_name == kDebuggerOutput) {
-    std::string str;
-    if (!list_msg->GetString(0, &str))
-      return;
-    DebuggerOutput(str);
+    DebuggerOutput(param1);
   } else if (class_name == kToolsAgentDelegate &&
              message_name == kFrameNavigate) {
-    std::string url;
-    if (!list_msg->GetString(0, &url)) {
-      NOTREACHED();
-      return;
-    }
-    FrameNavigate(url);
+    FrameNavigate(param1);
   }
 }
 
diff --git a/chrome/browser/debugger/inspectable_tab_proxy.h b/chrome/browser/debugger/inspectable_tab_proxy.h
index 454d248..13da2ec 100644
--- a/chrome/browser/debugger/inspectable_tab_proxy.h
+++ b/chrome/browser/debugger/inspectable_tab_proxy.h
@@ -83,7 +83,9 @@ class DevToolsClientHostImpl : public DevToolsClientHost {
   // Message handling routines
   void OnRpcMessage(const std::string& class_name,
                     const std::string& message_name,
-                    const std::string& msg);
+                    const std::string& param1,
+                    const std::string& param2,
+                    const std::string& param3);
   void DebuggerOutput(const std::string& msg);
   void FrameNavigate(const std::string& url);
   void TabClosed();
diff --git a/chrome/browser/extensions/extension_devtools_bridge.cc b/chrome/browser/extensions/extension_devtools_bridge.cc
index 2ac456f..2702394 100644
--- a/chrome/browser/extensions/extension_devtools_bridge.cc
+++ b/chrome/browser/extensions/extension_devtools_bridge.cc
@@ -85,17 +85,19 @@ static const char kTabUrlChangeEventMessageName[] = "TabUrlChangeEventMessage";
 
 void ExtensionDevToolsBridge::OnRpcMessage(const std::string& class_name,
                                            const std::string& message_name,
-                                           const std::string& msg) {
+                                           const std::string& param1,
+                                           const std::string& param2,
+                                           const std::string& param3) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   // TODO(jamesr): Update the filtering and message creation logic once
   // the TimelineAgent lands in WebKit.
   if (class_name == kTimelineAgentClassName) {
     if (message_name == kPageEventMessageName) {
-      std::string json = StringPrintf("[{\"record\": \"%s\"}]", msg.c_str());
+      std::string json = StringPrintf("[{\"record\": \"%s\"}]", param1.c_str());
       profile_->GetExtensionMessageService()->
           DispatchEventToRenderers(on_page_event_name_, json);
     } else if (message_name == kTabUrlChangeEventMessageName) {
-      std::string json = StringPrintf("[{\"record\": \"%s\"}]", msg.c_str());
+      std::string json = StringPrintf("[{\"record\": \"%s\"}]", param1.c_str());
       profile_->GetExtensionMessageService()->
           DispatchEventToRenderers(on_tab_url_change_event_name_, json);
     }
diff --git a/chrome/browser/extensions/extension_devtools_bridge.h b/chrome/browser/extensions/extension_devtools_bridge.h
index b4cb98d..d6fd960 100644
--- a/chrome/browser/extensions/extension_devtools_bridge.h
+++ b/chrome/browser/extensions/extension_devtools_bridge.h
@@ -34,7 +34,9 @@ class ExtensionDevToolsBridge : public DevToolsClientHost {
  private:
   void OnRpcMessage(const std::string& class_name,
                     const std::string& message_name,
-                    const std::string& msg);
+                    const std::string& param1,
+                    const std::string& param2,
+                    const std::string& param3);
 
   // ID of the tab we are monitoring.
   int tab_id_;
diff --git a/chrome/browser/extensions/extension_devtools_browsertests.cc b/chrome/browser/extensions/extension_devtools_browsertests.cc
index 9aaa071..19f7ba4 100644
--- a/chrome/browser/extensions/extension_devtools_browsertests.cc
+++ b/chrome/browser/extensions/extension_devtools_browsertests.cc
@@ -63,7 +63,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionDevToolsBrowserTest, TimelineApi) {
   TabContents* tab_contents = browser()->tabstrip_model()->GetTabContentsAt(0);
   ASSERT_TRUE(tab_contents);
   int tab_id = ExtensionTabUtil::GetTabId(tab_contents);
-  
+
   // Test setup.
   bool result = false;
   std::wstring register_listeners_js = StringPrintf(L"setListenersOnTab(%d)",
@@ -81,7 +81,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionDevToolsBrowserTest, TimelineApi) {
 
   // Test onTabUrlChange event.
   DevToolsClientMsg_RpcMessage tabUrlChangeEventMessage(
-      "TimelineAgentClass", "TabUrlChangeEventMessage", "{}");
+      "TimelineAgentClass", "TabUrlChangeEventMessage", "", "", "");
   devtools_client_host->SendMessageToClient(tabUrlChangeEventMessage);
   ui_test_utils::ExecuteJavaScriptAndExtractBool(
       host->render_view_host(),
@@ -93,7 +93,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionDevToolsBrowserTest, TimelineApi) {
   // Test onPageEvent event.
   result = false;
   DevToolsClientMsg_RpcMessage pageEventMessage(
-      "TimelineAgentClass", "PageEventMessage", "{}");
+      "TimelineAgentClass", "PageEventMessage", "", "", "");
   devtools_client_host->SendMessageToClient(pageEventMessage);
   ui_test_utils::ExecuteJavaScriptAndExtractBool(
       host->render_view_host(), L"", L"testReceivePageEvent()", &result);
@@ -130,7 +130,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionDevToolsBrowserTest, ProcessRefCounting) {
   TabContents* tab_contents = browser()->tabstrip_model()->GetTabContentsAt(0);
   ASSERT_TRUE(tab_contents);
   int tab_id = ExtensionTabUtil::GetTabId(tab_contents);
-  
+
   // Test setup.
   bool result = false;
   std::wstring register_listeners_js = StringPrintf(L"setListenersOnTab(%d)",
diff --git a/chrome/common/devtools_messages_internal.h b/chrome/common/devtools_messages_internal.h
index 4411a21..e139c6c 100644
--- a/chrome/common/devtools_messages_internal.h
+++ b/chrome/common/devtools_messages_internal.h
@@ -49,10 +49,12 @@
 IPC_BEGIN_MESSAGES(DevToolsClient)
 
   // Sends glue-level Rpc message to the client.
-  IPC_MESSAGE_CONTROL3(DevToolsClientMsg_RpcMessage,
+  IPC_MESSAGE_CONTROL5(DevToolsClientMsg_RpcMessage,
                        std::string /* class_name */,
                        std::string /* method_name */,
-                       std::string /* raw_msg */)
+                       std::string /* p1 */,
+                       std::string /* p2 */,
+                       std::string /* p3 */)
 
 IPC_END_MESSAGES(DevToolsClient)
 
@@ -69,10 +71,12 @@ IPC_BEGIN_MESSAGES(DevToolsAgent)
   IPC_MESSAGE_CONTROL0(DevToolsAgentMsg_Detach)
 
   // Sends glue-level Rpc message to the agent.
-  IPC_MESSAGE_CONTROL3(DevToolsAgentMsg_RpcMessage,
+  IPC_MESSAGE_CONTROL5(DevToolsAgentMsg_RpcMessage,
                        std::string /* class_name */,
                        std::string /* method_name */,
-                       std::string /* raw_msg */)
+                       std::string /* p1 */,
+                       std::string /* p2 */,
+                       std::string /* p3 */)
 
   // Send debugger command to the debugger agent. Debugger commands should
   // be handled on IO thread(while all other devtools messages are handled in
diff --git a/chrome/renderer/devtools_agent.cc b/chrome/renderer/devtools_agent.cc
index aef7125..74af788 100644
--- a/chrome/renderer/devtools_agent.cc
+++ b/chrome/renderer/devtools_agent.cc
@@ -44,10 +44,13 @@ bool DevToolsAgent::OnMessageReceived(const IPC::Message& message) {
 
 void DevToolsAgent::SendMessageToClient(const std::string& class_name,
                                         const std::string& method_name,
-                                        const std::string& raw_msg) {
+                                        const std::string& param1,
+                                        const std::string& param2,
+                                        const std::string& param3) {
   IPC::Message* m = new ViewHostMsg_ForwardToDevToolsClient(
       routing_id_,
-      DevToolsClientMsg_RpcMessage(class_name, method_name, raw_msg));
+      DevToolsClientMsg_RpcMessage(class_name, method_name, param1, param2,
+                                   param3));
   view_->Send(m);
 }
 
@@ -85,10 +88,13 @@ void DevToolsAgent::OnDetach() {
 
 void DevToolsAgent::OnRpcMessage(const std::string& class_name,
                                  const std::string& method_name,
-                                 const std::string& raw_msg) {
+                                 const std::string& param1,
+                                 const std::string& param2,
+                                 const std::string& param3) {
   WebDevToolsAgent* web_agent = GetWebAgent();
   if (web_agent) {
-    web_agent->DispatchMessageFromClient(class_name, method_name, raw_msg);
+    web_agent->DispatchMessageFromClient(class_name, method_name, param1,
+                                         param2, param3);
   }
 }
 
diff --git a/chrome/renderer/devtools_agent.h b/chrome/renderer/devtools_agent.h
index 985d677..25906ae 100644
--- a/chrome/renderer/devtools_agent.h
+++ b/chrome/renderer/devtools_agent.h
@@ -34,7 +34,9 @@ class DevToolsAgent : public WebDevToolsAgentDelegate {
   // WebDevToolsAgentDelegate implementation
   virtual void SendMessageToClient(const std::string& class_name,
                                    const std::string& method_name,
-                                   const std::string& raw_msg);
+                                   const std::string& param1,
+                                   const std::string& param2,
+                                   const std::string& param3);
   virtual int GetHostId();
   virtual void ForceRepaint();
 
@@ -52,7 +54,9 @@ class DevToolsAgent : public WebDevToolsAgentDelegate {
   void OnDetach();
   void OnRpcMessage(const std::string& class_name,
                     const std::string& method_name,
-                    const std::string& raw_msg);
+                    const std::string& param1,
+                    const std::string& param2,
+                    const std::string& param3);
   void OnInspectElement(int x, int y);
 
   static std::map<int, DevToolsAgent*> agent_for_routing_id_;
diff --git a/chrome/renderer/devtools_client.cc b/chrome/renderer/devtools_client.cc
index e2ccb60..01de15f 100644
--- a/chrome/renderer/devtools_client.cc
+++ b/chrome/renderer/devtools_client.cc
@@ -45,8 +45,11 @@ bool DevToolsClient::OnMessageReceived(const IPC::Message& message) {
 
 void DevToolsClient::SendMessageToAgent(const std::string& class_name,
                                         const std::string& method_name,
-                                        const std::string& raw_msg) {
-  Send(DevToolsAgentMsg_RpcMessage(class_name, method_name, raw_msg));
+                                        const std::string& param1,
+                                        const std::string& param2,
+                                        const std::string& param3) {
+  Send(DevToolsAgentMsg_RpcMessage(class_name, method_name, param1, param2,
+                                   param3));
 }
 
 void DevToolsClient::SendDebuggerCommandToAgent(const std::string& command) {
@@ -81,6 +84,9 @@ void DevToolsClient::ToggleInspectElementMode(bool enabled) {
 
 void DevToolsClient::OnRpcMessage(const std::string& class_name,
                                   const std::string& method_name,
-                                  const std::string& raw_msg) {
-  web_tools_client_->DispatchMessageFromAgent(class_name, method_name, raw_msg);
+                                  const std::string& param1,
+                                  const std::string& param2,
+                                  const std::string& param3) {
+  web_tools_client_->DispatchMessageFromAgent(class_name, method_name, param1,
+      param2, param3);
 }
diff --git a/chrome/renderer/devtools_client.h b/chrome/renderer/devtools_client.h
index 200e068..188bcea 100644
--- a/chrome/renderer/devtools_client.h
+++ b/chrome/renderer/devtools_client.h
@@ -35,7 +35,9 @@ class DevToolsClient : public WebDevToolsClientDelegate {
   // WebDevToolsClient::Delegate implementation
   virtual void SendMessageToAgent(const std::string& class_name,
                                   const std::string& method_name,
-                                  const std::string& raw_msg);
+                                  const std::string& param1,
+                                  const std::string& param2,
+                                  const std::string& param3);
   virtual void SendDebuggerCommandToAgent(const std::string& command);
 
   virtual void ActivateWindow();
@@ -47,7 +49,9 @@ class DevToolsClient : public WebDevToolsClientDelegate {
  private:
   void OnRpcMessage(const std::string& class_name,
                     const std::string& method_name,
-                    const std::string& raw_msg);
+                    const std::string& param1,
+                    const std::string& param2,
+                    const std::string& param3);
 
   // Sends message to DevToolsAgent.
   void Send(const IPC::Message& tools_agent_message);
diff --git a/webkit/glue/devtools/debugger_agent.h b/webkit/glue/devtools/debugger_agent.h
index c447cb9..07c3232 100644
--- a/webkit/glue/devtools/debugger_agent.h
+++ b/webkit/glue/devtools/debugger_agent.h
@@ -9,8 +9,7 @@
 
 #include "webkit/glue/devtools/devtools_rpc.h"
 
-#define DEBUGGER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, \
-    METHOD4) \
+#define DEBUGGER_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) \
   /* Stops v8 execution as soon as it gets control. */ \
   METHOD0(DebugBreak) \
   \
@@ -31,8 +30,7 @@
 
 DEFINE_RPC_CLASS(DebuggerAgent, DEBUGGER_AGENT_STRUCT)
 
-#define DEBUGGER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, \
-    METHOD4) \
+#define DEBUGGER_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) \
   METHOD1(DebuggerOutput, std::string /* output text */) \
   \
   /* Pushes debugger context id into the client. */ \
diff --git a/webkit/glue/devtools/debugger_agent_impl.cc b/webkit/glue/devtools/debugger_agent_impl.cc
index 80db427..ac4c97d 100644
--- a/webkit/glue/devtools/debugger_agent_impl.cc
+++ b/webkit/glue/devtools/debugger_agent_impl.cc
@@ -33,7 +33,7 @@ using WebCore::String;
 using WebCore::V8ClassIndex;
 using WebCore::V8Custom;
 using WebCore::V8DOMWindow;
-using WebCore::V8DOMWrapper;;
+using WebCore::V8DOMWrapper;
 using WebCore::V8Proxy;
 
 DebuggerAgentImpl::DebuggerAgentImpl(
diff --git a/webkit/glue/devtools/debugger_agent_manager.h b/webkit/glue/devtools/debugger_agent_manager.h
index a095fe2..8ddae07 100644
--- a/webkit/glue/devtools/debugger_agent_manager.h
+++ b/webkit/glue/devtools/debugger_agent_manager.h
@@ -8,6 +8,7 @@
 #include <wtf/HashMap.h>
 
 #include "base/basictypes.h"
+#include "base/logging.h"
 #include "v8/include/v8-debug.h"
 #include "webkit/glue/webdevtoolsagent.h"
 
diff --git a/webkit/glue/devtools/devtools_mock_rpc.h b/webkit/glue/devtools/devtools_mock_rpc.h
index 44d7b59d..e69de29 100644
--- a/webkit/glue/devtools/devtools_mock_rpc.h
+++ b/webkit/glue/devtools/devtools_mock_rpc.h
@@ -1,91 +0,0 @@
-// 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.
-
-#ifndef WEBKIT_GLUE_DEVTOOLS_DEVTOOLS_MOCK_RPC_H_
-#define WEBKIT_GLUE_DEVTOOLS_DEVTOOLS_MOCK_RPC_H_
-
-#include <string>
-
-#include "base/string_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/glue/devtools/devtools_rpc.h"
-#include "webkit/glue/glue_util.h"
-
-// Universal mock delegate for DevToolsRpc. Typical usage of the mock is:
-// mock->Method1();  // Set expectation.
-// mock->Replay();
-// // Do Something here;
-// mock->Verify();  // Verify.
-class DevToolsMockRpc : public DevToolsRpc::Delegate {
- public:
-  DevToolsMockRpc() {}
-  ~DevToolsMockRpc() {}
-
-  virtual void SendRpcMessage(const std::string& class_name,
-                              const std::string& method_name,
-                              const std::string& msg) {
-    last_class_name_ = class_name;
-    last_method_name_ = method_name;
-    last_msg_ = msg;
-
-    if (!log_.length()) {
-      log_ = StringPrintf("%s %s %s", class_name.c_str(),
-                          method_name.c_str(), msg.c_str());;
-    } else {
-      log_ = StringPrintf("%s\n%s %s %s", log_.c_str(), class_name.c_str(),
-                          method_name.c_str(), msg.c_str());
-    }
-  }
-
-  void Replay() {
-    ref_last_class_name_ = last_class_name_;
-    last_class_name_ = "";
-    ref_last_method_name_ = last_method_name_;
-    last_method_name_ = "";
-    ref_last_msg_ = last_msg_;
-    last_msg_ = "";
-
-    ref_log_ = log_;
-    log_ = "";
-  }
-
-  void Verify() {
-    ASSERT_EQ(ref_last_class_name_, last_class_name_);
-    ASSERT_EQ(ref_last_method_name_, last_method_name_);
-    ASSERT_EQ(ref_last_msg_, last_msg_);
-    ASSERT_EQ(ref_log_, log_);
-  }
-
-  void Reset() {
-    last_class_name_ = "";
-    last_method_name_ = "";
-    last_msg_ = "";
-
-    ref_last_class_name_ = "";
-    ref_last_method_name_ = "";
-    ref_last_msg_ = "";
-
-    ref_log_ = "";
-    log_ = "";
-  }
-
-  const std::string& last_class_name() { return last_class_name_; }
-  const std::string& last_method_name() { return last_method_name_; }
-  const std::string& last_msg() { return last_msg_; }
-
- private:
-  std::string last_class_name_;
-  std::string last_method_name_;
-  std::string last_msg_;
-
-  std::string ref_last_class_name_;
-  std::string ref_last_method_name_;
-  std::string ref_last_msg_;
-
-  std::string log_;
-  std::string ref_log_;
-  DISALLOW_COPY_AND_ASSIGN(DevToolsMockRpc);
-};
-
-#endif  // WEBKIT_GLUE_DEVTOOLS_DEVTOOLS_MOCK_RPC_H_
diff --git a/webkit/glue/devtools/devtools_rpc.cc b/webkit/glue/devtools/devtools_rpc.cc
index 3d5667d..e69de29 100644
--- a/webkit/glue/devtools/devtools_rpc.cc
+++ b/webkit/glue/devtools/devtools_rpc.cc
@@ -1,109 +0,0 @@
-// 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.
-
-// TODO(pfeldman): Remove these once JSON is available in
-// WebCore namespace.
-
-#include "PlatformString.h"
-#undef LOG
-
-#include "base/json_reader.h"
-#include "base/json_writer.h"
-#include "base/values.h"
-#include "webkit/glue/devtools/devtools_rpc.h"
-#include "webkit/glue/glue_util.h"
-
-DevToolsRpc::DevToolsRpc(Delegate* delegate) : delegate_(delegate) {
-}
-
-DevToolsRpc::~DevToolsRpc() {
-}
-
-void DevToolsRpc::SendValueMessage(const std::string& class_name,
-                                   const std::string& method_name,
-                                   const Value& value) {
-  delegate_->SendRpcMessage(class_name, method_name, Serialize(value));
-}
-
-// static
-Value* DevToolsRpc::ParseMessage(const std::string& raw_msg) {
-  return JSONReader::Read(raw_msg, false);
-}
-
-// static
-std::string DevToolsRpc::Serialize(const Value& value) {
-  std::string json;
-  // TODO(pfeldman): find out why faster way in no longer working.
-  // JSONWriter::WriteWithOptionalEscape(&value, false, false, &json);
-  JSONWriter::Write(&value, false, &json);
-  return json;
-}
-
-// static
-void DevToolsRpc::GetListValue(
-    const ListValue& message,
-    int index,
-    bool* value) {
-  message.GetBoolean(index, value);
-}
-
-// static
-void DevToolsRpc::GetListValue(
-    const ListValue& message,
-    int index,
-    int* value) {
-  message.GetInteger(index, value);
-}
-
-// static
-void DevToolsRpc::GetListValue(
-    const ListValue& message,
-    int index,
-    String* value) {
-  std::string tmp;
-  message.GetString(index, &tmp);
-  *value = webkit_glue::StdStringToString(tmp);
-}
-
-// static
-void DevToolsRpc::GetListValue(
-    const ListValue& message,
-    int index,
-    std::string* value) {
-  message.GetString(index, value);
-}
-
-// static
-void DevToolsRpc::GetListValue(
-    const ListValue& message,
-    int index,
-    Value** value) {
-  message.Get(index, value);
-}
-
-// static
-Value* DevToolsRpc::CreateValue(const String* value) {
-  return Value::CreateStringValue(
-      webkit_glue::StringToStdString(*value));
-}
-
-// static
-Value* DevToolsRpc::CreateValue(const std::string* value) {
-  return Value::CreateStringValue(*value);
-}
-
-// static
-Value* DevToolsRpc::CreateValue(int* value) {
-  return Value::CreateIntegerValue(*value);
-}
-
-// static
-Value* DevToolsRpc::CreateValue(bool* value) {
-  return Value::CreateBooleanValue(*value);
-}
-
-// static
-Value* DevToolsRpc::CreateValue(const Value* value) {
-  return value->DeepCopy();
-}
diff --git a/webkit/glue/devtools/devtools_rpc.h b/webkit/glue/devtools/devtools_rpc.h
index b61caf5..072116e 100644
--- a/webkit/glue/devtools/devtools_rpc.h
+++ b/webkit/glue/devtools/devtools_rpc.h
@@ -6,9 +6,8 @@
 // implementation. The client is responsible for defining the Rpc-enabled
 // interface in terms of its macros:
 //
-// #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4)
+// #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3)
 //   METHOD0(Method1)
-//   METHOD3(Method2, int, String, Value)
 //   METHOD1(Method3, int)
 // (snippet above should be multiline macro, add trailing backslashes)
 //
@@ -53,11 +52,12 @@
 
 #include <string>
 
+// Do not remove this one although it is not used.
 #include <wtf/OwnPtr.h>
 
 #include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/values.h"
+#include "base/string_util.h"
+#include "webkit/glue/glue_util.h"
 
 namespace WebCore {
 class String;
@@ -71,36 +71,55 @@ using WebCore::String;
 template<typename T>
 struct RpcTypeTrait {
   typedef T ApiType;
-  typedef T DispatchType;
-  static const DispatchType& Pass(const DispatchType& t) {
-    return t;
+};
+
+template<>
+struct RpcTypeTrait<bool> {
+  typedef bool ApiType;
+  static bool Parse(const std::string& t) {
+    int i;
+    bool success = StringToInt(t, &i);
+    ASSERT(success);
+    return i;
+  }
+  static std::string ToString(bool b) {
+    return IntToString(b ? 1 : 0);
   }
 };
 
 template<>
-struct RpcTypeTrait<Value> {
-  typedef const Value& ApiType;
-  typedef Value* DispatchType;
-  static const Value& Pass(Value* t) {
-    return *t;
+struct RpcTypeTrait<int> {
+  typedef int ApiType;
+  static int Parse(const std::string& t) {
+    int i;
+    bool success = StringToInt(t, &i);
+    ASSERT(success);
+    return i;
+  }
+  static std::string ToString(int i) {
+    return IntToString(i);
   }
 };
 
 template<>
 struct RpcTypeTrait<String> {
   typedef const String& ApiType;
-  typedef String DispatchType;
-  static const DispatchType& Pass(const DispatchType& t) {
-    return t;
+  static String Parse(const std::string& t) {
+    return webkit_glue::StdStringToString(t);
+  }
+  static std::string ToString(const String& t) {
+    return webkit_glue::StringToStdString(t);
   }
 };
 
 template<>
 struct RpcTypeTrait<std::string> {
   typedef const std::string& ApiType;
-  typedef std::string DispatchType;
-  static const DispatchType& Pass(const DispatchType& t) {
-    return t;
+  static std::string Parse(const std::string& s) {
+    return s;
+  }
+  static std::string ToString(const std::string& s) {
+    return s;
   }
 };
 
@@ -122,44 +141,42 @@ struct RpcTypeTrait<std::string> {
                       RpcTypeTrait<T2>::ApiType t2, \
                       RpcTypeTrait<T3>::ApiType t3) = 0;
 
-#define TOOLS_RPC_API_METHOD4(Method, T1, T2, T3, T4) \
-  virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
-                      RpcTypeTrait<T2>::ApiType t2, \
-                      RpcTypeTrait<T3>::ApiType t3, \
-                      RpcTypeTrait<T4>::ApiType t4) = 0;
-
 ///////////////////////////////////////////////////////
 // RPC stub method implementations
 
 #define TOOLS_RPC_STUB_METHOD0(Method) \
   virtual void Method() { \
-    InvokeAsync(class_name, #Method); \
+    this->delegate_->SendRpcMessage(class_name, #Method); \
   }
 
 #define TOOLS_RPC_STUB_METHOD1(Method, T1) \
   virtual void Method(RpcTypeTrait<T1>::ApiType t1) { \
-    InvokeAsync(class_name, #Method, &t1); \
+    this->delegate_->SendRpcMessage( \
+        class_name, \
+        #Method, \
+        RpcTypeTrait<T1>::ToString(t1)); \
   }
 
 #define TOOLS_RPC_STUB_METHOD2(Method, T1, T2) \
   virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                       RpcTypeTrait<T2>::ApiType t2) { \
-    InvokeAsync(class_name, #Method, &t1, &t2); \
+    this->delegate_->SendRpcMessage( \
+        class_name, \
+        #Method, \
+        RpcTypeTrait<T1>::ToString(t1), \
+        RpcTypeTrait<T2>::ToString(t2)); \
   }
 
 #define TOOLS_RPC_STUB_METHOD3(Method, T1, T2, T3) \
   virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                       RpcTypeTrait<T2>::ApiType t2, \
                       RpcTypeTrait<T3>::ApiType t3) { \
-    InvokeAsync(class_name, #Method, &t1, &t2, &t3); \
-  }
-
-#define TOOLS_RPC_STUB_METHOD4(Method, T1, T2, T3, T4) \
-  virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
-                      RpcTypeTrait<T2>::ApiType t2, \
-                      RpcTypeTrait<T3>::ApiType t3, \
-                      RpcTypeTrait<T4>::ApiType t4) { \
-    InvokeAsync(class_name, #Method, &t1, &t2, &t3, &t4); \
+    this->delegate_->SendRpcMessage( \
+        class_name, \
+        #Method, \
+        RpcTypeTrait<T1>::ToString(t1), \
+        RpcTypeTrait<T2>::ToString(t2), \
+        RpcTypeTrait<T3>::ToString(t3)); \
   }
 
 ///////////////////////////////////////////////////////
@@ -173,57 +190,25 @@ if (method_name == #Method) { \
 
 #define TOOLS_RPC_DISPATCH1(Method, T1) \
 if (method_name == #Method) { \
-  RpcTypeTrait<T1>::DispatchType t1; \
-  DevToolsRpc::GetListValue(message, 0, &t1); \
-  delegate->Method( \
-      RpcTypeTrait<T1>::Pass(t1)); \
+  delegate->Method(RpcTypeTrait<T1>::Parse(p1)); \
   return true; \
 }
 
 #define TOOLS_RPC_DISPATCH2(Method, T1, T2) \
 if (method_name == #Method) { \
-  RpcTypeTrait<T1>::DispatchType t1; \
-  RpcTypeTrait<T2>::DispatchType t2; \
-  DevToolsRpc::GetListValue(message, 0, &t1); \
-  DevToolsRpc::GetListValue(message, 1, &t2); \
   delegate->Method( \
-      RpcTypeTrait<T1>::Pass(t1), \
-      RpcTypeTrait<T2>::Pass(t2) \
+      RpcTypeTrait<T1>::Parse(p1), \
+      RpcTypeTrait<T2>::Parse(p2) \
   ); \
   return true; \
 }
 
 #define TOOLS_RPC_DISPATCH3(Method, T1, T2, T3) \
 if (method_name == #Method) { \
-  RpcTypeTrait<T1>::DispatchType t1; \
-  RpcTypeTrait<T2>::DispatchType t2; \
-  RpcTypeTrait<T3>::DispatchType t3; \
-  DevToolsRpc::GetListValue(message, 0, &t1); \
-  DevToolsRpc::GetListValue(message, 1, &t2); \
-  DevToolsRpc::GetListValue(message, 2, &t3); \
-  delegate->Method( \
-      RpcTypeTrait<T1>::Pass(t1), \
-      RpcTypeTrait<T2>::Pass(t2), \
-      RpcTypeTrait<T3>::Pass(t3) \
-  ); \
-  return true; \
-}
-
-#define TOOLS_RPC_DISPATCH4(Method, T1, T2, T3, T4) \
-if (method_name == #Method) { \
-  RpcTypeTrait<T1>::DispatchType t1; \
-  RpcTypeTrait<T2>::DispatchType t2; \
-  RpcTypeTrait<T3>::DispatchType t3; \
-  RpcTypeTrait<T4>::DispatchType t4; \
-  DevToolsRpc::GetListValue(message, 0, &t1); \
-  DevToolsRpc::GetListValue(message, 1, &t2); \
-  DevToolsRpc::GetListValue(message, 2, &t3); \
-  DevToolsRpc::GetListValue(message, 3, &t4); \
   delegate->Method( \
-      RpcTypeTrait<T1>::Pass(t1), \
-      RpcTypeTrait<T2>::Pass(t2), \
-      RpcTypeTrait<T3>::Pass(t3), \
-      RpcTypeTrait<T4>::Pass(t4) \
+      RpcTypeTrait<T1>::Parse(p1), \
+      RpcTypeTrait<T2>::Parse(p2), \
+      RpcTypeTrait<T3>::Parse(p3) \
   ); \
   return true; \
 }
@@ -246,8 +231,7 @@ class Class {\
       TOOLS_RPC_API_METHOD0, \
       TOOLS_RPC_API_METHOD1, \
       TOOLS_RPC_API_METHOD2, \
-      TOOLS_RPC_API_METHOD3, \
-      TOOLS_RPC_API_METHOD4) \
+      TOOLS_RPC_API_METHOD3) \
   std::string class_name; \
  private: \
   DISALLOW_COPY_AND_ASSIGN(Class); \
@@ -262,8 +246,7 @@ class Class##Stub : public Class, public DevToolsRpc { \
       TOOLS_RPC_STUB_METHOD0, \
       TOOLS_RPC_STUB_METHOD1, \
       TOOLS_RPC_STUB_METHOD2, \
-      TOOLS_RPC_STUB_METHOD3, \
-      TOOLS_RPC_STUB_METHOD4) \
+      TOOLS_RPC_STUB_METHOD3) \
  private: \
   DISALLOW_COPY_AND_ASSIGN(Class##Stub); \
 }; \
@@ -276,16 +259,9 @@ class Class##Dispatch { \
   static bool Dispatch(Class* delegate, \
                        const std::string& class_name, \
                        const std::string& method_name, \
-                       const std::string& raw_msg) { \
-    OwnPtr<ListValue> message( \
-        static_cast<ListValue*>(DevToolsRpc::ParseMessage(raw_msg))); \
-    return Dispatch(delegate, class_name, method_name, *message.get()); \
-  } \
-  \
-  static bool Dispatch(Class* delegate, \
-                       const std::string& class_name, \
-                       const std::string& method_name, \
-                       const ListValue& message) { \
+                       const std::string& p1, \
+                       const std::string& p2, \
+                       const std::string& p3) { \
     if (class_name != #Class) { \
       return false; \
     } \
@@ -294,8 +270,7 @@ class Class##Dispatch { \
         TOOLS_RPC_DISPATCH0, \
         TOOLS_RPC_DISPATCH1, \
         TOOLS_RPC_DISPATCH2, \
-        TOOLS_RPC_DISPATCH3, \
-        TOOLS_RPC_DISPATCH4) \
+        TOOLS_RPC_DISPATCH3) \
     return false; \
   } \
  private: \
@@ -312,98 +287,20 @@ class DevToolsRpc {
     virtual ~Delegate() {}
     virtual void SendRpcMessage(const std::string& class_name,
                                 const std::string& method_name,
-                                const std::string& raw_msg) = 0;
+                                const std::string& p1 = "",
+                                const std::string& p2 = "",
+                                const std::string& p3 = "") = 0;
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
-  explicit DevToolsRpc(Delegate* delegate);
-  virtual ~DevToolsRpc();
-
-  void InvokeAsync(
-      const std::string& class_name,
-      const std::string& method_name) {
-    ListValue message;
-    SendValueMessage(class_name, method_name, message);
-  }
-
-  template<typename T1>
-  void InvokeAsync(
-      const std::string& class_name,
-      const std::string& method_name,
-      T1 t1) {
-    ListValue message;
-    message.Append(CreateValue(t1));
-    SendValueMessage(class_name, method_name, message);
-  }
-
-  template<typename T1, typename T2>
-  void InvokeAsync(
-      const std::string& class_name,
-      const std::string& method_name,
-      T1 t1, T2 t2) {
-    ListValue message;
-    message.Append(CreateValue(t1));
-    message.Append(CreateValue(t2));
-    SendValueMessage(class_name, method_name, message);
-  }
-
-  template<typename T1, typename T2, typename T3>
-  void InvokeAsync(
-      const std::string& class_name,
-      const std::string& method_name,
-      T1 t1, T2 t2, T3 t3) {
-    ListValue message;
-    message.Append(CreateValue(t1));
-    message.Append(CreateValue(t2));
-    message.Append(CreateValue(t3));
-    SendValueMessage(class_name, method_name, message);
-  }
-
-  template<typename T1, typename T2, typename T3, typename T4>
-  void InvokeAsync(
-      const std::string& class_name,
-      const std::string& method_name,
-      T1 t1, T2 t2, T3 t3, T4 t4) {
-    ListValue message;
-    message.Append(CreateValue(t1));
-    message.Append(CreateValue(t2));
-    message.Append(CreateValue(t3));
-    message.Append(CreateValue(t4));
-    SendValueMessage(class_name, method_name, message);
-  }
-
-  static Value* ParseMessage(const std::string& raw_msg);
-  static std::string Serialize(const Value& value);
-  static void GetListValue(const ListValue& message, int index, bool* value);
-  static void GetListValue(const ListValue& message, int index, int* value);
-  static void GetListValue(
-      const ListValue& message,
-      int index,
-      String* value);
-  static void GetListValue(
-      const ListValue& message,
-      int index,
-      std::string* value);
-  static void GetListValue(const ListValue& message, int index, Value** value);
+  explicit DevToolsRpc(Delegate* delegate)
+      : delegate_(delegate) {}
+  virtual ~DevToolsRpc() {};
 
  protected:
-  // Primarily for unit testing.
-  void set_delegate(Delegate* delegate) { this->delegate_ = delegate; }
-
- private:
-  // Value adapters for supported Rpc types.
-  static Value* CreateValue(const String* value);
-  static Value* CreateValue(const std::string* value);
-  static Value* CreateValue(int* value);
-  static Value* CreateValue(bool* value);
-  static Value* CreateValue(const Value* value);
-
-  void SendValueMessage(const std::string& class_name,
-                        const std::string& method_name,
-                        const Value& value);
-
   Delegate* delegate_;
+ private:
   DISALLOW_COPY_AND_ASSIGN(DevToolsRpc);
 };
 
diff --git a/webkit/glue/devtools/devtools_rpc_js.h b/webkit/glue/devtools/devtools_rpc_js.h
index 4e82273..bb54150 100644
--- a/webkit/glue/devtools/devtools_rpc_js.h
+++ b/webkit/glue/devtools/devtools_rpc_js.h
@@ -9,11 +9,10 @@
 
 #include <string>
 
+// Do not remove this one although it is not used.
 #include <wtf/OwnPtr.h>
 
 #include "base/basictypes.h"
-#include "base/logging.h"
-#include "base/values.h"
 #include "webkit/api/public/WebFrame.h"
 #include "webkit/glue/cpp_bound_class.h"
 #include "webkit/glue/devtools/devtools_rpc.h"
@@ -28,28 +27,28 @@ struct RpcJsTypeTrait {
 
 template<>
 struct RpcJsTypeTrait<bool> {
-  static bool Pass(const CppVariant& var) {
-    return var.ToBoolean();
+  static std::string ToString(const CppVariant& var) {
+    return IntToString(var.ToBoolean() ? 1 : 0);
   }
 };
 
 template<>
 struct RpcJsTypeTrait<int> {
-  static int Pass(const CppVariant& var) {
-    return var.ToInt32();
+  static std::string ToString(const CppVariant& var) {
+    return IntToString(var.ToInt32());
   }
 };
 
 template<>
 struct RpcJsTypeTrait<String> {
-  static String Pass(const CppVariant& var) {
-    return webkit_glue::StdStringToString(var.ToString());
+  static std::string ToString(const CppVariant& var) {
+    return var.ToString();
   }
 };
 
 template<>
 struct RpcJsTypeTrait<std::string> {
-  static std::string Pass(const CppVariant& var) {
+  static std::string ToString(const CppVariant& var) {
     return var.ToString();
   }
 };
@@ -66,46 +65,33 @@ struct RpcJsTypeTrait<std::string> {
 #define TOOLS_RPC_JS_BIND_METHOD3(Method, T1, T2, T3) \
   BindMethod(#Method, &OCLASS::Js##Method);
 
-#define TOOLS_RPC_JS_BIND_METHOD4(Method, T1, T2, T3, T4) \
-  BindMethod(#Method, &OCLASS::Js##Method);
-
 #define TOOLS_RPC_JS_STUB_METHOD0(Method) \
   void Js##Method(const CppArgumentList& args, CppVariant* result) { \
-    InvokeAsync(class_name, #Method); \
+    this->delegate_->SendRpcMessage(class_name, #Method); \
     result->SetNull(); \
   }
 
 #define TOOLS_RPC_JS_STUB_METHOD1(Method, T1) \
   void Js##Method(const CppArgumentList& args, CppVariant* result) { \
-    T1 t1 = RpcJsTypeTrait<T1>::Pass(args[0]); \
-    InvokeAsync(class_name, #Method, &t1); \
+    this->delegate_->SendRpcMessage(class_name, #Method, \
+        RpcJsTypeTrait<T1>::ToString(args[0])); \
     result->SetNull(); \
   }
 
 #define TOOLS_RPC_JS_STUB_METHOD2(Method, T1, T2) \
   void Js##Method(const CppArgumentList& args, CppVariant* result) { \
-    T1 t1 = RpcJsTypeTrait<T1>::Pass(args[0]); \
-    T2 t2 = RpcJsTypeTrait<T2>::Pass(args[1]); \
-    InvokeAsync(class_name, #Method, &t1, &t2); \
+    this->delegate_->SendRpcMessage(class_name, #Method, \
+        RpcJsTypeTrait<T1>::ToString(args[0]), \
+        RpcJsTypeTrait<T2>::ToString(args[1])); \
     result->SetNull(); \
   }
 
 #define TOOLS_RPC_JS_STUB_METHOD3(Method, T1, T2, T3) \
   void Js##Method(const CppArgumentList& args, CppVariant* result) { \
-    T1 t1 = RpcJsTypeTrait<T1>::Pass(args[0]); \
-    T2 t2 = RpcJsTypeTrait<T2>::Pass(args[1]); \
-    T3 t3 = RpcJsTypeTrait<T3>::Pass(args[2]); \
-    InvokeAsync(class_name, #Method, &t1, &t2, &t3); \
-    result->SetNull(); \
-  }
-
-#define TOOLS_RPC_JS_STUB_METHOD4(Method, T1, T2, T3, T4) \
-  void Js##Method(const CppArgumentList& args, CppVariant* result) { \
-    T1 t1 = RpcJsTypeTrait<T1>::Pass(args[0]); \
-    T2 t2 = RpcJsTypeTrait<T2>::Pass(args[1]); \
-    T3 t3 = RpcJsTypeTrait<T3>::Pass(args[2]); \
-    T4 t4 = RpcJsTypeTrait<T4>::Pass(args[3]); \
-    InvokeAsync(class_name, #Method, &t1, &t2, &t3, &t4); \
+    this->delegate_->SendRpcMessage(class_name, #Method, \
+        RpcJsTypeTrait<T1>::ToString(args[0]), \
+        RpcJsTypeTrait<T2>::ToString(args[1]), \
+        RpcJsTypeTrait<T3>::ToString(args[2])); \
     result->SetNull(); \
   }
 
@@ -124,8 +110,7 @@ class Js##Class##BoundObj : public Class##Stub, \
         TOOLS_RPC_JS_BIND_METHOD0, \
         TOOLS_RPC_JS_BIND_METHOD1, \
         TOOLS_RPC_JS_BIND_METHOD2, \
-        TOOLS_RPC_JS_BIND_METHOD3, \
-        TOOLS_RPC_JS_BIND_METHOD4) \
+        TOOLS_RPC_JS_BIND_METHOD3) \
   } \
   virtual ~Js##Class##BoundObj() {} \
   typedef Js##Class##BoundObj OCLASS; \
@@ -133,8 +118,7 @@ class Js##Class##BoundObj : public Class##Stub, \
       TOOLS_RPC_JS_STUB_METHOD0, \
       TOOLS_RPC_JS_STUB_METHOD1, \
       TOOLS_RPC_JS_STUB_METHOD2, \
-      TOOLS_RPC_JS_STUB_METHOD3, \
-      TOOLS_RPC_JS_STUB_METHOD4) \
+      TOOLS_RPC_JS_STUB_METHOD3) \
  private: \
   DISALLOW_COPY_AND_ASSIGN(Js##Class##BoundObj); \
 };
diff --git a/webkit/glue/devtools/devtools_rpc_unittest.cc b/webkit/glue/devtools/devtools_rpc_unittest.cc
index 9f9b1a6..e69de29 100644
--- a/webkit/glue/devtools/devtools_rpc_unittest.cc
+++ b/webkit/glue/devtools/devtools_rpc_unittest.cc
@@ -1,130 +0,0 @@
-// 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 "PlatformString.h"
-#undef LOG
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "webkit/glue/devtools/devtools_mock_rpc.h"
-#include "webkit/glue/devtools/devtools_rpc.h"
-
-namespace {
-
-#define TEST_RPC_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4) \
-  METHOD0(Method0) \
-  METHOD1(Method1, int) \
-  METHOD2(Method2, int, String) \
-  METHOD3(Method3, int, String, Value)
-DEFINE_RPC_CLASS(TestRpcClass, TEST_RPC_STRUCT)
-
-#define ANOTHER_TEST_RPC_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4) \
-  METHOD0(Method0)
-DEFINE_RPC_CLASS(AnotherTestRpcClass, ANOTHER_TEST_RPC_STRUCT)
-
-class MockTestRpcClass : public TestRpcClassStub,
-                         public DevToolsMockRpc {
- public:
-  MockTestRpcClass() : TestRpcClassStub(NULL) {
-    set_delegate(this);
-  }
-  ~MockTestRpcClass() {}
-};
-
-class MockAnotherTestRpcClass : public AnotherTestRpcClassStub,
-                                public DevToolsMockRpc {
- public:
-  MockAnotherTestRpcClass() : AnotherTestRpcClassStub(NULL) {
-    set_delegate(this);
-  }
-  ~MockAnotherTestRpcClass() {}
-};
-
-class DevToolsRpcTests : public testing::Test {
- public:
-  DevToolsRpcTests() {}
-
- protected:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-// Tests method call serialization.
-TEST_F(DevToolsRpcTests, TestSerialize) {
-  MockTestRpcClass mock;
-  mock.Method0();
-  EXPECT_EQ("TestRpcClass", mock.last_class_name());
-  EXPECT_EQ("Method0", mock.last_method_name());
-  EXPECT_EQ("[]", mock.last_msg());
-  mock.Reset();
-
-  mock.Method1(10);
-  EXPECT_EQ("TestRpcClass", mock.last_class_name());
-  EXPECT_EQ("Method1", mock.last_method_name());
-  EXPECT_EQ("[10]", mock.last_msg());
-  mock.Reset();
-
-  mock.Method2(20, "foo");
-  EXPECT_EQ("TestRpcClass", mock.last_class_name());
-  EXPECT_EQ("Method2", mock.last_method_name());
-  EXPECT_EQ("[20,\"foo\"]", mock.last_msg());
-  mock.Reset();
-
-  StringValue value("bar");
-  mock.Method3(30, "foo", value);
-  EXPECT_EQ("TestRpcClass", mock.last_class_name());
-  EXPECT_EQ("Method3", mock.last_method_name());
-  EXPECT_EQ("[30,\"foo\",\"bar\"]", mock.last_msg());
-  mock.Reset();
-}
-
-// Tests method call dispatch.
-TEST_F(DevToolsRpcTests, TestDispatch) {
-  MockTestRpcClass local;
-  MockTestRpcClass remote;
-
-  // Call 1.
-  local.Reset();
-  local.Method0();
-  remote.Reset();
-  remote.Method0();
-  remote.Replay();
-
-  TestRpcClassDispatch::Dispatch(&remote, local.last_class_name(),
-                                 local.last_method_name(), local.last_msg());
-  remote.Verify();
-
-  // Call 2.
-  local.Reset();
-  local.Method1(10);
-  remote.Reset();
-  remote.Method1(10);
-  remote.Replay();
-  TestRpcClassDispatch::Dispatch(&remote, local.last_class_name(),
-                                 local.last_method_name(), local.last_msg());
-  remote.Verify();
-
-  // Call 3.
-  local.Reset();
-  remote.Reset();
-  local.Method2(20, "foo");
-  remote.Method2(20, "foo");
-
-  remote.Replay();
-  TestRpcClassDispatch::Dispatch(&remote, local.last_class_name(),
-                                 local.last_method_name(), local.last_msg());
-  remote.Verify();
-
-  // Call 4.
-  local.Reset();
-  remote.Reset();
-  StringValue value("bar");
-  local.Method3(30, "foo", value);
-  remote.Method3(30, "foo", value);
-
-  remote.Replay();
-  TestRpcClassDispatch::Dispatch(&remote, local.last_class_name(),
-                                 local.last_method_name(), local.last_msg());
-  remote.Verify();
-}
-
-}  // namespace
diff --git a/webkit/glue/devtools/js/devtools.js b/webkit/glue/devtools/js/devtools.js
index 5ff7561..c82cac11 100644
--- a/webkit/glue/devtools/js/devtools.js
+++ b/webkit/glue/devtools/js/devtools.js
@@ -16,9 +16,9 @@ goog.require('devtools.DebuggerAgent');
  * Dispatches raw message from the host.
  * @param {string} remoteName
  * @prama {string} methodName
- * @param {Object} msg Message to dispatch.
+ * @param {string} param1, param2, param3 Arguments to dispatch.
  */
-devtools.dispatch = function(remoteName, methodName, msg) {
+devtools$$dispatch = function(remoteName, methodName, param1, param2, param3) {
   remoteName = 'Remote' + remoteName.substring(0, remoteName.length - 8);
   var agent = window[remoteName];
   if (!agent) {
@@ -30,7 +30,7 @@ devtools.dispatch = function(remoteName, methodName, msg) {
     debugPrint('No method "' + remoteName + '.' + methodName + '" found.');
     return;
   }
-  method.apply(this, msg);
+  method.call(this, param1, param2, param3);
 };
 
 
diff --git a/webkit/glue/devtools/tools_agent.h b/webkit/glue/devtools/tools_agent.h
index fa106e6..6fd6e50 100644
--- a/webkit/glue/devtools/tools_agent.h
+++ b/webkit/glue/devtools/tools_agent.h
@@ -9,7 +9,7 @@
 
 // Tools agent provides API for enabling / disabling other agents as well as
 // API for auxiliary UI functions such as dom elements highlighting.
-#define TOOLS_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4) \
+#define TOOLS_AGENT_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) \
   /* Requests that utility js function is executed with the given args. */ \
   METHOD3(ExecuteUtilityFunction, int /* call_id */, \
       String /* function_name */, String /* json_args */) \
@@ -20,8 +20,7 @@
 
 DEFINE_RPC_CLASS(ToolsAgent, TOOLS_AGENT_STRUCT)
 
-#define TOOLS_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, \
-    METHOD4) \
+#define TOOLS_AGENT_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) \
   /* Updates focused node on the client. */ \
   METHOD1(FrameNavigate, std::string /* url */) \
   \
@@ -34,8 +33,7 @@ DEFINE_RPC_CLASS(ToolsAgent, TOOLS_AGENT_STRUCT)
 
 DEFINE_RPC_CLASS(ToolsAgentDelegate, TOOLS_AGENT_DELEGATE_STRUCT)
 
-#define TOOLS_AGENT_NATIVE_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, \
-    METHOD4) \
+#define TOOLS_AGENT_NATIVE_DELEGATE_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) \
   /* Response to the async call. */ \
   METHOD2(DidGetResourceContent, int /* call_id */, String /* content */) \
 
diff --git a/webkit/glue/webdevtoolsagent.h b/webkit/glue/webdevtoolsagent.h
index e5c060d..37ab24f 100644
--- a/webkit/glue/webdevtoolsagent.h
+++ b/webkit/glue/webdevtoolsagent.h
@@ -32,7 +32,9 @@ class WebDevToolsAgent {
 
   virtual void DispatchMessageFromClient(const std::string& class_name,
                                          const std::string& method_name,
-                                         const std::string& raw_msg) = 0;
+                                         const std::string& param1,
+                                         const std::string& param2,
+                                         const std::string& param3) = 0;
 
   virtual void InspectElement(int x, int y) = 0;
 
diff --git a/webkit/glue/webdevtoolsagent_delegate.h b/webkit/glue/webdevtoolsagent_delegate.h
index 0e06714..83f0091 100644
--- a/webkit/glue/webdevtoolsagent_delegate.h
+++ b/webkit/glue/webdevtoolsagent_delegate.h
@@ -15,7 +15,9 @@ class WebDevToolsAgentDelegate {
 
   virtual void SendMessageToClient(const std::string& class_name,
                                    const std::string& method_name,
-                                   const std::string& raw_msg) = 0;
+                                   const std::string& param1,
+                                   const std::string& param2,
+                                   const std::string& param3) = 0;
 
   // Invalidates widget which leads to the repaint.
   virtual void ForceRepaint() = 0;
diff --git a/webkit/glue/webdevtoolsagent_impl.cc b/webkit/glue/webdevtoolsagent_impl.cc
index 1d3f5fd..cf79aec 100644
--- a/webkit/glue/webdevtoolsagent_impl.cc
+++ b/webkit/glue/webdevtoolsagent_impl.cc
@@ -22,7 +22,6 @@
 #include <wtf/OwnPtr.h>
 #undef LOG
 
-#include "base/values.h"
 #include "webkit/api/public/WebDataSource.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLRequest.h"
@@ -191,11 +190,11 @@ void WebDevToolsAgentImpl::GetResourceContent(
 void WebDevToolsAgentImpl::DispatchMessageFromClient(
     const std::string& class_name,
     const std::string& method_name,
-    const std::string& raw_msg) {
-  OwnPtr<ListValue> message(
-      static_cast<ListValue*>(DevToolsRpc::ParseMessage(raw_msg)));
+    const std::string& param1,
+    const std::string& param2,
+    const std::string& param3) {
   if (ToolsAgentDispatch::Dispatch(
-      this, class_name, method_name, *message.get())) {
+      this, class_name, method_name, param1, param2, param3)) {
     return;
   }
 
@@ -206,7 +205,7 @@ void WebDevToolsAgentImpl::DispatchMessageFromClient(
   if (debugger_agent_impl_.get() &&
       DebuggerAgentDispatch::Dispatch(
           debugger_agent_impl_.get(), class_name, method_name,
-          *message.get())) {
+          param1, param2, param3)) {
     return;
   }
 }
@@ -223,8 +222,11 @@ void WebDevToolsAgentImpl::InspectElement(int x, int y) {
 void WebDevToolsAgentImpl::SendRpcMessage(
     const std::string& class_name,
     const std::string& method_name,
-    const std::string& raw_msg) {
-  delegate_->SendMessageToClient(class_name, method_name, raw_msg);
+    const std::string& param1,
+    const std::string& param2,
+    const std::string& param3) {
+  delegate_->SendMessageToClient(class_name, method_name, param1, param2,
+      param3);
 }
 
 void WebDevToolsAgentImpl::InitDevToolsAgentHost() {
diff --git a/webkit/glue/webdevtoolsagent_impl.h b/webkit/glue/webdevtoolsagent_impl.h
index 9d2ae78..af5b271 100644
--- a/webkit/glue/webdevtoolsagent_impl.h
+++ b/webkit/glue/webdevtoolsagent_impl.h
@@ -56,13 +56,17 @@ class WebDevToolsAgentImpl
   virtual void OnNavigate();
   virtual void DispatchMessageFromClient(const std::string& class_name,
                                          const std::string& method_name,
-                                         const std::string& raw_msg);
+                                         const std::string& param1,
+                                         const std::string& param2,
+                                         const std::string& param3);
   virtual void InspectElement(int x, int y);
 
   // DevToolsRpc::Delegate implementation.
   void SendRpcMessage(const std::string& class_name,
                       const std::string& method_name,
-                      const std::string& raw_msg);
+                      const std::string& param1,
+                      const std::string& param2,
+                      const std::string& param3);
 
   // Methods called by the glue.
   void SetMainFrameDocumentReady(bool ready);
diff --git a/webkit/glue/webdevtoolsclient.h b/webkit/glue/webdevtoolsclient.h
index 4e36a54..e19af39 100644
--- a/webkit/glue/webdevtoolsclient.h
+++ b/webkit/glue/webdevtoolsclient.h
@@ -25,7 +25,9 @@ class WebDevToolsClient {
 
   virtual void DispatchMessageFromAgent(const std::string& class_name,
                                         const std::string& method_name,
-                                        const std::string& raw_msg) = 0;
+                                        const std::string& param1,
+                                        const std::string& param2,
+                                        const std::string& param3) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebDevToolsClient);
diff --git a/webkit/glue/webdevtoolsclient_delegate.h b/webkit/glue/webdevtoolsclient_delegate.h
index b7ef635..59067ca 100644
--- a/webkit/glue/webdevtoolsclient_delegate.h
+++ b/webkit/glue/webdevtoolsclient_delegate.h
@@ -15,7 +15,9 @@ class WebDevToolsClientDelegate {
 
   virtual void SendMessageToAgent(const std::string& class_name,
                                   const std::string& method_name,
-                                  const std::string& raw_msg) = 0;
+                                  const std::string& param1,
+                                  const std::string& param2,
+                                  const std::string& param3) = 0;
   virtual void SendDebuggerCommandToAgent(const std::string& command) = 0;
 
   virtual void ActivateWindow() = 0;
diff --git a/webkit/glue/webdevtoolsclient_impl.cc b/webkit/glue/webdevtoolsclient_impl.cc
index 70703c4..a0cfe1b 100644
--- a/webkit/glue/webdevtoolsclient_impl.cc
+++ b/webkit/glue/webdevtoolsclient_impl.cc
@@ -24,7 +24,6 @@
 #undef LOG
 
 #include "base/string_util.h"
-#include "base/values.h"
 #include "webkit/api/public/WebFrame.h"
 #include "webkit/api/public/WebScriptSource.h"
 #include "webkit/glue/devtools/bound_object.h"
@@ -201,25 +200,30 @@ WebDevToolsClientImpl::~WebDevToolsClientImpl() {
 void WebDevToolsClientImpl::DispatchMessageFromAgent(
       const std::string& class_name,
       const std::string& method_name,
-      const std::string& raw_msg) {
+      const std::string& param1,
+      const std::string& param2,
+      const std::string& param3) {
   if (ToolsAgentNativeDelegateDispatch::Dispatch(
           tools_agent_native_delegate_impl_.get(),
           class_name,
           method_name,
-          raw_msg)) {
+          param1,
+          param2,
+          param3)) {
     return;
   }
 
-  std::string expr = StringPrintf(
-      "devtools.dispatch('%s','%s',%s)",
-      class_name.c_str(),
-      method_name.c_str(),
-      raw_msg.c_str());
+  Vector<std::string> v;
+  v.append(class_name);
+  v.append(method_name);
+  v.append(param1);
+  v.append(param2);
+  v.append(param3);
   if (!loaded_) {
-    pending_incoming_messages_.append(expr);
+    pending_incoming_messages_.append(v);
     return;
   }
-  ExecuteScript(expr);
+  ExecuteScript(v);
 }
 
 void WebDevToolsClientImpl::AddResourceSourceToFrame(int resource_id,
@@ -233,16 +237,32 @@ void WebDevToolsClientImpl::AddResourceSourceToFrame(int resource_id,
   tools_agent_native_delegate_impl_->RequestSent(resource_id, mime_type, frame);
 }
 
-void WebDevToolsClientImpl::ExecuteScript(const std::string& expr) {
-  web_view_impl_->GetMainFrame()->executeScript(
-      WebScriptSource(WebString::fromUTF8(expr)));
+void WebDevToolsClientImpl::ExecuteScript(const Vector<std::string>& v) {
+  WebFrameImpl* frame = web_view_impl_->main_frame();
+  v8::HandleScope scope;
+  v8::Handle<v8::Context> frame_context = V8Proxy::context(frame->frame());
+  v8::Context::Scope context_scope(frame_context);
+  v8::Handle<v8::Value> dispatch_function =
+      frame_context->Global()->Get(v8::String::New("devtools$$dispatch"));
+  ASSERT(dispatch_function->IsFunction());
+  v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(dispatch_function);
+  v8::Handle<v8::Value> args[] = {
+    v8::String::New(v.at(0).c_str()),
+    v8::String::New(v.at(1).c_str()),
+    v8::String::New(v.at(2).c_str()),
+    v8::String::New(v.at(3).c_str()),
+    v8::String::New(v.at(4).c_str())
+  };
+  function->Call(frame_context->Global(), 5, args);
 }
 
-
 void WebDevToolsClientImpl::SendRpcMessage(const std::string& class_name,
                                            const std::string& method_name,
-                                           const std::string& raw_msg) {
-  delegate_->SendMessageToAgent(class_name, method_name, raw_msg);
+                                           const std::string& param1,
+                                           const std::string& param2,
+                                           const std::string& param3) {
+  delegate_->SendMessageToAgent(class_name, method_name, param1, param2,
+                                param3);
 }
 
 // static
@@ -313,7 +333,7 @@ v8::Handle<v8::Value> WebDevToolsClientImpl::JsLoaded(
   SecurityOrigin* origin = page->mainFrame()->domWindow()->securityOrigin();
   origin->grantUniversalAccess();
 
-  for (Vector<std::string>::iterator it =
+  for (Vector<Vector<std::string> >::iterator it =
            client->pending_incoming_messages_.begin();
        it != client->pending_incoming_messages_.end();
        ++it) {
diff --git a/webkit/glue/webdevtoolsclient_impl.h b/webkit/glue/webdevtoolsclient_impl.h
index f407863..e58414a 100644
--- a/webkit/glue/webdevtoolsclient_impl.h
+++ b/webkit/glue/webdevtoolsclient_impl.h
@@ -43,19 +43,23 @@ class WebDevToolsClientImpl : public WebDevToolsClient,
   // DevToolsRpc::Delegate implementation.
   virtual void SendRpcMessage(const std::string& class_name,
                               const std::string& method_name,
-                              const std::string& raw_msg);
+                              const std::string& param1,
+                              const std::string& param2,
+                              const std::string& param3);
 
   // WebDevToolsClient implementation.
   virtual void DispatchMessageFromAgent(const std::string& class_name,
                                         const std::string& method_name,
-                                        const std::string& raw_msg);
+                                        const std::string& param1,
+                                        const std::string& param2,
+                                        const std::string& param3);
 
  private:
   void AddResourceSourceToFrame(int resource_id,
                                 String mime_type,
                                 WebCore::Node* frame);
 
-  void ExecuteScript(const std::string& expr);
+  void ExecuteScript(const Vector<std::string>& v);
   static v8::Handle<v8::Value> JsReset(const v8::Arguments& args);
   static v8::Handle<v8::Value> JsAddSourceToFrame(const v8::Arguments& args);
   static v8::Handle<v8::Value> JsAddResourceSourceToFrame(
@@ -79,7 +83,7 @@ class WebDevToolsClientImpl : public WebDevToolsClient,
   OwnPtr<JsDebuggerAgentBoundObj> debugger_agent_obj_;
   OwnPtr<JsToolsAgentBoundObj> tools_agent_obj_;
   bool loaded_;
-  Vector<std::string> pending_incoming_messages_;
+  Vector<Vector<std::string> > pending_incoming_messages_;
   OwnPtr<BoundObject> dev_tools_host_;
   OwnPtr<ToolsAgentNativeDelegateImpl> tools_agent_native_delegate_impl_;
   DISALLOW_COPY_AND_ASSIGN(WebDevToolsClientImpl);
diff --git a/webkit/tools/test_shell/test_shell.gyp b/webkit/tools/test_shell/test_shell.gyp
index 43086e3..73249ed 100644
--- a/webkit/tools/test_shell/test_shell.gyp
+++ b/webkit/tools/test_shell/test_shell.gyp
@@ -325,7 +325,6 @@
         '../../glue/context_menu_unittest.cc',
         '../../glue/cpp_bound_class_unittest.cc',
         '../../glue/cpp_variant_unittest.cc',
-        '../../glue/devtools/devtools_rpc_unittest.cc',
         '../../glue/dom_operations_unittest.cc',
         '../../glue/dom_serializer_unittest.cc',
         '../../glue/glue_serialize_unittest.cc',
diff --git a/webkit/webkit.gyp b/webkit/webkit.gyp
index 3092d23..cd40e35 100644
--- a/webkit/webkit.gyp
+++ b/webkit/webkit.gyp
@@ -1292,7 +1292,6 @@
         # This list contains all .h, .cc, and .mm files in glue except for
         # those in the test subdirectory and those with unittest in in their
         # names.
-        'glue/devtools/devtools_rpc.cc',
         'glue/devtools/devtools_rpc.h',
         'glue/devtools/devtools_rpc_js.h',
         'glue/devtools/bound_object.cc',