Issue 6957 - Return common style sheet for unknown domains

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
@@ skipping 61 matching lines @@
 let commonStyleSheet = null;
 
 /**
  * Map to be used instead when a filter has a blank domains property.
  * @type {Map.<string,boolean>}
  * @const
  */
 let defaultDomains = new Map([["", true]]);
 
 /**
- * Set containing all known domains
- * @type {Set.<string>}
- */
-let knownDomains = new Set();
-
-/**
  * Set containing known element hiding filters
  * @type {Set.<ElemHideFilter>}
  */
 let knownFilters = new Set();
+
+/**
+ * All domains known to occur in exceptions
+ * @type {Set.<string>}
+ */
+let knownExceptionDomains = new Set();
 
 /**
  * Returns the suffix of the given domain that is known. If no suffix is known,
  * an empty string is returned.
  * @param {?string} domain
  * @returns {string}
  */
 function getKnownSuffix(domain)
 {
-  if (!domain)
-    return "";
-
-  if (domain[domain.length - 1] == ".")
-    domain = domain.replace(/\.+$/, "");
-
-  domain = domain.toLowerCase();
-
-  while (domain)
-  {
-    if (knownDomains.has(domain) || ElemHideExceptions.isKnownDomain(domain))
-      break;
-
+  while (domain && !filtersByDomain.has(domain) &&
+         !knownExceptionDomains.has(domain))
+  {
     let index = domain.indexOf(".");
     domain = index == -1 ? "" : domain.substring(index + 1);
   }
 
   return domain;
 }
 
 /**
  * Adds a filter to the lookup table of filters by domain.
  * @param {Filter} filter
  */
 function addToFiltersByDomain(filter)
 {
   let domains = filter.domains || defaultDomains;
   for (let [domain, isIncluded] of domains)
   {
     // There's no need to note that a filter is generically disabled.
-    if (domain == "")
-    {
-      if (!isIncluded)
-        continue;
-    }
-    else
-    {
-      // Note: Once a domain is known it never becomes unknown, even when all
-      // the filters containing that domain are removed. This is a best-case
-      // optimization.
-      knownDomains.add(domain);
-    }
+    if (!isIncluded && domain == "")
+      continue;
 
     let filters = filtersByDomain.get(domain);
     if (!filters)
       filtersByDomain.set(domain, filters = new Map());
     filters.set(filter, isIncluded);
   }
 }
 
 /**
  * Returns a list of selectors that apply on each website unconditionally.
  * @returns {string[]}
  */
 function getUnconditionalSelectors()
 {
   if (!unconditionalSelectors)
     unconditionalSelectors = [...filterBySelector.keys()];
 
   return unconditionalSelectors;
 }
 
 /**
  * Returns the list of selectors that apply on a given domain from the subset
  * of filters that do not apply unconditionally on all domains.
  *
  * @param {string} domain The domain.
- * @param {boolean} [specificOnly=false] Whether selectors from generic filters
- *   should be included.
+ * @param {boolean} specificOnly Whether selectors from generic filters should
+ *   be included.
  *
  * @returns {Array.<string>} The list of selectors.
  */
-function getConditionalSelectorsForDomain(domain, specificOnly = false)
+function getConditionalSelectors(domain, specificOnly)
 {
   let selectors = [];
 
   let excluded = new Set();
   let currentDomain = domain;
 
   // This code is a performance hot-spot, which is why we've made certain
   // micro-optimisations. Please be careful before making changes.
   while (true)
   {
@@ skipping 37 matching lines @@
  */
 function getDefaultStyleSheet()
 {
   if (!defaultStyleSheet)
     defaultStyleSheet = createStyleSheet(getUnconditionalSelectors());
 
   return defaultStyleSheet;
 }
 
 /**
- * Returns the default style sheet that applies on all unknown domains.
+ * Returns the common style sheet that applies on all unknown domains.
  * @returns {string}
  */
 function getCommonStyleSheet()
 {
   if (!commonStyleSheet)
+  {
     commonStyleSheet = getDefaultStyleSheet() +
-                       createStyleSheet(getConditionalSelectorsForDomain(""));
+                       createStyleSheet(getConditionalSelectors("", false));
+  }
 
   return commonStyleSheet;
 }
 
-ElemHideExceptions.on("added", ({selector}) =>
+ElemHideExceptions.on("added", ({domains, selector}) =>
 {
   commonStyleSheet = null;
+
+  if (domains)
+  {
+    for (let domain of domains.keys())
+    {
+      // Note: Once an exception domain is known it never becomes unknown, even
+      // when all the exceptions containing that domain are removed. This is a
+      // best-case optimization.
+      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);
     filterBySelector.delete(selector);
     unconditionalSelectors = null;
     defaultStyleSheet = null;
   }
 });
 
 /**
  * Container for element hiding filters
  * @class
  */
 exports.ElemHide = {
   /**
    * Removes all known filters
    */
   clear()
   {
     commonStyleSheet = null;
 
-    for (let collection of [filtersByDomain, filterBySelector, knownDomains,
-                            knownFilters])
+    for (let collection of [filtersByDomain, filterBySelector, knownFilters,
+                            knownExceptionDomains])
+    {
       collection.clear();
+    }
 
     unconditionalSelectors = null;
     defaultStyleSheet = null;
 
     filterNotifier.emit("elemhideupdate");
   },
 
   /**
    * Add a new element hiding filter
    * @param {ElemHideFilter} filter
@@ skipping 77 matching lines @@
    *
    * @param {string} domain The domain.
    * @param {boolean} [specificOnly=false] Whether selectors from generic
    *   filters should be included.
    *
    * @returns {ElemHideStyleSheet} An object containing the CSS code and the
    *   list of selectors.
    */
   generateStyleSheetForDomain(domain, specificOnly = false)
   {
-    let knownSuffix = getKnownSuffix(domain);
-
-    let selectors = getConditionalSelectorsForDomain(knownSuffix, specificOnly);
-    let code = specificOnly ? createStyleSheet(selectors) :
-                 knownSuffix == "" ? getCommonStyleSheet() :
-                   (getDefaultStyleSheet() + createStyleSheet(selectors));
-
-    if (!specificOnly)
+    let code = null;
+    let selectors = null;
+
+    if (domain[domain.length - 1] == ".")
+      domain = domain.replace(/\.+$/, "");
+
+    domain = domain.toLowerCase();
+
+    if (specificOnly)
+    {
+      selectors = getConditionalSelectors(domain, true);
+      code = createStyleSheet(selectors);
+    }
+    else
+    {
+      let knownSuffix = getKnownSuffix(domain);
+
+      selectors = getConditionalSelectors(knownSuffix, false);
+      code = knownSuffix == "" ? getCommonStyleSheet() :
+               (getDefaultStyleSheet() + createStyleSheet(selectors));
+
       selectors = getUnconditionalSelectors().concat(selectors);
+    }
 
     return {code, selectors};
   }
 };
 
 /**
  * Splits a list of selectors into groups determined by the value of
  * <code>{@link selectorGroupSize}</code>.
  *
  * @param {Array.<string>} selectors
@@ skipping 43 matching lines @@
 {
   let styleSheet = "";
 
   for (let selectorGroup of splitSelectors(selectors))
     styleSheet += createRule(selectorGroup);
 
   return styleSheet;
 }
 
 exports.createStyleSheet = createStyleSheet;