DevToolsRPC.h   [plain text]

/*
 * Copyright (C) 2010 Google Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

// 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)
//   METHOD0(Method1)
//   METHOD1(Method3, int)
// (snippet above should be multiline macro, add trailing backslashes)
//
// DEFINE_RPC_CLASS(MyApi, MYAPI_STRUCT)
//
// The snippet above will generate three classes: MyApi, MyApiStub and
// MyApiDispatch.
//
// 1. For each method defined in the marco MyApi will have a
// pure virtual function generated, so that MyApi would look like:
//
// class MyApi {
// private:
//     MyApi() { }
//     ~MyApi() { }
//     virtual void method1() = 0;
//     virtual void method2(
//         int param1,
//         const String& param2,
//         const Value& param3) = 0;
//     virtual void method3(int param1) = 0;
// };
//
// 2. MyApiStub will implement MyApi interface and would serialize all calls
// into the string-based calls of the underlying transport:
//
// DevToolsRPC::Delegate* transport;
// myApi = new MyApiStub(transport);
// myApi->method1();
// myApi->method3(2);
//
// 3. MyApiDelegate is capable of dispatching the calls and convert them to the
// calls to the underlying MyApi methods:
//
// MyApi* realObject;
// MyApiDispatch::dispatch(realObject, rawStringCallGeneratedByStub);
//
// will make corresponding calls to the real object.

#ifndef DevToolsRPC_h
#define DevToolsRPC_h

#include "PlatformString.h"
#include "Vector.h"
#include "WebDevToolsMessageData.h"

#include <wtf/Noncopyable.h>

namespace WebCore {
class String;
}

using WebCore::String;
using WTF::Vector;

namespace WebKit {

///////////////////////////////////////////////////////
// RPC dispatch macro

template<typename T>
struct RpcTypeTrait {
    typedef T ApiType;
};

template<>
struct RpcTypeTrait<bool> {
    typedef bool ApiType;
    static bool parse(const WebCore::String& t)
    {
        return t == "true";
    }
    static WebCore::String toString(bool b)
    {
        return b ? "true" : "false";
    }
};

template<>
struct RpcTypeTrait<int> {
    typedef int ApiType;
    static int parse(const WebCore::String& t)
    {
        bool success;
        int i = t.toIntStrict(&success);
        ASSERT(success);
        return i;
    }
    static WebCore::String toString(int i)
    {
        return WebCore::String::number(i);
    }
};

template<>
struct RpcTypeTrait<String> {
    typedef const String& ApiType;
    static String parse(const WebCore::String& t)
    {
        return t;
    }
    static WebCore::String toString(const String& t)
    {
        return t;
    }
};

///////////////////////////////////////////////////////
// RPC Api method declarations

#define TOOLS_RPC_API_METHOD0(Method) \
    virtual void Method() = 0;

#define TOOLS_RPC_API_METHOD1(Method, T1) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1) = 0;

#define TOOLS_RPC_API_METHOD2(Method, T1, T2) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        RpcTypeTrait<T2>::ApiType t2) = 0;

#define TOOLS_RPC_API_METHOD3(Method, T1, T2, T3) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        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;

#define TOOLS_RPC_API_METHOD5(Method, T1, T2, T3, T4, T5) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        RpcTypeTrait<T2>::ApiType t2, \
                        RpcTypeTrait<T3>::ApiType t3, \
                        RpcTypeTrait<T4>::ApiType t4, \
                        RpcTypeTrait<T5>::ApiType t5) = 0;

///////////////////////////////////////////////////////
// RPC stub method implementations

#define TOOLS_RPC_STUB_METHOD0(Method) \
    virtual void Method() { \
        Vector<String> args; \
        this->sendRpcMessage(m_className, #Method, args); \
    }

#define TOOLS_RPC_STUB_METHOD1(Method, T1) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1) { \
        Vector<String> args(1); \
        args[0] = RpcTypeTrait<T1>::toString(t1); \
        this->sendRpcMessage(m_className, #Method, args); \
    }

#define TOOLS_RPC_STUB_METHOD2(Method, T1, T2) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        RpcTypeTrait<T2>::ApiType t2) { \
        Vector<String> args(2); \
        args[0] = RpcTypeTrait<T1>::toString(t1); \
        args[1] = RpcTypeTrait<T2>::toString(t2); \
        this->sendRpcMessage(m_className, #Method, args); \
    }

#define TOOLS_RPC_STUB_METHOD3(Method, T1, T2, T3) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        RpcTypeTrait<T2>::ApiType t2, \
                        RpcTypeTrait<T3>::ApiType t3) { \
        Vector<String> args(3); \
        args[0] = RpcTypeTrait<T1>::toString(t1); \
        args[1] = RpcTypeTrait<T2>::toString(t2); \
        args[2] = RpcTypeTrait<T3>::toString(t3); \
        this->sendRpcMessage(m_className, #Method, args); \
    }

#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) { \
        Vector<String> args(4); \
        args[0] = RpcTypeTrait<T1>::toString(t1); \
        args[1] = RpcTypeTrait<T2>::toString(t2); \
        args[2] = RpcTypeTrait<T3>::toString(t3); \
        args[3] = RpcTypeTrait<T4>::toString(t4); \
        this->sendRpcMessage(m_className, #Method, args); \
    }

#define TOOLS_RPC_STUB_METHOD5(Method, T1, T2, T3, T4, T5) \
    virtual void Method(RpcTypeTrait<T1>::ApiType t1, \
                        RpcTypeTrait<T2>::ApiType t2, \
                        RpcTypeTrait<T3>::ApiType t3, \
                        RpcTypeTrait<T4>::ApiType t4, \
                        RpcTypeTrait<T5>::ApiType t5) { \
        Vector<String> args(5); \
        args[0] = RpcTypeTrait<T1>::toString(t1); \
        args[1] = RpcTypeTrait<T2>::toString(t2); \
        args[2] = RpcTypeTrait<T3>::toString(t3); \
        args[3] = RpcTypeTrait<T4>::toString(t4); \
        args[4] = RpcTypeTrait<T5>::toString(t5); \
        this->sendRpcMessage(m_className, #Method, args); \
    }

///////////////////////////////////////////////////////
// RPC dispatch method implementations

#define TOOLS_RPC_DISPATCH0(Method) \
if (methodName == #Method) { \
    delegate->Method(); \
    return true; \
}

#define TOOLS_RPC_DISPATCH1(Method, T1) \
if (methodName == #Method) { \
    delegate->Method(RpcTypeTrait<T1>::parse(args[0])); \
    return true; \
}

#define TOOLS_RPC_DISPATCH2(Method, T1, T2) \
if (methodName == #Method) { \
    delegate->Method( \
        RpcTypeTrait<T1>::parse(args[0]), \
        RpcTypeTrait<T2>::parse(args[1]) \
    ); \
    return true; \
}

#define TOOLS_RPC_DISPATCH3(Method, T1, T2, T3) \
if (methodName == #Method) { \
    delegate->Method( \
        RpcTypeTrait<T1>::parse(args[0]), \
        RpcTypeTrait<T2>::parse(args[1]), \
        RpcTypeTrait<T3>::parse(args[2]) \
    ); \
    return true; \
}

#define TOOLS_RPC_DISPATCH4(Method, T1, T2, T3, T4) \
if (methodName == #Method) { \
    delegate->Method( \
        RpcTypeTrait<T1>::parse(args[0]), \
        RpcTypeTrait<T2>::parse(args[1]), \
        RpcTypeTrait<T3>::parse(args[2]), \
        RpcTypeTrait<T4>::parse(args[3]) \
    ); \
    return true; \
}

#define TOOLS_RPC_DISPATCH5(Method, T1, T2, T3, T4, T5) \
if (methodName == #Method) { \
    delegate->Method( \
        RpcTypeTrait<T1>::parse(args[0]), \
        RpcTypeTrait<T2>::parse(args[1]), \
        RpcTypeTrait<T3>::parse(args[2]), \
        RpcTypeTrait<T4>::parse(args[3]), \
        RpcTypeTrait<T5>::parse(args[4]) \
    ); \
    return true; \
}

#define TOOLS_END_RPC_DISPATCH() \
}

// This macro defines three classes: Class with the Api, ClassStub that is
// serializing method calls and ClassDispatch that is capable of dispatching
// the serialized message into its delegate.
#define DEFINE_RPC_CLASS(Class, STRUCT) \
class Class : public Noncopyable {\
public: \
    Class() \
    { \
        m_className = #Class; \
    } \
    virtual ~Class() { } \
    \
    STRUCT( \
        TOOLS_RPC_API_METHOD0, \
        TOOLS_RPC_API_METHOD1, \
        TOOLS_RPC_API_METHOD2, \
        TOOLS_RPC_API_METHOD3, \
        TOOLS_RPC_API_METHOD4, \
        TOOLS_RPC_API_METHOD5) \
    WebCore::String m_className; \
}; \
\
class Class##Stub \
    : public Class \
    , public DevToolsRPC { \
public: \
    explicit Class##Stub(Delegate* delegate) : DevToolsRPC(delegate) { } \
    virtual ~Class##Stub() { } \
    typedef Class CLASS; \
    STRUCT( \
        TOOLS_RPC_STUB_METHOD0, \
        TOOLS_RPC_STUB_METHOD1, \
        TOOLS_RPC_STUB_METHOD2, \
        TOOLS_RPC_STUB_METHOD3, \
        TOOLS_RPC_STUB_METHOD4, \
        TOOLS_RPC_STUB_METHOD5) \
}; \
\
class Class##Dispatch : public Noncopyable { \
public: \
    Class##Dispatch() { } \
    virtual ~Class##Dispatch() { } \
    \
    static bool dispatch(Class* delegate, \
                         const WebKit::WebDevToolsMessageData& data) { \
        String className = data.className; \
        if (className != #Class) \
            return false; \
        String methodName = data.methodName; \
        Vector<String> args; \
        for (size_t i = 0; i < data.arguments.size(); i++) \
            args.append(data.arguments[i]); \
        typedef Class CLASS; \
        STRUCT( \
            TOOLS_RPC_DISPATCH0, \
            TOOLS_RPC_DISPATCH1, \
            TOOLS_RPC_DISPATCH2, \
            TOOLS_RPC_DISPATCH3, \
            TOOLS_RPC_DISPATCH4, \
            TOOLS_RPC_DISPATCH5) \
        return false; \
    } \
};

///////////////////////////////////////////////////////
// RPC base class
class DevToolsRPC {
public:
    class Delegate {
    public:
        Delegate() { }
        virtual ~Delegate() { }
        virtual void sendRpcMessage(const WebKit::WebDevToolsMessageData& data) = 0;
    };

    explicit DevToolsRPC(Delegate* delegate) : m_delegate(delegate) { }
    virtual ~DevToolsRPC() { };

protected:
    void sendRpcMessage(const String& className,
                        const String& methodName,
                        const Vector<String>& args) {
      WebKit::WebVector<WebKit::WebString> webArgs(args.size());
      for (size_t i = 0; i < args.size(); i++)
          webArgs[i] = args[i];
      WebKit::WebDevToolsMessageData data;
      data.className = className;
      data.methodName = methodName;
      data.arguments.swap(webArgs);
      this->m_delegate->sendRpcMessage(data);
    }

    Delegate* m_delegate;
};

} // namespace WebKit

#endif