Issue 616 - Add $generichide + $genericblock filter options and enforce them.

lib/contentPolicy.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/>.
  */
 
 /**
  * @fileOverview Content policy implementation, responsible for blocking things.
  */
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 
 let {Utils} = require("utils");
 let {Prefs} = require("prefs");
 let {FilterStorage} = require("filterStorage");
-let {BlockingFilter, WhitelistFilter} = require("filterClasses");
+let {BlockingFilter, WhitelistFilter, RegExpFilter} = require("filterClasses");
 let {defaultMatcher} = require("matcher");
 let {objectMouseEventHander} = require("objectTabs");
 let {RequestNotifier} = require("requestNotifier");
 let {ElemHide} = require("elemHide");
 
 /**
  * List of explicitly supported content types
- * @type Array of String
+ * @type string[]
  */
 let contentTypes = ["OTHER", "SCRIPT", "IMAGE", "STYLESHEET", "OBJECT", "SUBDOCUMENT", "DOCUMENT", "XMLHTTPREQUEST", "OBJECT_SUBREQUEST", "FONT", "MEDIA"];
 
 /**
  * List of content types that aren't associated with a visual document area
- * @type Array of String
+ * @type string[]
  */
 let nonVisualTypes = ["SCRIPT", "STYLESHEET", "XMLHTTPREQUEST", "OBJECT_SUBREQUEST", "FONT"];
 
 /**
  * Randomly generated class name, to be applied to collapsed nodes.
  */
 let collapsedClass = "";
 
 /**
  * Public policy checking functions and auxiliary objects
  * @class
  */
 let Policy = exports.Policy =
 {
   /**
    * Map of content type identifiers by their name.
    * @type Object
    */
   type: {},
 
   /**
    * Map of content type names by their identifiers (reverse of type map).
    * @type Object
    */
   typeDescr: {},
+
+  /**
+   * Map of numerical content types with their corresponding masks
+   * @type Object
+   */
+  typeMask: {},
 
   /**
    * Map of localized content type names by their identifiers.
    * @type Object
    */
   localizedDescr: {},
 
   /**
    * Lists the non-visual content types.
    * @type Object
@@ skipping 14 matching lines @@
     // type constant by type description and type description by type constant
     let iface = Ci.nsIContentPolicy;
     for (let typeName of contentTypes)
     {
       if ("TYPE_" + typeName in iface)
       {
         let id = iface["TYPE_" + typeName];
         this.type[typeName] = id;
         this.typeDescr[id] = typeName;
         this.localizedDescr[id] = Utils.getString("type_label_" + typeName.toLowerCase());
+        this.typeMask[id] = RegExpFilter.typeMap[typeName];
       }
     }
 
     this.type.ELEMHIDE = 0xFFFD;
     this.typeDescr[0xFFFD] = "ELEMHIDE";
     this.localizedDescr[0xFFFD] = Utils.getString("type_label_elemhide");
+    this.typeMask[0xFFFD] = RegExpFilter.typeMap.ELEMHIDE;
 
     this.type.POPUP = 0xFFFE;
     this.typeDescr[0xFFFE] = "POPUP";
     this.localizedDescr[0xFFFE] = Utils.getString("type_label_popup");
+    this.typeMask[0xFFFE] = RegExpFilter.typeMap.POPUP;
 
     for (let type of nonVisualTypes)
       this.nonVisual[this.type[type]] = true;
 
     // whitelisted URL schemes
     for (let scheme of Prefs.whitelistschemes.toLowerCase().split(" "))
       this.whitelistSchemes[scheme] = true;
 
     // Generate class identifier used to collapse node and register corresponding
     // stylesheet.
@@ skipping 24 matching lines @@
   {
     let topWnd = wnd.top;
     if (!topWnd || !topWnd.location || !topWnd.location.href)
       return true;
 
     let originWindow = Utils.getOriginWindow(wnd);
     let wndLocation = originWindow.location.href;
     let docDomain = getHostname(wndLocation);
     let match = null;
     let [sitekey, sitekeyWnd] = getSitekey(wnd);
-    let genericblock = { match: null };
+    let nogeneric = false;
+
     if (!match && Prefs.enabled)
     {
       let testWnd = wnd;
       let testSitekey = sitekey;
       let testSitekeyWnd = sitekeyWnd;
       let parentWndLocation = getWindowLocation(testWnd);
       while (true)
       {
         let testWndLocation = parentWndLocation;
         parentWndLocation = (testWnd == testWnd.parent ? testWndLocation : getWindowLocation(testWnd.parent));
         match = Policy.isWhitelisted(testWndLocation, parentWndLocation, testSitekey);
 
         if (match instanceof WhitelistFilter)
         {
           FilterStorage.increaseHitCount(match, wnd);
           RequestNotifier.addNodeData(testWnd.document, topWnd, Policy.type.DOCUMENT, getHostname(parentWndLocation), false, testWndLocation, match);
           return true;
         }
-        else if (!(genericblock.match instanceof WhitelistFilter) && contentType != Policy.type.ELEMHIDE)
-        {
-          let parentDocDomain = getHostname(parentWndLocation);
-          genericblock.match = defaultMatcher.matchesAny(testWndLocation, "GENERICBLOCK", parentDocDomain, false);
-          if (genericblock.match instanceof WhitelistFilter)
-          {
-            genericblock.parentDocDomain = parentDocDomain;
-            genericblock.testWnd = testWnd;
-            genericblock.testWndLocation = testWndLocation;
-          }
+
+        let genericType = (contentType == Policy.type.ELEMHIDE ?
+                           RegExpFilter.typeMap.GENERICHIDE :
+                           RegExpFilter.typeMap.GENERICBLOCK);
+        let parentDocDomain = getHostname(parentWndLocation);
+        let nogenericMatch = defaultMatcher.matchesAny(
+          testWndLocation, genericType, parentDocDomain, false, testSitekey
+        );
+        if (nogenericMatch instanceof WhitelistFilter)
+        {
+          nogeneric = true;
+
+          FilterStorage.increaseHitCount(nogenericMatch, wnd);
+          RequestNotifier.addNodeData(testWnd.document, topWnd, contentType,
+                                      parentDocDomain, false, testWndLocation,
+                                      nogenericMatch);
         }
 
         if (testWnd.parent == testWnd)
           break;
 
         if (testWnd == testSitekeyWnd)
           [testSitekey, testSitekeyWnd] = getSitekey(testWnd.parent);
         testWnd = testWnd.parent;
       }
     }
 
     // Data loaded by plugins should be attached to the document
     if (contentType == Policy.type.OBJECT_SUBREQUEST && node instanceof Ci.nsIDOMElement)
       node = node.ownerDocument;
 
     // Fix type for objects misrepresented as frames or images
     if (contentType != Policy.type.OBJECT && (node instanceof Ci.nsIDOMHTMLObjectElement || node instanceof Ci.nsIDOMHTMLEmbedElement))
       contentType = Policy.type.OBJECT;
 
     let locationText = location.spec;
     if (!match && contentType == Policy.type.ELEMHIDE)
     {
       let testWnd = wnd;
       let parentWndLocation = getWindowLocation(testWnd);
       while (true)
       {
         let testWndLocation = parentWndLocation;
         parentWndLocation = (testWnd == testWnd.parent ? testWndLocation : getWindowLocation(testWnd.parent));
         let parentDocDomain = getHostname(parentWndLocation);
-        match = defaultMatcher.matchesAny(testWndLocation, "ELEMHIDE", parentDocDomain, false);
-
-        if (!(match instanceof WhitelistFilter) && (!location.domains || location.domains[""]))
-          match = defaultMatcher.matchesAny(testWndLocation, "GENERICHIDE", parentDocDomain, false);
-
+        match = defaultMatcher.matchesAny(testWndLocation, RegExpFilter.typeMap.ELEMHIDE, parentDocDomain, false, sitekey);
         if (match instanceof WhitelistFilter)
         {
           FilterStorage.increaseHitCount(match, wnd);
           RequestNotifier.addNodeData(testWnd.document, topWnd, contentType, parentDocDomain, false, testWndLocation, match);
           return true;
         }
 
         if (testWnd.parent == testWnd)
           break;
         else
           testWnd = testWnd.parent;
       }
 
       match = location;
       locationText = match.text.replace(/^.*?#/, '#');
       location = locationText;
 
       if (!match.isActiveOnDomain(docDomain))
         return true;
 
       let exception = ElemHide.getException(match, docDomain);
       if (exception)
       {
         FilterStorage.increaseHitCount(exception, wnd);
         RequestNotifier.addNodeData(node, topWnd, contentType, docDomain, false, locationText, exception);
         return true;
       }
+
+      if (nogeneric && match.isGeneric())
+        return true;
     }
 
     let thirdParty = (contentType == Policy.type.ELEMHIDE ? false : isThirdParty(location, docDomain));
 
-    if (!match && Prefs.enabled)
-    {
-      match = defaultMatcher.matchesAny(locationText, Policy.typeDescr[contentType] || "", docDomain, thirdParty, sitekey);
-      if (match instanceof BlockingFilter)
-      {
-        if ((!match.domains || match.domains[""]) && genericblock.match instanceof WhitelistFilter)
-        {
-          FilterStorage.increaseHitCount(genericblock.match, wnd);
-          RequestNotifier.addNodeData(
-            genericblock.testWnd.document,
-            topWnd, contentType,
-            genericblock.parentDocDomain,
-            false, genericblock.testWndLocation,
-            genericblock.match
-          );
-          return true;
-        }
-
-        if (node.ownerDocument && !(contentType in Policy.nonVisual))
-        {
-          let prefCollapse = (match.collapse != null ? match.collapse : !Prefs.fastcollapse);
-          if (collapse || prefCollapse)
-            schedulePostProcess(node);
-        }
+    if (!match && Prefs.enabled && contentType in Policy.typeMask)
+    {
+      match = defaultMatcher.matchesAny(locationText, Policy.typeMask[contentType],
+                                        docDomain, thirdParty, sitekey, nogeneric);
+      if (match instanceof BlockingFilter && node.ownerDocument && !(contentType in Policy.nonVisual))
+      {
+        let prefCollapse = (match.collapse != null ? match.collapse : !Prefs.fastcollapse);
+        if (collapse || prefCollapse)
+          schedulePostProcess(node);
       }
 
       // Track mouse events for objects
       if (!match && contentType == Policy.type.OBJECT && node.nodeType == Ci.nsIDOMNode.ELEMENT_NODE)
       {
         node.addEventListener("mouseover", objectMouseEventHander, true);
         node.addEventListener("mouseout", objectMouseEventHander, true);
       }
     }
 
@@ skipping 33 matching lines @@
       return null;
 
     if (!parentUrl)
       parentUrl = url;
 
     // Ignore fragment identifier
     let index = url.indexOf("#");
     if (index >= 0)
       url = url.substring(0, index);
 
-    let result = defaultMatcher.matchesAny(url, "DOCUMENT", getHostname(parentUrl), false, sitekey);
+    let result = defaultMatcher.matchesAny(url, RegExpFilter.typeMap.DOCUMENT, getHostname(parentUrl), false, sitekey);
     return (result instanceof WhitelistFilter ? result : null);
   },
 
   /**
    * Checks whether the page loaded in a window is whitelisted for indication in the UI.
    * @param wnd {nsIDOMWindow}
    * @return {Filter} matching exception rule or null if not whitelisted
    */
   isWindowWhitelisted: function(wnd)
   {
     return Policy.isWhitelisted(getWindowLocation(wnd));
   },
 
   /**
    * Asynchronously re-checks filters for given nodes.
-   */
-  refilterNodes: function(/**Node[]*/ nodes, /**RequestEntry*/ entry)
+   * @param {Node[]} nodes
+   * @param {RequestEntry} entry
+   */
+  refilterNodes: function(nodes, entry)
   {
     // Ignore nodes that have been blocked already
     if (entry.filter && !(entry.filter instanceof WhitelistFilter))
       return;
 
     for (let node of nodes)
-      Utils.runAsync(refilterNode, this, node, entry);
+      Utils.runAsync(() => refilterNode(node, entry));
   }
 };
 Policy.init();
 
 /**
  * Actual nsIContentPolicy and nsIChannelEventSink implementation
  * @class
  */
 let PolicyImplementation =
 {
   classDescription: "Adblock Plus content policy",
   classID: Components.ID("cfeaabe6-1dd1-11b2-a0c6-cb5c268894c9"),
   contractID: "@adblockplus.org/abp/policy;1",
   xpcom_categories: ["content-policy", "net-channel-event-sinks"],
 
   /**
    * Registers the content policy on startup.
    */
   init: function()
   {
     let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
     try
     {
       registrar.registerFactory(this.classID, this.classDescription, this.contractID, this);
     }
-    catch (e if e.result == Cr.NS_ERROR_FACTORY_EXISTS)
+    catch (e)
     {
       // See bug 924340 - it might be too early to init now, the old version
       // we are replacing didn't finish removing itself yet.
-      Utils.runAsync(this.init.bind(this));
-      return;
+      if (e.result == Cr.NS_ERROR_FACTORY_EXISTS)
+      {
+        Utils.runAsync(this.init.bind(this));
+        return;
+      }
+
+      Cu.reportError(e);
     }
 
     let catMan = Utils.categoryManager;
     for (let category of this.xpcom_categories)
       catMan.addCategoryEntry(category, this.contractID, this.contractID, false, true);
 
     // http-on-opening-request is new in Gecko 18, http-on-modify-request can
     // be used in earlier releases.
     let httpTopic = "http-on-opening-request";
     if (Services.vc.compare(Utils.platformVersion, "18.0") < 0)
@@ skipping 85 matching lines @@
     {
       case "content-document-global-created":
       {
         if (!(subject instanceof Ci.nsIDOMWindow) || !subject.opener)
           return;
 
         let uri = additional || Utils.makeURI(subject.location.href);
         if (!Policy.processNode(subject.opener, subject.opener.document, Policy.type.POPUP, uri, false))
         {
           subject.stop();
-          Utils.runAsync(subject.close, subject);
+          Utils.runAsync(() => subject.close());
         }
         else if (uri.spec == "about:blank")
         {
           // An about:blank pop-up most likely means that a load will be
           // initiated synchronously. Set a flag for our "http-on-opening-request"
           // handler.
           this.expectingPopupLoad = true;
           Utils.runAsync(function()
           {
             this.expectingPopupLoad = false;
@@ skipping 122 matching lines @@
   {
     if (outer)
       throw Cr.NS_ERROR_NO_AGGREGATION;
     return this.QueryInterface(iid);
   }
 };
 PolicyImplementation.init();
 
 /**
  * Nodes scheduled for post-processing (might be null).
- * @type Array of Node
+ * @type Node[]
  */
 let scheduledNodes = null;
 
 /**
  * Schedules a node for post-processing.
  */
 function schedulePostProcess(/**Element*/ node)
 {
   if (scheduledNodes)
     scheduledNodes.push(node);
@@ skipping 169 matching lines @@
   if (!wnd || wnd.closed)
     return;
 
   if (entry.type == Policy.type.OBJECT)
   {
     node.removeEventListener("mouseover", objectMouseEventHander, true);
     node.removeEventListener("mouseout", objectMouseEventHander, true);
   }
   Policy.processNode(wnd, node, entry.type, Utils.makeURI(entry.location), true);
 }