DevTools: pass class and method name as arguments to RPC messages

webkit/glue/devtools/devtools_rpc.h

 // 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.
 
 // DevTools RPC subsystem is a simple string serialization-based rpc
 // implementation. The client is responsible for defining the Rpc-enabled
 // interface in terms of its macros:
 //
 // #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3, METHOD4)
 //   METHOD0(Method1)
@@ skipping 156 matching lines @@
 
 #define TOOLS_RPC_DISPATCH0(Method) \
 if (method_name == #Method) { \
   delegate->Method(); \
   return true; \
 }
 
 #define TOOLS_RPC_DISPATCH1(Method, T1) \
 if (method_name == #Method) { \
   RpcTypeTrait<T1>::DispatchType t1; \
-  DevToolsRpc::GetListValue(message, 2, &t1); \
+  DevToolsRpc::GetListValue(message, 0, &t1); \
   delegate->Method( \
       RpcTypeTrait<T1>::Pass(t1)); \
   return true; \
 }
 
 #define TOOLS_RPC_DISPATCH2(Method, T1, T2) \
 if (method_name == #Method) { \
   RpcTypeTrait<T1>::DispatchType t1; \
   RpcTypeTrait<T2>::DispatchType t2; \
-  DevToolsRpc::GetListValue(message, 2, &t1); \
-  DevToolsRpc::GetListValue(message, 3, &t2); \
+  DevToolsRpc::GetListValue(message, 0, &t1); \
+  DevToolsRpc::GetListValue(message, 1, &t2); \
   delegate->Method( \
       RpcTypeTrait<T1>::Pass(t1), \
       RpcTypeTrait<T2>::Pass(t2) \
   ); \
   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, 2, &t1); \
-  DevToolsRpc::GetListValue(message, 3, &t2); \
-  DevToolsRpc::GetListValue(message, 4, &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, 2, &t1); \
-  DevToolsRpc::GetListValue(message, 3, &t2); \
-  DevToolsRpc::GetListValue(message, 4, &t3); \
-  DevToolsRpc::GetListValue(message, 5, &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) \
   ); \
   return true; \
 }
 
 #define TOOLS_END_RPC_DISPATCH() \
@@ skipping 34 matching lines @@
       TOOLS_RPC_STUB_METHOD4) \
  private: \
   DISALLOW_COPY_AND_ASSIGN(Class##Stub); \
 }; \
 \
 class Class##Dispatch { \
  public: \
   Class##Dispatch() {} \
   virtual ~Class##Dispatch() {} \
   \
-  static bool Dispatch(Class* delegate, const std::string& raw_msg) { \
+  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, *message.get()); \
+    return Dispatch(delegate, class_name, method_name, *message.get()); \
   } \
   \
-  static bool Dispatch(Class* delegate, const ListValue& message) { \
-    std::string class_name; \
-    message.GetString(0, &class_name); \
+  static bool Dispatch(Class* delegate, \
+                       const std::string& class_name, \
+                       const std::string& method_name, \
+                       const ListValue& message) { \
     if (class_name != #Class) { \
       return false; \
     } \
-    std::string method_name; \
-    message.GetString(1, &method_name); \
     typedef Class CLASS; \
     STRUCT( \
         TOOLS_RPC_DISPATCH0, \
         TOOLS_RPC_DISPATCH1, \
         TOOLS_RPC_DISPATCH2, \
         TOOLS_RPC_DISPATCH3, \
         TOOLS_RPC_DISPATCH4) \
     return false; \
   } \
  private: \
   DISALLOW_COPY_AND_ASSIGN(Class##Dispatch); \
 };
 
 ///////////////////////////////////////////////////////
 // RPC base class
 class DevToolsRpc {
  public:
   class Delegate {
    public:
     Delegate() {}
     virtual ~Delegate() {}
-    virtual void SendRpcMessage(const std::string& msg) = 0;
+    virtual void SendRpcMessage(const std::string& class_name,
+                                const std::string& method_name,
+                                const std::string& raw_msg) = 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;
-    message.Append(CreateValue(&class_name));
-    message.Append(CreateValue(&method_name));
-    SendValueMessage(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(&class_name));
-    message.Append(CreateValue(&method_name));
     message.Append(CreateValue(t1));
-    SendValueMessage(message);
+    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(&class_name));
-    message.Append(CreateValue(&method_name));
     message.Append(CreateValue(t1));
     message.Append(CreateValue(t2));
-    SendValueMessage(message);
+    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(&class_name));
-    message.Append(CreateValue(&method_name));
     message.Append(CreateValue(t1));
     message.Append(CreateValue(t2));
     message.Append(CreateValue(t3));
-    SendValueMessage(message);
+    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(&class_name));
-    message.Append(CreateValue(&method_name));
     message.Append(CreateValue(t1));
     message.Append(CreateValue(t2));
     message.Append(CreateValue(t3));
     message.Append(CreateValue(t4));
-    SendValueMessage(message);
+    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);
 
  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 Value& value);
+  void SendValueMessage(const std::string& class_name,
+                        const std::string& method_name,
+                        const Value& value);
 
   Delegate* delegate_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsRpc);
 };
 
 #endif  // WEBKIT_GLUE_DEVTOOLS_DEVTOOLS_RPC_H_