Issue 3024 - Added opt-out to Chrome notifications

lib/notificationHelper.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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/>.
  */
 
 /** @module notificationHelper */
 
 let {startIconAnimation, stopIconAnimation} = require("icon");
 let {Utils} = require("utils");
 let {Notification: NotificationStorage} = require("notification");
 let {stringifyURL} = require("url");
 let {initAntiAdblockNotification} = require("antiadblockInit");
 
 let activeNotification = null;
+let activeButtons = null;
 let defaultDisplayMethods = ["popup"];
 let displayMethods = Object.create(null);
 displayMethods.critical = ["icon", "notification", "popup"];
 displayMethods.question = ["notification"];
 displayMethods.normal = ["notification"];
 displayMethods.information = ["icon", "popup"];
 
 // Chrome on Linux does not fully support chrome.notifications until version 35
 // https://code.google.com/p/chromium/issues/detail?id=291485
 let canUseChromeNotifications = (function()
@@ skipping 15 matching lines @@
   activeNotification.onClicked = function()
   {
     if (animateIcon)
       stopIconAnimation();
     notificationClosed();
   };
   if (animateIcon)
     startIconAnimation(activeNotification.type);
 }
 
+function getNotificationButtons(message)
+{
+  activeButtons = [];

[Sebastian Noack, 2015/09/11 14:15:39]

I find it kinda unexpected that a function that is supposed to "get" something,
changes global state. Also the function would be easier to debug, if you could
call it from the console, without these unexpcted side effects. So why don't you
set the global variable in the calling code?

[Thomas Greiner, 2015/09/11 14:43:58]

Done. The idea was to ensure that `activeButtons` is always kept in sync but I
do see your point.

+  if (activeNotification.type == "question")
+  {
+    activeButtons.push({
+      type: "question",
+      title: ext.i18n.getMessage("overlay_notification_button_yes")
+    });
+    activeButtons.push({
+      type: "question",
+      title: ext.i18n.getMessage("overlay_notification_button_no")
+    });
+  }
+  else
+  {
+    let regex = /<a>(.*?)<\/a>/g;
+    let match;
+    while (match = regex.exec(message))
+    {
+      activeButtons.push({
+        type: "link",
+        title: match[1]
+      });
+    }
+
+    // Chrome only allows two notification buttons so we need to fall back
+    // to a single button to open all links if there are more than two.
+    let maxButtons = (activeNotification.type == "critical") ? 2 : 1;
+    if (activeButtons.length > maxButtons)
+    {
+      activeButtons = [
+        {
+          type: "open-all",
+          title: ext.i18n.getMessage("notification_open_all")
+        }
+      ];
+    }
+    if (activeNotification.type != "critical")
+    {
+      activeButtons.push({
+        type: "configure",
+        title: ext.i18n.getMessage("notification_configure")
+      });
+    }
+  }
+
+  return activeButtons.map(button => ({title: button.title}));
+}
+
 function openNotificationLinks()
 {
   if (activeNotification.links)
   {
-    activeNotification.links.forEach(function(link)
-    {
-      ext.windows.getLastFocused(function(win)
-      {
-        win.openTab(Utils.getDocLink(link));
-      });
-    });
+    for (let link of activeNotification.links)
+      ext.pages.open(Utils.getDocLink(link));
   }
 }
 
 function notificationButtonClick(buttonIndex)
 {
-  if (activeNotification.type == "question")
+  switch (activeButtons[buttonIndex].type)
   {
-    NotificationStorage.triggerQuestionListeners(activeNotification.id, buttonIndex == 0);
-    NotificationStorage.markAsShown(activeNotification.id);
-    activeNotification.onClicked();
-  }
-  else if (activeNotification.links && activeNotification.links[buttonIndex])
-  {
-    ext.windows.getLastFocused(function(win)
-    {
-      win.openTab(Utils.getDocLink(activeNotification.links[buttonIndex]));
-    });
+    case "link":
+      ext.pages.open(Utils.getDocLink(activeNotification.links[buttonIndex]));
+      break;
+    case "open-all":
+      openNotificationLinks();
+      break;
+    case "configure":
+      Prefs.notifications_showui = true;
+      ext.showOptions(function(page)
+      {
+        page.sendMessage({
+          type: "focus-section",
+          section: "notifications"
+        });
+      });
+      break;
+    case "question":
+      NotificationStorage.triggerQuestionListeners(activeNotification.id, buttonIndex == 0);
+      NotificationStorage.markAsShown(activeNotification.id);
+      activeNotification.onClicked();
+      break;
   }
 }
 
 function notificationClosed()
 {
   activeNotification = null;
 }
 
 function imgToBase64(url, callback)
 {
@@ skipping 40 matching lines @@
   if (activeNotification && activeNotification.id == notification.id)
     return;
 
   activeNotification = notification;
   if (shouldDisplay("notification", activeNotification.type))
   {
     let texts = NotificationStorage.getLocalizedTexts(notification);
     let title = texts.title || "";
     let message = texts.message ? texts.message.replace(/<\/?(a|strong)>/g, "") : "";
     let iconUrl = ext.getURL("icons/detailed/abp-128.png");
-    let hasLinks = activeNotification.links && activeNotification.links.length > 0;
+    let linkCount = (activeNotification.links || []).length;
 
     if (canUseChromeNotifications)
     {
       let opts = {
         type: "basic",
         title: title,
         message: message,
-        buttons: [],
+        buttons: getNotificationButtons(texts.message),
         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
-      {
-        let regex = /<a>(.*?)<\/a>/g;
-        let plainMessage = texts.message || "";
-        let match;
-        while (match = regex.exec(plainMessage))
-          opts.buttons.push({title: match[1]});
-      }
 
       imgToBase64(iconUrl, function(iconData)
       {
-        opts["iconUrl"] = iconData;
+        opts.iconUrl = iconData;
         chrome.notifications.create("", opts, function() {});
       });
     }
     else if ("Notification" in window && activeNotification.type != "question")
     {
-      if (hasLinks)
+      if (linkCount > 0)
         message += " " + ext.i18n.getMessage("notification_without_buttons");
 
       imgToBase64(iconUrl, function(iconData)
       {
         let notification = new Notification(
           title,
           {
             lang: Utils.appLocale,
             dir: ext.i18n.getMessage("@@bidi_dir"),
             body: message,
             icon: iconData
           }
         );
 
         notification.addEventListener("click", openNotificationLinks);
         notification.addEventListener("close", notificationClosed);
       });
     }
     else
     {
       let message = title + "\n" + message;
-      if (hasLinks)
+      if (linkCount > 0)
         message += "\n\n" + ext.i18n.getMessage("notification_with_buttons");
 
       let approved = confirm(message);
       if (activeNotification.type == "question")
         notificationButtonClick(approved ? 0 : 1);
       else if (approved)
         openNotificationLinks();
     }
   }
   prepareNotificationIconAndPopup();
@@ skipping 22 matching lines @@
 /**
  * Gets the active notification to be shown if any.
  *
  * @return {?object}
  */
 exports.getActiveNotification = function()
 {
   return activeNotification;
 };
 
+let shouldDisplay =
 /**
  * Determines whether a given display method should be used for a
  * specified notification type.
  * 
  * @param {string} method Display method: icon, notification or popup
  * @param {string} notificationType
  * @return {boolean}
  */
-exports.shouldDisplay = shouldDisplay;
-function shouldDisplay(method, notificationType)
+exports.shouldDisplay = function(method, notificationType)
 {
   let methods = displayMethods[notificationType] || defaultDisplayMethods;
   return methods.indexOf(method) > -1;
 }
 
 NotificationStorage.addShowListener(showNotification);