Issue 6994 - Use shortcut matching for location-only filters

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 49 matching lines @@
 
 /**
  * Blacklist/whitelist filter matching
  */
 class Matcher
 {
   constructor()
   {
     /**
      * Lookup table for simple filters by their associated keyword
      * @type {Map.<string,(RegExpFilter|Set.<RegExpFilter>)>}

[Manish Jethani, 2018/10/25 21:24:10]

Unrelated documentation update, but these can only be RegExpFilter objects.

      * @private
      */
     this._simpleFiltersByKeyword = new Map();
 
     /**
      * Lookup table for complex filters by their associated keyword
      * @type {Map.<string,(RegExpFilter|Set.<RegExpFilter>)>}
      * @private
      */
     this._complexFiltersByKeyword = new Map();
   }
 
   /**
    * Removes all known filters
    */
   clear()
   {
     this._simpleFiltersByKeyword.clear();
     this._complexFiltersByKeyword.clear();
   }
 
   /**
    * Adds a filter to the matcher
    * @param {RegExpFilter} filter
    */
   add(filter)
   {
     let filtersByKeyword = filter.isLocationOnly() ?

[Manish Jethani, 2018/10/25 21:24:10]

The filter goes into one of the two maps, depending on whether it's a
location-only filter or not.

                              this._simpleFiltersByKeyword :
                              this._complexFiltersByKeyword;
     // Look for a suitable keyword
     let keyword = this.findKeyword(filter);
     let set = filtersByKeyword.get(keyword);
     if (typeof set == "undefined")
     {
       filtersByKeyword.set(keyword, filter);
     }
     else if (set.size == 1)
@@ skipping 52 matching lines @@
     if (!candidates)
       return result;
 
     let resultCount = 0xFFFFFF;
     let resultLength = 0;
     for (let i = 0, l = candidates.length; i < l; i++)
     {
       let candidate = candidates[i].substr(1);
       let simpleFilters = this._simpleFiltersByKeyword.get(candidate);
       let complexFilters = this._complexFiltersByKeyword.get(candidate);
       let count = (typeof simpleFilters != "undefined" ?

[Manish Jethani, 2018/10/25 21:24:10]

Now count needs to be the sum of the sizes of the two sets.

                      simpleFilters.size : 0) +
                   (typeof complexFilters != "undefined" ?
                      complexFilters.size : 0);
       if (count < resultCount ||
           (count == resultCount && candidate.length > resultLength))
       {
         result = candidate;
         resultCount = count;
         resultLength = candidate.length;
       }
@@ skipping 10 matching lines @@
    * @param {boolean} [thirdParty]
    * @param {string} [sitekey]
    * @param {boolean} [specificOnly]
    * @returns {?Filter}
    * @protected
    */
   checkEntryMatch(keyword, location, typeMask, docDomain, thirdParty, sitekey,
                   specificOnly)
   {
     // We need to skip the simple (location-only) filters if the type mask does
-    // not contain any non-default content types like $document, $elemhide,
-    // $csp, and so on.
+    // not contain any default content types.

[Manish Jethani, 2018/10/25 21:28:40]

Fixed the comment, it's actually the opposite.

     if ((typeMask & RegExpFilter.prototype.contentType) != 0)
     {
       let simpleSet = this._simpleFiltersByKeyword.get(keyword);
       if (simpleSet)
       {
         for (let filter of simpleSet)
         {
-          if ((!specificOnly || filter instanceof WhitelistFilter) &&
-              filter.matchesLocation(location))

[Manish Jethani, 2018/10/25 21:24:10]

For these filters, we only match the location. We know that the content type
matches (from the check above), we know that the third-party flag is irrelevant,
and we know also that `docDomain` and `sitekey` are irrelevant (because the
filter doesn't have anything to match these against).

-          {
+          if (specificOnly && !(filter instanceof WhitelistFilter))
+            continue;
+
+          if (filter.matchesLocation(location))
             return filter;
-          }
         }
       }
     }
 
     let complexSet = this._complexFiltersByKeyword.get(keyword);
     if (complexSet)
     {
       for (let filter of complexSet)
       {
         if (specificOnly && filter.isGeneric() &&
@@ skipping 207 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;