JsEngine.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
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ADBLOCK_PLUS_JS_ENGINE_H
#define ADBLOCK_PLUS_JS_ENGINE_H

#include <functional>
#include <map>
#include <list>
#include <stdexcept>
#include <stdint.h>
#include <string>
#include <mutex>
#include <AdblockPlus/AppInfo.h>
#include <AdblockPlus/LogSystem.h>
#include <AdblockPlus/IFileSystem.h>
#include <AdblockPlus/JsValue.h>
#include <AdblockPlus/IWebRequest.h>
#include <AdblockPlus/ITimer.h>
#include <AdblockPlus/Scheduler.h>

namespace v8
{
  class Isolate;
  class Value;
  class Context;
  template<typename T> class FunctionCallbackInfo;
  typedef void(*FunctionCallback)(const FunctionCallbackInfo<Value>& info);
}

namespace AdblockPlus
{
  class JsEngine;
  class Platform;

  typedef std::shared_ptr<JsEngine> JsEnginePtr;

  struct IV8IsolateProvider
  {
    virtual ~IV8IsolateProvider() {}

    virtual v8::Isolate* Get() = 0;
  };

  class JsEngine : public std::enable_shared_from_this<JsEngine>
  {
    friend class JsValue;
    friend class JsContext;

    struct JsWeakValuesList
    {
      ~JsWeakValuesList();
      std::vector<v8::Global<v8::Value>> values;
    };
    typedef std::list<JsWeakValuesList> JsWeakValuesLists;
  public:
    typedef std::function<void(JsValueList&& params)> EventCallback;

    typedef std::map<std::string, EventCallback> EventMap;

    class JsWeakValuesID
    {
      friend class JsEngine;
      JsWeakValuesLists::const_iterator iterator;
    };

    static JsEnginePtr New(const AppInfo& appInfo, Platform& platform, std::unique_ptr<IV8IsolateProvider> isolate = nullptr);
    void SetEventCallback(const std::string& eventName, const EventCallback& callback);

    void RemoveEventCallback(const std::string& eventName);

    void TriggerEvent(const std::string& eventName, JsValueList&& params);

    JsValue Evaluate(const std::string& source,
        const std::string& filename = "");

    void Gc();


    JsValue NewValue(const std::string& val);
    JsValue NewValue(int64_t val);
    JsValue NewValue(bool val);
    inline JsValue NewValue(const char* val)
    {
      return NewValue(std::string(val));
    }
    inline JsValue NewValue(int val)
    {
      return NewValue(static_cast<int64_t>(val));
    }
#ifdef __APPLE__
    inline JsValue NewValue(long val)
    {
      return NewValue(static_cast<int64_t>(val));
    }
#endif


    JsValue NewObject();

    JsValue NewCallback(const v8::FunctionCallback& callback);

    static JsEnginePtr FromArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments);

    JsWeakValuesID StoreJsValues(const JsValueList& values);

    JsValueList TakeJsValues(const JsWeakValuesID& id);

    JsValueList GetJsValues(const JsWeakValuesID& id);

    /*
     * Private functionality required to implement timers.
     * @param arguments `v8::FunctionCallbackInfo` is the arguments received in C++
     * callback associated for global setTimeout method.
     */
    static void ScheduleTimer(const v8::FunctionCallbackInfo<v8::Value>& arguments);

    /*
     * Private functionality required to implement web requests.
     * @param arguments `v8::FunctionCallbackInfo` is the arguments received in C++
     * callback associated for global GET method.
     */
    static void ScheduleWebRequest(const v8::FunctionCallbackInfo<v8::Value>& arguments);

    JsValueList ConvertArguments(const v8::FunctionCallbackInfo<v8::Value>& arguments);

    void SetGlobalProperty(const std::string& name, const AdblockPlus::JsValue& value);

    v8::Isolate* GetIsolate()
    {
      return isolate->Get();
    }

    void NotifyLowMemory();

    Platform& GetPlatform()
    {
      return platform;
    }
  private:
    void CallTimerTask(const JsWeakValuesID& timerParamsID);

    explicit JsEngine(Platform& platform, std::unique_ptr<IV8IsolateProvider> isolate);

    JsValue GetGlobalObject();

    Platform& platform;
    std::unique_ptr<IV8IsolateProvider> isolate;

    std::unique_ptr<v8::Global<v8::Context>> context;
    EventMap eventCallbacks;
    std::mutex eventCallbacksMutex;
    JsWeakValuesLists jsWeakValuesLists;
    std::mutex jsWeakValuesListsMutex;
  };
}

#endif