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
@@ skipping 144 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 = null;
-    let generichide = null;

[Wladimir Palant, 2015/09/03 13:09:42]

It's either a blocking rule or hiding rule - so at most one of these variables
will be used. I suggest having a single variable called nogeneric here.

[kzar, 2015/09/05 14:39:58]

Done.

+    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;
         }
 
-        if (contentType != Policy.type.ELEMHIDE)
-        {
-          let parentDocDomain = getHostname(parentWndLocation);
-          let genericblockMatch = defaultMatcher.matchesAny(
-            testWndLocation, RegExpFilter.typeMap.GENERICBLOCK,
-            parentDocDomain, false, testSitekey
-          );
-          if (genericblockMatch instanceof WhitelistFilter)
-          {
-            genericblock = {
-              match: genericblockMatch,
-              parentDocDomain: parentDocDomain,
-              testWnd: testWnd,
-              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, 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;
-        }
-
-        let generichideMatch = defaultMatcher.matchesAny(
-          testWndLocation, RegExpFilter.typeMap.GENERICHIDE,
-          parentDocDomain, false, sitekey
-        );
-        if (generichideMatch instanceof WhitelistFilter)
-        {
-          generichide = {
-            match: generichideMatch,
-            parentDocDomain: parentDocDomain,
-            testWnd: testWnd,
-            testWndLocation: testWndLocation
-          };
         }

[Wladimir Palant, 2015/09/03 13:09:42]

This is simply duplicating the logic from above. I suggest that you merge this
with the check above - for contentType == Policy.type.ELEMHIDE you should check
for RegExpFilter.typeMap.GENERICHIDE, otherwise
RegExpFilter.typeMap.GENERICBLOCK. And the same variable as mentioned above.

[kzar, 2015/09/05 14:39:58]

Done.

 
         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 (generichide && match && match.isGeneric())
-      {
-        FilterStorage.increaseHitCount(generichide.match, wnd);
-        RequestNotifier.addNodeData(
-          generichide.testWnd.document,
-          topWnd, contentType,
-          generichide.parentDocDomain,
-          false, generichide.testWndLocation,
-          generichide.match
-        );
+      if (nogeneric && match.isGeneric())
         return true;
-      }
     }
 
     let thirdParty = (contentType == Policy.type.ELEMHIDE ? false : isThirdParty(location, docDomain));
 
     if (!match && Prefs.enabled && contentType in Policy.typeMask)
     {
-      match = defaultMatcher.matchesAny(locationText, Policy.typeMask[contentType], docDomain, thirdParty, sitekey);
-      if (match instanceof BlockingFilter)
-      {
-        if (genericblock && match.isGeneric())

[Wladimir Palant, 2015/09/03 13:09:43]

What if there are multiple filters potentially matching here, one that is
generic and another that isn't? You cannot rely on Matcher.matchesAny() to
always return the latter.

[kzar, 2015/09/04 15:49:10]

Hmm good point, any suggestions? In the other review I add a specificOnly
parameter to matchesAny(), so one option would be to search for a specific rule
here before deciding the genericblock exception should be used. That would mean
adding another search however.

[Wladimir Palant, 2015/09/04 16:16:23]

Why another search? Just pass specificOnly and be done with it. Yes, you won't
know whether the $genericelemhide exception really had any effect - but you can
just count this hit unconditionally. It's sufficient to know that the
$genericelemhide exception applied on that page, no real need to know whether it
had any effect (see $document exceptions, they work the same).

Note that there are the same issues with $genericelemhide currently, these
cannot be solved in Firefox however.

[kzar, 2015/09/05 14:39:58]

Oh, of course! Done.

-        {
-          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);
-        }
+      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 534 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);
 }