Issue 6992 - Try all keyword candidates when removing a filter

lib/matcher.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 92 matching lines @@
   {
     set.add(filter);
   }
 }
 
 /**
  * Removes a filter by a given keyword from a map.
  * @param {RegExpFilter} filter
  * @param {string} keyword
  * @param {Map.<string,(RegExpFilter|Set.<RegExpFilter>)>} map
+ * @returns {boolean} Whether the filter was removed.
  */
 function removeFilterByKeyword(filter, keyword, map)
 {
   let set = map.get(keyword);
   if (typeof set == "undefined")
-    return;
+    return false;
 
   if (set.size == 1)
   {
-    if (filter == set)
-      map.delete(keyword);
+    if (filter != set)
+      return false;
+
+    map.delete(keyword);
   }
   else
   {
+    let count = set.size;
+
     set.delete(filter);
 
+    if (set.size == count)
+      return false;
+
     if (set.size == 1)
       map.set(keyword, [...set][0]);
   }
+
+  return true;
 }
 
 /**
  * Checks whether a particular filter is slow.
  * @param {RegExpFilter} filter
  * @returns {boolean}
  */
 function isSlowFilter(filter)
 {
   return !filter.pattern || !keywordRegExp.test(filter.pattern);
@@ skipping 67 matching lines @@
       addFilterByKeyword(filter, keyword, map);
     }
   }
 
   /**
    * Removes a filter from the matcher
    * @param {RegExpFilter} filter
    */
   remove(filter)
   {
-    let keyword = this.findKeyword(filter);
+    let keyword = null;
+    let candidates = null;
+
+    let {pattern} = filter;
+    if (pattern == null)
+    {
+      candidates = [""];
+    }
+    else
+    {
+      candidates = pattern.toLowerCase().match(allKeywordsRegExp);
+      if (!candidates)
+        candidates = [""];
+    }
+
     let locationOnly = filter.isLocationOnly();
 
-    removeFilterByKeyword(filter, keyword,
-                          locationOnly ? this._simpleFiltersByKeyword :
-                            this._complexFiltersByKeyword);
+    // The keyword used to add a filter depends on the current list of filters
+    // at the time of addition. At this point we don't know what keyword was
+    // used to add the filter. We must try all the candidates.
+    for (let candidate of candidates)
+    {
+      candidate = candidate.substring(1);
 
-    if (locationOnly)
+      if (removeFilterByKeyword(filter, candidate,
+                                locationOnly ? this._simpleFiltersByKeyword :
+                                  this._complexFiltersByKeyword))
+      {
+        keyword = candidate;
+        break;
+      }
+    }
+
+    if (locationOnly || keyword == null)
       return;
 
     for (let type of nonDefaultTypes(filter.contentType))
     {
       let map = this._filterMapsByType.get(type);
       if (map)
         removeFilterByKeyword(filter, keyword, map);
     }
   }
 
@@ skipping 315 matching lines @@
 
 exports.CombinedMatcher = CombinedMatcher;
 
 /**
  * Shared {@link CombinedMatcher} instance that should usually be used.
  * @type {CombinedMatcher}
  */
 let defaultMatcher = new CombinedMatcher();
 
 exports.defaultMatcher = defaultMatcher;