Implemented anti-adblock message notification

lib/notification.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2013 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /**
  * @fileOverview Handles notifications.
  */
 
 Cu.import("resource://gre/modules/Services.jsm");
 
 let {TimeLine} = require("timeline");
 let {Prefs} = require("prefs");
 let {Downloader, Downloadable, MILLIS_IN_MINUTE, MILLIS_IN_HOUR, MILLIS_IN_DAY} = require("downloader");
 let {Utils} = require("utils");
+let {Matcher} = require("matcher");
+let {Filter} = require("filterClasses");
 
 let INITIAL_DELAY = 12 * MILLIS_IN_MINUTE;
 let CHECK_INTERVAL = 1 * MILLIS_IN_HOUR;
 let EXPIRATION_INTERVAL = 1 * MILLIS_IN_DAY;
+let TYPES = {

[Felix Dahlke, 2014/02/13 10:22:04]

Maybe we should call this TYPE_SEVERITY since it's effectively a type: severity
mapping now? (also: singular)

[Thomas Greiner, 2014/02/13 12:57:54]

I don't think we need to make it overly specific given that "information" and
"critical" can also be considered notification types.

+  information: 0,
+  question: 1,
+  critical: 2
+};
+
+let listeners = {};
 
 function getNumericalSeverity(notification)
 {
-  let levels = {information: 0, critical: 1};
-  return (notification.severity in levels ? levels[notification.severity] : levels.information);
+  let type = ("type" in notification) ? notification.type : notification.severity;
+  return (type in TYPES ? TYPES[type] : TYPES.information);
 }
 
 function saveNotificationData()
 {
   // HACK: JSON values aren't saved unless they are assigned a different object.
   Prefs.notificationdata = JSON.parse(JSON.stringify(Prefs.notificationdata));
 }
 
 function localize(translations, locale)
 {
   if (locale in translations)
     return translations[locale];
 
   let languagePart = locale.substring(0, locale.indexOf("-"));
   if (languagePart && languagePart in translations)
     return translations[languagePart];
 
   let defaultLocale = "en-US";
   return translations[defaultLocale];
 }
 
 /**
  * The object providing actual downloading functionality.
  * @type Downloader
  */
 let downloader = null;
