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, isLiteralPattern,
-       locationMatchesPattern} = require("./common");
+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 758 matching lines @@
            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)
   {
-    if (this.regexp)
-      return this.regexp.test(location);
+    let {regexp} = this;
+
+    if (regexp)
+      return regexp.test(location);
 
     if (!this.matchCase)
       location = location.toLowerCase();
 
-    return locationMatchesPattern(location, this.pattern);
+    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 474 matching lines @@
 
   /**
    * Script that should be executed
    * @type {string}
    */
   get script()
   {
     return this.body;
   }
 });