Issue 1965 - Simplified and fixed missing image for icon animation

background.js

 /*
- * This file is part of Adblock Plus <http://adblockplus.org/>,
- * Copyright (C) 2006-2013 Eyeo GmbH
+ * 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/>.
  */
 
 with(require("filterClasses"))
 {
   this.Filter = Filter;
   this.RegExpFilter = RegExpFilter;
   this.BlockingFilter = BlockingFilter;
   this.WhitelistFilter = WhitelistFilter;
 }
 with(require("subscriptionClasses"))
 {
   this.Subscription = Subscription;
   this.DownloadableSubscription = DownloadableSubscription;
+  this.SpecialSubscription = SpecialSubscription;
 }
 with(require("whitelisting"))
 {
-  this.isWhitelisted = isWhitelisted;
+  this.isPageWhitelisted = isPageWhitelisted;
   this.isFrameWhitelisted = isFrameWhitelisted;
-  this.processKeyException = processKeyException;
+  this.processKey = processKey;
+  this.getKey = getKey;
+}
+with(require("url"))
+{
+  this.stringifyURL = stringifyURL;
+  this.isThirdParty = isThirdParty;
+  this.extractHostFromFrame = extractHostFromFrame;
+}
+with(require("icon"))
+{
+  this.updateIcon = updateIcon;
+  this.startIconAnimation = startIconAnimation;
+  this.stopIconAnimation = stopIconAnimation;
 }
 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 NotificationStorage = require("notification").Notification;
+var initAntiAdblockNotification = require("antiadblockInit").initAntiAdblockNotification;
+var parseFilters = require("filterValidation").parseFilters;
 
 // Some types cannot be distinguished
 RegExpFilter.typeMap.OBJECT_SUBREQUEST = RegExpFilter.typeMap.OBJECT;
 RegExpFilter.typeMap.MEDIA = RegExpFilter.typeMap.FONT = RegExpFilter.typeMap.OTHER;
 
-var isFirstRun = false;
+// 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, 10) > 34);
+
 var seenDataCorruption = false;
+var filterlistsReinitialized = false;
 require("filterNotifier").FilterNotifier.addListener(function(action)
 {
   if (action == "load")
   {
-    var importingOldData = importOldData();
-
     var addonVersion = require("info").addonVersion;
-    var prevVersion = localStorage.currentVersion;
-    if (prevVersion != addonVersion)
-    {
-      isFirstRun = !prevVersion;
-      localStorage.currentVersion = addonVersion;
-      if (!importingOldData)
-        addSubscription(prevVersion);
-    }
+    var prevVersion = ext.storage.currentVersion;
+
+    // There are no filters stored so we need to reinitialize all filterlists
+    if (!FilterStorage.firstRun && FilterStorage.subscriptions.length === 0)
+    {
+      filterlistsReinitialized = true;
+      prevVersion = null;
+    }
+
+    if (prevVersion != addonVersion || FilterStorage.firstRun)
+    {
+      seenDataCorruption = prevVersion && FilterStorage.firstRun;
+      ext.storage.currentVersion = addonVersion;
+      addSubscription(prevVersion);
+    }
+
+    if (canUseChromeNotifications)
+      initChromeNotifications();
+    initAntiAdblockNotification();
+
+    // The "Hide placeholders" option has been removed from the UI in 1.8.8.1285
+    // So we reset the option for users updating from older versions.
+    if (prevVersion && Services.vc.compare(prevVersion, "1.8.8.1285") < 0)
+      Prefs.hidePlaceholders = true;
   }
 
   // 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++)
-      {
-        windows[i].getAllTabs(function(tabs)
-        {
-          tabs.forEach(refreshIconAndContextMenu);
-        });
-      }
-    });
-  }
+    refreshIconAndContextMenuForAllPages();
 });
 
 // Special-case domains for which we cannot use style-based hiding rules.
 // See http://crbug.com/68705.
 var noStyleRulesHosts = ["mail.google.com", "mail.yahoo.com", "www.google.com"];
 
