Fixed miscellaneous issues with anti-adblock notification port

background.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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/>.
  */
 
 with(require("filterClasses"))
 {
   this.Filter = Filter;
-  this.ActiveFilter = ActiveFilter;
   this.RegExpFilter = RegExpFilter;
   this.BlockingFilter = BlockingFilter;
   this.WhitelistFilter = WhitelistFilter;
 }
 with(require("subscriptionClasses"))
 {
   this.Subscription = Subscription;
   this.DownloadableSubscription = DownloadableSubscription;
 }
 with(require("whitelisting"))
 {
   this.isWhitelisted = isWhitelisted;
   this.isFrameWhitelisted = isFrameWhitelisted;
   this.processKeyException = processKeyException;
 }
 var FilterStorage = require("filterStorage").FilterStorage;
 var ElemHide = require("elemHide").ElemHide;
 var defaultMatcher = require("matcher").defaultMatcher;
 var Prefs = require("prefs").Prefs;
 var Synchronizer = require("synchronizer").Synchronizer;
 var Utils = require("utils").Utils;
 var Notification = require("notification").Notification;
 var initAntiAdblockNotification = require("antiadblockInit").initAntiAdblockNotification;
 
 // Some types cannot be distinguished
 RegExpFilter.typeMap.OBJECT_SUBREQUEST = RegExpFilter.typeMap.OBJECT;
 RegExpFilter.typeMap.MEDIA = RegExpFilter.typeMap.FONT = RegExpFilter.typeMap.OTHER;
 
