Issue 7016 - Convert serialization functions into generators

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
  * 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 Definition of Filter class and its subclasses.
  */
 
 const {filterNotifier} = require("./filterNotifier");
 const {extend} = require("./coreUtils");
 const {filterToRegExp} = require("./common");
 
 /**
+ * Regular expression used to match the <code>||</code> prefix in an otherwise
+ * literal pattern.
+ * @type {RegExp}
+ */
+let doubleAnchorRegExp = new RegExp(filterToRegExp("||") + "$");
+
+/**
  * All known unique domain sources mapped to their parsed values.
  * @type {Map.<string,Map.<string,boolean>>}
  */
 let knownDomainMaps = new Map();
+
+/**
+ * Checks whether the given pattern is a string of literal characters with no
+ * wildcards or any other special characters. If the pattern is prefixed with a
+ * <code>||</code> but otherwise contains no special characters, it is still
+ * considered to be a literal pattern.
+ * @param {string} pattern
+ * @returns {boolean}
+ */
+function isLiteralPattern(pattern)
+{
+  return !/[*^|]/.test(pattern.replace(/^\|{2}/, ""));
+}
 
 /**
  * Abstract base class for filters
  *
  * @param {string} text   string representation of the filter
  * @constructor
  */
 function Filter(text)
 {
   this.text = text;
@@ skipping 93 matching lines @@
           this._subscriptions = [...this._subscriptions][0];
       }
       else if (subscription == this._subscriptions)
       {
         this._subscriptions = null;
       }
     }
   },
 
   /**
-   * Generates serialized filter.
+   * Serializes the filter for writing out on disk.
    * @yields {string}
    */
   *serialize()
   {
+    let {text} = this;
+
     yield "[Filter]";
-    yield "text=" + this.text;
+    yield "text=" + text;
   },
 
   toString()
   {
     return this.text;
   }
 };
 
 /**
  * Cache for known filters, maps string representation to filter objects.
@@ skipping 287 matching lines @@
    * 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()
   {
     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)
+        if (!domains || cacheDomains)
           knownDomainMaps.set(source, domains);
       }
 
-      this.domainSource = null;
-    }
-
-    Object.defineProperty(this, "domains", {value: domains});
-    return this.domains;
-  },
+      if (!domains || cacheDomains)
+      {
+        this.domainSource = null;
+        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 83 matching lines @@
 
     return !(sitekeys && sitekeys.length) && (!domains || domains.get(""));
   },
 
   /**
    * See Filter.serialize()
    * @inheritdoc
    */
   *serialize()
   {
-    if (this._disabled || this._hitCount || this._lastHit)
+    let {_disabled, _hitCount, _lastHit} = this;
+
+    if (_disabled || _hitCount || _lastHit)
     {
       yield* Filter.prototype.serialize.call(this);
-      if (this._disabled)
+      if (_disabled)
         yield "disabled=true";
-      if (this._hitCount)
-        yield "hitCount=" + this._hitCount;
-      if (this._lastHit)
-        yield "lastHit=" + this._lastHit;
+      if (_hitCount)
+        yield "hitCount=" + _hitCount;
+      if (_lastHit)
+        yield "lastHit=" + _lastHit;
     }
   }
 });
 
 /**
  * Abstract base class for RegExp-based filters
  * @param {string} text see {@link Filter Filter()}
  * @param {string} regexpSource
  *   filter part that the regular expression should be build from
  * @param {number} [contentType]
@@ skipping 31 matching lines @@
       regexpSource[regexpSource.length - 1] == "/")
   {
     // The filter is a regular expression - convert it immediately to
     // catch syntax errors
     let regexp = new RegExp(regexpSource.substr(1, regexpSource.length - 2),
                             this.matchCase ? "" : "i");
     Object.defineProperty(this, "regexp", {value: regexp});
   }
   else
   {
+    if (!this.matchCase && isLiteralPattern(regexpSource))
+      regexpSource = regexpSource.toLowerCase();
+
     // No need to convert this filter to regular expression yet, do it on demand
     this.pattern = regexpSource;
   }
 }
 exports.RegExpFilter = RegExpFilter;
 
 RegExpFilter.prototype = extend(ActiveFilter, {
   /**
    * Number of filters contained, will always be 1 (required to
    * optimize {@link Matcher}).
@@ skipping 11 matching lines @@
    * for delayed creation of the regexp property
    * @type {?string}
    */
   pattern: null,
   /**
    * Regular expression to be used when testing against this filter
    * @type {RegExp}
    */
   get regexp()
   {
-    let source = filterToRegExp(this.pattern, this.rewrite != null);
-    let regexp = new RegExp(source, this.matchCase ? "" : "i");
-    Object.defineProperty(this, "regexp", {value: regexp});
-    return regexp;
+    let value = null;
+
+    let {pattern, rewrite} = this;
+    if (rewrite != null || !isLiteralPattern(pattern))
+    {
+      value = new RegExp(filterToRegExp(pattern, rewrite != null),
+                         this.matchCase ? "" : "i");
+    }
+
+    Object.defineProperty(this, "regexp", {value});
+    return value;
   },
   /**
    * Content types the filter applies to, combination of values from
    * RegExpFilter.typeMap
    * @type {number}
    */
   contentType: 0x7FFFFFFF,
   /**
    * Defines whether the filter should distinguish between lower and
    * upper case letters
@@ skipping 40 matching lines @@
    * @param {boolean} [thirdParty] should be true if the URL is a third-party
    *                               request
    * @param {string} [sitekey] public key provided by the document
    * @return {boolean} true in case of a match
    */
   matches(location, typeMask, docDomain, thirdParty, sitekey)
   {
     return (this.contentType & typeMask) != 0 &&
            (this.thirdParty == null || this.thirdParty == thirdParty) &&
            this.isActiveOnDomain(docDomain, sitekey) &&
-           this.regexp.test(location);
+           this.matchesLocation(location);
+  },
+
+  /**
+   * Checks whether the given URL matches this filter's pattern.
+   * @param {string} location The URL to check.
+   * @returns {boolean} <code>true</code> if the URL matches.
+   */
+  matchesLocation(location)
+  {
+    let {regexp} = this;
+
+    if (regexp)
+      return regexp.test(location);
+
+    if (!this.matchCase)
+      location = location.toLowerCase();
+
+    let {pattern} = this;
+
+    if (pattern[0] == "|" && pattern[1] == "|")
+    {
+      let index = location.indexOf(pattern.substring(2));
+
+      // The "||" prefix requires that the text that follows does not start
+      // with a forward slash.
+      return index != -1 && location[index] != "/" &&
+             doubleAnchorRegExp.test(location.substring(0, index));
+    }
+
+    return location.includes(pattern);
   }
 });
 
 /**
  * Yields the filter itself (required to optimize {@link Matcher}).
  * @yields {RegExpFilter}
  */
 RegExpFilter.prototype[Symbol.iterator] = function*()
 {
   yield this;
@@ skipping 50 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;
   }
 });