+var htmlPages = new ext.PageMap();
+
 function removeDeprecatedOptions()
 {
   var deprecatedOptions = ["specialCaseYouTube", "experimental", "disableInlineTextAds"];
   deprecatedOptions.forEach(function(option)
   {
-    if (option in localStorage)
-      delete localStorage[option];
+    if (option in ext.storage)
+      delete ext.storage[option];
   });
 }
 
 // Remove deprecated options before we do anything else.
 removeDeprecatedOptions();
 
 var activeNotification = null;
 
-function getTabStatus(tab, animation)
-{
-  var whitelisted = isWhitelisted(tab.url);
-
-  var icon;
-  if (require("info").platform == "safari")
-    // pick an icon with approtiate size for Safari. However since
-    // toolbar item icons can't use different colors, we don't have
-    // different versions indicating whether the page is whitelisted
-    icon = "icons/abp-16";
-  else
-  {
-    // pick an icon with the approtiate size for Chrome/Opera
-    // that indicates whether the page is whitelisted
-    if (whitelisted && (!animation || animation.step < 10))

[Felix Dahlke, 2014/02/27 22:02:05]

So we will use the red ABP icon if the animation step is >= 10? Why not the grey
one?

[Sebastian Noack, 2014/02/28 08:35:16]

We are neither going to use the red default nor the gray whitelisted icon, but
the notification icon at full opacity, which is the same for both states, and is
called "abp-[16|19]-notification-[information|critical].png".

-      icon = "icons/abp-19-whitelisted";
-    else
-      icon = "icons/abp-19";
-  }
-
-  // pick the current frame if the icon is currently animating
-  // in order to indicate a pending notification
-  if (animation && animation.step > 0)
-  {
-    icon += "-notification-";
-    icon += animation.severity;

[Wladimir Palant, 2014/03/06 14:31:35]

Nit: why split this to two statements? This seems more intuitive:

  icon += "-notification-" + animation.severity;

Same below with animation.step.

[Sebastian Noack, 2014/03/06 20:41:13]

I found it slightly more readable to have one operation per line here.
Done.

-
-    if (animation.step < 10)
-    {
-      icon += "-";
-      icon += animation.step;
-    }
-  }
-
-  icon += ".png";
-
-  return {icon: icon, whitelisted: whitelisted};
-}
-
-function refreshIconAndContextMenu(tab)
-{
-  var status = getTabStatus(tab);
-
-  // update icon indicating whether the page is whitelisted.
-  // But don't interfere the icon animation if active.

[Felix Dahlke, 2014/02/27 22:02:05]

s/interfere/interrupt/?

[Sebastian Noack, 2014/02/28 08:35:16]

Don't know. It wouldn't just pause the animation, but inject a wrong frame
(showing the default icon) into the animation. Do you call that interrupting or
interfering?

[Wladimir Palant, 2014/03/06 14:31:35]

If we now have a generic function to calculate the icon, why add this special
case in the first place?

  var animation = iconAnimation.tabs.get(tab) ? iconAnimation : null;

This can be added to getTabStatus() instead of the animation parameter. And then
you will always set the correct icon, animation or not.

[Wladimir Palant, 2014/03/06 14:34:33]

In fact, this isn't even necessary. If iconAnimation.stop() resets
iconAnimation.step to zero then getTabStatus() can just always work with
iconAnimation.step. Not sure whether iconAnimation.tabs is even required then.

[Sebastian Noack, 2014/03/06 20:41:13]

Done.

On 2014/03/06 14:34:33, Wladimir Palant wrote:
The reason this is necessary is that otherwise when you open a new tab while the
animation is running, the icon for the new tab will be a still of the current
step of the animation.

[Wladimir Palant, 2014/03/06 20:49:44]

Isn't that exactly the issue that registerTab() was addressing? The animation
should be running for new tabs as well. You seem to have overlooked that
comment.

[Sebastian Noack, 2014/03/07 17:26:11]

Now it is addressed within getTabStatus() as you suggested.

[Wladimir Palant, 2014/03/07 22:13:29]

Still missing something that would start the animation for new tabs (like the
registerTab() function you removed).

[Sebastian Noack, 2014/03/08 11:36:39]

Considering that the animation is interrupted anyway when you switch to an other
open tab, I don't know it is worth to  keep the animation running while opening
a new tab. If we don't want to interrupt the animation when switching tabs, we
would have to update the icon always for all tabs. What do you think?

[Wladimir Palant, 2014/03/21 14:10:11]

Why interrupted? The animation step doesn't change when you open a new tab. So
the icon we show for this tab should be correct - if we consider the animation
there at all.

[Sebastian Noack, 2014/03/31 13:20:32]

Since the icon is set per tab, when the active tab changes, the icon changes as
well.

Of course we could update the icon every time a new tab becomes active. But
beside that case, onActivated wouldn't be needed anymore and therefore is going
to be removed with http://codereview.adblockplus.org/5464830253203456/.

Alternatively we could update the icon for every tab, regardless whether it is
visible or not, while animating.

Or we could limit the animation to the tabs that were visible when the animation
started. This is how it is currently implemented.

-  // In that case the icon animation takes care to update
-  // the icon to its new status with its next frame.
-  if (!iconAnimation.tabs.has(tab))
-    tab.browserAction.setIcon(status.icon);
+var contextMenuItem = {
+  title: ext.i18n.getMessage("block_element"),
+  contexts: ["image", "video", "audio"],
+  onclick: function(page)
+  {
+    page.sendMessage({type: "clickhide-new-filter"});
+  }
+};
+
+// Adds or removes browser action icon according to options.
+function refreshIconAndContextMenu(page)
+{
+  var whitelisted = isPageWhitelisted(page);
+  updateIcon(page, whitelisted);
 
   // show or hide the context menu entry dependent on whether
-  // adblocking is active in the tab
-  if (status.whitelisted || !/^https?:/.test(tab.url))
-    ext.contextMenus.hideMenuItems();
-  else
-    ext.contextMenus.showMenuItems();
-}
-
-/**
- * Old versions for Opera stored patterns.ini in the localStorage object, this
- * will import it into FilterStorage properly.
- * @return {Boolean} true if data import is in progress
- */
-function importOldData()
-{
-  if ("patterns.ini" in localStorage)
-  {
-    FilterStorage.loadFromDisk(localStorage["patterns.ini"]);
-
-    var remove = [];
-    for (var key in localStorage)
-      if (key.indexOf("patterns.ini") == 0 || key.indexOf("patterns-backup") == 0)
-        remove.push(key);
-    for (var i = 0; i < remove.length; i++)
-      delete localStorage[remove[i]];
-
-    return true;
-  }
-  else
-    return false;
+  // adblocking is active on that page
+  page.contextMenus.removeAll();
+  if (Prefs.shouldShowBlockElementMenu && !whitelisted && htmlPages.has(page))
+    page.contextMenus.create(contextMenuItem);
+}
+
+function refreshIconAndContextMenuForAllPages()
+{
+  ext.pages.query({}, function(pages)
+  {
+    pages.forEach(refreshIconAndContextMenu);
+  });
 }
 
 /**
  * This function is called on an extension update. It will add the default
  * filter subscription if necessary.
  */
 function addSubscription(prevVersion)
 {
   // Make sure to remove "Recommended filters", no longer necessary
   var toRemove = "https://easylist-downloads.adblockplus.org/chrome_supplement.txt";
@@ skipping 35 matching lines @@
     {
       subscription.title = "Allow non-intrusive advertising";
       FilterStorage.addSubscription(subscription);
       if (subscription instanceof DownloadableSubscription && !subscription.lastDownload)
         Synchronizer.execute(subscription);
     }
     else
       addAcceptable = false;
   }
 
+  // Add "anti-adblock messages" subscription for new users and users updating from old ABP versions
+  if (!prevVersion || Services.vc.compare(prevVersion, "1.8") < 0)
+  {
+    var subscription = Subscription.fromURL(Prefs.subscriptions_antiadblockurl);
+    if (subscription && !(subscription.url in FilterStorage.knownSubscriptions))
+    {
+      subscription.disabled = true;
+      FilterStorage.addSubscription(subscription);
+      if (subscription instanceof DownloadableSubscription && !subscription.lastDownload)
+        Synchronizer.execute(subscription);
+    }
+  }
+
   if (!addSubscription && !addAcceptable)
     return;
 
   function notifyUser()
   {
-    ext.windows.getLastFocused(function(win)
-    {
-      win.openTab(ext.getURL("firstRun.html"));
-    });
+    ext.pages.open(ext.getURL("firstRun.html"));
   }
 
   if (addSubscription)
   {
     // Load subscriptions data
     var request = new XMLHttpRequest();
     request.open("GET", "subscriptions.xml");
     request.addEventListener("load", function()
     {
       var node = Utils.chooseFilterSubscription(request.responseXML.getElementsByTagName("subscription"));
       var subscription = (node ? Subscription.fromURL(node.getAttribute("url")) : null);
       if (subscription)
       {
         FilterStorage.addSubscription(subscription);
         subscription.disabled = false;
         subscription.title = node.getAttribute("title");
         subscription.homepage = node.getAttribute("homepage");
         if (subscription instanceof DownloadableSubscription && !subscription.lastDownload)
           Synchronizer.execute(subscription);
 
           notifyUser();
       }
     }, false);
     request.send(null);
   }
   else
     notifyUser();
 }
 
