Issue 1162 - Cache notification URL matcher

lib/notification.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 20 matching lines @@
 
 const INITIAL_DELAY = 1 * MILLIS_IN_MINUTE;
 const CHECK_INTERVAL = 1 * MILLIS_IN_HOUR;
 const EXPIRATION_INTERVAL = 1 * MILLIS_IN_DAY;
 const TYPE = {
   information: 0,
   question: 1,
   relentless: 2,
   critical: 3
 };
+const MATCHER = Symbol("Notification matcher");
 
 let showListeners = [];
 let questionListeners = {};
 
 function getNumericalSeverity(notification)
 {
   if (notification.type in TYPE)
     return TYPE[notification.type];
   return TYPE.information;
 }
@@ skipping 45 matching lines @@
   // Compare version suffix (e.g. 0.1alpha < 0.1b1 < 01.b2 < 0.1).
   // However, note that this is a simple string comparision, meaning: b10 < b2
   if (tail1 == tail2)
     return 0;
   if (!tail1 || tail2 && tail1 > tail2)
     return 1;
   return -1;
 }
 
 /**
+ * Initializes notification's matcher based on notification's URL filters
+ * @param {Object} notification
+ */
+function initNotificationMatcher(notification)
+{
+  if (MATCHER in notification || !(notification.urlFilters instanceof Array))
+    return;
+
+  let matcher = new Matcher();
+  for (let urlFilter of notification.urlFilters)
+  {
+    matcher.add(Filter.fromText(urlFilter));
+  }
+  notification[MATCHER] = matcher;
+}
+
+/**
+ * Matches URL against notification's URL filters
+ * @param {Object} notification
+ * @param {string} [url]
+ * @return {boolean} whether notification and URL match
+ */
+function matchesUrl(notification, url)
+{
+  // No matching necessary if there's nothing to match
+  if (typeof url !== "string" && !(MATCHER in notification))
+    return true;
+
+  // Notification shouldn't match if extension is disabled
+  if (!Prefs.enabled)
+    return false;
+
+  // Notification shouldn't match if matching cannot be done
+  if (typeof url !== "string" || !(MATCHER in notification))
+    return false;
+
+  let host;
+  try
+  {
+    host = new URL(url).hostname;
+  }
+  catch (e)
+  {
+    host = "";
+  }
+
+  // Notification shouldn't match if extension is disabled on provided domain
+  let exception = defaultMatcher.matchesAny(
+    url, RegExpFilter.typeMap.DOCUMENT, host, false, null
+  );
+  if (exception instanceof WhitelistFilter)
+    return false;
+
+  // Notification should match if one of its filters matches
+  let filter = notification[MATCHER].matchesAny(
+    url, RegExpFilter.typeMap.DOCUMENT, host, false, null
+  );
+  return !!filter;
+}
+
+/**
  * The object providing actual downloading functionality.
  * @type {Downloader}
  */
 let downloader = null;
+
+/**
+ * List of notifications provided by the extension
+ * @type {Object[]}
+ */
 let localData = [];
 
 /**
  * Regularly fetches notifications and decides which to show.
  * @class
  */
 let Notification = exports.Notification =
 {
   /**
    * Called on module startup.
    */
   init()
   {
+    let {data} = Prefs.notificationdata;
+    if (data)
+    {
+      for (let notification of data.notifications)
+      {
+        initNotificationMatcher(notification);
+      }
+    }
+
     downloader = new Downloader(this._getDownloadables.bind(this),
                                 INITIAL_DELAY, CHECK_INTERVAL);
     downloader.onExpirationChange = this._onExpirationChange.bind(this);
     downloader.onDownloadSuccess = this._onDownloadSuccess.bind(this);
     downloader.onDownloadError = this._onDownloadError.bind(this);
     onShutdown.add(() => downloader.cancel());
   },
 
   /**
    * Yields a Downloadable instances for the notifications download.
@@ skipping 34 matching lines @@
     {
       let data = JSON.parse(responseText);
       for (let notification of data.notifications)
       {
         if ("severity" in notification)
         {
           if (!("type" in notification))
             notification.type = notification.severity;
           delete notification.severity;
         }
+        initNotificationMatcher(notification);
       }
       Prefs.notificationdata.data = data;
     }
     catch (e)
     {
       Cu.reportError(e);
       errorCallback("synchronize_invalid_data");
       return;
     }
 
@@ skipping 39 matching lines @@
       showListeners.splice(index, 1);
   },
 
   /**
    * Determines which notification is to be shown next.
    * @param {string} url URL to match notifications to (optional)
    * @return {Object} notification to be shown, or null if there is none
    */
   _getNextToShow(url)
   {
-    let remoteData = [];
-    if (typeof Prefs.notificationdata.data == "object" &&
-        Prefs.notificationdata.data.notifications instanceof Array)
-    {
-      remoteData = Prefs.notificationdata.data.notifications;
-    }
-
+    let remoteData = Prefs.notificationdata.data.notifications;
     let notifications = localData.concat(remoteData);
     if (notifications.length === 0)
       return null;
 
     const {addonName, addonVersion, application,
            applicationVersion, platform, platformVersion} = require("info");
 
     let targetChecks = {
       extension: v => v == addonName,
       extensionMinVersion:
@@ skipping 38 matching lines @@
             continue;
         }
 
         if (notification.type !== "relentless" &&
             Prefs.notifications_ignoredcategories.indexOf("*") != -1)
         {
           continue;
         }
       }
 
-      if (typeof url === "string" || notification.urlFilters instanceof Array)
-      {
-        if (Prefs.enabled && typeof url === "string" &&
-            notification.urlFilters instanceof Array)
-        {
-          let host;
-          try
-          {
-            host = new URL(url).hostname;
-          }
-          catch (e)
-          {
-            host = "";
-          }
-
-          let exception = defaultMatcher.matchesAny(
-            url, RegExpFilter.typeMap.DOCUMENT, host, false, null
-          );
-          if (exception instanceof WhitelistFilter)
-            continue;
-
-          let matcher = new Matcher();
-          for (let urlFilter of notification.urlFilters)
-            matcher.add(Filter.fromText(urlFilter));
-          if (!matcher.matchesAny(url, RegExpFilter.typeMap.DOCUMENT, host,
-              false, null))
-          {
-            continue;
-          }
-        }
-        else
-          continue;
-      }
+      if (!matchesUrl(notification, url))
+        continue;
 
       if (notification.targets instanceof Array)
       {
         let match = false;
 
         for (let target of notification.targets)
         {
           if (Object.keys(target).every(key =>
               targetChecks.hasOwnProperty(key) &&
               targetChecks[key](target[key])))
@@ skipping 82 matching lines @@
     return localizedTexts;
   },
 
   /**
    * Adds a local notification.
    * @param {Object} notification notification to add
    */
   addNotification(notification)
   {
     if (localData.indexOf(notification) == -1)
+    {
+      initNotificationMatcher(notification);
       localData.push(notification);
+    }
   },
 
   /**
    * Removes an existing local notification.
    * @param {Object} notification notification to remove
    */
   removeNotification(notification)
   {
     let index = localData.indexOf(notification);
     if (index > -1)
@@ skipping 67 matching lines @@
     else if (index != -1 && forceValue !== true)
       categories.splice(index, 1);
 
     // HACK: JSON values aren't saved unless they are assigned a
     // different object.
     Prefs.notifications_ignoredcategories =
       JSON.parse(JSON.stringify(categories));
   }
 };
 Notification.init();