18 files changed, 175 insertions, 589 deletions

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);