Issue 7452 - Do not cache element hiding filter objects by default

lib/elemHide.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 Element hiding implementation.
  */
 
+const {Filter} = require("./filterClasses");

[Manish Jethani, 2019/04/07 18:14:11]

I have minimized the changes in this file for now so it becomes easier to review
what's actually changed. I'd like to make those changes too (renaming `filter`
to `filterText` in places) but I can do that once the important parts are
reviewed.

In this rebase no logic has changed except for the second argument to
`Filter.fromText()`.

 const {ElemHideExceptions} = require("./elemHideExceptions");
 const {filterNotifier} = require("./filterNotifier");
 const {normalizeHostname, domainSuffixes} = require("./url");
 const {Cache} = require("./caching");
 
 /**
  * The maximum number of selectors in a CSS rule. This is used by
  * <code>{@link createStyleSheet}</code> to split up a long list of selectors
  * into multiple rules.
  * @const {number}
@@ skipping 93 matching lines @@
 {
   for (let [domain, isIncluded] of domains || defaultDomains)
   {
     // There's no need to note that a filter is generically disabled.
     if (!isIncluded && domain == "")
       continue;
 
     let filters = filtersByDomain.get(domain);
     if (!filters)
       filtersByDomain.set(domain, filters = new Map());
-    filters.set(filter, isIncluded);
+    filters.set(filter.text, isIncluded ? filter.selector : null);
   }
 }
 
 /**
  * Returns a list of selectors that apply on each website unconditionally.
  * @returns {string[]}
  */
 function getUnconditionalSelectors()
 {
   if (!unconditionalSelectors)
@@ skipping 16 matching lines @@
 {
   let selectors = [];
 
   let excluded = new Set();
 
   for (let currentDomain of domainSuffixes(domain, !specificOnly))
   {
     let filters = filtersByDomain.get(currentDomain);
     if (filters)
     {
-      for (let [filter, isIncluded] of filters)
+      for (let [text, selector] of filters)
       {
-        if (!isIncluded)
+        if (!selector)
         {
-          excluded.add(filter);
+          excluded.add(text);
         }
-        else
+        else if ((excluded.size == 0 || !excluded.has(text)) &&
+                 !ElemHideExceptions.getException(selector, domain))
         {
-          let {selector} = filter;
-          if ((excluded.size == 0 || !excluded.has(filter)) &&
-              !ElemHideExceptions.getException(selector, domain))
-          {
-            selectors.push(selector);
-          }
+          selectors.push(selector);
         }
       }
     }
   }
 
   return selectors;
 }
 
 /**
  * Returns the list of selectors and the list of exceptions that apply on a
@@ skipping 12 matching lines @@
   let selectors = [];
   let exceptions = [];
 
   let excluded = new Set();
 
   for (let currentDomain of domainSuffixes(domain, !specificOnly))
   {
     let filters = filtersByDomain.get(currentDomain);
     if (filters)
     {
-      for (let [filter, isIncluded] of filters)
+      for (let [text, selector] of filters)
       {
-        if (!isIncluded)
+        if (!selector)
         {
-          excluded.add(filter);
+          excluded.add(text);
         }
-        else if (excluded.size == 0 || !excluded.has(filter))
+        else if (excluded.size == 0 || !excluded.has(text))
         {
-          {
-            let {selector} = filter;
-            let exception = ElemHideExceptions.getException(selector, domain);
+          let exception = ElemHideExceptions.getException(selector, domain);
 
-            if (exception)
-              exceptions.push(exception);
-            else
-              selectors.push(selector);
-          }
+          if (exception)
+            exceptions.push(exception);
+          else
+            selectors.push(selector);
         }
       }
     }
   }
 
   return {selectors, exceptions};
 }
 
 /**
  * Returns the default style sheet that applies on all domains.
@@ skipping 55 matching lines @@
       if (domain != "")
         knownExceptionDomains.add(domain);
     }
   }
 
   // If this is the first exception for a previously unconditionally applied
   // element hiding selector we need to take care to update the lookups.
   let unconditionalFilterForSelector = filterBySelector.get(selector);
   if (unconditionalFilterForSelector)
   {
-    addToFiltersByDomain(unconditionalFilterForSelector);
+    addToFiltersByDomain(Filter.fromText(unconditionalFilterForSelector,
+                                         false));
     filterBySelector.delete(selector);
     unconditionalSelectors = null;
     defaultStyleSheet = null;
   }
 });
 
 /**
  * Container for element hiding filters
  * @class
  */
@@ skipping 16 matching lines @@
 
     filterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
    */
   add(filter)
   {
-    if (knownFilters.has(filter))
+    let {text} = filter;
+
+    if (knownFilters.has(text))
       return;
 
     styleSheetCache.clear();
     commonStyleSheet = null;
 
     let {domains, selector} = filter;
 
     if (!(domains || ElemHideExceptions.hasExceptions(selector)))
     {
       // The new filter's selector is unconditionally applied to all domains
-      filterBySelector.set(selector, filter);
+      filterBySelector.set(selector, text);
       unconditionalSelectors = null;
       defaultStyleSheet = null;
     }
     else
     {
       // The new filter's selector only applies to some domains
       addToFiltersByDomain(filter, domains);
     }
 
-    knownFilters.add(filter);
+    knownFilters.add(text);
     filterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Removes an element hiding filter
    * @param {ElemHideFilter} filter
    */
   remove(filter)
   {
-    if (!knownFilters.has(filter))
+    let {text} = filter;
+
+    if (!knownFilters.has(text))
       return;
 
     styleSheetCache.clear();
     commonStyleSheet = null;
 
     let {selector} = filter;
 
     // Unconditially applied element hiding filters
-    if (filterBySelector.get(selector) == filter)
+    if (filterBySelector.get(selector) == text)
     {
       filterBySelector.delete(selector);
       unconditionalSelectors = null;
       defaultStyleSheet = null;
     }
     // Conditionally applied element hiding filters
     else
     {
       let domains = filter.domains || defaultDomains;
       for (let domain of domains.keys())
       {
         let filters = filtersByDomain.get(domain);
         if (filters)
         {
-          filters.delete(filter);
+          filters.delete(text);
 
           if (filters.size == 0)
             filtersByDomain.delete(domain);
         }
       }
     }
 
-    knownFilters.delete(filter);
+    knownFilters.delete(text);
     filterNotifier.emit("elemhideupdate");
   },
 
   /**
    * @typedef {object} ElemHideStyleSheet
    * @property {string} code CSS code.
    * @property {Array.<string>} selectors List of selectors.
    */
 
   /**
@@ skipping 156 matching lines @@
 {
   let styleSheet = "";
 
   for (let selectorGroup of splitSelectors(selectors))
     styleSheet += createRule(selectorGroup);
 
   return styleSheet;
 }
 
 exports.createStyleSheet = createStyleSheet;