Template out V8 and prepare for other JS engine implementations

include/AdblockPlus/JsValue.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 11 matching lines @@
 #include <string>
 #include <vector>
 #include <memory>
 
 #include <AdblockPlus/IFileSystem.h>
 
 namespace v8
 {
   class Value;
   class Object;
+  class Isolate;
+  class Context;
+  class Locker;
+  class HandleScope;
   template<class T> class Local;
   template<class T> class Global;
+  template<typename T> class FunctionCallbackInfo;
+  typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>& info);
 }
 
+namespace duktape
+{
+  class Value;
+  class Object;
+  class Isolate;
+  class Context;
+  class Locker;
+  class HandleScope;
+  template<class T> class Local;
+  template<class T> class Global;
+  template<typename T> class FunctionCallbackInfo;
+  typedef void(*FunctionCallback)(const FunctionCallbackInfo<v8::Value>& info);
+}
+
+template <class TValue, class TObject, class TLocalValue, class TGlobalValue, class TLocalObject, class TCallbackFunc, class TCallbackFuncInfo, class TContext, class TLocalContext, class TGlobalContext, class THandleScope, class TLocker, class TIsolate> 
+struct JsEngineNamespace
+{
+  typedef TValue Value;
+  typedef TObject Object;
+  typedef TLocalValue LocalValue;
+  typedef TGlobalValue GlobalValue;
+  typedef TLocalObject LocalObject;
+  typedef TCallbackFunc CallbackFunc;
+  typedef TCallbackFuncInfo CallbackFuncInfo;
+  typedef TContext Context;
+  typedef TLocalContext LocalContext;
+  typedef TGlobalContext GlobalContext;
+  typedef THandleScope HandleScope;
+  typedef TLocker Locker;
+  typedef TIsolate Isolate;
+};
+#ifdef ABP_DUKTAPE
+typedef JsEngineNamespace<duktape::Value, duktape::Object, duktape::Local<duktape::Value>, duktape::Global<duktape::Value>, duktape::Local<duktape::Object>, duktape::FunctionCallback, duktape::FunctionCallbackInfo<duktape::Value>, duktape::Context, duktape::Local<duktape::Context>, duktape::Global<duktape::Context>, duktape::HandleScope, duktape::Locker, duktape::Isolate> JsEngineNamespaceImpl;
+#define JSVALUEIMPL JsValueTemplate<JsEngineNamespaceImpl>
+#define JSENGINEIMPL JsEngineTemplate<JsEngineNamespaceImpl>
+#define JSVALUEDUKTAPE JSVALUEIMPL
+#define JSENGINEDUKTAPE JSENGINEIMPL
+#else // default to V8
+typedef JsEngineNamespace<v8::Value, v8::Object, v8::Local<v8::Value>, v8::Global<v8::Value>, v8::Local<v8::Object>, v8::FunctionCallback, v8::FunctionCallbackInfo<v8::Value>, v8::Context, v8::Local<v8::Context>, v8::Global<v8::Context>, v8::HandleScope, v8::Locker, v8::Isolate> JsEngineNamespaceImpl;
+#define JSVALUEIMPL JsValueTemplate<JsEngineNamespaceImpl>
+#define JSENGINEIMPL JsEngineTemplate<JsEngineNamespaceImpl>
+#define JSVALUEV8 JSVALUEIMPL
+#define JSENGINEV8 JSENGINEIMPL
+#endif
+
 namespace AdblockPlus
 {
-  class JsValue;
-  class JsEngine;
+  template <class T> class JsValueTemplate;
+  typedef JSVALUEIMPL JsValue;
+  
+  template <class T> class JsEngineTemplate;
+  typedef JSENGINEIMPL JsEngine;
 
   typedef std::shared_ptr<JsEngine> JsEnginePtr;
 
   typedef IFileSystem::IOBuffer StringBuffer;
 
   /**
    * List of JavaScript values.
    */
   typedef std::vector<AdblockPlus::JsValue> JsValueList;
 
   /**
    * Wrapper for JavaScript values.
    * See `JsEngine` for creating `JsValue` objects.
    */
-  class JsValue
+  template <class T> class JsValueTemplate
   {
-    friend class JsEngine;
+    template <typename T> friend class JsEngineTemplate;
   public:
-    JsValue(JsValue&& src);
-    JsValue(const JsValue& src);
-    virtual ~JsValue();
+    JsValueTemplate(JsValueTemplate<T>&& src);
+    JsValueTemplate(const JsValueTemplate<T>& src);
+    virtual ~JsValueTemplate();
 
-    JsValue& operator=(const JsValue& src);
-    JsValue& operator=(JsValue&& src);
+    JsValueTemplate<T>& operator=(const JsValueTemplate<T>& src);
+    JsValueTemplate<T>& operator=(JsValueTemplate<T>&& src);
 
     bool IsUndefined() const;
     bool IsNull() const;
     bool IsString() const;
     bool IsNumber() const;
     bool IsBool() const;
     bool IsObject() const;
     bool IsArray() const;
     bool IsFunction() const;
     std::string AsString() const;
@@ skipping 68 matching lines @@
     JsValue Call(const JsValueList& params, const AdblockPlus::JsValue& thisValue) const;
 
     /**
      * Invokes the value as a function (see `IsFunction()`) with single
      * parameter.
      * @param arg A single required parameter.
      * @return Value returned by the function.
      */
     JsValue Call(const JsValue& arg) const;
 
-    v8::Local<v8::Value> UnwrapValue() const;
+    typename T::LocalValue UnwrapValue() const;
 
   protected:
     JsEnginePtr jsEngine;
   private:
-    JsValue(JsEnginePtr jsEngine, v8::Local<v8::Value> value);
-    void SetProperty(const std::string& name, v8::Local<v8::Value> val);
+    JsValueTemplate<T>(JsEnginePtr jsEngine, typename T::LocalValue);
+    void SetProperty(const std::string& name, typename T::LocalValue val);
 
     // Parameter args is not const because a pointer to its internal arrays is
     // passed to v8::Function::Call but the latter does not expect a const pointer.
-    JsValue Call(std::vector<v8::Local<v8::Value>>& args, v8::Local<v8::Object> thisObj) const;
+    JsValue Call(std::vector<typename T::LocalValue>& args, typename T::LocalObject thisObj) const;
 
-    std::unique_ptr<v8::Global<v8::Value>> value;
+    std::unique_ptr<typename T::GlobalValue> value;
   };
 }
 
 #endif