Issue 7244 - Maintain cache of domain-specific style sheets

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
@@ skipping 16 matching lines @@
 /**
  * The maximum number of selectors in a CSS rule. This is used by
  * <code>{@link createStyleSheet}</code> to split up a long list of selectors
  * into multiple rules.
  * @const {number}
  * @default
  */
 const selectorGroupSize = 1024;
 
 /**
+ * The maximum number of entries to keep in
+ * <code>{@link styleSheetCache}</code>.
+ */
+const maxStyleSheetCacheEntries = 100;
+
+/**
  * 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>>}
  */
 let filtersByDomain = new Map();
 
 /**
  * Lookup table, filter by selector. (Only used for selectors that are
  * unconditionally matched for all domains.)
  * @type {Map.<string,Filter>}
@@ skipping 18 matching lines @@
 /**
  * The common style sheet that applies on all unknown domains. This is a
  * concatenation of the default style sheet and an additional style sheet based
  * on selectors from all generic filters that are not in the
  * <code>{@link unconditionalSelectors}</code> list.
  * @type {?string}
  */
 let commonStyleSheet = null;
 
 /**
+ * Cache of generated domain-specific style sheets. This contains entries for
+ * only known domains. If a domain is unknown, it gets
+ * <code>{@link commonStyleSheet}</code>.
+ * @type {Map.<string,string>}
+ */
+let styleSheetCache = new Map();
+
+/**
  * Map to be used instead when a filter has a blank domains property.
  * @type {Map.<string,boolean>}
  * @const
  */
 let defaultDomains = new Map([["", true]]);
 
 /**
  * Set containing known element hiding filters
  * @type {Set.<ElemHideFilter>}
  */
@@ skipping 130 matching lines @@
 {
   if (!commonStyleSheet)
   {
     commonStyleSheet = getDefaultStyleSheet() +
                        createStyleSheet(getConditionalSelectors("", false));
   }
 
   return commonStyleSheet;
 }
 
+/**
+ * Returns the domain-specific style sheet that applies on a given domain.
+ * @param {string} domain
+ * @returns {string}
+ */
+function getDomainSpecificStyleSheet(domain)
+{
+  let styleSheet = styleSheetCache.get(domain);
+
+  if (typeof styleSheet == "undefined")
+  {
+    styleSheet = createStyleSheet(getConditionalSelectors(domain, false));
+
+    if (styleSheetCache.size >= maxStyleSheetCacheEntries)
+      styleSheetCache.clear();
+
+    styleSheetCache.set(domain, styleSheet);
+  }
+
+  return styleSheet;
+}
+
 ElemHideExceptions.on("added", ({domains, selector}) =>
 {
+  styleSheetCache.clear();
   commonStyleSheet = null;
 
   if (domains)
   {
     for (let domain of domains.keys())
     {
       // Note: Once an exception domain is known it never becomes unknown, even
       // when all the exceptions containing that domain are removed. This is a
       // best-case optimization.
       if (domain != "")
@@ skipping 18 matching lines @@
  * @class
  */
 exports.ElemHide = {
   /**
    * Removes all known filters
    */
   clear()
   {
     commonStyleSheet = null;
 
-    for (let collection of [filtersByDomain, filterBySelector, knownFilters,
-                            knownExceptionDomains])
+    for (let collection of [styleSheetCache, filtersByDomain, filterBySelector,
+                            knownFilters, knownExceptionDomains])
     {
       collection.clear();
     }
 
     unconditionalSelectors = null;
     defaultStyleSheet = null;
 
     filterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add(filter)
   {
     if (knownFilters.has(filter))
       return;
 
+    styleSheetCache.clear();
     commonStyleSheet = null;
 
     let {domains, selector} = filter;
 
     if (!(domains || ElemHideExceptions.hasExceptions(selector)))
     {
       // The new filter's selector is unconditionally applied to all domains
       filterBySelector.set(selector, filter);
       unconditionalSelectors = null;
       defaultStyleSheet = null;
@@ skipping 10 matching lines @@
 
   /**
    * Removes an element hiding filter
    * @param {ElemHideFilter} filter
    */
   remove(filter)
   {
     if (!knownFilters.has(filter))
       return;
 
+    styleSheetCache.clear();
     commonStyleSheet = null;
 
     let {selector} = filter;
 
     // Unconditially applied element hiding filters
     if (filterBySelector.get(selector) == filter)
     {
       filterBySelector.delete(selector);
       unconditionalSelectors = null;
       defaultStyleSheet = null;
@@ skipping 63 matching lines @@
         selectors = getConditionalSelectors(knownSuffix, false);
         code = knownSuffix == "" ? getCommonStyleSheet() :
                  (getDefaultStyleSheet() + createStyleSheet(selectors));
 
         selectors = getUnconditionalSelectors().concat(selectors);
       }
       else
       {
         code = knownSuffix == "" ? getCommonStyleSheet() :
                  (getDefaultStyleSheet() +
-                  createStyleSheet(getConditionalSelectors(knownSuffix,
-                                                           false)));
+                  getDomainSpecificStyleSheet(knownSuffix));
       }
     }
 
     return {code, selectors: includeSelectors ? selectors : null};
   }
 };
 
 /**
  * Yields rules from a style sheet returned by
  * <code>{@link createStyleSheet}</code>.
@@ skipping 68 matching lines @@
 {
   let styleSheet = "";
 
   for (let selectorGroup of splitSelectors(selectors))
     styleSheet += createRule(selectorGroup);
 
   return styleSheet;
 }
 
 exports.createStyleSheet = createStyleSheet;