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
@@ skipping 12 matching lines @@
 
 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 tripleAnchorRegExp = new RegExp(filterToRegExp("|||"));
+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
@@ skipping 662 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))

[Manish Jethani, 2018/10/17 09:05:04]

Lowercase the pattern once here if it is literal and case-insensitive.

       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, {
   /**
@@ skipping 109 matching lines @@
     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. Normally this is part of the generated regular
-      // expression, but since we're faking it here with string-based matching
-      // we need to do the check ourselves.
+      // with a forward slash.
       return index != -1 && location[index] != "/" &&

[Manish Jethani, 2018/10/17 09:05:04]

If the index is not -1 then it's highly unlikely that it'll fail the other two
tests; this is why it makes sense to get the index first.

-             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 477 matching lines @@
 
   /**
    * Script that should be executed
    * @type {string}
    */
   get script()
   {
     return this.body;
   }
 });