diff --git a/src/lib/adblock/adblockplugin.cpp b/src/lib/adblock/adblockplugin.cpp
index 0b43c1a4..95838c85 100644
--- a/src/lib/adblock/adblockplugin.cpp
+++ b/src/lib/adblock/adblockplugin.cpp
@@ -1,67 +1,102 @@
 /* ============================================================
 * QupZilla - Qt web browser
 * Copyright (C) 2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 
 #include "adblockplugin.h"
 #include "adblockmanager.h"
 #include "adblockicon.h"
 
 #include "scripts.h"
 #include "webpage.h"
 #include "pluginproxy.h"
 #include "browserwindow.h"
 #include "navigationbar.h"
 #include "mainapplication.h"
 
-AdBlockPlugin::AdBlockPlugin(QObject *parent)
-    : QObject(parent)
+AdBlockPlugin::AdBlockPlugin()
+    : QObject()
 {
+}
+
+PluginSpec AdBlockPlugin::pluginSpec()
+{
+    return PluginSpec();
+}
+
+void AdBlockPlugin::init(InitState state, const QString &settingsPath)
+{
+    Q_UNUSED(settingsPath)
+    Q_ASSERT(state == StartupInitState);
+
     connect(mApp, &MainApplication::aboutToQuit, AdBlockManager::instance(), &AdBlockManager::save);
     connect(mApp->plugins(), &PluginProxy::webPageCreated, this, &AdBlockPlugin::webPageCreated);
     connect(mApp->plugins(), &PluginProxy::webPageDeleted, this, &AdBlockPlugin::webPageDeleted);
     connect(mApp->plugins(), &PluginProxy::mainWindowCreated, this, &AdBlockPlugin::mainWindowCreated);
 }
 
+void AdBlockPlugin::unload()
+{
+}
+
+bool AdBlockPlugin::testPlugin()
+{
+    return true;
+}
+
 void AdBlockPlugin::webPageCreated(WebPage *page)
 {
     connect(page, &WebPage::loadFinished, this, [=]() {
         AdBlockManager *manager = AdBlockManager::instance();
         if (!manager->isEnabled()) {
             return;
         }
         // Apply global element hiding rules
         const QString elementHiding = manager->elementHidingRules(page->url());
         if (!elementHiding.isEmpty()) {
             page->runJavaScript(Scripts::setCss(elementHiding), WebPage::SafeJsWorld);
         }
         // Apply domain-specific element hiding rules
         const QString siteElementHiding = manager->elementHidingRulesForDomain(page->url());
         if (!siteElementHiding.isEmpty()) {
             page->runJavaScript(Scripts::setCss(siteElementHiding), WebPage::SafeJsWorld);
         }
     });
 }
 
 void AdBlockPlugin::webPageDeleted(WebPage *page)
 {
     AdBlockManager::instance()->clearBlockedRequestsForUrl(page->url());
 }
 
 void AdBlockPlugin::mainWindowCreated(BrowserWindow *window)
 {
     window->navigationBar()->addToolButton(new AdBlockIcon(window));
 }
+
+bool AdBlockPlugin::acceptNavigationRequest(WebPage *page, const QUrl &url, QWebEnginePage::NavigationType type, bool isMainFrame)
+{
+    Q_UNUSED(type)
+
+    AdBlockManager *manager = AdBlockManager::instance();
+    if (isMainFrame) {
+        manager->clearBlockedRequestsForUrl(page->url());
+    }
+    if (url.scheme() == QL1S("abp") && AdBlockManager::instance()->addSubscriptionFromUrl(url)) {
+        return false;
+    }
+    return true;
+}
diff --git a/src/lib/adblock/adblockplugin.h b/src/lib/adblock/adblockplugin.h
index 9350abba..8ef50abd 100644
--- a/src/lib/adblock/adblockplugin.h
+++ b/src/lib/adblock/adblockplugin.h
@@ -1,34 +1,42 @@
 /* ============================================================
 * QupZilla - Qt web browser
 * Copyright (C) 2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #pragma once
 
-#include <QObject>
+#include "plugininterface.h"
 
 class WebPage;
 class BrowserWindow;
 
-class AdBlockPlugin : public QObject
+class AdBlockPlugin : public QObject, public PluginInterface
 {
+    Q_OBJECT
+
 public:
-    explicit AdBlockPlugin(QObject *parent = nullptr);
+    explicit AdBlockPlugin();
+    PluginSpec pluginSpec();
+    void init(InitState state, const QString &settingsPath);
+    void unload();
+    bool testPlugin();
 
 private:
     void webPageCreated(WebPage *page);
     void webPageDeleted(WebPage *page);
     void mainWindowCreated(BrowserWindow *window);
+    bool acceptNavigationRequest(WebPage *page, const QUrl &url, QWebEnginePage::NavigationType type, bool isMainFrame) override;
+
 };
diff --git a/src/lib/app/mainapplication.cpp b/src/lib/app/mainapplication.cpp
index 80b1dc22..a6103116 100644
--- a/src/lib/app/mainapplication.cpp
+++ b/src/lib/app/mainapplication.cpp
@@ -1,1244 +1,1242 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "mainapplication.h"
 #include "history.h"
 #include "qztools.h"
 #include "updater.h"
 #include "autofill.h"
 #include "settings.h"
 #include "qzregexp.h"
 #include "autosaver.h"
 #include "datapaths.h"
 #include "tabwidget.h"
 #include "cookiejar.h"
 #include "bookmarks.h"
 #include "qzsettings.h"
 #include "proxystyle.h"
 #include "pluginproxy.h"
 #include "iconprovider.h"
 #include "browserwindow.h"
 #include "checkboxdialog.h"
 #include "networkmanager.h"
 #include "profilemanager.h"
 #include "restoremanager.h"
 #include "browsinglibrary.h"
 #include "downloadmanager.h"
 #include "clearprivatedata.h"
 #include "useragentmanager.h"
 #include "commandlineoptions.h"
 #include "searchenginesmanager.h"
 #include "desktopnotificationsfactory.h"
 #include "html5permissions/html5permissionsmanager.h"
 #include "scripts.h"
 #include "sessionmanager.h"
 #include "closedwindowsmanager.h"
-#include "adblock/adblockplugin.h"
 
 #include <QWebEngineSettings>
 #include <QDesktopServices>
 #include <QFontDatabase>
 #include <QSqlDatabase>
 #include <QLibraryInfo>
 #include <QMessageBox>
 #include <QTranslator>
 #include <QThreadPool>
 #include <QSettings>
 #include <QProcess>
 #include <QTimer>
 #include <QDir>
 #include <QStandardPaths>
 #include <QWebEngineProfile>
 #include <QWebEngineDownloadItem>
 #include <QWebEngineScriptCollection>
 
 #ifdef Q_OS_WIN
 #include <QtWin>
 #include <QWinJumpList>
 #include <QWinJumpListCategory>
 #endif
 
 #include <iostream>
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
 #include "registerqappassociation.h"
 #endif
 
 MainApplication::MainApplication(int &argc, char** argv)
     : QtSingleApplication(argc, argv)
     , m_isPrivate(false)
     , m_isPortable(false)
     , m_isClosing(false)
     , m_isStartingAfterCrash(false)
     , m_history(0)
     , m_bookmarks(0)
     , m_autoFill(0)
     , m_cookieJar(0)
     , m_plugins(0)
     , m_browsingLibrary(0)
     , m_networkManager(0)
     , m_restoreManager(0)
     , m_sessionManager(0)
     , m_downloadManager(0)
     , m_userAgentManager(0)
     , m_searchEnginesManager(0)
     , m_closedWindowsManager(0)
     , m_html5PermissionsManager(0)
     , m_desktopNotifications(0)
     , m_webProfile(0)
     , m_autoSaver(0)
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
     , m_registerQAppAssociation(0)
 #endif
 {
     setAttribute(Qt::AA_UseHighDpiPixmaps);
     setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
 
     setApplicationName(QLatin1String("falkon"));
     setOrganizationDomain(QLatin1String("org.kde"));
     setWindowIcon(QIcon::fromTheme(QSL("qupzilla"), QIcon(QSL(":icons/exeicons/qupzilla-window.png"))));
     setDesktopFileName(QSL("org.kde.Falkon"));
 
 #ifdef GIT_REVISION
     setApplicationVersion(QSL("%1 (%2)").arg(Qz::VERSION, GIT_REVISION));
 #else
     setApplicationVersion(Qz::VERSION);
 #endif
 
     // Set fallback icon theme (eg. on Windows/Mac)
     if (QIcon::fromTheme(QSL("view-refresh")).isNull()) {
         QIcon::setThemeSearchPaths(QStringList() << QL1S(":/breeze-fallback"));
         QIcon::setThemeName(QSL("breeze-fallback"));
     }
 
     // QSQLITE database plugin is required
     if (!QSqlDatabase::isDriverAvailable(QSL("QSQLITE"))) {
         QMessageBox::critical(0, QSL("Error"), QSL("Qt SQLite database plugin is not available. Please install it and restart the application."));
         m_isClosing = true;
         return;
     }
 
 #ifdef Q_OS_WIN
     // Set default app font (needed for N'ko)
     int fontId = QFontDatabase::addApplicationFont(QSL("font.ttf"));
     if (fontId != -1) {
         const QStringList families = QFontDatabase::applicationFontFamilies(fontId);
         if (!families.empty())
             setFont(QFont(families.at(0)));
     }
 #endif
 
     QUrl startUrl;
     QString startProfile;
     QStringList messages;
 
     bool noAddons = false;
     bool newInstance = false;
 
     if (argc > 1) {
         CommandLineOptions cmd;
         foreach (const CommandLineOptions::ActionPair &pair, cmd.getActions()) {
             switch (pair.action) {
             case Qz::CL_StartWithoutAddons:
                 noAddons = true;
                 break;
             case Qz::CL_StartWithProfile:
                 startProfile = pair.text;
                 break;
             case Qz::CL_StartPortable:
                 m_isPortable = true;
                 break;
             case Qz::CL_NewTab:
                 messages.append(QLatin1String("ACTION:NewTab"));
                 m_postLaunchActions.append(OpenNewTab);
                 break;
             case Qz::CL_NewWindow:
                 messages.append(QLatin1String("ACTION:NewWindow"));
                 break;
             case Qz::CL_ToggleFullScreen:
                 messages.append(QLatin1String("ACTION:ToggleFullScreen"));
                 m_postLaunchActions.append(ToggleFullScreen);
                 break;
             case Qz::CL_ShowDownloadManager:
                 messages.append(QLatin1String("ACTION:ShowDownloadManager"));
                 m_postLaunchActions.append(OpenDownloadManager);
                 break;
             case Qz::CL_StartPrivateBrowsing:
                 m_isPrivate = true;
                 break;
             case Qz::CL_StartNewInstance:
                 newInstance = true;
                 break;
             case Qz::CL_OpenUrlInCurrentTab:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("ACTION:OpenUrlInCurrentTab" + pair.text);
                 break;
             case Qz::CL_OpenUrlInNewWindow:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("ACTION:OpenUrlInNewWindow" + pair.text);
                 break;
             case Qz::CL_OpenUrl:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("URL:" + pair.text);
                 break;
             case Qz::CL_ExitAction:
                 m_isClosing = true;
                 return;
             default:
                 break;
             }
         }
     }
 
     if (isPortable()) {
         std::cout << "Falkon: Running in Portable Mode." << std::endl;
         DataPaths::setPortableVersion();
     }
 
     // Don't start single application in private browsing
     if (!isPrivate()) {
         QString appId = QLatin1String("FalkonWebBrowser");
 
         if (isPortable()) {
             appId.append(QLatin1String("Portable"));
         }
 
         if (newInstance) {
             if (startProfile.isEmpty() || startProfile == QLatin1String("default")) {
                 std::cout << "New instance cannot be started with default profile!" << std::endl;
             }
             else {
                 // Generate unique appId so it is possible to start more separate instances
                 // of the same profile. It is dangerous to run more instances of the same profile,
                 // but if the user wants it, we should allow it.
                 appId.append(startProfile + QString::number(QDateTime::currentMSecsSinceEpoch()));
             }
         }
 
         setAppId(appId);
     }
 
     // If there is nothing to tell other instance, we need to at least wake it
     if (messages.isEmpty()) {
         messages.append(QLatin1String(" "));
     }
 
     if (isRunning()) {
         m_isClosing = true;
         foreach (const QString &message, messages) {
             sendMessage(message);
         }
         return;
     }
 
 #ifdef Q_OS_MACOS
     setQuitOnLastWindowClosed(false);
     // disable tabbing issue#2261
     extern void disableWindowTabbing();
     disableWindowTabbing();
 #else
     setQuitOnLastWindowClosed(true);
 #endif
 
     QSettings::setDefaultFormat(QSettings::IniFormat);
     QDesktopServices::setUrlHandler(QSL("http"), this, "addNewTab");
     QDesktopServices::setUrlHandler(QSL("https"), this, "addNewTab");
     QDesktopServices::setUrlHandler(QSL("ftp"), this, "addNewTab");
 
     ProfileManager profileManager;
     profileManager.initConfigDir();
     profileManager.initCurrentProfile(startProfile);
 
     Settings::createSettings(DataPaths::currentProfilePath() + QLatin1String("/settings.ini"));
 
     m_webProfile = isPrivate() ? new QWebEngineProfile(this) : QWebEngineProfile::defaultProfile();
     connect(m_webProfile, &QWebEngineProfile::downloadRequested, this, &MainApplication::downloadRequested);
 
     m_networkManager = new NetworkManager(this);
 
     // Setup QWebChannel userscript
     QWebEngineScript script;
     script.setName(QSL("_falkon_webchannel"));
     script.setInjectionPoint(QWebEngineScript::DocumentCreation);
     script.setWorldId(QWebEngineScript::MainWorld);
     script.setRunsOnSubFrames(true);
     script.setSourceCode(Scripts::setupWebChannel());
     m_webProfile->scripts()->insert(script);
 
     if (!isPrivate()) {
         m_sessionManager = new SessionManager(this);
         m_autoSaver = new AutoSaver(this);
         connect(m_autoSaver, SIGNAL(save()), m_sessionManager, SLOT(autoSaveLastSession()));
 
         Settings settings;
         settings.beginGroup(QSL("SessionRestore"));
         const bool wasRunning = settings.value(QSL("isRunning"), false).toBool();
         const bool wasRestoring = settings.value(QSL("isRestoring"), false).toBool();
         settings.setValue(QSL("isRunning"), true);
         settings.setValue(QSL("isRestoring"), wasRunning);
         settings.endGroup();
         settings.sync();
 
         m_isStartingAfterCrash = wasRunning && wasRestoring;
 
         if (wasRunning) {
             QTimer::singleShot(60 * 1000, this, [this]() {
                 Settings().setValue(QSL("SessionRestore/isRestoring"), false);
             });
         }
 
         // we have to ask about startup session before creating main window
         if (!m_isStartingAfterCrash && afterLaunch() == SelectSession)
             m_restoreManager = new RestoreManager(sessionManager()->askSessionFromUser());
     }
 
     translateApp();
     loadSettings();
 
     m_plugins = new PluginProxy;
     m_autoFill = new AutoFill(this);
-    new AdBlockPlugin(this);
 
     if (!noAddons)
         m_plugins->loadPlugins();
 
     BrowserWindow* window = createWindow(Qz::BW_FirstAppWindow, startUrl);
     connect(window, SIGNAL(startingCompleted()), this, SLOT(restoreOverrideCursor()));
 
     connect(this, SIGNAL(focusChanged(QWidget*,QWidget*)), this, SLOT(onFocusChanged()));
 
     if (!isPrivate()) {
 #ifndef DISABLE_CHECK_UPDATES
         Settings settings;
         bool checkUpdates = settings.value("Web-Browser-Settings/CheckUpdates", true).toBool();
 
         if (checkUpdates) {
             new Updater(window);
         }
 #endif
 
         sessionManager()->backupSavedSessions();
 
         if (m_isStartingAfterCrash || afterLaunch() == RestoreSession) {
             m_restoreManager = new RestoreManager(sessionManager()->lastActiveSessionPath());
             if (!m_restoreManager->isValid()) {
                 destroyRestoreManager();
             }
         }
 
         if (!m_isStartingAfterCrash && m_restoreManager) {
             restoreSession(window, m_restoreManager->restoreData());
         }
     }
 
     QTimer::singleShot(0, this, SLOT(postLaunch()));
 }
 
 MainApplication::~MainApplication()
 {
     IconProvider::instance()->saveIconsToDatabase();
 
     // Wait for all QtConcurrent jobs to finish
     QThreadPool::globalInstance()->waitForDone();
 
     // Delete all classes that are saving data in destructor
     delete m_bookmarks;
     delete m_cookieJar;
     delete m_plugins;
 
     Settings::syncSettings();
 }
 
 bool MainApplication::isClosing() const
 {
     return m_isClosing;
 }
 
 bool MainApplication::isPrivate() const
 {
     return m_isPrivate;
 }
 
 bool MainApplication::isPortable() const
 {
 #ifdef PORTABLE_BUILD
     return true;
 #else
     return m_isPortable;
 #endif
 }
 
 bool MainApplication::isStartingAfterCrash() const
 {
     return m_isStartingAfterCrash;
 }
 
 int MainApplication::windowCount() const
 {
     return m_windows.count();
 }
 
 QList<BrowserWindow*> MainApplication::windows() const
 {
     return m_windows;
 }
 
 BrowserWindow* MainApplication::getWindow() const
 {
     if (m_lastActiveWindow) {
         return m_lastActiveWindow.data();
     }
 
     return m_windows.isEmpty() ? 0 : m_windows.at(0);
 }
 
 BrowserWindow* MainApplication::createWindow(Qz::BrowserWindowType type, const QUrl &startUrl)
 {
     if (windowCount() == 0 && type != Qz::BW_MacFirstWindow) {
         type = Qz::BW_FirstAppWindow;
     }
 
     BrowserWindow* window = new BrowserWindow(type, startUrl);
     connect(window, SIGNAL(destroyed(QObject*)), this, SLOT(windowDestroyed(QObject*)));
 
     m_windows.prepend(window);
     return window;
 }
 
 MainApplication::AfterLaunch MainApplication::afterLaunch() const
 {
     return static_cast<AfterLaunch>(Settings().value(QSL("Web-URL-Settings/afterLaunch"), RestoreSession).toInt());
 }
 
 void MainApplication::openSession(BrowserWindow* window, RestoreData &restoreData)
 {
     setOverrideCursor(Qt::BusyCursor);
 
     if (!window)
         window = createWindow(Qz::BW_OtherRestoredWindow);
 
     if (window->tabCount() != 0) {
         // This can only happen when recovering crashed session!
         // Don't restore tabs in current window as user already opened some new tabs.
         createWindow(Qz::BW_OtherRestoredWindow)->restoreWindow(restoreData.windows.takeAt(0));
     } else {
         window->restoreWindow(restoreData.windows.takeAt(0));
     }
 
     foreach (const BrowserWindow::SavedWindow &data, restoreData.windows) {
         BrowserWindow* window = createWindow(Qz::BW_OtherRestoredWindow);
         window->restoreWindow(data);
     }
 
     m_closedWindowsManager->restoreState(restoreData.closedWindows);
 
     restoreOverrideCursor();
 }
 
 bool MainApplication::restoreSession(BrowserWindow* window, RestoreData restoreData)
 {
     if (m_isPrivate || !restoreData.isValid()) {
         return false;
     }
 
     openSession(window, restoreData);
 
     m_restoreManager->clearRestoreData();
     destroyRestoreManager();
 
     return true;
 }
 
 void MainApplication::destroyRestoreManager()
 {
     if (m_restoreManager && m_restoreManager->isValid()) {
         return;
     }
 
     delete m_restoreManager;
     m_restoreManager = 0;
 }
 
 void MainApplication::reloadSettings()
 {
     loadSettings();
     emit settingsReloaded();
 }
 
 QString MainApplication::styleName() const
 {
     return m_proxyStyle ? m_proxyStyle->name() : QString();
 }
 
 void MainApplication::setProxyStyle(ProxyStyle *style)
 {
     m_proxyStyle = style;
     setStyle(style);
 }
 
 QString MainApplication::currentLanguageFile() const
 {
     return m_languageFile;
 }
 
 QString MainApplication::currentLanguage() const
 {
     QString lang = m_languageFile;
 
     if (lang.isEmpty()) {
         return "en_US";
     }
 
     return lang.left(lang.length() - 3);
 }
 
 History* MainApplication::history()
 {
     if (!m_history) {
         m_history = new History(this);
     }
     return m_history;
 }
 
 Bookmarks* MainApplication::bookmarks()
 {
     if (!m_bookmarks) {
         m_bookmarks = new Bookmarks(this);
     }
     return m_bookmarks;
 }
 
 AutoFill* MainApplication::autoFill()
 {
     return m_autoFill;
 }
 
 CookieJar* MainApplication::cookieJar()
 {
     if (!m_cookieJar) {
         m_cookieJar = new CookieJar(this);
     }
     return m_cookieJar;
 }
 
 PluginProxy* MainApplication::plugins()
 {
     return m_plugins;
 }
 
 BrowsingLibrary* MainApplication::browsingLibrary()
 {
     if (!m_browsingLibrary) {
         m_browsingLibrary = new BrowsingLibrary(getWindow());
     }
     return m_browsingLibrary;
 }
 
 NetworkManager *MainApplication::networkManager()
 {
     return m_networkManager;
 }
 
 RestoreManager* MainApplication::restoreManager()
 {
     return m_restoreManager;
 }
 
 SessionManager* MainApplication::sessionManager()
 {
     return m_sessionManager;
 }
 
 DownloadManager* MainApplication::downloadManager()
 {
     if (!m_downloadManager) {
         m_downloadManager = new DownloadManager();
     }
     return m_downloadManager;
 }
 
 UserAgentManager* MainApplication::userAgentManager()
 {
     if (!m_userAgentManager) {
         m_userAgentManager = new UserAgentManager(this);
     }
     return m_userAgentManager;
 }
 
 SearchEnginesManager* MainApplication::searchEnginesManager()
 {
     if (!m_searchEnginesManager) {
         m_searchEnginesManager = new SearchEnginesManager(this);
     }
     return m_searchEnginesManager;
 }
 
 ClosedWindowsManager* MainApplication::closedWindowsManager()
 {
     if (!m_closedWindowsManager) {
         m_closedWindowsManager = new ClosedWindowsManager(this);
     }
     return m_closedWindowsManager;
 }
 
 HTML5PermissionsManager* MainApplication::html5PermissionsManager()
 {
     if (!m_html5PermissionsManager) {
         m_html5PermissionsManager = new HTML5PermissionsManager(this);
     }
     return m_html5PermissionsManager;
 }
 
 DesktopNotificationsFactory* MainApplication::desktopNotifications()
 {
     if (!m_desktopNotifications) {
         m_desktopNotifications = new DesktopNotificationsFactory(this);
     }
     return m_desktopNotifications;
 }
 
 QWebEngineProfile *MainApplication::webProfile() const
 {
     return m_webProfile;
 }
 
 QWebEngineSettings *MainApplication::webSettings() const
 {
     return m_webProfile->settings();
 }
 
 // static
 MainApplication* MainApplication::instance()
 {
     return static_cast<MainApplication*>(QCoreApplication::instance());
 }
 
 void MainApplication::addNewTab(const QUrl &url)
 {
     BrowserWindow* window = getWindow();
 
     if (window) {
         window->tabWidget()->addView(url, url.isEmpty() ? Qz::NT_SelectedNewEmptyTab : Qz::NT_SelectedTabAtTheEnd);
     }
 }
 
 void MainApplication::startPrivateBrowsing(const QUrl &startUrl)
 {
     QUrl url = startUrl;
     if (QAction* act = qobject_cast<QAction*>(sender())) {
         url = act->data().toUrl();
     }
 
     QStringList args;
     args.append(QSL("--private-browsing"));
     args.append(QSL("--profile=") + ProfileManager::currentProfile());
 
     if (!url.isEmpty()) {
         args << url.toEncoded();
     }
 
     if (!QProcess::startDetached(applicationFilePath(), args)) {
         qWarning() << "MainApplication: Cannot start new browser process for private browsing!" << applicationFilePath() << args;
     }
 }
 
 void MainApplication::reloadUserStyleSheet()
 {
     const QString userCssFile = Settings().value("Web-Browser-Settings/userStyleSheet", QString()).toString();
     setUserStyleSheet(userCssFile);
 }
 
 void MainApplication::restoreOverrideCursor()
 {
     QApplication::restoreOverrideCursor();
 }
 
 void MainApplication::changeOccurred()
 {
     if (m_autoSaver)
         m_autoSaver->changeOccurred();
 }
 
 void MainApplication::quitApplication()
 {
     if (m_downloadManager && !m_downloadManager->canClose()) {
         m_downloadManager->show();
         return;
     }
 
     if (m_sessionManager && m_windows.count() > 0) {
         m_sessionManager->autoSaveLastSession();
     }
 
     m_isClosing = true;
 
     for (BrowserWindow *window : qAsConst(m_windows)) {
         window->close();
     }
 
     // Saving settings in saveSettings() slot called from quit() so
     // everything gets saved also when quitting application in other
     // way than clicking Quit action in File menu or closing last window
     // eg. on Mac (#157)
 
     if (!isPrivate()) {
         removeLockFile();
     }
 
     quit();
 }
 
 void MainApplication::postLaunch()
 {
     if (m_postLaunchActions.contains(OpenDownloadManager)) {
         downloadManager()->show();
     }
 
     if (m_postLaunchActions.contains(OpenNewTab)) {
         getWindow()->tabWidget()->addView(QUrl(), Qz::NT_SelectedNewEmptyTab);
     }
 
     if (m_postLaunchActions.contains(ToggleFullScreen)) {
         getWindow()->toggleFullScreen();
     }
 
     QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, DataPaths::currentProfilePath());
 
     connect(this, SIGNAL(messageReceived(QString)), this, SLOT(messageReceived(QString)));
     connect(this, SIGNAL(aboutToQuit()), this, SLOT(saveSettings()));
 
     createJumpList();
     initPulseSupport();
 
     QTimer::singleShot(5000, this, &MainApplication::runDeferredPostLaunchActions);
 }
 
 QByteArray MainApplication::saveState() const
 {
     RestoreData restoreData;
     restoreData.windows.reserve(m_windows.count());
     for (BrowserWindow *window : qAsConst(m_windows)) {
         restoreData.windows.append(BrowserWindow::SavedWindow(window));
     }
 
     if (m_restoreManager && m_restoreManager->isValid()) {
         QDataStream stream(&restoreData.crashedSession, QIODevice::WriteOnly);
         stream << m_restoreManager->restoreData();
     }
 
     restoreData.closedWindows = m_closedWindowsManager->saveState();
 
     QByteArray data;
     QDataStream stream(&data, QIODevice::WriteOnly);
 
     stream << Qz::sessionVersion;
     stream << restoreData;
 
     return data;
 }
 
 void MainApplication::saveSettings()
 {
     if (isPrivate()) {
         return;
     }
 
     m_isClosing = true;
 
     Settings settings;
     settings.beginGroup("SessionRestore");
     settings.setValue("isRunning", false);
     settings.setValue("isRestoring", false);
     settings.endGroup();
 
     settings.beginGroup("Web-Browser-Settings");
     bool deleteCache = settings.value("deleteCacheOnClose", false).toBool();
     bool deleteHistory = settings.value("deleteHistoryOnClose", false).toBool();
     bool deleteHtml5Storage = settings.value("deleteHTML5StorageOnClose", false).toBool();
     settings.endGroup();
 
     settings.beginGroup("Cookie-Settings");
     bool deleteCookies = settings.value("deleteCookiesOnClose", false).toBool();
     settings.endGroup();
 
     if (deleteHistory) {
         m_history->clearHistory();
     }
     if (deleteHtml5Storage) {
         ClearPrivateData::clearLocalStorage();
     }
     if (deleteCookies) {
         m_cookieJar->deleteAllCookies();
     }
     if (deleteCache) {
         QzTools::removeDir(mApp->webProfile()->cachePath());
     }
 
     m_searchEnginesManager->saveSettings();
     m_plugins->shutdown();
     m_networkManager->shutdown();
 
     qzSettings->saveSettings();
     QFile::remove(DataPaths::currentProfilePath() + QLatin1String("/WebpageIcons.db"));
 
     sessionManager()->saveSettings();
 }
 
 void MainApplication::messageReceived(const QString &message)
 {
     QWidget* actWin = getWindow();
     QUrl actUrl;
 
     if (message.startsWith(QLatin1String("URL:"))) {
         const QUrl url = QUrl::fromUserInput(message.mid(4));
         addNewTab(url);
         actWin = getWindow();
     }
     else if (message.startsWith(QLatin1String("ACTION:"))) {
         const QString text = message.mid(7);
         if (text == QLatin1String("NewTab")) {
             addNewTab();
         }
         else if (text == QLatin1String("NewWindow")) {
             actWin = createWindow(Qz::BW_NewWindow);
         }
         else if (text == QLatin1String("ShowDownloadManager")) {
             downloadManager()->show();
             actWin = downloadManager();
         }
         else if (text == QLatin1String("ToggleFullScreen") && actWin) {
             BrowserWindow* qz = static_cast<BrowserWindow*>(actWin);
             qz->toggleFullScreen();
         }
         else if (text.startsWith(QLatin1String("OpenUrlInCurrentTab"))) {
             actUrl = QUrl::fromUserInput(text.mid(19));
         }
         else if (text.startsWith(QLatin1String("OpenUrlInNewWindow"))) {
             createWindow(Qz::BW_NewWindow, QUrl::fromUserInput(text.mid(18)));
             return;
         }
     }
     else {
         // User attempted to start another instance, let's open a new window
         actWin = createWindow(Qz::BW_NewWindow);
     }
 
     if (!actWin) {
         if (!isClosing()) {
             // It can only occur if download manager window was still opened
             createWindow(Qz::BW_NewWindow, actUrl);
         }
         return;
     }
 
     actWin->setWindowState(actWin->windowState() & ~Qt::WindowMinimized);
     actWin->raise();
     actWin->activateWindow();
     actWin->setFocus();
 
     BrowserWindow* win = qobject_cast<BrowserWindow*>(actWin);
 
     if (win && !actUrl.isEmpty()) {
         win->loadAddress(actUrl);
     }
 }
 
 void MainApplication::windowDestroyed(QObject* window)
 {
     // qobject_cast doesn't work because QObject::destroyed is emitted from destructor
     Q_ASSERT(static_cast<BrowserWindow*>(window));
     Q_ASSERT(m_windows.contains(static_cast<BrowserWindow*>(window)));
 
     m_windows.removeOne(static_cast<BrowserWindow*>(window));
 }
 
 void MainApplication::onFocusChanged()
 {
     BrowserWindow* activeBrowserWindow = qobject_cast<BrowserWindow*>(activeWindow());
 
     if (activeBrowserWindow) {
         m_lastActiveWindow = activeBrowserWindow;
 
         emit activeWindowChanged(m_lastActiveWindow);
     }
 }
 
 void MainApplication::runDeferredPostLaunchActions()
 {
     checkDefaultWebBrowser();
     checkOptimizeDatabase();
 }
 
 void MainApplication::downloadRequested(QWebEngineDownloadItem *download)
 {
     downloadManager()->download(download);
 }
 
 void MainApplication::loadSettings()
 {
     Settings settings;
     settings.beginGroup("Themes");
     QString activeTheme = settings.value("activeTheme", DEFAULT_THEME_NAME).toString();
     settings.endGroup();
 
     loadTheme(activeTheme);
 
     QWebEngineSettings* webSettings = m_webProfile->settings();
 
     // Web browsing settings
     settings.beginGroup("Web-Browser-Settings");
 
     webSettings->setAttribute(QWebEngineSettings::LocalStorageEnabled, settings.value("HTML5StorageEnabled", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::PluginsEnabled, settings.value("allowPlugins", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptEnabled, settings.value("allowJavaScript", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptCanOpenWindows, settings.value("allowJavaScriptOpenWindow", false).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptCanAccessClipboard, settings.value("allowJavaScriptAccessClipboard", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::LinksIncludedInFocusChain, settings.value("IncludeLinkInFocusChain", false).toBool());
     webSettings->setAttribute(QWebEngineSettings::XSSAuditingEnabled, settings.value("XSSAuditing", false).toBool());
     webSettings->setAttribute(QWebEngineSettings::PrintElementBackgrounds, settings.value("PrintElementBackground", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::SpatialNavigationEnabled, settings.value("SpatialNavigation", false).toBool());
     webSettings->setAttribute(QWebEngineSettings::ScrollAnimatorEnabled, settings.value("AnimateScrolling", true).toBool());
     webSettings->setAttribute(QWebEngineSettings::HyperlinkAuditingEnabled, false);
     webSettings->setAttribute(QWebEngineSettings::FullScreenSupportEnabled, true);
     webSettings->setAttribute(QWebEngineSettings::LocalContentCanAccessRemoteUrls, true);
     webSettings->setAttribute(QWebEngineSettings::FocusOnNavigationEnabled, false);
 
     webSettings->setDefaultTextEncoding(settings.value("DefaultEncoding", webSettings->defaultTextEncoding()).toString());
 
     setWheelScrollLines(settings.value("wheelScrollLines", wheelScrollLines()).toInt());
 
     const QString userCss = settings.value("userStyleSheet", QString()).toString();
     settings.endGroup();
 
     setUserStyleSheet(userCss);
 
     settings.beginGroup("Browser-Fonts");
     webSettings->setFontFamily(QWebEngineSettings::StandardFont, settings.value("StandardFont", webSettings->fontFamily(QWebEngineSettings::StandardFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::CursiveFont, settings.value("CursiveFont", webSettings->fontFamily(QWebEngineSettings::CursiveFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::FantasyFont, settings.value("FantasyFont", webSettings->fontFamily(QWebEngineSettings::FantasyFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::FixedFont, settings.value("FixedFont", webSettings->fontFamily(QWebEngineSettings::FixedFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::SansSerifFont, settings.value("SansSerifFont", webSettings->fontFamily(QWebEngineSettings::SansSerifFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::SerifFont, settings.value("SerifFont", webSettings->fontFamily(QWebEngineSettings::SerifFont)).toString());
     webSettings->setFontSize(QWebEngineSettings::DefaultFontSize, settings.value("DefaultFontSize", 15).toInt());
     webSettings->setFontSize(QWebEngineSettings::DefaultFixedFontSize, settings.value("FixedFontSize", 14).toInt());
     webSettings->setFontSize(QWebEngineSettings::MinimumFontSize, settings.value("MinimumFontSize", 3).toInt());
     webSettings->setFontSize(QWebEngineSettings::MinimumLogicalFontSize, settings.value("MinimumLogicalFontSize", 5).toInt());
     settings.endGroup();
 
     QWebEngineProfile* profile = QWebEngineProfile::defaultProfile();
     profile->setPersistentCookiesPolicy(QWebEngineProfile::AllowPersistentCookies);
     profile->setPersistentStoragePath(DataPaths::currentProfilePath());
 
     QString defaultPath = DataPaths::path(DataPaths::Cache);
     if (!defaultPath.startsWith(DataPaths::currentProfilePath()))
         defaultPath.append(QLatin1Char('/') + ProfileManager::currentProfile());
     const QString &cachePath = settings.value("Web-Browser-Settings/CachePath", defaultPath).toString();
     profile->setCachePath(cachePath);
 
     const bool allowCache = settings.value(QSL("Web-Browser-Settings/AllowLocalCache"), true).toBool();
     profile->setHttpCacheType(allowCache ? QWebEngineProfile::DiskHttpCache : QWebEngineProfile::MemoryHttpCache);
 
     const int cacheSize = settings.value(QSL("Web-Browser-Settings/LocalCacheSize"), 50).toInt() * 1000 * 1000;
     profile->setHttpCacheMaximumSize(cacheSize);
 
     settings.beginGroup(QSL("SpellCheck"));
     profile->setSpellCheckEnabled(settings.value(QSL("Enabled"), false).toBool());
     profile->setSpellCheckLanguages(settings.value(QSL("Languages")).toStringList());
     settings.endGroup();
 
     if (isPrivate()) {
         webSettings->setAttribute(QWebEngineSettings::LocalStorageEnabled, false);
         history()->setSaving(false);
     }
 
     if (m_downloadManager) {
         m_downloadManager->loadSettings();
     }
 
     qzSettings->loadSettings();
     networkManager()->loadSettings();
     userAgentManager()->loadSettings();
 }
 
 void MainApplication::loadTheme(const QString &name)
 {
     QString activeThemePath;
     const QStringList themePaths = DataPaths::allPaths(DataPaths::Themes);
 
     foreach (const QString &path, themePaths) {
         const QString theme = QString("%1/%2").arg(path, name);
         if (QFile::exists(theme + QLatin1String("/main.css"))) {
             activeThemePath = theme;
             break;
         }
     }
 
     if (activeThemePath.isEmpty()) {
         qWarning() << "Cannot load theme " << name;
         activeThemePath = QString("%1/%2").arg(DataPaths::path(DataPaths::Themes), DEFAULT_THEME_NAME);
     }
 
     QString qss = QzTools::readAllFileContents(activeThemePath + QLatin1String("/main.css"));
 
 #if defined(Q_OS_MACOS)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/mac.css")));
 #elif defined(Q_OS_UNIX)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/linux.css")));
 #elif defined(Q_OS_WIN) || defined(Q_OS_OS2)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/windows.css")));
 #endif
 
     if (isRightToLeft()) {
         qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/rtl.css")));
     }
 
     qss.append(QzTools::readAllFileContents(DataPaths::currentProfilePath() + QL1S("/userChrome.css")));
 
     QString relativePath = QDir::current().relativeFilePath(activeThemePath);
     qss.replace(QzRegExp(QSL("url\\s*\\(\\s*([^\\*:\\);]+)\\s*\\)"), Qt::CaseSensitive), QString("url(%1/\\1)").arg(relativePath));
     setStyleSheet(qss);
 }
 
 void MainApplication::translateApp()
 {
     QString file = Settings().value(QSL("Language/language"), QLocale::system().name()).toString();
 
     // It can only be "C" locale, for which we will use default English language
     if (file.size() < 2)
         file.clear();
 
     if (!file.isEmpty() && !file.endsWith(QL1S(".qm")))
         file.append(QL1S(".qm"));
 
     // Either we load default language (with empty file), or we attempt to load xx.qm (xx_yy.qm)
     Q_ASSERT(file.isEmpty() || file.size() >= 5);
 
     QString translationPath = DataPaths::path(DataPaths::Translations);
 
     if (!file.isEmpty()) {
         const QStringList translationsPaths = DataPaths::allPaths(DataPaths::Translations);
 
         foreach (const QString &path, translationsPaths) {
             // If "xx_yy" translation doesn't exists, try to use "xx*" translation
             // It can only happen when language is chosen from system locale
 
             if (!QFile(QString("%1/%2").arg(path, file)).exists()) {
                 QDir dir(path);
                 QString lang = file.left(2) + QL1S("*.qm");
 
                 const QStringList translations = dir.entryList(QStringList(lang));
 
                 // If no translation can be found, default English will be used
                 file = translations.isEmpty() ? QString() : translations.at(0);
             }
 
             if (!file.isEmpty() && QFile(QString("%1/%2").arg(path, file)).exists()) {
                 translationPath = path;
                 break;
             }
         }
     }
 
     // Load application translation
     QTranslator* app = new QTranslator(this);
     app->load(file, translationPath);
 
     // Load Qt translation (first try to load from Qt path)
     QTranslator* sys = new QTranslator(this);
     sys->load(QL1S("qt_") + file, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
 
     // If there is no translation in Qt path for specified language, try to load it from our path
     if (sys->isEmpty()) {
         sys->load(QL1S("qt_") + file, translationPath);
     }
 
     m_languageFile = file;
 
     installTranslator(app);
     installTranslator(sys);
 }
 
 void MainApplication::checkDefaultWebBrowser()
 {
     if (isPortable()) {
         return;
     }
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
     Settings settings;
     bool checkNow = settings.value("Web-Browser-Settings/CheckDefaultBrowser", DEFAULT_CHECK_DEFAULTBROWSER).toBool();
 
     if (!checkNow) {
         return;
     }
 
     bool checkAgain = true;
 
     if (!associationManager()->isDefaultForAllCapabilities()) {
         CheckBoxDialog dialog(QMessageBox::Yes | QMessageBox::No, getWindow());
         dialog.setDefaultButton(QMessageBox::Yes);
         dialog.setText(tr("Falkon is not currently your default browser. Would you like to make it your default browser?"));
         dialog.setCheckBoxText(tr("Always perform this check when starting Falkon."));
         dialog.setDefaultCheckState(Qt::Checked);
         dialog.setWindowTitle(tr("Default Browser"));
         dialog.setIcon(QMessageBox::Warning);
 
         if (dialog.exec() == QMessageBox::Yes) {
             if (!mApp->associationManager()->showNativeDefaultAppSettingsUi())
                 mApp->associationManager()->registerAllAssociation();
         }
 
         checkAgain = dialog.isChecked();
     }
 
     settings.setValue("Web-Browser-Settings/CheckDefaultBrowser", checkAgain);
 #endif
 }
 
 void MainApplication::checkOptimizeDatabase()
 {
     Settings settings;
     settings.beginGroup(QSL("Browser"));
     const int numberOfRuns = settings.value(QSL("RunsWithoutOptimizeDb"), 0).toInt();
     settings.setValue(QSL("RunsWithoutOptimizeDb"), numberOfRuns + 1);
 
     if (numberOfRuns > 20) {
         std::cout << "Optimizing database..." << std::endl;
         IconProvider::instance()->clearOldIconsInDatabase();
         settings.setValue(QSL("RunsWithoutOptimizeDb"), 0);
     }
 
     settings.endGroup();
 }
 
 void MainApplication::setUserStyleSheet(const QString &filePath)
 {
     QString userCss;
 
 #if !defined(Q_OS_UNIX) && !defined(Q_OS_MACOS)
     // Don't grey out selection on losing focus (to prevent graying out found text)
     QString highlightColor;
     QString highlightedTextColor;
 #ifdef Q_OS_MACOS
     highlightColor = QLatin1String("#b6d6fc");
     highlightedTextColor = QLatin1String("#000");
 #else
     QPalette pal = style()->standardPalette();
     highlightColor = pal.color(QPalette::Highlight).name();
     highlightedTextColor = pal.color(QPalette::HighlightedText).name();
 #endif
     userCss += QString("::selection {background: %1; color: %2;} ").arg(highlightColor, highlightedTextColor);
 #endif
 
     userCss += QzTools::readAllFileContents(filePath).remove(QLatin1Char('\n'));
 
     const QString name = QStringLiteral("_falkon_userstylesheet");
 
     QWebEngineScript oldScript = m_webProfile->scripts()->findScript(name);
     if (!oldScript.isNull()) {
         m_webProfile->scripts()->remove(oldScript);
     }
 
     if (userCss.isEmpty())
         return;
 
     QWebEngineScript script;
     script.setName(name);
     script.setInjectionPoint(QWebEngineScript::DocumentReady);
     script.setWorldId(WebPage::SafeJsWorld);
     script.setRunsOnSubFrames(true);
     script.setSourceCode(Scripts::setCss(userCss));
     m_webProfile->scripts()->insert(script);
 }
 
 void MainApplication::createJumpList()
 {
 #ifdef Q_OS_WIN
     QWinJumpList *jumpList = new QWinJumpList(this);
     jumpList->clear();
 
     // Frequent
     QWinJumpListCategory *frequent = jumpList->frequent();
     frequent->setVisible(true);
     const QVector<HistoryEntry> mostList = m_history->mostVisited(7);
     for (const HistoryEntry &entry : mostList) {
         frequent->addLink(IconProvider::iconForUrl(entry.url), entry.title, applicationFilePath(), QStringList{entry.url.toEncoded()});
     }
 
     // Tasks
     QWinJumpListCategory *tasks = jumpList->tasks();
     tasks->setVisible(true);
     tasks->addLink(IconProvider::newTabIcon(), tr("Open new tab"), applicationFilePath(), {QSL("--new-tab")});
     tasks->addLink(IconProvider::newWindowIcon(), tr("Open new window"), applicationFilePath(), {QSL("--new-window")});
     tasks->addLink(IconProvider::privateBrowsingIcon(), tr("Open new private window"), applicationFilePath(), {QSL("--private-browsing")});
 #endif
 }
 
 void MainApplication::initPulseSupport()
 {
     qputenv("PULSE_PROP_OVERRIDE_application.name", "Falkon");
     qputenv("PULSE_PROP_OVERRIDE_application.icon_name", "qupzilla");
     qputenv("PULSE_PROP_OVERRIDE_media.icon_name", "qupzilla");
 }
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
 RegisterQAppAssociation* MainApplication::associationManager()
 {
     if (!m_registerQAppAssociation) {
         QString desc = tr("Falkon is a new, fast and secure open-source WWW browser. Falkon is licensed under GPL version 3 or (at your option) any later version. It is based on WebKit core and Qt Framework.");
         QString fileIconPath = QApplication::applicationFilePath() + ",1";
         QString appIconPath = QApplication::applicationFilePath() + ",0";
         m_registerQAppAssociation = new RegisterQAppAssociation("Falkon", QApplication::applicationFilePath(), appIconPath, desc, this);
         m_registerQAppAssociation->addCapability(".html", "Falkon.HTML", "HTML File", fileIconPath, RegisterQAppAssociation::FileAssociation);
         m_registerQAppAssociation->addCapability(".htm", "Falkon.HTM", "HTM File", fileIconPath, RegisterQAppAssociation::FileAssociation);
         m_registerQAppAssociation->addCapability("http", "Falkon.HTTP", "URL:HyperText Transfer Protocol", appIconPath, RegisterQAppAssociation::UrlAssociation);
         m_registerQAppAssociation->addCapability("https", "Falkon.HTTPS", "URL:HyperText Transfer Protocol with Privacy", appIconPath, RegisterQAppAssociation::UrlAssociation);
     }
     return m_registerQAppAssociation;
 }
 #endif
 
 #ifdef Q_OS_MACOS
 #include <QFileOpenEvent>
 
 bool MainApplication::event(QEvent* e)
 {
     switch (e->type()) {
     case QEvent::FileOpen: {
         QFileOpenEvent *ev = static_cast<QFileOpenEvent*>(e);
         if (!ev->url().isEmpty()) {
             addNewTab(ev->url());
         } else if (!ev->file().isEmpty()) {
             addNewTab(QUrl::fromLocalFile(ev->file()));
         } else {
             return false;
         }
         return true;
     }
 
     case QEvent::ApplicationActivate:
         if (!activeWindow() && m_windows.isEmpty())
             createWindow(Qz::BW_NewWindow);
         break;
 
     default:
         break;
     }
 
     return QtSingleApplication::event(e);
 }
 #endif
diff --git a/src/lib/plugins/plugins.cpp b/src/lib/plugins/plugins.cpp
index 10b4dfd4..c066440f 100644
--- a/src/lib/plugins/plugins.cpp
+++ b/src/lib/plugins/plugins.cpp
@@ -1,235 +1,242 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "pluginproxy.h"
 #include "plugininterface.h"
 #include "mainapplication.h"
 #include "speeddial.h"
 #include "settings.h"
 #include "datapaths.h"
+#include "adblock/adblockplugin.h"
 
 #include <iostream>
 #include <QPluginLoader>
 #include <QDir>
 
 Plugins::Plugins(QObject* parent)
     : QObject(parent)
     , m_pluginsLoaded(false)
     , m_speedDial(new SpeedDial(this))
 {
     loadSettings();
 }
 
 QList<Plugins::Plugin> Plugins::getAvailablePlugins()
 {
     loadAvailablePlugins();
 
     return m_availablePlugins;
 }
 
 bool Plugins::loadPlugin(Plugins::Plugin* plugin)
 {
     if (plugin->isLoaded()) {
         return true;
     }
 
     plugin->pluginLoader->setFileName(plugin->fullPath);
     PluginInterface* iPlugin = qobject_cast<PluginInterface*>(plugin->pluginLoader->instance());
     if (!iPlugin) {
         return false;
     }
 
     m_availablePlugins.removeOne(*plugin);
     plugin->instance = initPlugin(PluginInterface::LateInitState, iPlugin, plugin->pluginLoader);
     m_availablePlugins.prepend(*plugin);
 
     refreshLoadedPlugins();
 
     return plugin->isLoaded();
 }
 
 void Plugins::unloadPlugin(Plugins::Plugin* plugin)
 {
     if (!plugin->isLoaded()) {
         return;
     }
 
     plugin->instance->unload();
     plugin->pluginLoader->unload();
     emit pluginUnloaded(plugin->instance);
 
     m_availablePlugins.removeOne(*plugin);
     plugin->instance = 0;
     m_availablePlugins.append(*plugin);
 
     refreshLoadedPlugins();
 }
 
 void Plugins::loadSettings()
 {
     Settings settings;
     settings.beginGroup("Plugin-Settings");
     m_pluginsEnabled = settings.value("EnablePlugins", !mApp->isPortable()).toBool();
     m_allowedPlugins = settings.value("AllowedPlugins", QStringList()).toStringList();
     settings.endGroup();
 
     // Plugins are saved with relative path in portable mode
 #ifdef NO_SYSTEM_DATAPATH
     if (true) {
 #else
     if (mApp->isPortable()) {
 #endif
         QDir dir(DataPaths::path(DataPaths::Plugins));
         for (int i = 0; i < m_allowedPlugins.count(); ++i)
             m_allowedPlugins[i] = dir.absoluteFilePath(QFileInfo(m_allowedPlugins[i]).fileName());
     }
 }
 
 void Plugins::shutdown()
 {
     foreach (PluginInterface* iPlugin, m_loadedPlugins) {
         iPlugin->unload();
     }
 }
 
 void Plugins::loadPlugins()
 {
     if (!m_pluginsEnabled) {
         return;
     }
 
     QDir settingsDir(DataPaths::currentProfilePath() + "/extensions/");
     if (!settingsDir.exists()) {
         settingsDir.mkdir(settingsDir.absolutePath());
     }
 
     foreach (const QString &fullPath, m_allowedPlugins) {
         QPluginLoader* loader = new QPluginLoader(fullPath);
         PluginInterface* iPlugin = qobject_cast<PluginInterface*>(loader->instance());
 
         if (!iPlugin) {
             qWarning() << "Plugins::loadPlugins Loading" << fullPath << "failed:" << loader->errorString();
             continue;
         }
 
         Plugin plugin;
         plugin.fileName = QFileInfo(fullPath).fileName();
         plugin.fullPath = fullPath;
         plugin.pluginLoader = loader;
         plugin.instance = initPlugin(PluginInterface::StartupInitState, iPlugin, loader);
 
         if (plugin.isLoaded()) {
             plugin.pluginSpec = iPlugin->pluginSpec();
-
-            m_loadedPlugins.append(plugin.instance);
             m_availablePlugins.append(plugin);
         }
     }
 
+    // Internal plugins
+    AdBlockPlugin *adBlock = new AdBlockPlugin();
+    if (initPlugin(PluginInterface::StartupInitState, adBlock, nullptr)) {
+        m_internalPlugins.append(adBlock);
+    }
+
     refreshLoadedPlugins();
 
-    std::cout << "Falkon: " << m_loadedPlugins.count() << " extensions loaded"  << std::endl;
+    std::cout << "Falkon: " << (m_loadedPlugins.count() - m_internalPlugins.count()) << " extensions loaded"  << std::endl;
 }
 
 void Plugins::loadAvailablePlugins()
 {
     if (m_pluginsLoaded) {
         return;
     }
 
     m_pluginsLoaded = true;
 
     QStringList dirs = DataPaths::allPaths(DataPaths::Plugins);
 
     // Portable build: Load only plugins from DATADIR/plugins/ directory.
 #ifndef NO_SYSTEM_DATAPATH
     if (mApp->isPortable())
 #endif
         dirs = QStringList(DataPaths::path(DataPaths::Plugins));
 
     foreach (const QString &dir, dirs) {
         QDir pluginsDir = QDir(dir);
         foreach (const QString &fileName, pluginsDir.entryList(QDir::Files)) {
             const QString absolutePath = pluginsDir.absoluteFilePath(fileName);
 
             QPluginLoader* loader = new QPluginLoader(absolutePath);
             PluginInterface* iPlugin = qobject_cast<PluginInterface*>(loader->instance());
 
             if (!iPlugin) {
                 qWarning() << "Plugins::loadAvailablePlugins" << loader->errorString();
                 continue;
             }
 
             Plugin plugin;
             plugin.fileName = fileName;
             plugin.fullPath = absolutePath;
             plugin.pluginSpec = iPlugin->pluginSpec();
             plugin.pluginLoader = loader;
             plugin.instance = 0;
 
             loader->unload();
 
             if (!alreadySpecInAvailable(plugin.pluginSpec)) {
                 m_availablePlugins.append(plugin);
             }
         }
     }
 }
 
 PluginInterface* Plugins::initPlugin(PluginInterface::InitState state, PluginInterface* pluginInterface, QPluginLoader* loader)
 {
     if (!pluginInterface) {
         return 0;
     }
 
     pluginInterface->init(state, DataPaths::currentProfilePath() + QL1S("/extensions"));
 
     if (!pluginInterface->testPlugin()) {
         pluginInterface->unload();
-        loader->unload();
+        if (loader) {
+            loader->unload();
+        }
 
         emit pluginUnloaded(pluginInterface);
 
         return 0;
     }
 
     qApp->installTranslator(pluginInterface->getTranslator(mApp->currentLanguageFile()));
 
     return pluginInterface;
 }
 
 void Plugins::refreshLoadedPlugins()
 {
-    m_loadedPlugins.clear();
+    m_loadedPlugins = m_internalPlugins;
 
     foreach (const Plugin &plugin, m_availablePlugins) {
         if (plugin.isLoaded()) {
             m_loadedPlugins.append(plugin.instance);
         }
     }
 }
 
 bool Plugins::alreadySpecInAvailable(const PluginSpec &spec)
 {
     foreach (const Plugin &plugin, m_availablePlugins) {
         if (plugin.pluginSpec == spec) {
             return true;
         }
     }
 
     return false;
 }
diff --git a/src/lib/plugins/plugins.h b/src/lib/plugins/plugins.h
index f38d68bf..d4ad5025 100644
--- a/src/lib/plugins/plugins.h
+++ b/src/lib/plugins/plugins.h
@@ -1,101 +1,102 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #ifndef PLUGINLOADER_H
 #define PLUGINLOADER_H
 
 #include <QObject>
 #include <QVariant>
 #include <QPointer>
 
 #include "qzcommon.h"
 #include "plugininterface.h"
 
 class QPluginLoader;
 
 class SpeedDial;
 
 class FALKON_EXPORT Plugins : public QObject
 {
     Q_OBJECT
 public:
     struct Plugin {
         QString fileName;
         QString fullPath;
         PluginSpec pluginSpec;
         QPluginLoader* pluginLoader;
         PluginInterface* instance;
 
         Plugin() {
             pluginLoader = 0;
             instance = 0;
         }
 
         bool isLoaded() const {
             return instance;
         }
 
         bool operator==(const Plugin &other) const {
             return (this->fileName == other.fileName &&
                     this->fullPath == other.fullPath &&
                     this->pluginSpec == other.pluginSpec &&
                     this->instance == other.instance);
         }
     };
 
     explicit Plugins(QObject* parent = 0);
 
     QList<Plugin> getAvailablePlugins();
 
     bool loadPlugin(Plugin* plugin);
     void unloadPlugin(Plugin* plugin);
 
     void shutdown();
 
     // SpeedDial
     SpeedDial* speedDial() { return m_speedDial; }
 
 public slots:
     void loadSettings();
 
     void loadPlugins();
 
 protected:
     QList<PluginInterface*> m_loadedPlugins;
 
 signals:
     void pluginUnloaded(PluginInterface* plugin);
 
 private:
     bool alreadySpecInAvailable(const PluginSpec &spec);
     PluginInterface* initPlugin(PluginInterface::InitState state , PluginInterface* pluginInterface, QPluginLoader* loader);
 
     void refreshLoadedPlugins();
     void loadAvailablePlugins();
 
     QList<Plugin> m_availablePlugins;
     QStringList m_allowedPlugins;
 
     bool m_pluginsEnabled;
     bool m_pluginsLoaded;
 
     SpeedDial* m_speedDial;
+    QList<PluginInterface*> m_internalPlugins;
 };
 
 Q_DECLARE_METATYPE(Plugins::Plugin)
 
 #endif // PLUGINLOADER_H
diff --git a/src/lib/webengine/webpage.cpp b/src/lib/webengine/webpage.cpp
index 345e8053..544b13b9 100644
--- a/src/lib/webengine/webpage.cpp
+++ b/src/lib/webengine/webpage.cpp
@@ -1,645 +1,635 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "webpage.h"
 #include "tabbedwebview.h"
 #include "browserwindow.h"
 #include "pluginproxy.h"
 #include "downloadmanager.h"
 #include "mainapplication.h"
 #include "checkboxdialog.h"
 #include "widget.h"
 #include "qztools.h"
 #include "speeddial.h"
 #include "autofill.h"
 #include "popupwebview.h"
 #include "popupwindow.h"
 #include "iconprovider.h"
 #include "qzsettings.h"
 #include "useragentmanager.h"
 #include "delayedfilewatcher.h"
 #include "searchenginesmanager.h"
 #include "html5permissions/html5permissionsmanager.h"
 #include "javascript/externaljsobject.h"
 #include "tabwidget.h"
 #include "networkmanager.h"
 #include "webhittestresult.h"
-#include "adblock/adblockmanager.h"
 #include "ui_jsconfirm.h"
 #include "ui_jsalert.h"
 #include "ui_jsprompt.h"
 
 #include <iostream>
 
 #include <QDir>
 #include <QMouseEvent>
 #include <QWebChannel>
 #include <QWebEngineHistory>
 #include <QWebEngineSettings>
 #include <QTimer>
 #include <QDesktopServices>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QAuthenticator>
 #include <QPushButton>
 
 QString WebPage::s_lastUploadLocation = QDir::homePath();
 QUrl WebPage::s_lastUnsupportedUrl;
 QTime WebPage::s_lastUnsupportedUrlTime;
 
 static const bool kEnableJsOutput = qEnvironmentVariableIsSet("QUPZILLA_ENABLE_JS_OUTPUT");
 static const bool kEnableJsNonBlockDialogs = qEnvironmentVariableIsSet("QUPZILLA_ENABLE_JS_NONBLOCK_DIALOGS");
 
 WebPage::WebPage(QObject* parent)
     : QWebEnginePage(mApp->webProfile(), parent)
     , m_fileWatcher(0)
     , m_runningLoop(0)
     , m_loadProgress(-1)
     , m_blockAlerts(false)
     , m_secureStatus(false)
 {
     QWebChannel *channel = new QWebChannel(this);
     ExternalJsObject::setupWebChannel(channel, this);
     setWebChannel(channel);
 
     connect(this, &QWebEnginePage::loadProgress, this, &WebPage::progress);
     connect(this, &QWebEnginePage::loadFinished, this, &WebPage::finished);
     connect(this, &QWebEnginePage::urlChanged, this, &WebPage::urlChanged);
     connect(this, &QWebEnginePage::featurePermissionRequested, this, &WebPage::featurePermissionRequested);
     connect(this, &QWebEnginePage::windowCloseRequested, this, &WebPage::windowCloseRequested);
     connect(this, &QWebEnginePage::fullScreenRequested, this, &WebPage::fullScreenRequested);
     connect(this, &QWebEnginePage::renderProcessTerminated, this, &WebPage::renderProcessTerminated);
 
     connect(this, &QWebEnginePage::authenticationRequired, this, [this](const QUrl &url, QAuthenticator *auth) {
         mApp->networkManager()->authentication(url, auth, view());
     });
 
     connect(this, &QWebEnginePage::proxyAuthenticationRequired, this, [this](const QUrl &, QAuthenticator *auth, const QString &proxyHost) {
         mApp->networkManager()->proxyAuthentication(proxyHost, auth, view());
     });
 
     // Workaround QWebEnginePage not scrolling to anchors when opened in background tab
     m_contentsResizedConnection = connect(this, &QWebEnginePage::contentsSizeChanged, this, [this]() {
         const QString fragment = url().fragment();
         if (!fragment.isEmpty()) {
             const QString src = QSL("var els = document.querySelectorAll(\"[name='%1']\"); if (els.length) els[0].scrollIntoView();");
             runJavaScript(src.arg(fragment));
         }
         disconnect(m_contentsResizedConnection);
     });
 }
 
 WebPage::~WebPage()
 {
     mApp->plugins()->emitWebPageDeleted(this);
 
     if (m_runningLoop) {
         m_runningLoop->exit(1);
         m_runningLoop = 0;
     }
 }
 
 WebView *WebPage::view() const
 {
     return static_cast<WebView*>(QWebEnginePage::view());
 }
 
 bool WebPage::execPrintPage(QPrinter *printer, int timeout)
 {
     QPointer<QEventLoop> loop = new QEventLoop;
     bool result = false;
     QTimer::singleShot(timeout, loop.data(), &QEventLoop::quit);
 
     print(printer, [loop, &result](bool res) {
         if (loop && loop->isRunning()) {
             result = res;
             loop->quit();
         }
     });
 
     loop->exec();
     delete loop;
 
     return result;
 }
 
 QVariant WebPage::execJavaScript(const QString &scriptSource, quint32 worldId, int timeout)
 {
     QPointer<QEventLoop> loop = new QEventLoop;
     QVariant result;
     QTimer::singleShot(timeout, loop.data(), &QEventLoop::quit);
 
     runJavaScript(scriptSource, worldId, [loop, &result](const QVariant &res) {
         if (loop && loop->isRunning()) {
             result = res;
             loop->quit();
         }
     });
 
     loop->exec(QEventLoop::ExcludeUserInputEvents);
     delete loop;
 
     return result;
 }
 
 QPointF WebPage::mapToViewport(const QPointF &pos) const
 {
     return QPointF(pos.x() / zoomFactor(), pos.y() / zoomFactor());
 }
 
 WebHitTestResult WebPage::hitTestContent(const QPoint &pos) const
 {
     return WebHitTestResult(this, pos);
 }
 
 void WebPage::scroll(int x, int y)
 {
     runJavaScript(QSL("window.scrollTo(window.scrollX + %1, window.scrollY + %2)").arg(x).arg(y), WebPage::SafeJsWorld);
 }
 
 void WebPage::setScrollPosition(const QPointF &pos)
 {
     const QPointF v = mapToViewport(pos.toPoint());
     runJavaScript(QSL("window.scrollTo(%1, %2)").arg(v.x()).arg(v.y()), WebPage::SafeJsWorld);
 }
 
 bool WebPage::isRunningLoop()
 {
     return m_runningLoop;
 }
 
 bool WebPage::isLoading() const
 {
     return m_loadProgress < 100;
 }
 
 void WebPage::urlChanged(const QUrl &url)
 {
     Q_UNUSED(url)
 
     if (isLoading()) {
         m_blockAlerts = false;
     }
 }
 
 void WebPage::progress(int prog)
 {
     m_loadProgress = prog;
 
     bool secStatus = url().scheme() == QL1S("https");
 
     if (secStatus != m_secureStatus) {
         m_secureStatus = secStatus;
         emit privacyChanged(secStatus);
     }
 }
 
 void WebPage::finished()
 {
     progress(100);
 
     // File scheme watcher
     if (url().scheme() == QLatin1String("file")) {
         QFileInfo info(url().toLocalFile());
         if (info.isFile()) {
             if (!m_fileWatcher) {
                 m_fileWatcher = new DelayedFileWatcher(this);
                 connect(m_fileWatcher, SIGNAL(delayedFileChanged(QString)), this, SLOT(watchedFileChanged(QString)));
             }
 
             const QString filePath = url().toLocalFile();
 
             if (QFile::exists(filePath) && !m_fileWatcher->files().contains(filePath)) {
                 m_fileWatcher->addPath(filePath);
             }
         }
     }
     else if (m_fileWatcher && !m_fileWatcher->files().isEmpty()) {
         m_fileWatcher->removePaths(m_fileWatcher->files());
     }
 
     // AutoFill
     m_passwordEntries = mApp->autoFill()->completePage(this, url());
 }
 
 void WebPage::watchedFileChanged(const QString &file)
 {
     if (url().toLocalFile() == file) {
         triggerAction(QWebEnginePage::Reload);
     }
 }
 
 void WebPage::handleUnknownProtocol(const QUrl &url)
 {
     const QString protocol = url.scheme();
 
     if (protocol == QLatin1String("mailto")) {
         desktopServicesOpen(url);
         return;
     }
 
     if (qzSettings->blockedProtocols.contains(protocol)) {
         qDebug() << "WebPage::handleUnknownProtocol Protocol" << protocol << "is blocked!";
         return;
     }
 
     if (qzSettings->autoOpenProtocols.contains(protocol)) {
         desktopServicesOpen(url);
         return;
     }
 
     CheckBoxDialog dialog(QMessageBox::Yes | QMessageBox::No, view());
     dialog.setDefaultButton(QMessageBox::Yes);
 
     const QString wrappedUrl = QzTools::alignTextToWidth(url.toString(), "<br/>", dialog.fontMetrics(), 450);
     const QString text = tr("Falkon cannot handle <b>%1:</b> links. The requested link "
                             "is <ul><li>%2</li></ul>Do you want Falkon to try "
                             "open this link in system application?").arg(protocol, wrappedUrl);
 
     dialog.setText(text);
     dialog.setCheckBoxText(tr("Remember my choice for this protocol"));
     dialog.setWindowTitle(tr("External Protocol Request"));
     dialog.setIcon(QMessageBox::Question);
 
     switch (dialog.exec()) {
     case QMessageBox::Yes:
         if (dialog.isChecked()) {
             qzSettings->autoOpenProtocols.append(protocol);
             qzSettings->saveSettings();
         }
 
 
         QDesktopServices::openUrl(url);
         break;
 
     case QMessageBox::No:
         if (dialog.isChecked()) {
             qzSettings->blockedProtocols.append(protocol);
             qzSettings->saveSettings();
         }
 
         break;
 
     default:
         break;
     }
 }
 
 void WebPage::desktopServicesOpen(const QUrl &url)
 {
     // Open same url only once in 2 secs
     const int sameUrlTimeout = 2 * 1000;
 
     if (s_lastUnsupportedUrl != url || s_lastUnsupportedUrlTime.isNull() || s_lastUnsupportedUrlTime.elapsed() > sameUrlTimeout) {
         s_lastUnsupportedUrl = url;
         s_lastUnsupportedUrlTime.restart();
         QDesktopServices::openUrl(url);
     }
     else {
         qWarning() << "WebPage::desktopServicesOpen Url" << url << "has already been opened!\n"
                    "Ignoring it to prevent infinite loop!";
     }
 }
 
 void WebPage::windowCloseRequested()
 {
     if (!view())
         return;
     view()->closeView();
 }
 
 void WebPage::fullScreenRequested(QWebEngineFullScreenRequest fullScreenRequest)
 {
     view()->requestFullScreen(fullScreenRequest.toggleOn());
 
     const bool accepted = fullScreenRequest.toggleOn() == view()->isFullScreen();
 
     if (accepted)
         fullScreenRequest.accept();
     else
         fullScreenRequest.reject();
 }
 
 void WebPage::featurePermissionRequested(const QUrl &origin, const QWebEnginePage::Feature &feature)
 {
     if (feature == MouseLock && view()->isFullScreen())
         setFeaturePermission(origin, feature, PermissionGrantedByUser);
     else
         mApp->html5PermissionsManager()->requestPermissions(this, origin, feature);
 }
 
 void WebPage::renderProcessTerminated(QWebEnginePage::RenderProcessTerminationStatus terminationStatus, int exitCode)
 {
     Q_UNUSED(exitCode)
 
     if (terminationStatus == NormalTerminationStatus)
         return;
 
     QTimer::singleShot(0, this, [this]() {
         QString page = QzTools::readAllFileContents(":html/tabcrash.html");
         page.replace(QL1S("%IMAGE%"), QzTools::pixmapToDataUrl(IconProvider::standardIcon(QStyle::SP_MessageBoxWarning).pixmap(45)).toString());
         page.replace(QL1S("%TITLE%"), tr("Failed loading page"));
         page.replace(QL1S("%HEADING%"), tr("Failed loading page"));
         page.replace(QL1S("%LI-1%"), tr("Something went wrong while loading this page."));
         page.replace(QL1S("%LI-2%"), tr("Try reloading the page or closing some tabs to make more memory available."));
         page.replace(QL1S("%RELOAD-PAGE%"), tr("Reload page"));
         page = QzTools::applyDirectionToPage(page);
         load(url()); // Workaround for QtWebEngine crash
         setHtml(page.toUtf8(), url());
     });
 }
 
 bool WebPage::acceptNavigationRequest(const QUrl &url, QWebEnginePage::NavigationType type, bool isMainFrame)
 {
     if (!mApp->plugins()->acceptNavigationRequest(this, url, type, isMainFrame))
         return false;
 
-    // AdBlock
-    AdBlockManager *manager = AdBlockManager::instance();
-    if (isMainFrame) {
-        manager->clearBlockedRequestsForUrl(WebPage::url());
-    }
-    if (url.scheme() == QL1S("abp") && AdBlockManager::instance()->addSubscriptionFromUrl(url)) {
-        return false;
-    }
-
     const bool result = QWebEnginePage::acceptNavigationRequest(url, type, isMainFrame);
 
     if (result && isMainFrame) {
         const bool isWeb = url.scheme() == QL1S("http") || url.scheme() == QL1S("https");
         const bool globalJsEnabled = mApp->webSettings()->testAttribute(QWebEngineSettings::JavascriptEnabled);
         settings()->setAttribute(QWebEngineSettings::JavascriptEnabled, isWeb ? globalJsEnabled : true);
     }
 
     return result;
 }
 
 bool WebPage::certificateError(const QWebEngineCertificateError &error)
 {
     return mApp->networkManager()->certificateError(error, view());
 }
 
 QStringList WebPage::chooseFiles(QWebEnginePage::FileSelectionMode mode, const QStringList &oldFiles, const QStringList &acceptedMimeTypes)
 {
     Q_UNUSED(acceptedMimeTypes);
 
     QStringList files;
     QString suggestedFileName = s_lastUploadLocation;
     if (!oldFiles.isEmpty())
         suggestedFileName = oldFiles.at(0);
 
     switch (mode) {
     case FileSelectOpen:
         files = QStringList(QzTools::getOpenFileName("WebPage-ChooseFile", view(), tr("Choose file..."), suggestedFileName));
         break;
 
     case FileSelectOpenMultiple:
         files = QzTools::getOpenFileNames("WebPage-ChooseFile", view(), tr("Choose files..."), suggestedFileName);
         break;
 
     default:
         files = QWebEnginePage::chooseFiles(mode, oldFiles, acceptedMimeTypes);
         break;
     }
 
     if (!files.isEmpty())
         s_lastUploadLocation = files.at(0);
 
     return files;
 }
 
 bool WebPage::hasMultipleUsernames() const
 {
     return m_passwordEntries.count() > 1;
 }
 
 QVector<PasswordEntry> WebPage::autoFillData() const
 {
     return m_passwordEntries;
 }
 
 bool WebPage::javaScriptPrompt(const QUrl &securityOrigin, const QString &msg, const QString &defaultValue, QString* result)
 {
     if (!kEnableJsNonBlockDialogs) {
         return QWebEnginePage::javaScriptPrompt(securityOrigin, msg, defaultValue, result);
     }
 
     if (m_runningLoop) {
         return false;
     }
 
     ResizableFrame* widget = new ResizableFrame(view()->overlayWidget());
 
     widget->setObjectName("jsFrame");
     Ui_jsPrompt* ui = new Ui_jsPrompt();
     ui->setupUi(widget);
     ui->message->setText(msg);
     ui->lineEdit->setText(defaultValue);
     ui->lineEdit->setFocus();
     widget->resize(view()->size());
     widget->show();
 
     connect(view(), SIGNAL(viewportResized(QSize)), widget, SLOT(slotResize(QSize)));
     connect(ui->lineEdit, SIGNAL(returnPressed()), ui->buttonBox->button(QDialogButtonBox::Ok), SLOT(animateClick()));
 
     QEventLoop eLoop;
     m_runningLoop = &eLoop;
     connect(ui->buttonBox, SIGNAL(clicked(QAbstractButton*)), &eLoop, SLOT(quit()));
 
     if (eLoop.exec() == 1) {
         return result;
     }
     m_runningLoop = 0;
 
     QString x = ui->lineEdit->text();
     bool _result = ui->buttonBox->clickedButtonRole() == QDialogButtonBox::AcceptRole;
     *result = x;
 
     delete widget;
     view()->setFocus();
 
     return _result;
 }
 
 bool WebPage::javaScriptConfirm(const QUrl &securityOrigin, const QString &msg)
 {
     if (!kEnableJsNonBlockDialogs) {
         return QWebEnginePage::javaScriptConfirm(securityOrigin, msg);
     }
 
     if (m_runningLoop) {
         return false;
     }
 
     ResizableFrame* widget = new ResizableFrame(view()->overlayWidget());
 
     widget->setObjectName("jsFrame");
     Ui_jsConfirm* ui = new Ui_jsConfirm();
     ui->setupUi(widget);
     ui->message->setText(msg);
     ui->buttonBox->button(QDialogButtonBox::Ok)->setFocus();
     widget->resize(view()->size());
     widget->show();
 
     connect(view(), SIGNAL(viewportResized(QSize)), widget, SLOT(slotResize(QSize)));
 
     QEventLoop eLoop;
     m_runningLoop = &eLoop;
     connect(ui->buttonBox, SIGNAL(clicked(QAbstractButton*)), &eLoop, SLOT(quit()));
 
     if (eLoop.exec() == 1) {
         return false;
     }
     m_runningLoop = 0;
 
     bool result = ui->buttonBox->clickedButtonRole() == QDialogButtonBox::AcceptRole;
 
     delete widget;
     view()->setFocus();
 
     return result;
 }
 
 void WebPage::javaScriptAlert(const QUrl &securityOrigin, const QString &msg)
 {
     Q_UNUSED(securityOrigin)
 
     if (m_blockAlerts || m_runningLoop) {
         return;
     }
 
     if (!kEnableJsNonBlockDialogs) {
         QString title = tr("JavaScript alert");
         if (!url().host().isEmpty()) {
             title.append(QString(" - %1").arg(url().host()));
         }
 
         CheckBoxDialog dialog(QMessageBox::Ok, view());
         dialog.setDefaultButton(QMessageBox::Ok);
         dialog.setWindowTitle(title);
         dialog.setText(msg);
         dialog.setCheckBoxText(tr("Prevent this page from creating additional dialogs"));
         dialog.setIcon(QMessageBox::Information);
         dialog.exec();
 
         m_blockAlerts = dialog.isChecked();
         return;
     }
 
     ResizableFrame* widget = new ResizableFrame(view()->overlayWidget());
 
     widget->setObjectName("jsFrame");
     Ui_jsAlert* ui = new Ui_jsAlert();
     ui->setupUi(widget);
     ui->message->setText(msg);
     ui->buttonBox->button(QDialogButtonBox::Ok)->setFocus();
     widget->resize(view()->size());
     widget->show();
 
     connect(view(), SIGNAL(viewportResized(QSize)), widget, SLOT(slotResize(QSize)));
 
     QEventLoop eLoop;
     m_runningLoop = &eLoop;
     connect(ui->buttonBox, SIGNAL(clicked(QAbstractButton*)), &eLoop, SLOT(quit()));
 
     if (eLoop.exec() == 1) {
         return;
     }
     m_runningLoop = 0;
 
     m_blockAlerts = ui->preventAlerts->isChecked();
 
     delete widget;
 
     view()->setFocus();
 }
 
 void WebPage::javaScriptConsoleMessage(JavaScriptConsoleMessageLevel level, const QString &message, int lineNumber, const QString &sourceID)
 {
     if (!kEnableJsOutput) {
         return;
     }
 
     switch (level) {
     case InfoMessageLevel:
         std::cout << "[I] ";
         break;
 
     case WarningMessageLevel:
         std::cout << "[W] ";
         break;
 
     case ErrorMessageLevel:
         std::cout << "[E] ";
         break;
     }
 
     std::cout << qPrintable(sourceID) << ":" << lineNumber << " " << qPrintable(message);
 }
 
 QWebEnginePage* WebPage::createWindow(QWebEnginePage::WebWindowType type)
 {
     TabbedWebView *tView = qobject_cast<TabbedWebView*>(view());
     BrowserWindow *window = tView ? tView->browserWindow() : mApp->getWindow();
 
     auto createTab = [=](Qz::NewTabPositionFlags pos) {
         int index = window->tabWidget()->addView(QUrl(), pos);
         TabbedWebView* view = window->weView(index);
         view->setPage(new WebPage);
         // Workaround focus issue when creating tab
         if (pos.testFlag(Qz::NT_SelectedTab)) {
             QPointer<TabbedWebView> pview = view;
             QTimer::singleShot(0, this, [pview]() {
                 if (pview && pview->webTab()->isCurrentTab()) {
                     pview->setFocus();
                 }
             });
         }
         return view->page();
     };
 
     switch (type) {
     case QWebEnginePage::WebBrowserWindow: {
         BrowserWindow *window = mApp->createWindow(Qz::BW_NewWindow);
         WebPage *page = new WebPage;
         window->setStartPage(page);
         return page;
     }
 
     case QWebEnginePage::WebDialog:
         if (!qzSettings->openPopupsInTabs) {
             PopupWebView* view = new PopupWebView;
             view->setPage(new WebPage);
             PopupWindow* popup = new PopupWindow(view);
             popup->show();
             window->addDeleteOnCloseWidget(popup);
             return view->page();
         }
         // else fallthrough
 
     case QWebEnginePage::WebBrowserTab:
         return createTab(Qz::NT_CleanSelectedTab);
 
     case QWebEnginePage::WebBrowserBackgroundTab:
         return createTab(Qz::NT_CleanNotSelectedTab);
 
     default:
         break;
     }
 
     return Q_NULLPTR;
 }