Added regexps work on adblocks.

rssguard.pro

@@ -334,8 +334,7 @@ HEADERS +=  src/core/feeddownloader.h \
             src/core/messagesmodelsqllayer.h \
             src/gui/treeviewcolumnsmenu.h \
             src/services/abstract/labelsrootitem.h \
-            src/services/abstract/label.h \
+            src/services/abstract/label.h
-            src/gui/clickablelabel.h
 
 SOURCES +=  src/core/feeddownloader.cpp \
             src/core/feedsmodel.cpp \
@@ -461,8 +460,7 @@ SOURCES +=  src/core/feeddownloader.cpp \
             src/core/messagesmodelsqllayer.cpp \
             src/gui/treeviewcolumnsmenu.cpp \
             src/services/abstract/labelsrootitem.cpp \
-            src/services/abstract/label.cpp \
+            src/services/abstract/label.cpp
-            src/gui/clickablelabel.cpp
 
 OBJECTIVE_SOURCES += src/miscellaneous/disablewindowtabbing.mm
 
@@ -518,7 +516,9 @@ equals(USE_WEBENGINE, true) {
                 src/network-web/adblock/adblocktreewidget.h \
                 src/network-web/adblock/adblockurlinterceptor.h \
                 src/network-web/urlinterceptor.h \
-                src/network-web/networkurlinterceptor.h
+                src/network-web/networkurlinterceptor.h \
+                src/gui/clickablelabel.h \
+                src/miscellaneous/simpleregexp.h
 
   SOURCES +=    src/network-web/adblock/adblockaddsubscriptiondialog.cpp \
                 src/network-web/adblock/adblockdialog.cpp \
@@ -530,7 +530,9 @@ equals(USE_WEBENGINE, true) {
                 src/network-web/adblock/adblocksubscription.cpp \
                 src/network-web/adblock/adblocktreewidget.cpp \
                 src/network-web/adblock/adblockurlinterceptor.cpp \
-                src/network-web/networkurlinterceptor.cpp
+                src/network-web/networkurlinterceptor.cpp \
+                src/gui/clickablelabel.cpp \
+                src/miscellaneous/simpleregexp.cpp
 
   FORMS +=      src/network-web/adblock/adblockaddsubscriptiondialog.ui \
                 src/network-web/adblock/adblockdialog.ui

src/definitions/definitions.h

@@ -26,6 +26,8 @@
 
 #define ARGUMENTS_LIST_SEPARATOR  "\n"
 
+#define ADBLOCK_CUSTOMLIST_NAME               "customlist.txt"
+#define ADBLOCK_LISTS_SUBDIRECTORY            "adblock"
 #define ADBLOCK_EASYLIST_URL                  "https://easylist-downloads.adblockplus.org/easylist.txt"
 #define DEFAULT_SQL_MESSAGES_FILTER           "0 > 1"
 #define MAX_MULTICOLUMN_SORT_STATES           3

src/miscellaneous/settings.cpp

@@ -28,9 +28,15 @@
 // AdBlock.
 DKEY AdBlock::ID                        = "adblock";
 
+DKEY AdBlock::DisabledRules                   = "disabled_rules";
+DVALUE(QStringList) AdBlock::DisabledRulesDef = QStringList();
+
 DKEY AdBlock::AdBlockEnabled            = "enabled";
 DVALUE(bool) AdBlock::AdBlockEnabledDef = false;
 
+DKEY AdBlock::LastUpdatedOn            = "last_updated_on";
+DVALUE(QDateTime) AdBlock::LastUpdatedOnDef = QDateTime();
+
 // Feeds.
 DKEY Feeds::ID                            = "feeds";
 

src/miscellaneous/settings.h

@@ -28,6 +28,7 @@
 #include <QStringList>
 #include <QColor>
 #include <QByteArray>
+#include <QDateTime>
 
 #define KEY extern const char*
 #define DKEY const char*
@@ -45,6 +46,12 @@ namespace AdBlock {
 
   KEY AdBlockEnabled;
   VALUE(bool) AdBlockEnabledDef;
+
+  KEY DisabledRules;
+  VALUE(QStringList) DisabledRulesDef;
+
+  KEY LastUpdatedOn;
+  VALUE(QDateTime) LastUpdatedOnDef;
 }
 
 // Feeds.

src/network-web/adblock/adblockmanager.cpp

@@ -34,6 +34,7 @@
 #include <QMutexLocker>
 #include <QSaveFile>
 #include <QWebEngineUrlRequestInfo>
+#include <QWebEngineProfile>
 
 Q_GLOBAL_STATIC(AdBlockManager, qz_adblock_manager)
 
@@ -170,9 +171,8 @@ AdBlockSubscription *AdBlockManager::addSubscription(const QString &title, const
     return 0;
   }
 
-  QString fileName = QzTools::filterCharsFromFilename(title.toLower()) + ".txt";
+  QString fileName = title + QSL(".txt");
-  QString filePath = QzTools::ensureUniqueFilename(DataPaths::currentProfilePath() + "/adblock/" + fileName);
+  QString filePath = storedListsPath() + QDir::separator() + fileName;
-
   QByteArray data = QString("Title: %1\nUrl: %2\n[Adblock Plus 1.1.1]").arg(title, url).toLatin1();
 
   QSaveFile file(filePath);
@@ -212,10 +212,9 @@ bool AdBlockManager::removeSubscription(AdBlockSubscription* subscription) {
   return true;
 }
 
-AdBlockCustomList* AdBlockManager::customList() const
+AdBlockCustomList *AdBlockManager::customList() const {
-{
+  foreach (AdBlockSubscription *subscription, m_subscriptions) {
-  foreach (AdBlockSubscription* subscription, m_subscriptions) {
+    AdBlockCustomList *list = qobject_cast<AdBlockCustomList*>(subscription);
-    AdBlockCustomList* list = qobject_cast<AdBlockCustomList*>(subscription);
 
     if (list) {
       return list;
@@ -225,43 +224,40 @@ AdBlockCustomList* AdBlockManager::customList() const
   return 0;
 }
 
-void AdBlockManager::load()
+QString AdBlockManager::storedListsPath() const {
-{
+  return qApp->getUserDataPath() + QDir::separator() + ADBLOCK_LISTS_SUBDIRECTORY;
+}
+
+void AdBlockManager::load() {
   QMutexLocker locker(&m_mutex);
 
   if (m_loaded) {
     return;
   }
 
-#ifdef ADBLOCK_DEBUG
+  m_enabled = qApp->settings()->value(GROUP(AdBlock), SETTING(AdBlock::AdBlockEnabled)).toBool();
-  QElapsedTimer timer;
+  m_disabledRules = qApp->settings()->value(GROUP(AdBlock), SETTING(AdBlock::DisabledRules)).toStringList();
-  timer.start();
+  QDateTime lastUpdate = qApp->settings()->value(GROUP(AdBlock), SETTING(AdBlock::LastUpdatedOn)).toDateTime();
-#endif
-
-  Settings settings;
-  settings.beginGroup("AdBlock");
-  m_enabled = settings.value("enabled", m_enabled).toBool();
-  m_disabledRules = settings.value("disabledRules", QStringList()).toStringList();
-  QDateTime lastUpdate = settings.value("lastUpdate", QDateTime()).toDateTime();
-  settings.endGroup();
 
   if (!m_enabled) {
     return;
   }
 
-  QDir adblockDir(DataPaths::currentProfilePath() + "/adblock");
+  QDir adblockDir(storedListsPath());
+
   // Create if neccessary
   if (!adblockDir.exists()) {
-    QDir(DataPaths::currentProfilePath()).mkdir("adblock");
+    QDir().mkpath(storedListsPath());
   }
 
   foreach (const QString &fileName, adblockDir.entryList(QStringList("*.txt"), QDir::Files)) {
-    if (fileName == QLatin1String("customlist.txt")) {
+    if (fileName == ADBLOCK_CUSTOMLIST_NAME) {
       continue;
     }
 
     const QString absolutePath = adblockDir.absoluteFilePath(fileName);
     QFile file(absolutePath);
+
     if (!file.open(QFile::ReadOnly)) {
       continue;
     }
@@ -272,7 +268,7 @@ void AdBlockManager::load()
     QUrl url = QUrl(textStream.readLine(1024).remove(QLatin1String("Url: ")));
 
     if (title.isEmpty() || !url.isValid()) {
-      qWarning() << "AdBlockManager: Invalid subscription file" << absolutePath;
+      qWarning("Invalid AdBlock subscription file '%s'.", qPrintable(absolutePath));
       continue;
     }
 
@@ -283,21 +279,22 @@ void AdBlockManager::load()
     m_subscriptions.append(subscription);
   }
 
-  // Prepend EasyList if subscriptions are empty
+  // Prepend EasyList if subscriptions are empty.
   if (m_subscriptions.isEmpty()) {
     AdBlockSubscription* easyList = new AdBlockSubscription(tr("EasyList"), this);
+
     easyList->setUrl(QUrl(ADBLOCK_EASYLIST_URL));
-    easyList->setFilePath(DataPaths::currentProfilePath() + QLatin1String("/adblock/easylist.txt"));
+    easyList->setFilePath(storedListsPath() + QDir::separator() + QSL("easylist.txt"));
 
     m_subscriptions.prepend(easyList);
   }
 
-  // Append CustomList
+  // Append CustomList.
   AdBlockCustomList* customList = new AdBlockCustomList(this);
   m_subscriptions.append(customList);
 
   // Load all subscriptions
-  foreach (AdBlockSubscription* subscription, m_subscriptions) {
+  foreach (AdBlockSubscription *subscription, m_subscriptions) {
     subscription->loadSubscription(m_disabledRules);
 
     connect(subscription, SIGNAL(subscriptionUpdated()), mApp, SLOT(reloadUserStyleSheet()));
@@ -308,88 +305,73 @@ void AdBlockManager::load()
     QTimer::singleShot(1000 * 60, this, SLOT(updateAllSubscriptions()));
   }
 
-#ifdef ADBLOCK_DEBUG
-  qDebug() << "AdBlock loaded in" << timer.elapsed();
-#endif
-
   m_matcher->update();
   m_loaded = true;
 
-  mApp->networkManager()->installUrlInterceptor(m_interceptor);
+  // TODO: instalovat interceptor, asi dát tu logiku
+  // někam sem, nedávat třeba do Application
+  //mApp->networkManager()->installUrlInterceptor(m_interceptor);
 }
 
-void AdBlockManager::updateMatcher()
+void AdBlockManager::updateMatcher() {
-{
   QMutexLocker locker(&m_mutex);
 
   m_matcher->update();
 }
 
-void AdBlockManager::updateAllSubscriptions()
+void AdBlockManager::updateAllSubscriptions() {
-{
   foreach (AdBlockSubscription* subscription, m_subscriptions) {
     subscription->updateSubscription();
   }
 
-  Settings settings;
+  qApp->settings()->setValue(GROUP(AdBlock), AdBlock::LastUpdatedOn, QDateTime::currentDateTime());
-  settings.beginGroup("AdBlock");
-  settings.setValue("lastUpdate", QDateTime::currentDateTime());
-  settings.endGroup();
 }
 
-void AdBlockManager::save()
+void AdBlockManager::save() {
-{
   if (!m_loaded) {
     return;
   }
 
-  foreach (AdBlockSubscription* subscription, m_subscriptions) {
+  foreach (AdBlockSubscription *subscription, m_subscriptions) {
     subscription->saveSubscription();
   }
 
-  Settings settings;
+  qApp->settings()->setValue(GROUP(AdBlock), AdBlock::AdBlockEnabled, m_enabled);
-  settings.beginGroup("AdBlock");
+  qApp->settings()->setValue(GROUP(AdBlock), AdBlock::DisabledRules, m_disabledRules);
-  settings.setValue("enabled", m_enabled);
-  settings.setValue("disabledRules", m_disabledRules);
-  settings.endGroup();
 }
 
-bool AdBlockManager::isEnabled() const
+bool AdBlockManager::isEnabled() const {
-{
   return m_enabled;
 }
 
-bool AdBlockManager::canRunOnScheme(const QString &scheme) const
+bool AdBlockManager::canRunOnScheme(const QString &scheme) const {
-{
+  return !(scheme == QSL("file") || scheme == QSL("qrc") || scheme == QSL("data") || scheme == QSL("abp"));
-  return !(scheme == QLatin1String("file") || scheme == QLatin1String("qrc")
-           || scheme == QLatin1String("qupzilla") || scheme == QLatin1String("data")
-           || scheme == QLatin1String("abp"));
 }
 
-bool AdBlockManager::canBeBlocked(const QUrl &url) const
+bool AdBlockManager::canBeBlocked(const QUrl &url) const {
-{
   return !m_matcher->adBlockDisabledForUrl(url);
 }
 
-QString AdBlockManager::elementHidingRules(const QUrl &url) const
+QString AdBlockManager::elementHidingRules(const QUrl &url) const {
-{
+  if (!isEnabled() || !canRunOnScheme(url.scheme()) || !canBeBlocked(url)) {
-  if (!isEnabled() || !canRunOnScheme(url.scheme()) || !canBeBlocked(url))
     return QString();
-
+  }
+  else {
     return m_matcher->elementHidingRules();
+  }
 }
 
-QString AdBlockManager::elementHidingRulesForDomain(const QUrl &url) const
+QString AdBlockManager::elementHidingRulesForDomain(const QUrl &url) const {
-{
+  if (!isEnabled() || !canRunOnScheme(url.scheme()) || !canBeBlocked(url)) {
-  if (!isEnabled() || !canRunOnScheme(url.scheme()) || !canBeBlocked(url))
     return QString();
-
+  }
+  else {
     return m_matcher->elementHidingRulesForDomain(url.host());
+  }
 }
 
-AdBlockSubscription* AdBlockManager::subscriptionByName(const QString &name) const
+AdBlockSubscription* AdBlockManager::subscriptionByName(const QString &name) const {
-{
+  foreach (AdBlockSubscription *subscription, m_subscriptions) {
-  foreach (AdBlockSubscription* subscription, m_subscriptions) {
     if (subscription->title() == name) {
       return subscription;
     }
@@ -398,8 +380,7 @@ AdBlockSubscription* AdBlockManager::subscriptionByName(const QString &name) con
   return 0;
 }
 
-AdBlockDialog* AdBlockManager::showDialog()
+AdBlockDialog *AdBlockManager::showDialog() {
-{
   if (!m_adBlockDialog) {
     m_adBlockDialog = new AdBlockDialog;
   }
@@ -411,10 +392,9 @@ AdBlockDialog* AdBlockManager::showDialog()
   return m_adBlockDialog.data();
 }
 
-void AdBlockManager::showRule()
+void AdBlockManager::showRule() {
-{
+  if (QAction *action = qobject_cast<QAction*>(sender())) {
-  if (QAction* action = qobject_cast<QAction*>(sender())) {
+    const AdBlockRule *rule = static_cast<const AdBlockRule*>(action->data().value<void*>());
-    const AdBlockRule* rule = static_cast<const AdBlockRule*>(action->data().value<void*>());
 
     if (rule) {
       showDialog()->showRule(rule);

src/network-web/adblock/adblockmanager.h

@@ -67,6 +67,8 @@ class AdBlockManager : public QObject {
 
     AdBlockCustomList *customList() const;
 
+    QString storedListsPath() const;
+
     static AdBlockManager *instance();
 
   signals:

src/network-web/adblock/adblockmatcher.cpp

@@ -16,93 +16,103 @@
 // You should have received a copy of the GNU General Public License
 // along with RSS Guard. If not, see <http://www.gnu.org/licenses/>.
 
-#include "adblockmatcher.h"
+#include "network-web/adblock/adblockmatcher.h"
-#include "adblockmanager.h"
+#include "network-web/adblock/adblockmanager.h"
-#include "adblockrule.h"
+#include "network-web/adblock/adblockrule.h"
-#include "adblocksubscription.h"
+#include "network-web/adblock/adblocksubscription.h"
+
+#include "definitions/definitions.h"
+
 
 AdBlockMatcher::AdBlockMatcher(AdBlockManager* manager)
-    : QObject(manager)
+  : QObject(manager), m_manager(manager) {
-    , m_manager(manager)
-{
 }
 
-AdBlockMatcher::~AdBlockMatcher()
+AdBlockMatcher::~AdBlockMatcher() {
-{
   clear();
 }
 
-const AdBlockRule* AdBlockMatcher::match(const QWebEngineUrlRequestInfo &request, const QString &urlDomain, const QString &urlString) const
+const AdBlockRule* AdBlockMatcher::match(const QWebEngineUrlRequestInfo &request, const QString &urlDomain, const QString &urlString) const {
-{
+  // Exception rules.
-    // Exception rules
+  if (m_networkExceptionTree.find(request, urlDomain, urlString)) {
-    if (m_networkExceptionTree.find(request, urlDomain, urlString))
-        return 0;
-
-    int count = m_networkExceptionRules.count();
-    for (int i = 0; i < count; ++i) {
-        const AdBlockRule* rule = m_networkExceptionRules.at(i);
-        if (rule->networkMatch(request, urlDomain, urlString))
     return 0;
   }
 
-    // Block rules
+  int count = m_networkExceptionRules.count();
-    if (const AdBlockRule* rule = m_networkBlockTree.find(request, urlDomain, urlString))
+
+  for (int i = 0; i < count; ++i) {
+    const AdBlockRule* rule = m_networkExceptionRules.at(i);
+
+    if (rule->networkMatch(request, urlDomain, urlString)) {
+      return 0;
+    }
+  }
+
+  // Block rules.
+  if (const AdBlockRule* rule = m_networkBlockTree.find(request, urlDomain, urlString)) {
     return rule;
+  }
 
   count = m_networkBlockRules.count();
+
   for (int i = 0; i < count; ++i) {
     const AdBlockRule* rule = m_networkBlockRules.at(i);
-        if (rule->networkMatch(request, urlDomain, urlString))
+
+    if (rule->networkMatch(request, urlDomain, urlString)) {
       return rule;
     }
+  }
 
   return 0;
 }
 
-bool AdBlockMatcher::adBlockDisabledForUrl(const QUrl &url) const
+bool AdBlockMatcher::adBlockDisabledForUrl(const QUrl &url) const {
-{
   int count = m_documentRules.count();
 
-    for (int i = 0; i < count; ++i)
+  for (int i = 0; i < count; ++i) {
-        if (m_documentRules.at(i)->urlMatch(url))
+    if (m_documentRules.at(i)->urlMatch(url)) {
       return true;
+    }
+  }
 
   return false;
 }
 
-bool AdBlockMatcher::elemHideDisabledForUrl(const QUrl &url) const
+bool AdBlockMatcher::elemHideDisabledForUrl(const QUrl &url) const {
-{
+  if (adBlockDisabledForUrl(url)) {
-    if (adBlockDisabledForUrl(url))
     return true;
+  }
 
   int count = m_elemhideRules.count();
 
-    for (int i = 0; i < count; ++i)
+  for (int i = 0; i < count; ++i) {
-        if (m_elemhideRules.at(i)->urlMatch(url))
+    if (m_elemhideRules.at(i)->urlMatch(url)) {
       return true;
+    }
+  }
 
   return false;
 }
 
-QString AdBlockMatcher::elementHidingRules() const
+QString AdBlockMatcher::elementHidingRules() const {
-{
   return m_elementHidingRules;
 }
 
-QString AdBlockMatcher::elementHidingRulesForDomain(const QString &domain) const
+QString AdBlockMatcher::elementHidingRulesForDomain(const QString &domain) const {
-{
   QString rules;
   int addedRulesCount = 0;
   int count = m_domainRestrictedCssRules.count();
 
   for (int i = 0; i < count; ++i) {
     const AdBlockRule* rule = m_domainRestrictedCssRules.at(i);
-        if (!rule->matchDomain(domain))
+
+    if (!rule->matchDomain(domain)) {
       continue;
+    }
 
     if (Q_UNLIKELY(addedRulesCount == 1000)) {
       rules.append(rule->cssSelector());
-            rules.append(QL1S("{display:none !important;}\n"));
+      rules.append(QSL("{display:none !important;}\n"));
       addedRulesCount = 0;
     }
     else {
@@ -113,14 +123,13 @@ QString AdBlockMatcher::elementHidingRulesForDomain(const QString &domain) const
 
   if (addedRulesCount != 0) {
     rules = rules.left(rules.size() - 1);
-        rules.append(QL1S("{display:none !important;}\n"));
+    rules.append(QSL("{display:none !important;}\n"));
   }
 
   return rules;
 }
 
-void AdBlockMatcher::update()
+void AdBlockMatcher::update() {
-{
   clear();
 
   QHash<QString, const AdBlockRule*> cssRulesHash;
@@ -128,21 +137,25 @@ void AdBlockMatcher::update()
 
   foreach (AdBlockSubscription* subscription, m_manager->subscriptions()) {
     foreach (const AdBlockRule* rule, subscription->allRules()) {
-            // Don't add internally disabled rules to cache
+      // Don't add internally disabled rules to cache.
-            if (rule->isInternalDisabled())
+      if (rule->isInternalDisabled()) {
         continue;
+      }
 
       if (rule->isCssRule()) {
         // We will add only enabled css rules to cache, because there is no enabled/disabled
         // check on match. They are directly embedded to pages.
-                if (!rule->isEnabled())
+        if (!rule->isEnabled()) {
           continue;
+        }
 
-                if (rule->isException())
+        if (rule->isException()) {
           exceptionCssRules.append(rule);
-                else
+        }
+        else {
           cssRulesHash.insert(rule->cssSelector(), rule);
         }
+      }
       else if (rule->isDocument()) {
         m_documentRules.append(rule);
       }
@@ -150,24 +163,27 @@ void AdBlockMatcher::update()
         m_elemhideRules.append(rule);
       }
       else if (rule->isException()) {
-                if (!m_networkExceptionTree.add(rule))
+        if (!m_networkExceptionTree.add(rule)) {
           m_networkExceptionRules.append(rule);
         }
+      }
       else {
-                if (!m_networkBlockTree.add(rule))
+        if (!m_networkBlockTree.add(rule)) {
           m_networkBlockRules.append(rule);
         }
       }
     }
+  }
 
-    foreach (const AdBlockRule* rule, exceptionCssRules) {
+  foreach (const AdBlockRule *rule, exceptionCssRules) {
-        const AdBlockRule* originalRule = cssRulesHash.value(rule->cssSelector());
+    const AdBlockRule *originalRule = cssRulesHash.value(rule->cssSelector());
 
     // If we don't have this selector, the exception does nothing
-        if (!originalRule)
+    if (!originalRule) {
       continue;
+    }
 
-        AdBlockRule* copiedRule = originalRule->copy();
+    AdBlockRule *copiedRule = originalRule->copy();
     copiedRule->m_options |= AdBlockRule::DomainRestrictedOption;
     copiedRule->m_blockedDomains.append(rule->m_allowedDomains);
 
@@ -183,7 +199,7 @@ void AdBlockMatcher::update()
   QHashIterator<QString, const AdBlockRule*> it(cssRulesHash);
   while (it.hasNext()) {
     it.next();
-        const AdBlockRule* rule = it.value();
+    const AdBlockRule *rule = it.value();
 
     if (rule->isDomainRestricted()) {
       m_domainRestrictedCssRules.append(rule);
@@ -205,8 +221,7 @@ void AdBlockMatcher::update()
   }
 }
 
-void AdBlockMatcher::clear()
+void AdBlockMatcher::clear() {
-{
   m_networkExceptionTree.clear();
   m_networkExceptionRules.clear();
   m_networkBlockTree.clear();

src/network-web/adblock/adblockmatcher.h

@@ -22,20 +22,18 @@
 #include <QUrl>
 #include <QObject>
 
-#include "qzcommon.h"
+#include "network-web/adblock/adblocksearchtree.h"
-#include "adblocksearchtree.h"
+
 
 class QWebEngineUrlRequestInfo;
-
 class AdBlockManager;
 
-class QUPZILLA_EXPORT AdBlockMatcher : public QObject
+class AdBlockMatcher : public QObject {
-{
     Q_OBJECT
 
-public:
+  public:
     explicit AdBlockMatcher(AdBlockManager* manager);
-    ~AdBlockMatcher();
+    virtual ~AdBlockMatcher();
 
     const AdBlockRule* match(const QWebEngineUrlRequestInfo &request, const QString &urlDomain, const QString &urlString) const;
 
@@ -45,12 +43,12 @@ public:
     QString elementHidingRules() const;
     QString elementHidingRulesForDomain(const QString &domain) const;
 
-public slots:
+  public slots:
     void update();
     void clear();
 
-private:
+  private:
-    AdBlockManager* m_manager;
+    AdBlockManager *m_manager;
 
     QVector<AdBlockRule*> m_createdRules;
     QVector<const AdBlockRule*> m_networkExceptionRules;

src/network-web/adblock/adblockrule.h

@@ -51,26 +51,24 @@
 #include <QStringList>
 #include <QStringMatcher>
 
-#include "qzcommon.h"
+#include "miscellaneous/simpleregexp.h"
-#include "qzregexp.h"
+
 
 class QUrl;
 class QWebEngineUrlRequestInfo;
-
 class AdBlockSubscription;
 
-class QUPZILLA_EXPORT AdBlockRule
+class AdBlockRule {
-{
     Q_DISABLE_COPY(AdBlockRule)
 
-public:
+  public:
-    AdBlockRule(const QString &filter = QString(), AdBlockSubscription* subscription = 0);
+    explicit AdBlockRule(const QString &filter = QString(), AdBlockSubscription *subscription = 0);
-    ~AdBlockRule();
+    virtual ~AdBlockRule();
 
-    AdBlockRule* copy() const;
+    AdBlockRule *copy() const;
 
-    AdBlockSubscription* subscription() const;
+    AdBlockSubscription *subscription() const;
-    void setSubscription(AdBlockSubscription* subscription);
+    void setSubscription(AdBlockSubscription *subscription);
 
     QString filter() const;
     void setFilter(const QString &filter);
@@ -104,13 +102,13 @@ public:
     bool matchStyleSheet(const QWebEngineUrlRequestInfo &request) const;
     bool matchObjectSubrequest(const QWebEngineUrlRequestInfo &request) const;
 
-protected:
+  protected:
     bool stringMatch(const QString &domain, const QString &encodedUrl) const;
     bool isMatchingDomain(const QString &domain, const QString &filter) const;
     bool isMatchingRegExpStrings(const QString &url) const;
     QStringList parseRegExpFilter(const QString &filter) const;
 
-private:
+  private:
     enum RuleType {
       CssRule = 0,
       DomainMatchRule = 1,
@@ -131,7 +129,7 @@ private:
       StyleSheetOption = 128,
       ObjectSubrequestOption = 256,
 
-        // Exception only options
+      // Exception only options.
       DocumentOption = 1024,
       ElementHideOption = 2048
     };
@@ -151,7 +149,7 @@ private:
     QString createRegExpFromFilter(const QString &filter) const;
     QList<QStringMatcher> createStringMatchers(const QStringList &filters) const;
 
-    AdBlockSubscription* m_subscription;
+    AdBlockSubscription *m_subscription;
 
     RuleType m_type;
     RuleOptions m_options;
@@ -172,12 +170,12 @@ private:
     QStringList m_blockedDomains;
 
     struct RegExp {
-        QzRegExp regExp;
+        SimpleRegExp regExp;
         QList<QStringMatcher> matchers;
     };
 
     // Use dynamic allocation to save memory
-    RegExp* m_regExp;
+    RegExp *m_regExp;
 
     friend class AdBlockMatcher;
     friend class AdBlockSearchTree;