+let localData = [];
 
 /**
  * Regularly fetches notifications and decides which to show.
  * @class
  */
 let Notification = exports.Notification =
 {
   /**
    * Called on module startup.
    */
@@ skipping 62 matching lines @@
 
   _onDownloadError: function(downloadable, downloadURL, error, channelStatus, responseStatus, redirectCallback)
   {
     Prefs.notificationdata.lastError = Date.now();
     Prefs.notificationdata.downloadStatus = error;
     saveNotificationData();
   },
 
   /**
    * Determines which notification is to be shown next.
-   * @param {Array of Object} notifications active notifications
+   * @param {String} url URL to match notifications to (optional)
    * @return {Object} notification to be shown, or null if there is none
    */
-  getNextToShow: function()
+  getNextToShow: function(url)
   {
     function checkTarget(target, parameter, name, version)
     {
       let minVersionKey = parameter + "MinVersion";
       let maxVersionKey = parameter + "MaxVersion";
       return !((parameter in target && target[parameter] != name) ||
                (minVersionKey in target && Services.vc.compare(version, target[minVersionKey]) < 0) ||
                (maxVersionKey in target && Services.vc.compare(version, target[maxVersionKey]) > 0));
-
     }
 
-    if (typeof Prefs.notificationdata.data != "object" || !(Prefs.notificationdata.data.notifications instanceof Array))
-      return null;
+    let remoteData = [];
+    if (typeof Prefs.notificationdata.data == "object" && Prefs.notificationdata.data.notifications instanceof Array)
+      remoteData = Prefs.notificationdata.data.notifications;
 
     if (!(Prefs.notificationdata.shown instanceof Array))
     {
       Prefs.notificationdata.shown = [];
       saveNotificationData();
     }
 
+    let notifications = localData.concat(remoteData);
+    if (notifications.length === 0)
+      return null;
+
     let {addonName, addonVersion, application, applicationVersion, platform, platformVersion} = require("info");
-    let notifications = Prefs.notificationdata.data.notifications;
     let notificationToShow = null;
     for each (let notification in notifications)
     {
-      if ((typeof notification.severity === "undefined" || notification.severity === "information")
+      if ((typeof notification.type === "undefined" || notification.type !== "critical")

[Felix Dahlke, 2014/02/13 10:22:04]

I'm sorry, my suggestion for being downwards compatible above wasn't complete,
we need to do something here to :( How about this:

When we download the notification, we do this:

if ("severity" in notification)
{
  if (!("type" in notification))
    notification.type = notification.severity;
  delete notification.severity;
}

That way we could centralise the type/severity confusion.

[Thomas Greiner, 2014/02/13 12:57:54]

Done.

           && Prefs.notificationdata.shown.indexOf(notification.id) !== -1)
         continue;
 
+      if (typeof url === "string" || notification.urlFilters instanceof Array)
+      {
+        if (typeof url === "string" && notification.urlFilters instanceof Array)
+        {
+          let matcher = new Matcher();
+          for each (let urlFilter in notification.urlFilters)
+            matcher.add(Filter.fromText(urlFilter));
+          if (!matcher.matchesAny(url, "DOCUMENT", url))
+            continue;
+        }
+        else
+          continue;
+      }
+
       if (notification.targets instanceof Array)
       {
         let match = false;
         for each (let target in notification.targets)
         {
           if (checkTarget(target, "extension", addonName, addonVersion) &&
               checkTarget(target, "application", application, applicationVersion) &&
               checkTarget(target, "platform", platform, platformVersion))
           {
             match = true;
             break;
           }
         }
         if (!match)
           continue;
       }
 
       if (!notificationToShow
           || getNumericalSeverity(notification) > getNumericalSeverity(notificationToShow))
         notificationToShow = notification;
     }
 
     if (notificationToShow && "id" in notificationToShow)
     {
-      Prefs.notificationdata.shown.push(notificationToShow.id);
-      saveNotificationData();
+      if (notificationToShow.type !== "question")
+        this.markAsShown(notificationToShow.id);
     }
 
     return notificationToShow;
   },
 
+  markAsShown: function(id)
+  {
+    if (Prefs.notificationdata.shown.indexOf(id) > -1)
+      return;
+
+    Prefs.notificationdata.shown.push(id);
+    saveNotificationData();
+  },
+
   /**
    * Localizes the texts of the supplied notification.
    * @param {Object} notification notification to translate
    * @param {String} locale the target locale (optional, defaults to the
    *                        application locale)
    * @return {Object} the translated texts
    */
   getLocalizedTexts: function(notification, locale)
   {
     locale = locale || Utils.appLocale;
     let textKeys = ["title", "message"];
     let localizedTexts = [];
     for each (let key in textKeys)
     {
       if (key in notification)
-        localizedTexts[key] = localize(notification[key], locale);
+      {
+        if (typeof notification[key] == "string")
+          localizedTexts[key] = notification[key];
+        else
+          localizedTexts[key] = localize(notification[key], locale);
+      }
     }
     return localizedTexts;
+  },
+
+  /**
+   * Adds a local notification.
+   * @param {Object} notification notification to add
+   */
+  addNotification: function(notification)
+  {
+    if (localData.indexOf(notification) == -1)
+      localData.push(notification);
+  },
+
+  /**
+   * Removes an existing local notification.
+   * @param {Object} notification notification to remove
+   */
+  removeNotification: function(notification)
+  {
+    let index = localData.indexOf(notification);
+    if (index > -1)
+      localData.splice(index, 1);
+  },
+
+  /**
+   * Adds a listener for question-type notifications
+   */
+  addQuestionListener: function(/**string*/ id, /**function(approved)*/ listener)
+  {
+    if (!(id in listeners))
+      listeners[id] = [];
+    if (listeners[id].indexOf(listener) === -1)
+      listeners[id].push(listener);
+  },
+
+  /**
+   * Removes a listener that was previously added via addQuestionListener
+   */
+  removeQuestionListener: function(/**string*/ id, /**function(approved)*/ listener)
+  {
+    if (!(id in listeners))
+      return;
+    let index = listeners[id].indexOf(listener);
+    if (index > -1)
+      listeners[id].splice(index, 1);
+    if (listeners[id].length === 0)
+      delete listeners[id];
+  },
+
+  /**
+   * Notifies listeners about interactions with a notification
+   * @param {String} id notification ID
+   * @param {Boolean} approved indicator whether notification has been approved or not
+   */
+  triggerQuestionListeners: function(id, approved)
+  {
+    if (!(id in listeners))
+      return;
+    for each (let listener in listeners[id])
+      listener(approved);
   }
 };
 Notification.init();