Template out V8 and prepare for other JS engine implementations

src/JsEngine.cpp

 /*
  * 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 90 matching lines @@
   private:
     ScopedV8Isolate(const ScopedV8Isolate&);
     ScopedV8Isolate& operator=(const ScopedV8Isolate&);
 
     v8::Isolate* isolate;
   };
 }
 
 using namespace AdblockPlus;
 
-JsEngine::JsWeakValuesList::~JsWeakValuesList()
+template <> JsWeakValuesList<v8::Global<v8::Value>>::~JsWeakValuesList()
 {
 }
 
-void JsEngine::NotifyLowMemory()
+
+template <> void AdblockPlus::JSENGINEV8::NotifyLowMemory()
 {
   const JsContext context(*this);
   GetIsolate()->MemoryPressureNotification(v8::MemoryPressureLevel::kCritical);
 }
 
-void JsEngine::ScheduleTimer(const v8::FunctionCallbackInfo<v8::Value>& arguments)
+template <> void AdblockPlus::JSENGINEV8::ScheduleTimer(const v8::FunctionCallbackInfo<v8::Value>& arguments)
 {
   auto jsEngine = FromArguments(arguments);
   if (arguments.Length() < 2)
     throw std::runtime_error("setTimeout requires at least 2 parameters");
 
   if (!arguments[0]->IsFunction())
     throw std::runtime_error("First argument to setTimeout must be a function");
 
   auto jsValueArguments = jsEngine->ConvertArguments(arguments);
   auto timerParamsID = jsEngine->StoreJsValues(jsValueArguments);
 
   std::weak_ptr<JsEngine> weakJsEngine = jsEngine;
   jsEngine->platform.WithTimer(
     [arguments, weakJsEngine, timerParamsID](ITimer& timer)
     {
       timer.SetTimer(
         std::chrono::milliseconds(
           arguments[1]->IntegerValue()), [weakJsEngine, timerParamsID]
           {
             if (auto jsEngine = weakJsEngine.lock())
               jsEngine->CallTimerTask(timerParamsID);
           });
     });
 }
 
-void JsEngine::CallTimerTask(const JsWeakValuesID& timerParamsID)
+template <> void AdblockPlus::JSENGINEV8::CallTimerTask(const JsWeakValuesID& timerParamsID)
 {
   auto timerParams = TakeJsValues(timerParamsID);
   JsValue callback = std::move(timerParams[0]);
 
   timerParams.erase(timerParams.begin()); // remove callback placeholder
   timerParams.erase(timerParams.begin()); // remove timeout param
   callback.Call(timerParams);
 }
 
-AdblockPlus::JsEngine::JsEngine(Platform& platform, std::unique_ptr<IV8IsolateProvider> isolate)
+template <> AdblockPlus::JSENGINEV8::JsEngineTemplate(Platform& platform, std::unique_ptr<IV8IsolateProvider> isolate)
   : platform(platform)
   , isolate(std::move(isolate))
 {
 }
 
-AdblockPlus::JsEnginePtr AdblockPlus::JsEngine::New(const AppInfo& appInfo,
+
+template <> AdblockPlus::JsEnginePtr AdblockPlus::JSENGINEV8::New(const AppInfo& appInfo,
   Platform& platform, std::unique_ptr<IV8IsolateProvider> isolate)
 {
   if (!isolate)
   {
     isolate.reset(new ScopedV8Isolate());
   }
   JsEnginePtr result(new JsEngine(platform, std::move(isolate)));
 
   const v8::Locker locker(result->GetIsolate());
   const v8::Isolate::Scope isolateScope(result->GetIsolate());
   const v8::HandleScope handleScope(result->GetIsolate());
 
   result->context.reset(new v8::Global<v8::Context>(result->GetIsolate(),
     v8::Context::New(result->GetIsolate())));
   auto global = result->GetGlobalObject();
   AdblockPlus::GlobalJsObject::Setup(*result, appInfo, global);
   return result;
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::GetGlobalObject()
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::GetGlobalObject()
 {
   JsContext context(*this);
-  return JsValue(shared_from_this(), context.GetV8Context()->Global());
+  return JsValue(shared_from_this(), context.GetJSEngineContext()->Global());
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::Evaluate(const std::string& source,
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::Evaluate(const std::string& source,
     const std::string& filename)
 {
   const JsContext context(*this);
   const v8::TryCatch tryCatch;
   const v8::Handle<v8::Script> script = CompileScript(GetIsolate(), source,
     filename);
   CheckTryCatch(tryCatch);
   v8::Local<v8::Value> result = script->Run();
   CheckTryCatch(tryCatch);
   return JsValue(shared_from_this(), result);
 }
 
-void AdblockPlus::JsEngine::SetEventCallback(const std::string& eventName,
-    const AdblockPlus::JsEngine::EventCallback& callback)
+template <> void AdblockPlus::JSENGINEV8::SetEventCallback(const std::string& eventName,
+    const AdblockPlus::JSENGINEV8::EventCallback& callback)
 {
   if (!callback)
   {
     RemoveEventCallback(eventName);
     return;
   }
   std::lock_guard<std::mutex> lock(eventCallbacksMutex);
   eventCallbacks[eventName] = callback;
 }
 
-void AdblockPlus::JsEngine::RemoveEventCallback(const std::string& eventName)
+template <> void AdblockPlus::JSENGINEV8::RemoveEventCallback(const std::string& eventName)
 {
   std::lock_guard<std::mutex> lock(eventCallbacksMutex);
   eventCallbacks.erase(eventName);
 }
 
-void AdblockPlus::JsEngine::TriggerEvent(const std::string& eventName, AdblockPlus::JsValueList&& params)
+template <> void AdblockPlus::JSENGINEV8::TriggerEvent(const std::string& eventName, AdblockPlus::JsValueList&& params)
 {
   EventCallback callback;
   {
     std::lock_guard<std::mutex> lock(eventCallbacksMutex);
     auto it = eventCallbacks.find(eventName);
     if (it == eventCallbacks.end())
       return;
     callback = it->second;
   }
   callback(move(params));
 }
 
-void AdblockPlus::JsEngine::Gc()
+template <> void AdblockPlus::JSENGINEV8::Gc()
 {
   while (!GetIsolate()->IdleNotification(1000));
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::NewValue(const std::string& val)
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::NewValue(const std::string& val)
 {
   const JsContext context(*this);
   return JsValue(shared_from_this(), Utils::ToV8String(GetIsolate(), val));
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::NewValue(int64_t val)
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::NewValue(int64_t val)
 {
   const JsContext context(*this);
   return JsValue(shared_from_this(), v8::Number::New(GetIsolate(), val));
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::NewValue(bool val)
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::NewValue(bool val)
 {
   const JsContext context(*this);
   return JsValue(shared_from_this(), v8::Boolean::New(GetIsolate(), val));
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::NewObject()
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::NewObject()
 {
   const JsContext context(*this);
   return JsValue(shared_from_this(), v8::Object::New(GetIsolate()));
 }
 
-AdblockPlus::JsValue AdblockPlus::JsEngine::NewCallback(
+template <> AdblockPlus::JsValue AdblockPlus::JSENGINEV8::NewCallback(
     const v8::FunctionCallback& callback)
 {
   const JsContext context(*this);
 
   // Note: we are leaking this weak pointer, no obvious way to destroy it when
   // it's no longer used
   std::weak_ptr<JsEngine>* data =
       new std::weak_ptr<JsEngine>(shared_from_this());
   v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(GetIsolate(), callback,
       v8::External::New(GetIsolate(), data));
   return JsValue(shared_from_this(), templ->GetFunction());
 }
 
-AdblockPlus::JsEnginePtr AdblockPlus::JsEngine::FromArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments)
+template <> AdblockPlus::JsEnginePtr AdblockPlus::JSENGINEV8::FromArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments)
 {
   const v8::Local<const v8::External> external =
       v8::Local<const v8::External>::Cast(arguments.Data());
   std::weak_ptr<JsEngine>* data =
       static_cast<std::weak_ptr<JsEngine>*>(external->Value());
   JsEnginePtr result = data->lock();
   if (!result)
     throw std::runtime_error("Oops, our JsEngine is gone, how did that happen?");
   return result;
 }
 
-JsEngine::JsWeakValuesID JsEngine::StoreJsValues(const JsValueList& values)
+template <> AdblockPlus::JsWeakValuesID AdblockPlus::JSENGINEV8::StoreJsValues(const JsValueList& values)
 {
   JsWeakValuesLists::iterator it;
   {
     std::lock_guard<std::mutex> lock(jsWeakValuesListsMutex);
     it = jsWeakValuesLists.emplace(jsWeakValuesLists.end());
   }
   {
     JsContext context(*this);
     for (const auto& value : values)
     {
       it->values.emplace_back(GetIsolate(), value.UnwrapValue());
     }
   }
   JsWeakValuesID retValue;
   retValue.iterator = it;
   return retValue;
 }
 
-JsValueList JsEngine::TakeJsValues(const JsWeakValuesID& id)
+template <> JsValueList JSENGINEV8::TakeJsValues(const JsWeakValuesID& id)
 {
   JsValueList retValue;
   {
     JsContext context(*this);
     for (const auto& v8Value : id.iterator->values)
     {
       retValue.emplace_back(JsValue(shared_from_this(), v8::Local<v8::Value>::New(GetIsolate(), v8Value)));
     }
   }
   {
     std::lock_guard<std::mutex> lock(jsWeakValuesListsMutex);
     jsWeakValuesLists.erase(id.iterator);
   }
   return retValue;
 }
 
-AdblockPlus::JsValueList AdblockPlus::JsEngine::ConvertArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments)
+template <> AdblockPlus::JsValueList AdblockPlus::JSENGINEV8::ConvertArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments)
 {
   const JsContext context(*this);
   JsValueList list;
   for (int i = 0; i < arguments.Length(); i++)
     list.push_back(JsValue(shared_from_this(), arguments[i]));
   return list;
 }
 
-void AdblockPlus::JsEngine::SetGlobalProperty(const std::string& name,
+void AdblockPlus::JSENGINEV8::SetGlobalProperty(const std::string& name,
                                               const AdblockPlus::JsValue& value)
 {
   auto global = GetGlobalObject();
   global.SetProperty(name, value);
 }