Issue 4057 - Further speedup ElemHide.getSelectorsforDomain

lib/elemHide.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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 43 matching lines @@
  */
 var filtersByDomain = Object.create(null);
 
 /**
  * Lookup table, filters by selector. (Only contains filters that have a
  * selector that is unconditionally matched for all domains.)
  */
 var filtersBySelector = Object.create(null);
 
 /**
- * Array of selectors which unconditionally apply to all domains.
- */
-var unconditionalSelectors = [];
-
-/**
- * Indicates that the unconditionalSelectors Array needs to be regenerated.
- */
-var unconditionalSelectorsDirty = false;
+ * This array caches the keys of filtersBySelector table (selectors which
+ * unconditionally apply on all domains). It will be null if the cache needs to
+ * be rebuilt.
+ */
+var unconditionalSelectors = null;
 
 /**
  * Object to be used instead when a filter has a blank domains property.
  */
 var defaultDomains = Object.create(null);
 defaultDomains[""] = true;
 
 /**
  * Lookup table, keys are known element hiding exceptions
  * @type Object
@@ skipping 49 matching lines @@
 
   /**
    * Removes all known filters
    */
   clear: function()
   {
     filterByKey = [];
     keyByFilter = Object.create(null);
     filtersByDomain = Object.create(null);
     filtersBySelector = Object.create(null);
-    unconditionalSelectors = [];
-    unconditionalSelectorsDirty = false;
+    unconditionalSelectors = null;
     knownExceptions = Object.create(null);
     exceptions = Object.create(null);
     ElemHide.isDirty = false;
     ElemHide.unapply();
   },
 
   _addToFiltersByDomain: function(filter)
   {
     let key = keyByFilter[filter.text];
     let domains = filter.domains || defaultDomains;
@@ skipping 30 matching lines @@
       {
         // If this is the first exception for a previously unconditionally
         // applied element hiding selector we need to take care to update the
         // lookups.
         let unconditionalFilters = filtersBySelector[selector];
         if (unconditionalFilters)
         {
           for (let f of unconditionalFilters)
             this._addToFiltersByDomain(f);
           delete filtersBySelector[selector];
-          unconditionalSelectorsDirty = true;
+          unconditionalSelectors = null;
         }
       }
 
       knownExceptions[filter.text] = true;
     }
     else
     {
       if (filter.text in keyByFilter)
         return;
 
       let key = filterByKey.push(filter) - 1;
       keyByFilter[filter.text] = key;
 
       if (usingGetSelectorsForDomain)
       {
-        // The new filter's selector is unconditionally applied to all domains
-        if (!filter.domains && !exceptions[filter.selector])
-        {
+        if (!(filter.domains || filter.selector in exceptions))
+        {
+          // The new filter's selector is unconditionally applied to all domains
           let filters = filtersBySelector[filter.selector];
           if (filters)
           {
             filters.push(filter);
           }
           else
           {
             filtersBySelector[filter.selector] = [filter];
-            unconditionalSelectorsDirty = true;
-          }
-        }
-        // The new filter's selector only applies to some domains
+            unconditionalSelectors = null;
+          }
+        }
         else
         {
+          // The new filter's selector only applies to some domains
           this._addToFiltersByDomain(filter);
         }
       }
 
       ElemHide.isDirty = true;
     }
   },
 
   /**
    * Removes an element hiding filter
@@ skipping 28 matching lines @@
         if (filters)
         {
           if (filters.length > 1)
           {
             let index = filters.indexOf(filter);
             filters.splice(index, 1);
           }
           else
           {
             delete filtersBySelector[filter.selector];
-            unconditionalSelectorsDirty = true;
+            unconditionalSelectors = null;
           }
         }
         else
         {
           let domains = filter.domains || defaultDomains;
           for (let domain in domains)
           {
             let filters = filtersByDomain[domain];
             if (filters)
               delete filters[key];
@@ skipping 209 matching lines @@
 
   /**
    * Returns a list of all selectors active on a particular domain, must not be
    * used in Firefox (when usingGetSelectorsForDomain is false).
    */
   getSelectorsForDomain: function(/**String*/ domain, /**Boolean*/ specificOnly)
   {
     if (!usingGetSelectorsForDomain)
       throw new Error("getSelectorsForDomain can not be used in Firefox!");
 
-    let selectors = [];
+    if (!unconditionalSelectors)
+      unconditionalSelectors = Object.keys(filtersBySelector);
+    let selectors = specificOnly ? [] : unconditionalSelectors.slice();
 
     let seenFilters = Object.create(null);
     let currentDomain = domain ? domain.toUpperCase() : "";
     while (true)
     {
       if (specificOnly && currentDomain == "")
         break;
 
       let filters = filtersByDomain[currentDomain];
       if (filters)
@@ skipping 10 matching lines @@
         }
       }
 
       if (currentDomain == "")
         break;
 
       let nextDot = currentDomain.indexOf(".");
       currentDomain = nextDot == -1 ? "" : currentDomain.substr(nextDot + 1);
     }
 
-    if (specificOnly)
-      return selectors;
-
-    if (unconditionalSelectorsDirty)
-    {
-      unconditionalSelectors = Object.keys(filtersBySelector);
-      unconditionalSelectorsDirty = false;
-    }
-    return unconditionalSelectors.concat(selectors);
+    return selectors;
   }
 };