Issue 7312 - Ignore lone pure generic filters for specific-only queries

lib/matcher.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present 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 450 matching lines @@
             return filter;
           }
         }
       }
     }
 
     return null;
   }
 
   _checkEntryMatchSimple(keyword, location, typeMask, docDomain, thirdParty,
-                         sitekey, specificOnly, collection)
+                         sitekey, collection)
   {
     let filters = this._simpleFiltersByKeyword.get(keyword);
     if (filters)
     {
       let lowerCaseLocation = location.toLowerCase();
 
       for (let filter of filters)
       {
-        if (specificOnly && !(filter instanceof WhitelistFilter))

[Manish Jethani, 2019/02/26 11:54:24]

There's no need for this check. We already decided not to check for the type of
the filter (changeset df4fb2d41cbf), and "simple" filters are generic by
definition.

-          continue;
-
         if (filter.matchesLocation(location, lowerCaseLocation))
         {
           if (!collection)
             return filter;
 
           collection.push(filter);
         }
       }
     }
 
     return null;
   }
 
   _checkEntryMatchForType(keyword, location, typeMask, docDomain, thirdParty,
                           sitekey, specificOnly, collection)
   {
     let filtersForType = this._filterMapsByType.get(typeMask);
     if (filtersForType)
     {
       let filters = filtersForType.get(keyword);
       if (filters)
       {
         for (let filter of filters)
         {
-          if (specificOnly && filter.isGeneric() &&

[Manish Jethani, 2019/02/26 11:54:24]

We decided not to do these checks in Matcher (changeset df4fb2d41cbf).
CombinedMatcher should not pass the specific-only flag to the whitelist matcher.

-              !(filter instanceof WhitelistFilter))
+          if (specificOnly && filter.isGeneric())
             continue;
 
           if (filter.matches(location, typeMask, docDomain, thirdParty,
                              sitekey))
           {
             if (!collection)
               return filter;
 
             collection.push(filter);
           }
@@ skipping 12 matching lines @@
     {
       if (filtersByDomain instanceof Map)
       {
         return this._matchFiltersByDomain(filtersByDomain, location, typeMask,
                                           docDomain, thirdParty, sitekey,
                                           specificOnly, collection);
       }
 
       // Because of the memory optimization in the add function, most of the
       // time this will be a filter rather than a map.
-      return this._matchFilterWithoutDomain(filtersByDomain, location,
-                                            typeMask, thirdParty, sitekey,
-                                            collection);
+
+      // Also see #7312: If it's a single filter, it's always the equivalent of
+      // Map { "" => Map { filter => true } } (i.e. applies to any domain). If
+      // the specific-only flag is set, we skip it.
+      if (!specificOnly)
+      {
+        return this._matchFilterWithoutDomain(filtersByDomain, location,
+                                              typeMask, thirdParty, sitekey,
+                                              collection);
+      }
     }
 
     return null;
   }
 
   /**
    * Checks whether the entries for a particular keyword match a URL
    * @param {string} keyword
    * @param {string} location
    * @param {number} typeMask
@@ skipping 10 matching lines @@
    */
   checkEntryMatch(keyword, location, typeMask, docDomain, thirdParty, sitekey,
                   specificOnly, collection)
   {
     // We need to skip the simple (location-only) filters if the type mask does
     // not contain any default content types.
     if (!specificOnly && (typeMask & DEFAULT_TYPES) != 0)
     {
       let filter = this._checkEntryMatchSimple(keyword, location, typeMask,
                                                docDomain, thirdParty, sitekey,
-                                               specificOnly, collection);
+                                               collection);
       if (filter)
         return filter;
     }
 
     // If the type mask contains a non-default type (first condition) and it is
     // the only type in the mask (second condition), we can use the
     // type-specific map, which typically contains a lot fewer filters. This
     // enables faster lookups for whitelisting types like $document, $elemhide,
     // and so on, as well as other special types like $csp.
     if ((typeMask & NON_DEFAULT_TYPES) != 0 && (typeMask & typeMask - 1) == 0)
@@ skipping 305 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;