Issue 235 - Improved performance of ElemHide.getSelectorsForDomain()

lib/elemHide.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 41 matching lines @@
  */
 let exceptions = Object.create(null);
 
 /**
  * Currently applied stylesheet URL
  * @type nsIURI
  */
 let styleURL = null;
 
 /**
+ * Lookup table, blocking filters by domain which they are applied to
+ * @type Object
+ */
+let filtersByDomain = Object.create(null);
+
+/**
  * Element hiding component
  * @class
  */
 let ElemHide = exports.ElemHide =
 {
   /**
    * Indicates whether filters have been added or removed since the last apply() call.
    * @type Boolean
    */
   isDirty: false,
@@ skipping 26 matching lines @@
 
   /**
    * Removes all known filters
    */
   clear: function()
   {
     filterByKey = Object.create(null);
     keyByFilter = Object.create(null);
     knownExceptions = Object.create(null);
     exceptions = Object.create(null);
+    filtersByDomain = Object.create(null);
     ElemHide.isDirty = false;
     ElemHide.unapply();
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add: function(filter)
   {
     if (filter instanceof ElemHideException)
     {
       if (filter.text in knownExceptions)
         return;
 
       let selector = filter.selector;
       if (!(selector in exceptions))
         exceptions[selector] = [];
       exceptions[selector].push(filter);
       knownExceptions[filter.text] = true;
     }
     else
     {
       if (filter.text in keyByFilter)
         return;
 
+      if (!("nsIStyleSheetService" in Ci))
+      {
+        let domains = filter.domains;
+        if (domains === null)
+        {
+          domains = Object.create(null);
+          domains[""] = undefined;
+        }
+
+        for (let domain in domains)
+        {
+          if (!(domain in filtersByDomain))
+            filtersByDomain[domain] = Object.create(null);
+
+          filtersByDomain[domain][filter.text] = filter.isActiveOnDomain(domain);
+        }
+      }
+
       let key;
       do {
         key = Math.random().toFixed(15).substr(5);
       } while (key in filterByKey);
 
       filterByKey[key] = filter;
       keyByFilter[filter.text] = key;
       ElemHide.isDirty = true;
     }
   },
@@ skipping 13 matching lines @@
       let index = list.indexOf(filter);
       if (index >= 0)
         list.splice(index, 1);
       delete knownExceptions[filter.text];
     }
     else
     {
       if (!(filter.text in keyByFilter))
         return;
 
+      if (!("nsIStyleSheetService" in Ci))
+      {
+        for (let domain in filter.domains)
+        {
+          if (domain in filtersByDomain && filter.text in filtersByDomain[domain])
+            delete filtersByDomain[domain][filter.text];
+
+          if (!Object.keys(filtersByDomain[domain]).length)
+            delete filtersByDomain[domain];
+        }
+      }
+
       let key = keyByFilter[filter.text];
       delete filterByKey[key];
       delete keyByFilter[filter.text];
       ElemHide.isDirty = true;
     }
   },
 
   /**
    * Checks whether an exception rule is registered for a filter on a particular
    * domain.
@@ skipping 193 matching lines @@
   {
     return (key in filterByKey ? filterByKey[key] : null);
   },
 
   /**
    * Returns a list of all selectors active on a particular domain (currently
    * used only in Chrome, Opera and Safari).
    */
   getSelectorsForDomain: function(/**String*/ domain, /**Boolean*/ specificOnly)
   {
-    let result = [];
-    for (let key in filterByKey)
+    let selectors = [];
+    domain = domain.toUpperCase();
+
+    if (!specificOnly)
     {
-      let filter = filterByKey[key];
-      if (specificOnly && (!filter.domains || filter.domains[""]))
-        continue;
+      let filterTexts = filtersByDomain[""];
+      if (filterTexts)
+      {
+        for (let filterText in filterTexts)
+        {
+          if (filterTexts[filterText])
+          {
+            let filter = filterByKey[keyByFilter[filterText]];
+            if (!filter)
+              continue;
+            
+            let selector = filter.selector;
+            if (filter.isActiveOnDomain(docDomain) && !this.getException(selector, docDomain))
+              selectors[selectors.length] = selector;
+          }
+        }
+      }
+    }
 
-      if (filter.isActiveOnDomain(domain) && !this.getException(filter, domain))
-        result.push(filter.selector);
+    while (true)
+    {
+      if (domain && domain in filtersByDomain)
+      {
+        let filterTexts = filtersByDomain[domain];
+        if (filterTexts)
+        {
+          for (let filterText in filterTexts)
+          {
+            if (filterTexts[filterText])
+            {
+              let filter = filterByKey[keyByFilter[filterText]];
+              if (!filter)
+                continue;
+              
+              let selector = filter.selector;
+              if (!this.getException(selector, docDomain))
+                selectors[selectors.length] = selector;
+            }
+          }
+        }
+      }
+
+      let nextDot = domain.indexOf(".");
+      if (nextDot < 0)
+        break;
+      domain = domain.substr(nextDot + 1);
     }
-    return result;
+
+    return selectors;
   }
 };