FilterEngine.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_FILTER_ENGINE_H
#define ADBLOCK_PLUS_FILTER_ENGINE_H

#include <functional>
#include <map>
#include <string>
#include <vector>
#include <AdblockPlus/JsEngine.h>
#include <AdblockPlus/JsValue.h>
#include <AdblockPlus/Notification.h>

namespace AdblockPlus
{
  class FilterEngine;
  typedef std::shared_ptr<FilterEngine> FilterEnginePtr;

  class Filter : public JsValue
  {
    friend class FilterEngine;
  public:
    Filter(const Filter& src);
    Filter(Filter&& src);
    Filter& operator=(const Filter& src);
    Filter& operator=(Filter&& src);

    enum Type {TYPE_BLOCKING, TYPE_EXCEPTION,
               TYPE_ELEMHIDE, TYPE_ELEMHIDE_EXCEPTION,
               TYPE_ELEMHIDE_EMULATION,
               TYPE_COMMENT, TYPE_INVALID};

    Type GetType() const;

    bool IsListed() const;

    void AddToList();

    void RemoveFromList();

    bool operator==(const Filter& filter) const;

  protected:
    Filter(JsValue&& value);
  };

  class Subscription : public JsValue
  {
    friend class FilterEngine;
  public:
    Subscription(const Subscription& src);

    Subscription(Subscription&& src);

    Subscription& operator=(const Subscription& src);

    Subscription& operator=(Subscription&& src);

    bool IsDisabled() const;

    void SetDisabled(bool value);

    bool IsListed() const;

    void AddToList();

    void RemoveFromList();

    void UpdateFilters();

    bool IsUpdating() const;

    bool IsAA() const;

    bool operator==(const Subscription& subscription) const;

  protected:
    Subscription(JsValue&& value);
  };

  typedef std::unique_ptr<Filter> FilterPtr;

  class FilterEngine
  {
  public:
    // Make sure to keep ContentType in sync with FilterEngine::contentTypes
    // and with RegExpFilter.typeMap from filterClasses.js.
    enum ContentType
    {
      CONTENT_TYPE_OTHER = 1,
      CONTENT_TYPE_SCRIPT = 2,
      CONTENT_TYPE_IMAGE = 4,
      CONTENT_TYPE_STYLESHEET = 8,
      CONTENT_TYPE_OBJECT = 16,
      CONTENT_TYPE_SUBDOCUMENT = 32,
      CONTENT_TYPE_DOCUMENT = 64,
      CONTENT_TYPE_WEBSOCKET = 128,
      CONTENT_TYPE_WEBRTC = 256,
      CONTENT_TYPE_PING = 1024,
      CONTENT_TYPE_XMLHTTPREQUEST = 2048,
      CONTENT_TYPE_OBJECT_SUBREQUEST = 4096,
      CONTENT_TYPE_MEDIA = 16384,
      CONTENT_TYPE_FONT = 32768,
      CONTENT_TYPE_GENERICBLOCK = 0x20000000,
      CONTENT_TYPE_ELEMHIDE = 0x40000000,
      CONTENT_TYPE_GENERICHIDE = 0x80000000
    };

    typedef int32_t ContentTypeMask;

    typedef std::function<void(const std::string&)> UpdateAvailableCallback;

    typedef std::function<void(const std::string&)> UpdateCheckDoneCallback;

    typedef std::function<void(const std::string&, JsValue&&)> FilterChangeCallback;

    typedef std::map<std::string, AdblockPlus::JsValue> Prefs;

    typedef std::function<void(Notification&&)> ShowNotificationCallback;

    typedef std::function<void(const std::string* allowedConnectionType, const std::function<void(bool)>&)> IsConnectionAllowedAsyncCallback;

    struct CreationParameters
    {
      Prefs preconfiguredPrefs;
      IsConnectionAllowedAsyncCallback isSubscriptionDownloadAllowedCallback;
    };

    typedef std::function<void(const FilterEnginePtr&)> OnCreatedCallback;

    static void CreateAsync(const JsEnginePtr& jsEngine,
      const OnCreatedCallback& onCreated,
      const CreationParameters& parameters = CreationParameters());

    JsEngine& GetJsEngine() const { return *jsEngine; }

    bool IsFirstRun() const;

    Filter GetFilter(const std::string& text) const;

    Subscription GetSubscription(const std::string& url) const;

    std::vector<Filter> GetListedFilters() const;

    std::vector<Subscription> GetListedSubscriptions() const;

    std::vector<Subscription> FetchAvailableSubscriptions() const;

    void SetAAEnabled(bool enabled);

    bool IsAAEnabled() const;

    std::string GetAAUrl() const;

    void ShowNextNotification(const std::string& url = std::string()) const;

    void SetShowNotificationCallback(const ShowNotificationCallback& value);

    void RemoveShowNotificationCallback();

    FilterPtr Matches(const std::string& url,
        ContentTypeMask contentTypeMask,
        const std::string& documentUrl) const;

    FilterPtr Matches(const std::string& url,
        ContentTypeMask contentTypeMask,
        const std::vector<std::string>& documentUrls) const;

    bool IsDocumentWhitelisted(const std::string& url,
        const std::vector<std::string>& documentUrls) const;

    bool IsElemhideWhitelisted(const std::string& url,
        const std::vector<std::string>& documentUrls) const;

    std::vector<std::string> GetElementHidingSelectors(const std::string& domain) const;

    JsValue GetPref(const std::string& pref) const;

    void SetPref(const std::string& pref, const JsValue& value);

    std::string GetHostFromURL(const std::string& url) const;

    void SetUpdateAvailableCallback(const UpdateAvailableCallback& callback);

    void RemoveUpdateAvailableCallback();

    void ForceUpdateCheck(const UpdateCheckDoneCallback& callback = UpdateCheckDoneCallback());

    void SetFilterChangeCallback(const FilterChangeCallback& callback);

    void RemoveFilterChangeCallback();

    void SetAllowedConnectionType(const std::string* value);

    std::unique_ptr<std::string> GetAllowedConnectionType() const;

    int CompareVersions(const std::string& v1, const std::string& v2) const;

    static ContentType StringToContentType(const std::string& contentType);

    static std::string ContentTypeToString(ContentType contentType);

  private:
    JsEnginePtr jsEngine;
    bool firstRun;
    int updateCheckId;
    static const std::map<ContentType, std::string> contentTypes;

    explicit FilterEngine(const JsEnginePtr& jsEngine);

    FilterPtr CheckFilterMatch(const std::string& url,
                               ContentTypeMask contentTypeMask,
                               const std::string& documentUrl) const;
    void FilterChanged(const FilterChangeCallback& callback, JsValueList&& params) const;
    FilterPtr GetWhitelistingFilter(const std::string& url,
      ContentTypeMask contentTypeMask, const std::string& documentUrl) const;
    FilterPtr GetWhitelistingFilter(const std::string& url,
      ContentTypeMask contentTypeMask,
      const std::vector<std::string>& documentUrls) const;
  };
}

#endif