Issue 7052 - Use string-based matching for literal patterns

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");
 
-let tripleAnchorRegExp = new RegExp(filterToRegExp("|||"));
+/**
+ * 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 614 matching lines @@
  * @param {boolean} [matchCase]
  *   Defines whether the filter should distinguish between lower and upper case
  *   letters
  * @param {string} [domains]
  *   Domains that the filter is restricted to, e.g. "foo.com|bar.com|~baz.com"
  * @param {boolean} [thirdParty]
  *   Defines whether the filter should apply to third-party or first-party
  *   content only
  * @param {string} [sitekeys]
  *   Public keys of websites that this filter should apply to
- * @param {?string} [rewrite]
- *   The (optional) rule specifying how to rewrite the URL.
+ * @constructor
  * @augments ActiveFilter
  */
 function RegExpFilter(text, regexpSource, contentType, matchCase, domains,
-                      thirdParty, sitekeys, rewrite)
+                      thirdParty, sitekeys)
 {
   ActiveFilter.call(this, text, domains);
 
   if (contentType != null)
     this.contentType = contentType;
   if (matchCase)
     this.matchCase = matchCase;
   if (thirdParty != null)
     this.thirdParty = thirdParty;
   if (sitekeys != null)
     this.sitekeySource = sitekeys;
 
   if (regexpSource.length >= 2 &&
       regexpSource[0] == "/" &&
       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;
-
-    if (!this.matchCase && rewrite == null &&
-        !/[*^|]/.test(this.pattern.replace(/^\|{2}/, "")))
-    {
-      this.pattern = this.pattern.toLowerCase();
-    }
   }
 }
 exports.RegExpFilter = RegExpFilter;
 
 RegExpFilter.prototype = extend(ActiveFilter, {
   /**
    * Number of filters contained, will always be 1 (required to
    * optimize {@link Matcher}).
    * @type {number}
    */
@@ skipping 12 matching lines @@
   pattern: null,
   /**
    * Regular expression to be used when testing against this filter
    * @type {RegExp}
    */
   get regexp()
   {
     let value = null;
 
     let {pattern, rewrite} = this;
-    if (rewrite != null || /[*^|]/.test(pattern.replace(/^\|{2}/, "")))
+    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
@@ skipping 50 matching lines @@
    * @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.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] != "/" &&
-             tripleAnchorRegExp.test(location.substring(0, index));
+             doubleAnchorRegExp.test(location.substring(0, index));
     }
 
     return location.includes(pattern);
   }
 });
 
 /**
  * Yields the filter itself (required to optimize {@link Matcher}).
  * @yields {RegExpFilter}
  */
@@ skipping 187 matching lines @@
  * @param {?string} [rewrite]
  *   The (optional) rule specifying how to rewrite the URL. See
  *   BlockingFilter.prototype.rewrite.
  * @constructor
  * @augments RegExpFilter
  */
 function BlockingFilter(text, regexpSource, contentType, matchCase, domains,
                         thirdParty, sitekeys, collapse, csp, rewrite)
 {
   RegExpFilter.call(this, text, regexpSource, contentType, matchCase, domains,
-                    thirdParty, sitekeys, rewrite);
+                    thirdParty, sitekeys);
 
   if (collapse != null)
     this.collapse = collapse;
 
   if (csp != null)
     this.csp = csp;
 
   if (rewrite != null)
     this.rewrite = rewrite;
 }
@@ skipping 269 matching lines @@
 
   /**
    * Script that should be executed
    * @type {string}
    */
   get script()
   {
     return this.body;
   }
 });