1 /* 2 * Copyright (C) 2010 Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 // DevTools RPC subsystem is a simple string serialization-based rpc 32 // implementation. The client is responsible for defining the Rpc-enabled 33 // interface in terms of its macros: 34 // 35 // #define MYAPI_STRUCT(METHOD0, METHOD1, METHOD2, METHOD3) 36 // METHOD0(Method1) 37 // METHOD1(Method3, int) 38 // (snippet above should be multiline macro, add trailing backslashes) 39 // 40 // DEFINE_RPC_CLASS(MyApi, MYAPI_STRUCT) 41 // 42 // The snippet above will generate three classes: MyApi, MyApiStub and 43 // MyApiDispatch. 44 // 45 // 1. For each method defined in the marco MyApi will have a 46 // pure virtual function generated, so that MyApi would look like: 47 // 48 // class MyApi { 49 // private: 50 // MyApi() { } 51 // ~MyApi() { } 52 // virtual void method1() = 0; 53 // virtual void method2( 54 // int param1, 55 // const String& param2, 56 // const Value& param3) = 0; 57 // virtual void method3(int param1) = 0; 58 // }; 59 // 60 // 2. MyApiStub will implement MyApi interface and would serialize all calls 61 // into the string-based calls of the underlying transport: 62 // 63 // DevToolsRPC::Delegate* transport; 64 // myApi = new MyApiStub(transport); 65 // myApi->method1(); 66 // myApi->method3(2); 67 // 68 // 3. MyApiDelegate is capable of dispatching the calls and convert them to the 69 // calls to the underlying MyApi methods: 70 // 71 // MyApi* realObject; 72 // MyApiDispatch::dispatch(realObject, rawStringCallGeneratedByStub); 73 // 74 // will make corresponding calls to the real object. 75 76 #ifndef DevToolsRPC_h 77 #define DevToolsRPC_h 78 79 #include "PlatformString.h" 80 #include "Vector.h" 81 #include "WebDevToolsMessageData.h" 82 83 #include <wtf/Noncopyable.h> 84 85 namespace WebCore { 86 class String; 87 } 88 89 using WebCore::String; 90 using WTF::Vector; 91 92 namespace WebKit { 93 94 /////////////////////////////////////////////////////// 95 // RPC dispatch macro 96 97 template<typename T> 98 struct RpcTypeTrait { 99 typedef T ApiType; 100 }; 101 102 template<> 103 struct RpcTypeTrait<bool> { 104 typedef bool ApiType; 105 static bool parse(const WebCore::String& t) 106 { 107 return t == "true"; 108 } 109 static WebCore::String toString(bool b) 110 { 111 return b ? "true" : "false"; 112 } 113 }; 114 115 template<> 116 struct RpcTypeTrait<int> { 117 typedef int ApiType; 118 static int parse(const WebCore::String& t) 119 { 120 bool success; 121 int i = t.toIntStrict(&success); 122 ASSERT(success); 123 return i; 124 } 125 static WebCore::String toString(int i) 126 { 127 return WebCore::String::number(i); 128 } 129 }; 130 131 template<> 132 struct RpcTypeTrait<String> { 133 typedef const String& ApiType; 134 static String parse(const WebCore::String& t) 135 { 136 return t; 137 } 138 static WebCore::String toString(const String& t) 139 { 140 return t; 141 } 142 }; 143 144 /////////////////////////////////////////////////////// 145 // RPC Api method declarations 146 147 #define TOOLS_RPC_API_METHOD0(Method) \ 148 virtual void Method() = 0; 149 150 #define TOOLS_RPC_API_METHOD1(Method, T1) \ 151 virtual void Method(RpcTypeTrait<T1>::ApiType t1) = 0; 152 153 #define TOOLS_RPC_API_METHOD2(Method, T1, T2) \ 154 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 155 RpcTypeTrait<T2>::ApiType t2) = 0; 156 157 #define TOOLS_RPC_API_METHOD3(Method, T1, T2, T3) \ 158 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 159 RpcTypeTrait<T2>::ApiType t2, \ 160 RpcTypeTrait<T3>::ApiType t3) = 0; 161 162 #define TOOLS_RPC_API_METHOD4(Method, T1, T2, T3, T4) \ 163 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 164 RpcTypeTrait<T2>::ApiType t2, \ 165 RpcTypeTrait<T3>::ApiType t3, \ 166 RpcTypeTrait<T4>::ApiType t4) = 0; 167 168 #define TOOLS_RPC_API_METHOD5(Method, T1, T2, T3, T4, T5) \ 169 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 170 RpcTypeTrait<T2>::ApiType t2, \ 171 RpcTypeTrait<T3>::ApiType t3, \ 172 RpcTypeTrait<T4>::ApiType t4, \ 173 RpcTypeTrait<T5>::ApiType t5) = 0; 174 175 /////////////////////////////////////////////////////// 176 // RPC stub method implementations 177 178 #define TOOLS_RPC_STUB_METHOD0(Method) \ 179 virtual void Method() { \ 180 Vector<String> args; \ 181 this->sendRpcMessage(m_className, #Method, args); \ 182 } 183 184 #define TOOLS_RPC_STUB_METHOD1(Method, T1) \ 185 virtual void Method(RpcTypeTrait<T1>::ApiType t1) { \ 186 Vector<String> args(1); \ 187 args[0] = RpcTypeTrait<T1>::toString(t1); \ 188 this->sendRpcMessage(m_className, #Method, args); \ 189 } 190 191 #define TOOLS_RPC_STUB_METHOD2(Method, T1, T2) \ 192 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 193 RpcTypeTrait<T2>::ApiType t2) { \ 194 Vector<String> args(2); \ 195 args[0] = RpcTypeTrait<T1>::toString(t1); \ 196 args[1] = RpcTypeTrait<T2>::toString(t2); \ 197 this->sendRpcMessage(m_className, #Method, args); \ 198 } 199 200 #define TOOLS_RPC_STUB_METHOD3(Method, T1, T2, T3) \ 201 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 202 RpcTypeTrait<T2>::ApiType t2, \ 203 RpcTypeTrait<T3>::ApiType t3) { \ 204 Vector<String> args(3); \ 205 args[0] = RpcTypeTrait<T1>::toString(t1); \ 206 args[1] = RpcTypeTrait<T2>::toString(t2); \ 207 args[2] = RpcTypeTrait<T3>::toString(t3); \ 208 this->sendRpcMessage(m_className, #Method, args); \ 209 } 210 211 #define TOOLS_RPC_STUB_METHOD4(Method, T1, T2, T3, T4) \ 212 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 213 RpcTypeTrait<T2>::ApiType t2, \ 214 RpcTypeTrait<T3>::ApiType t3, \ 215 RpcTypeTrait<T4>::ApiType t4) { \ 216 Vector<String> args(4); \ 217 args[0] = RpcTypeTrait<T1>::toString(t1); \ 218 args[1] = RpcTypeTrait<T2>::toString(t2); \ 219 args[2] = RpcTypeTrait<T3>::toString(t3); \ 220 args[3] = RpcTypeTrait<T4>::toString(t4); \ 221 this->sendRpcMessage(m_className, #Method, args); \ 222 } 223 224 #define TOOLS_RPC_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \ 225 virtual void Method(RpcTypeTrait<T1>::ApiType t1, \ 226 RpcTypeTrait<T2>::ApiType t2, \ 227 RpcTypeTrait<T3>::ApiType t3, \ 228 RpcTypeTrait<T4>::ApiType t4, \ 229 RpcTypeTrait<T5>::ApiType t5) { \ 230 Vector<String> args(5); \ 231 args[0] = RpcTypeTrait<T1>::toString(t1); \ 232 args[1] = RpcTypeTrait<T2>::toString(t2); \ 233 args[2] = RpcTypeTrait<T3>::toString(t3); \ 234 args[3] = RpcTypeTrait<T4>::toString(t4); \ 235 args[4] = RpcTypeTrait<T5>::toString(t5); \ 236 this->sendRpcMessage(m_className, #Method, args); \ 237 } 238 239 /////////////////////////////////////////////////////// 240 // RPC dispatch method implementations 241 242 #define TOOLS_RPC_DISPATCH0(Method) \ 243 if (methodName == #Method) { \ 244 delegate->Method(); \ 245 return true; \ 246 } 247 248 #define TOOLS_RPC_DISPATCH1(Method, T1) \ 249 if (methodName == #Method) { \ 250 delegate->Method(RpcTypeTrait<T1>::parse(args[0])); \ 251 return true; \ 252 } 253 254 #define TOOLS_RPC_DISPATCH2(Method, T1, T2) \ 255 if (methodName == #Method) { \ 256 delegate->Method( \ 257 RpcTypeTrait<T1>::parse(args[0]), \ 258 RpcTypeTrait<T2>::parse(args[1]) \ 259 ); \ 260 return true; \ 261 } 262 263 #define TOOLS_RPC_DISPATCH3(Method, T1, T2, T3) \ 264 if (methodName == #Method) { \ 265 delegate->Method( \ 266 RpcTypeTrait<T1>::parse(args[0]), \ 267 RpcTypeTrait<T2>::parse(args[1]), \ 268 RpcTypeTrait<T3>::parse(args[2]) \ 269 ); \ 270 return true; \ 271 } 272 273 #define TOOLS_RPC_DISPATCH4(Method, T1, T2, T3, T4) \ 274 if (methodName == #Method) { \ 275 delegate->Method( \ 276 RpcTypeTrait<T1>::parse(args[0]), \ 277 RpcTypeTrait<T2>::parse(args[1]), \ 278 RpcTypeTrait<T3>::parse(args[2]), \ 279 RpcTypeTrait<T4>::parse(args[3]) \ 280 ); \ 281 return true; \ 282 } 283 284 #define TOOLS_RPC_DISPATCH5(Method, T1, T2, T3, T4, T5) \ 285 if (methodName == #Method) { \ 286 delegate->Method( \ 287 RpcTypeTrait<T1>::parse(args[0]), \ 288 RpcTypeTrait<T2>::parse(args[1]), \ 289 RpcTypeTrait<T3>::parse(args[2]), \ 290 RpcTypeTrait<T4>::parse(args[3]), \ 291 RpcTypeTrait<T5>::parse(args[4]) \ 292 ); \ 293 return true; \ 294 } 295 296 #define TOOLS_END_RPC_DISPATCH() \ 297 } 298 299 // This macro defines three classes: Class with the Api, ClassStub that is 300 // serializing method calls and ClassDispatch that is capable of dispatching 301 // the serialized message into its delegate. 302 #define DEFINE_RPC_CLASS(Class, STRUCT) \ 303 class Class : public Noncopyable {\ 304 public: \ 305 Class() \ 306 { \ 307 m_className = #Class; \ 308 } \ 309 virtual ~Class() { } \ 310 \ 311 STRUCT( \ 312 TOOLS_RPC_API_METHOD0, \ 313 TOOLS_RPC_API_METHOD1, \ 314 TOOLS_RPC_API_METHOD2, \ 315 TOOLS_RPC_API_METHOD3, \ 316 TOOLS_RPC_API_METHOD4, \ 317 TOOLS_RPC_API_METHOD5) \ 318 WebCore::String m_className; \ 319 }; \ 320 \ 321 class Class##Stub \ 322 : public Class \ 323 , public DevToolsRPC { \ 324 public: \ 325 explicit Class##Stub(Delegate* delegate) : DevToolsRPC(delegate) { } \ 326 virtual ~Class##Stub() { } \ 327 typedef Class CLASS; \ 328 STRUCT( \ 329 TOOLS_RPC_STUB_METHOD0, \ 330 TOOLS_RPC_STUB_METHOD1, \ 331 TOOLS_RPC_STUB_METHOD2, \ 332 TOOLS_RPC_STUB_METHOD3, \ 333 TOOLS_RPC_STUB_METHOD4, \ 334 TOOLS_RPC_STUB_METHOD5) \ 335 }; \ 336 \ 337 class Class##Dispatch : public Noncopyable { \ 338 public: \ 339 Class##Dispatch() { } \ 340 virtual ~Class##Dispatch() { } \ 341 \ 342 static bool dispatch(Class* delegate, \ 343 const WebKit::WebDevToolsMessageData& data) { \ 344 String className = data.className; \ 345 if (className != #Class) \ 346 return false; \ 347 String methodName = data.methodName; \ 348 Vector<String> args; \ 349 for (size_t i = 0; i < data.arguments.size(); i++) \ 350 args.append(data.arguments[i]); \ 351 typedef Class CLASS; \ 352 STRUCT( \ 353 TOOLS_RPC_DISPATCH0, \ 354 TOOLS_RPC_DISPATCH1, \ 355 TOOLS_RPC_DISPATCH2, \ 356 TOOLS_RPC_DISPATCH3, \ 357 TOOLS_RPC_DISPATCH4, \ 358 TOOLS_RPC_DISPATCH5) \ 359 return false; \ 360 } \ 361 }; 362 363 /////////////////////////////////////////////////////// 364 // RPC base class 365 class DevToolsRPC { 366 public: 367 class Delegate { 368 public: 369 Delegate() { } 370 virtual ~Delegate() { } 371 virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data) = 0; 372 }; 373 374 explicit DevToolsRPC(Delegate* delegate) : m_delegate(delegate) { } 375 virtual ~DevToolsRPC() { }; 376 377 protected: 378 void sendRpcMessage(const String& className, 379 const String& methodName, 380 const Vector<String>& args) { 381 WebKit::WebVector<WebKit::WebString> webArgs(args.size()); 382 for (size_t i = 0; i < args.size(); i++) 383 webArgs[i] = args[i]; 384 WebKit::WebDevToolsMessageData data; 385 data.className = className; 386 data.methodName = methodName; 387 data.arguments.swap(webArgs); 388 this->m_delegate->sendRpcMessage(data); 389 } 390 391 Delegate* m_delegate; 392 }; 393 394 } // namespace WebKit 395 396 #endif 397
