Noissue - Use two sets for excluded and included filters by domain

lib/elemHide.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
  * 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/>.
  */
 
 "use strict";
 
 /**
  * @fileOverview Element hiding implementation.
  */
 
 const {ElemHideException} = require("./filterClasses");
 const {FilterNotifier} = require("./filterNotifier");
 
 /**
  * Lookup table, active flag, by filter by domain.
  * (Only contains filters that aren't unconditionally matched for all domains.)
- * @type {Map.<string,Map.<Filter,boolean>>}
+ * @type {Map.<string,Array.<Set.<Filter>>>}
  */
 let filtersByDomain = new Map();
 
 /**
  * Lookup table, filter by selector. (Only used for selectors that are
  * unconditionally matched for all domains.)
  * @type {Map.<string,Filter>}
  */
 let filterBySelector = new Map();
 
@@ skipping 44 matching lines @@
   {
     let domains = filter.domains || defaultDomains;
     for (let [domain, isIncluded] of domains)
     {
       // There's no need to note that a filter is generically disabled.
       if (!isIncluded && domain == "")
         continue;
 
       let filters = filtersByDomain.get(domain);
       if (!filters)
-        filtersByDomain.set(domain, filters = new Map());
-      filters.set(filter, isIncluded);
+        filtersByDomain.set(domain, filters = []);
+
+      let setIndex = +isIncluded;
+      if (!filters[setIndex])
+        filters[setIndex] = new Set();
+
+      filters[setIndex].add(filter);
     }
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideBase} filter
    */
   add(filter)
   {
     if (knownFilters.has(filter))
@@ skipping 57 matching lines @@
     {
       filterBySelector.delete(filter.selector);
       unconditionalSelectors = null;
     }
     // Conditionally applied element hiding filters
     else
     {
       let domains = filter.domains || defaultDomains;
       for (let domain of domains.keys())
       {
-        let filters = filtersByDomain.get(domain);
-        if (filters)
-          filters.delete(filter);
+        let filters = filtersByDomain.get(domain) || [];
+        for (let i = 0; i < filters.length; i++)
+        {
+          if (!filters[i])
+            continue;
+
+          filters[i].delete(filter);
+
+          if (filters[i].size == 0)
+            delete filters[i];
+        }
       }
     }
 
     knownFilters.delete(filter);
     FilterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Checks whether an exception rule is registered for a filter on a particular
    * domain.
@@ skipping 58 matching lines @@
   getSelectorsForDomain(domain, criteria)
   {
     let selectors = [];
 
     if (typeof criteria == "undefined")
       criteria = ElemHide.ALL_MATCHING;
     if (criteria < ElemHide.NO_UNCONDITIONAL)
       selectors = this.getUnconditionalSelectors();
 
     let specificOnly = (criteria >= ElemHide.SPECIFIC_ONLY);
-    let excludedFilters = new Set();
+    let excludedFilters = [];
 
     let currentDomain = domain ? domain.toUpperCase() : "";
     let currentDomainIsGeneric = currentDomain == "";
 
     // This code is a performance hot-spot, which is why we've made certain
     // micro-optimisations. Please be careful before making changes.
     while (true)
     {
       if (specificOnly && currentDomainIsGeneric)
         break;
 
-      let filters = filtersByDomain.get(currentDomain);
-      if (filters)
+      let [excluded, included] = filtersByDomain.get(currentDomain) || [];
+
+      if (excluded)
+        excludedFilters.push(excluded);
+
+      if (included)
       {
-        for (let [filter, isIncluded] of filters)
+        for (let filter of included)
         {
-          if (excludedFilters.size > 0 && excludedFilters.has(filter))
-            continue;
+          for (let i = 0; i < excludedFilters.length; i++)
+          {
+            if (excludedFilters[i].has(filter))
+            {
+              filter = null;
+              break;
+            }
+          }
 
-          if (isIncluded)
-          {
-            if (!this.getException(filter, domain))
-              selectors.push(filter.selector);
-          }
-          else if (!currentDomainIsGeneric)
-            excludedFilters.add(filter);
+          if (filter && !this.getException(filter, domain))
+            selectors.push(filter.selector);
         }
       }
 
       if (currentDomainIsGeneric)
         break;
 
       let nextDot = currentDomain.indexOf(".");
       if (nextDot == -1)
       {
         currentDomain = "";
         currentDomainIsGeneric = true;
       }
       else
         currentDomain = currentDomain.substr(nextDot + 1);
     }
 
     return selectors;
   }
 };