Issue 7265 - Orgnanize request blocking filters by domain

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 289 matching lines @@
 
     let filtersByDomain = this._filterDomainMapsByKeyword.get(keyword);
     if (filtersByDomain)
     {
       let domains = filter.domains || defaultDomains;
       for (let domain of domains.keys())
       {
         let map = filtersByDomain.get(domain);
         if (map)
         {
           if (map.size > 1 || map instanceof Map)

[Sebastian Noack, 2019/02/06 16:30:58]

In which scenario would "map" not be a Map object, and wouldn't the size
property doesn't exist either then?

[Manish Jethani, 2019/02/06 19:25:05]

It's a hack.

The filter object doubles up as a fake Map object. This way we don't have to
keep a map with only the filter as the key and true as the value (a very common
case). Without this hack, it would take 10 MB more for EasyList.

           {
             map.delete(filter);
 
             if (map.size == 0)
               filtersByDomain.delete(domain);
           }
           else if (filter == map)
           {
             filtersByDomain.delete(domain);
           }
@@ skipping 158 matching lines @@
    *   matching filters to the list; if omitted, the function directly returns
    *   the first matching filter.
    * @returns {?Filter}
    * @protected
    */
   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 ((typeMask & DEFAULT_TYPES) != 0)
+    if (!specificOnly && (typeMask & DEFAULT_TYPES) != 0)
     {
       let filter = this._checkEntryMatchSimple(keyword, location, typeMask,
                                                docDomain, thirdParty, sitekey,
                                                specificOnly, 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
@@ skipping 305 matching lines @@
 
     return result;
   }
 
   /**
    * Tests whether the URL is whitelisted
    * @see Matcher#matchesAny
    * @inheritdoc
    * @returns {boolean}
    */
-  isWhitelisted(location, typeMask, docDomain, thirdParty, sitekey,
-                specificOnly)
+  isWhitelisted(location, typeMask, docDomain, thirdParty, sitekey)
   {
     return !!this._whitelist.matchesAny(location, typeMask, docDomain,
-                                        thirdParty, sitekey, specificOnly);
+                                        thirdParty, sitekey);
   }
 }
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;