Issue 7046 - Defer caching of domain maps

lib/filterClasses.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 429 matching lines @@
   domainSource: null,
 
   /**
    * Separator character used in domainSource property, must be
    * overridden by subclasses
    * @type {string}
    */
   domainSeparator: null,
 
   /**
-   * Internal counter to keep track of the number of times the
-   * {@link ActiveFilter#domains} property is accessed.
-   * @type {number}
-   * @private
-   */
-  _domainsAccessCount: 0,
-
-  /**
-   * Maximum number of times the {@link ActiveFilter#domains} property can be
-   * accessed before the value is cached.
-   * @type {number}
-   * @private
-   */
-  _domainsAccessCacheThreshold: 3,
-
-  /**
    * Map containing domains that this filter should match on/not match
    * on or null if the filter should match on all domains
    * @type {?Map.<string,boolean>}
    */
   get domains()
   {
-    // For some filter types this property is accessed only rarely, especially
-    // when the subscriptions are initially loaded. We defer any caching for
-    // such filters.
-    let cacheValue = ++this._domainsAccessCount >
-                     this._domainsAccessCacheThreshold;
-
     let domains = null;
 
     if (this.domainSource)
     {
+      // For some filter types this property is accessed only rarely,
+      // especially when the subscriptions are initially loaded. We defer any
+      // caching for such filters.
+      let {cacheDomains} = this;
+
       let source = this.domainSource.toLowerCase();
 
       let knownMap = knownDomainMaps.get(source);
       if (knownMap)
       {
         domains = knownMap;
       }
       else
       {
         let list = source.split(this.domainSeparator);
@@ skipping 26 matching lines @@
             if (!domains)
               domains = new Map();
 
             domains.set(domain, include);
           }
 
           if (domains)
             domains.set("", !hasIncludes);
         }
 
-        if (!domains || cacheValue)
+        if (!domains || cacheDomains)
           knownDomainMaps.set(source, domains);
       }
 
-      if (!domains || cacheValue)
+      if (!domains || cacheDomains)
+      {
         this.domainSource = null;
-    }
-
-    if (!domains || cacheValue)
-      Object.defineProperty(this, "domains", {value: domains});
+        Object.defineProperty(this, "domains", {value: domains});
+      }
+    }
 
     return domains;
   },
+
+  /**
+   * Whether the value of {@link ActiveFilter#domains} should be cached.
+   * Defaults to <code>true</code>, but may be overridden by subclasses that
+   * don't want the value to be cached (for better memory usage).
+   * @type {boolean}
+   * @protected
+   */
+  cacheDomains: true,
 
   /**
    * Array containing public keys of websites that this filter should apply to
    * @type {?string[]}
    */
   sitekeys: null,
 
   /**
    * Checks whether this filter is active on a domain.
    * @param {string} [docDomain] domain name of the document that loads the URL
@@ skipping 309 matching lines @@
           if (contentType == null)
             ({contentType} = RegExpFilter.prototype);
           contentType &= ~type;
         }
         else
         {
           contentType |= type;
 
           if (type == RegExpFilter.typeMap.CSP)
           {
-            if (!value)
+            if (blocking && !value)
               return new InvalidFilter(origText, "filter_invalid_csp");
             csp = value;
           }
         }
       }
       else
       {
         switch (option.toLowerCase())
         {
           case "match-case":
@@ skipping 291 matching lines @@
  * @augments ContentFilter
  */
 function ElemHideBase(text, domains, selector)
 {
   ContentFilter.call(this, text, domains, selector);
 }
 exports.ElemHideBase = ElemHideBase;
 
 ElemHideBase.prototype = extend(ContentFilter, {
   /**
+   * @see ActiveFilter#domains
+   * @type {?Map.<string,boolean>}
+   */
+  get domains()
+  {
+    let {get} = Object.getOwnPropertyDescriptor(ActiveFilter.prototype,
+                                                "domains");
+    let value = get.call(this);
+    this.cacheDomains = true;
+    return value;
+  },
+
+  /**
+   * Initially <code>false</code>, but set to <code>true</code> after
+   * {@link ActiveFilter#domains} has been accessed once.
+   * @see ActiveFilter#cacheDomains
+   * @type {boolean}
+   * @protected
+   */
+  cacheDomains: false,
+
+  /**
    * CSS selector for the HTML elements that should be hidden
    * @type {string}
    */
   get selector()
   {
     // Braces are being escaped to prevent CSS rule injection.
     return this.body.replace("{", "\\7B ").replace("}", "\\7D ");
   }
 });
 
@@ skipping 70 matching lines @@
 
   /**
    * Script that should be executed
    * @type {string}
    */
   get script()
   {
     return this.body;
   }
 });