+// Chrome on Linux does not fully support chrome.notifications until version 35
+// https://code.google.com/p/chromium/issues/detail?id=291485
+var canUseChromeNotifications = require("info").platform == "chromium"
+  && "notifications" in chrome
+  && (navigator.platform.indexOf("Linux") == -1 || parseInt(require("info").applicationVersion) > 34);
+
 var isFirstRun = false;
 var seenDataCorruption = false;
 require("filterNotifier").FilterNotifier.addListener(function(action)
 {
   if (action == "load")
   {
     var importingOldData = importOldData();
 
     var addonVersion = require("info").addonVersion;
     var prevVersion = ext.storage.currentVersion;
     if (prevVersion != addonVersion)
     {
       isFirstRun = !prevVersion;
       ext.storage.currentVersion = addonVersion;
       if (!importingOldData)
         addSubscription(prevVersion);
     }
 
+    if (canUseChromeNotifications)
+      initChromeNotifications();
     initAntiAdblockNotification();
   }
 
   // update browser actions when whitelisting might have changed,
   // due to loading filters or saving filter changes
   if (action == "load" || action == "save")
   {
     ext.windows.getAll(function(windows)
     {
       for (var i = 0; i < windows.length; i++)
@@ skipping 229 matching lines @@
   });
 }
 
 function prepareNotificationIconAndPopup()
 {
   var animateIcon = (activeNotification.type !== "question");
   activeNotification.onClicked = function()
   {
     if (animateIcon)
       iconAnimation.stop();
-    activeNotification = null;
+    notificationClosed();
   };
   if (animateIcon)
     iconAnimation.update(activeNotification.type);
 }
 
 function openNotificationLinks() 
 {
   if (activeNotification.links)
   {
     activeNotification.links.forEach(function(link)
     {
       ext.windows.getLastFocused(function(win)
       {
         win.openTab(Utils.getDocLink(link));
       });
     });
   }
 }
 
-function notificationButtonClick(id, index)
+function notificationButtonClick(buttonIndex)
 {
   if (activeNotification.type === "question")
   {
-    Notification.triggerQuestionListeners(activeNotification.id, index === 0);
+    Notification.triggerQuestionListeners(activeNotification.id, buttonIndex === 0);
     Notification.markAsShown(activeNotification.id);
     activeNotification.onClicked();
   }
-  else if (activeNotification.links && activeNotification.links[index])
+  else if (activeNotification.links && activeNotification.links[buttonIndex])
   {
     ext.windows.getLastFocused(function(win)
     {
-      win.openTab(Utils.getDocLink(activeNotification.links[index]));
+      win.openTab(Utils.getDocLink(activeNotification.links[buttonIndex]));
     });
   }
 }
 
+function notificationClosed()
+{
+  activeNotification = null;
+}
+
+function initChromeNotifications()
+{
+  // Chrome hides notifications in notification center when clicked so we need to close them
+  function clearActiveNotification(notificationId)
+  {
+    if (activeNotification && activeNotification.type != "question")

[Felix Dahlke, 2014/03/28 16:16:39]

Why check for the notification type here? Seems to me this should be done for
all notifications that trigger a chrome.notification to be shown.

[Thomas Greiner, 2014/03/28 17:26:51]

What this function does is remove the notification from the notification center
- not close the notification if that's what you thought. It'd be nice to use the
notification center for non-interactive notifications but we can also go with
your suggestion for now.

Additional context:

While it's no problem that regular notifications are being kept in there, in
case users want to check for them, it's problematic for URL-specific
notifications because we can only show a notification again if it's not hidden
in the notification center.

In addition to that, we only save the last notification which means that
interacting with old notifications in the notificiation center wouldn't do
anything. So actually, we have three options:

1) Don't show any notifications in the notification center.

2) Change the check to the one below to only show notifications in the
notification center which do not offer any interaction.

if (activeNotification && (activeNotification.type == "question" || "links" in
activeNotification))

3) Keep all notifications in memory until they are properly closed to make use
of the notification center.

While I chose to go with (2) to at least keep non-interactive notifications in
the notification center, I could also live with (1). (3) would require more
effort to implement and is therefore not an option for now IMHO.

[Felix Dahlke, 2014/03/28 17:33:46]

Ah, no I get it. No it's fine let's go with 2 if you prefer that.

[Thomas Greiner, 2014/03/28 18:23:17]

For completeness' sake, what I meant for (2) was:

if (activeNotification && activeNotification.type != "question" && !("links" in
activeNotification))

+      return;
+    
+    chrome.notifications.clear(notificationId, function(wasCleared)
+    {
+      if (wasCleared)
+        notificationClosed();
+    });
+  }
+
+  chrome.notifications.onButtonClicked.addListener(function(notificationId, buttonIndex)
+  {
+    notificationButtonClick(buttonIndex);
+    clearActiveNotification(notificationId);

[Thomas Greiner, 2014/03/28 15:57:08]

I noticed that even notifications that were dismissed by clicking on one of the
buttons were only hidden in the notification center and not cleared so I added
this here.

+  });
+  chrome.notifications.onClicked.addListener(clearActiveNotification);
+  chrome.notifications.onClosed.addListener(notificationClosed);
+}
+
 function showNotification(notification)
 {
   if (activeNotification && activeNotification.id === notification.id)
     return;
   
   activeNotification = notification;
   if (activeNotification.type === "critical" || activeNotification.type === "question")
   {
     var hasWebkitNotifications = typeof webkitNotifications !== "undefined";
     if (hasWebkitNotifications && "createHTMLNotification" in webkitNotifications)
     {
       var notification = webkitNotifications.createHTMLNotification("notification.html");
       notification.show();
       prepareNotificationIconAndPopup();
       return;
     }
     
     var texts = Notification.getLocalizedTexts(notification);
     var title = texts.title || "";
     var message = texts.message ? texts.message.replace(/<\/?(a|strong)>/g, "") : "";
     var iconUrl = ext.getURL("icons/abp-128.png");
     var hasLinks = activeNotification.links && activeNotification.links.length > 0;
     
-    // Chrome on Linux does not fully support chrome.notifications yet
-    // https://code.google.com/p/chromium/issues/detail?id=291485
-    if (require("info").platform == "chromium" && "notifications" in chrome && navigator.platform.indexOf("Linux") == -1)
+    if (canUseChromeNotifications)
     {
       var opts = {
         type: "basic",
         title: title,
         message: message,
         iconUrl: iconUrl,
         buttons: [],
         priority: 2 // We use the highest priority to prevent the notification from closing automatically
       };
       if (activeNotification.type === "question")
       {
         opts.buttons.push({title: ext.i18n.getMessage("overlay_notification_button_yes")});
         opts.buttons.push({title: ext.i18n.getMessage("overlay_notification_button_no")});
       }
       else
       {
         var regex = /<a>(.*?)<\/a>/g;
         var plainMessage = texts.message || "";
         var match;
         while (match = regex.exec(plainMessage))
           opts.buttons.push({title: match[1]});
       }
       
       chrome.notifications.create("", opts, function() {});
-      chrome.notifications.onButtonClicked.addListener(notificationButtonClick);
     }
     else if (hasWebkitNotifications && "createNotification" in webkitNotifications && activeNotification.type !== "question")
     {
       if (hasLinks)
         message += " " + ext.i18n.getMessage("notification_without_buttons");
         
       var notification = webkitNotifications.createNotification(iconUrl, title, message);
       notification.show();
       notification.addEventListener("click", openNotificationLinks, false);
+      notification.addEventListener("close", notificationClosed, false);
     }
     else
     {
       var message = title + "\n" + message;
       if (hasLinks)
         message += "\n\n" + ext.i18n.getMessage("notification_with_buttons");
         
       var approved = confirm(message);
       if (activeNotification.type === "question")
         notificationButtonClick(null, approved ? 0 : 1);
@@ skipping 104 matching lines @@
   tab.sendMessage({type: "clickhide-deactivate"});
   refreshIconAndContextMenu(tab);
 });
 
 setTimeout(function()
 {
   var notificationToShow = Notification.getNextToShow();
   if (notificationToShow)
     showNotification(notificationToShow);
 }, 3 * 60 * 1000);