-function setContextMenu()
-{
-  if (Prefs.shouldShowBlockElementMenu)
-  {
-    // Register context menu item
-    ext.contextMenus.addMenuItem(ext.i18n.getMessage("block_element"), ["image", "video", "audio"], function(srcUrl, tab)
-    {
-      if (srcUrl)
-        tab.sendMessage({type: "clickhide-new-filter", filter: srcUrl});
-    });
-  }
-  else
-    ext.contextMenus.removeMenuItems();
-}
-
 Prefs.addListener(function(name)
 {
   if (name == "shouldShowBlockElementMenu")
-    setContextMenu();
+    refreshIconAndContextMenuForAllPages();
 });
-setContextMenu();
-
-/**
-  * Opens options tab or focuses an existing one, within the last focused window.
-  * @param {Function} callback  function to be called with the
-                                Tab object of the options tab
-  */
-function openOptions(callback)
-{
-  ext.windows.getLastFocused(function(win)
-  {
-    win.getAllTabs(function(tabs)
-    {
-      var optionsUrl = ext.getURL("options.html");
-
-      for (var i = 0; i < tabs.length; i++)
-      {
-        if (tabs[i].url == optionsUrl)
-        {
-          tabs[i].activate();
-          if (callback)
-            callback(tabs[i]);
-          return;
-        }
-      }
-
-      win.openTab(optionsUrl, callback && function(tab)
-      {
-        tab.onCompleted.addListener(callback);
+
+function prepareNotificationIconAndPopup()
+{
+  var animateIcon = (activeNotification.type !== "question");
+  activeNotification.onClicked = function()
+  {
+    if (animateIcon)
+      stopIconAnimation();
+    notificationClosed();
+  };
+  if (animateIcon)
+    startIconAnimation(activeNotification.type);
+}
+
+function openNotificationLinks()
+{
+  if (activeNotification.links)
+  {
+    activeNotification.links.forEach(function(link)
+    {
+      ext.windows.getLastFocused(function(win)
+      {
+        win.openTab(Utils.getDocLink(link));
       });
     });
+  }
+}
+
+function notificationButtonClick(buttonIndex)
+{
+  if (activeNotification.type === "question")
+  {
+    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]));
+    });
+  }
+}
+
+function notificationClosed()
+{
+  activeNotification = null;
+}
+
+function imgToBase64(url, callback)
+{
+  var canvas = document.createElement("canvas"),
+  ctx = canvas.getContext("2d"),
+  img = new Image;
+  img.src = url;
+  img.onload = function()
+  {
+    canvas.height = img.height;
+    canvas.width = img.width;
+    ctx.drawImage(img, 0, 0);
+    callback(canvas.toDataURL("image/png"));
+    canvas = null;
+  };
+}
+
+function initChromeNotifications()
+{
+  // Chrome hides notifications in notification center when clicked so we need to clear them
+  function clearActiveNotification(notificationId)
+  {
+    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);
   });
-}
-
-function prepareNotificationIconAndPopup()
-{
-  activeNotification.onClicked = function()
-  {
-    iconAnimation.stop();
-    activeNotification = null;
-  };
-
-  iconAnimation.update(activeNotification.severity);
+  chrome.notifications.onClicked.addListener(clearActiveNotification);
+  chrome.notifications.onClosed.addListener(notificationClosed);
 }
 
 function showNotification(notification)
 {
+  if (activeNotification && activeNotification.id === notification.id)
+    return;
+
   activeNotification = notification;
-
-  if (activeNotification.severity === "critical"
-      && typeof webkitNotifications !== "undefined")
-  {
-    var notification = webkitNotifications.createHTMLNotification("notification.html");
-    notification.show();
-    notification.addEventListener("close", prepareNotificationIconAndPopup);
-  }
-  else
-    prepareNotificationIconAndPopup();
+  if (activeNotification.type === "critical" || activeNotification.type === "question")
+  {
+    var texts = NotificationStorage.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;
+
+    if (canUseChromeNotifications)
+    {
+      var opts = {
+        type: "basic",
+        title: title,
+        message: message,
+        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]});
+      }
+
+      imgToBase64(iconUrl, function(iconData)
+      {
+        opts["iconUrl"] = iconData;
+        chrome.notifications.create("", opts, function() {});
+      });
+    }
+    else if ("Notification" in window && activeNotification.type !== "question")
+    {
+      if (hasLinks)
+        message += " " + ext.i18n.getMessage("notification_without_buttons");
+
+      imgToBase64(iconUrl, function(iconData)
+      {
+        var 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
+    {
+      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(approved ? 0 : 1);
+      else if (approved)
+        openNotificationLinks();
+    }
+  }
+  prepareNotificationIconAndPopup();
+}
+
+// This is a hack to speedup loading of the options page on Safari.
+// Once we replaced the background page proxy with message passing
+// this global function should removed.
+function getUserFilters()
+{
+  var filters = [];
+  var exceptions = [];
+
+  for (var i = 0; i < FilterStorage.subscriptions.length; i++)
+  {
+    var subscription = FilterStorage.subscriptions[i];
+    if (!(subscription instanceof SpecialSubscription))
+      continue;
+
+    for (var j = 0; j < subscription.filters.length; j++)
+    {
+      var filter = subscription.filters[j];
+      if (filter instanceof WhitelistFilter &&  /^@@\|\|([^\/:]+)\^\$document$/.test(filter.text))
+        exceptions.push(RegExp.$1);
+      else
+        filters.push(filter.text);
+    }
+  }
+
+  return {filters: filters, exceptions: exceptions};
 }
 
 ext.onMessage.addListener(function (msg, sender, sendResponse)
 {
   switch (msg.type)
   {
     case "get-selectors":
-      var selectors = null;
-
-      if (!isFrameWhitelisted(sender.tab, sender.frame, "DOCUMENT") &&
-          !isFrameWhitelisted(sender.tab, sender.frame, "ELEMHIDE"))
+      var selectors = [];
+
+      if (!isFrameWhitelisted(sender.page, sender.frame, "DOCUMENT") &&
+          !isFrameWhitelisted(sender.page, sender.frame, "ELEMHIDE"))
       {
         var noStyleRules = false;
-        var host = extractHostFromURL(sender.frame.url);
+        var host = extractHostFromFrame(sender.frame);
         for (var i = 0; i < noStyleRulesHosts.length; i++)
         {
           var noStyleHost = noStyleRulesHosts[i];
           if (host == noStyleHost || (host.length > noStyleHost.length &&
                                       host.substr(host.length - noStyleHost.length - 1) == "." + noStyleHost))
           {
             noStyleRules = true;
           }
         }
         selectors = ElemHide.getSelectorsForDomain(host, false);
         if (noStyleRules)
         {
           selectors = selectors.filter(function(s)
           {
             return !/\[style[\^\$]?=/.test(s);
           });
         }
       }
 
       sendResponse(selectors);
       break;
     case "should-collapse":
-      if (isFrameWhitelisted(sender.tab, sender.frame, "DOCUMENT"))
+      if (isFrameWhitelisted(sender.page, sender.frame, "DOCUMENT"))
       {
         sendResponse(false);
         break;
       }
 
-      var requestHost = extractHostFromURL(msg.url);
-      var documentHost = extractHostFromURL(sender.frame.url);
-      var thirdParty = isThirdParty(requestHost, documentHost);
-      var filter = defaultMatcher.matchesAny(msg.url, msg.mediatype, documentHost, thirdParty);
+      var url = new URL(msg.url);
+      var documentHost = extractHostFromFrame(sender.frame);
+      var filter = defaultMatcher.matchesAny(
+        stringifyURL(url), msg.mediatype,
+        documentHost, isThirdParty(url, documentHost)
+      );
+
       if (filter instanceof BlockingFilter)
       {
         var collapse = filter.collapse;
         if (collapse == null)
           collapse = Prefs.hidePlaceholders;
         sendResponse(collapse);
       }
       else
         sendResponse(false);
       break;
     case "get-domain-enabled-state":
       // Returns whether this domain is in the exclusion list.
       // The browser action popup asks us this.
-      if(sender.tab)
-      {
-        sendResponse({enabled: !isWhitelisted(sender.tab.url)});
+      if(sender.page)
+      {
+        sendResponse({enabled: !isPageWhitelisted(sender.page)});
         return;
       }
       break;
     case "add-filters":
-      if (msg.filters && msg.filters.length)
-      {
-        for (var i = 0; i < msg.filters.length; i++)
-          FilterStorage.addFilter(Filter.fromText(msg.filters[i]));
-      }
+      var filters;
+      try
+      {
+        filters = parseFilters(msg.text);
+      }
+      catch (error)
+      {
+        sendResponse({status: "invalid", error: error});
+        break;
+      }
+
+      for (var i = 0; i < filters.length; i++)
+        FilterStorage.addFilter(filters[i]);
+
+      sendResponse({status: "ok"});
       break;
     case "add-subscription":
-      openOptions(function(tab)
-      {
-        tab.sendMessage(msg);
+      ext.showOptions(function(page)
+      {
+        page.sendMessage(msg);
       });
       break;
-    case "add-key-exception":
-      processKeyException(msg.token, sender.tab, sender.frame);
+    case "add-sitekey":
+      processKey(msg.token, sender.page, sender.frame);
+      break;
+    case "report-html-page":
+      htmlPages.set(sender.page, null);
+      refreshIconAndContextMenu(sender.page);
       break;
     case "forward":
-      if (sender.tab)
-      {
-        sender.tab.sendMessage(msg.payload, sendResponse);
-        // Return true to indicate that we want to call
-        // sendResponse asynchronously
-        return true;
-      }
-      break;
-    default:
-      sendResponse({});
+      if (sender.page)
+      {
+        if (msg.expectsResponse)
+        {
+          sender.page.sendMessage(msg.payload, sendResponse);
+          return true;
+        }
+
+        sender.page.sendMessage(msg.payload);
+      }
       break;
   }
 });
 
-// Update icon if a tab changes location
-ext.tabs.onLoading.addListener(function(tab)
-{
-  tab.sendMessage({type: "clickhide-deactivate"});
-  refreshIconAndContextMenu(tab);
+// update icon when page changes location
+ext.pages.onLoading.addListener(function(page)
+{
+  page.sendMessage({type: "clickhide-deactivate"});
+  refreshIconAndContextMenu(page);
 });
 
 setTimeout(function()
 {
-  var notificationToShow = Notification.getNextToShow();
+  var notificationToShow = NotificationStorage.getNextToShow();
   if (notificationToShow)
     showNotification(notificationToShow);
 }, 3 * 60 * 1000);