Issue 5797 - Removed obsolete arguments from ElemHideEmulation constructor

lib/content/elemHideEmulation.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 284 matching lines @@
       yield [selector, subtree];
   }
 };
 
 function isSelectorHidingOnlyPattern(pattern)
 {
   return pattern.selectors.some(s => s.preferHideWithSelector) &&
     !pattern.selectors.some(s => s.requiresHiding);
 }
 
-function ElemHideEmulation(window, getFiltersFunc, addSelectorsFunc,
-                           hideElemsFunc)
+function ElemHideEmulation(addSelectorsFunc, hideElemsFunc)
 {
-  this.window = window;
-  this.getFiltersFunc = getFiltersFunc;
+  this.document = document;

[Sebastian Noack, 2017/09/27 00:20:45]

We still need a way to mock the document the element hiding emulation filters
are applied to for the tests.

   this.addSelectorsFunc = addSelectorsFunc;
   this.hideElemsFunc = hideElemsFunc;
-  this.observer = new window.MutationObserver(this.observe.bind(this));
+  this.observer = new MutationObserver(this.observe.bind(this));
 }
 
 ElemHideEmulation.prototype = {
   isSameOrigin(stylesheet)
   {
     try
     {
-      return new URL(stylesheet.href).origin == this.window.location.origin;
+      return new URL(stylesheet.href).origin == this.document.location.origin;
     }
     catch (e)
     {
       // Invalid URL, assume that it is first-party.
       return true;
     }
   },
 
   /** Parse the selector
    * @param {string} selector the selector to parse
@@ skipping 10 matching lines @@
       return [new PlainSelector(selector)];
 
     let selectors = [];
     if (match.index > 0)
       selectors.push(new PlainSelector(selector.substr(0, match.index)));
 
     let startIndex = match.index + match[0].length;
     let content = parseSelectorContent(selector, startIndex);
     if (!content)
     {
-      this.window.console.error(
-        new SyntaxError("Failed to parse Adblock Plus " +
-                        `selector ${selector} ` +
-                        "due to unmatched parentheses."));
+      console.error(new SyntaxError("Failed to parse Adblock Plus " +
+                                    `selector ${selector} ` +
+                                    "due to unmatched parentheses."));
       return null;
     }
     if (match[1] == "properties")
       selectors.push(new PropsSelector(content.text));
     else if (match[1] == "has")
     {
       let hasSelectors = this.parseSelector(content.text);
       if (hasSelectors == null)
         return null;
       selectors.push(new HasSelector(hasSelectors));
     }
     else if (match[1] == "contains")
       selectors.push(new ContainsSelector(content.text));
     else
     {
       // this is an error, can't parse selector.
-      this.window.console.error(
-        new SyntaxError("Failed to parse Adblock Plus " +
-                        `selector ${selector}, invalid ` +
-                        `pseudo-class :-abp-${match[1]}().`));
+      console.error(new SyntaxError("Failed to parse Adblock Plus " +
+                                    `selector ${selector}, invalid ` +
+                                    `pseudo-class :-abp-${match[1]}().`));
       return null;
     }
 
     let suffix = this.parseSelector(selector.substr(content.end + 1));
     if (suffix == null)
       return null;
 
     selectors.push(...suffix);
 
     if (selectors.length == 1 && selectors[0] instanceof ContainsSelector)
     {
-      this.window.console.error(
-        new SyntaxError("Failed to parse Adblock Plus " +
-                        `selector ${selector}, can't ` +
-                        "have a lonely :-abp-contains()."));
+      console.error(new SyntaxError("Failed to parse Adblock Plus " +
+                                    `selector ${selector}, can't ` +
+                                    "have a lonely :-abp-contains()."));
       return null;
     }
     return selectors;
   },
 
   /**
    * Processes the current document and applies all rules to it.
    * @param {CSSStyleSheet[]} [stylesheets]
    *    The list of new stylesheets that have been added to the document and
    *    made reprocessing necessary. This parameter shouldn't be passed in for
    *    the initial processing, all of document's stylesheets will be considered
    *    then and all rules, including the ones not dependent on styles.
    * @param {function} [done]
    *    Callback to call when done.
    */
   _addSelectors(stylesheets, done)
   {
     let selectors = [];
     let selectorFilters = [];
 
     let elements = [];
     let elementFilters = [];
 
     let cssStyles = [];
 
     let stylesheetOnlyChange = !!stylesheets;
     if (!stylesheets)
-      stylesheets = this.window.document.styleSheets;
+      stylesheets = this.document.styleSheets;
 
     // Chrome < 51 doesn't have an iterable StyleSheetList
     // https://issues.adblockplus.org/ticket/5381
     for (let i = 0; i < stylesheets.length; i++)
     {
       let stylesheet = stylesheets[i];
       // Explicitly ignore third-party stylesheets to ensure consistent behavior
       // between Firefox and Chrome.
       if (!this.isSameOrigin(stylesheet))
         continue;
 
       let rules = stylesheet.cssRules;
       if (!rules)
         continue;
 
       // Chrome < 51 doesn't have an iterable CSSRuleList
       // https://issues.adblockplus.org/ticket/5773
       for (let j = 0; j < rules.length; j++)
       {
         let rule = rules[j];
         if (rule.type != rule.STYLE_RULE)
           continue;
 
         cssStyles.push(stringifyStyle(rule));
       }
     }
 
-    let {document} = this.window;
-
     let patterns = this.patterns.slice();
     let pattern = null;
     let generator = null;
 
     let processPatterns = () =>
     {
-      let cycleStart = this.window.performance.now();
+      let cycleStart = performance.now();
 
       if (!pattern)
       {
         if (!patterns.length)
         {
           this.addSelectorsFunc(selectors, selectorFilters);
           this.hideElemsFunc(elements, elementFilters);
           if (typeof done == "function")
             done();
           return;
         }
 
         pattern = patterns.shift();
 
         if (stylesheetOnlyChange &&
             !pattern.selectors.some(selector => selector.dependsOnStyles))
         {
           pattern = null;
           return processPatterns();
         }
-        generator = evaluate(pattern.selectors, 0, "", document, cssStyles);
+        generator = evaluate(pattern.selectors, 0, "",
+                             this.document, cssStyles);
       }
       for (let selector of generator)
       {
         if (selector != null)
         {
           if (isSelectorHidingOnlyPattern(pattern))
           {
             selectors.push(selector);
             selectorFilters.push(pattern.text);
           }
           else
           {
-            for (let element of document.querySelectorAll(selector))
+            for (let element of this.document.querySelectorAll(selector))
             {
               elements.push(element);
               elementFilters.push(pattern.text);
             }
           }
         }
-        if (this.window.performance.now() -
-            cycleStart > MAX_SYNCHRONOUS_PROCESSING_TIME)
+        if (performance.now() - cycleStart > MAX_SYNCHRONOUS_PROCESSING_TIME)
         {
-          this.window.setTimeout(processPatterns, 0);
+          setTimeout(processPatterns, 0);
           return;
         }
       }
       pattern = null;
       return processPatterns();
     };
 
     processPatterns();
   },
 
@@ skipping 16 matching lines @@
   /**
    * Re-run filtering either immediately or queued.
    * @param {CSSStyleSheet[]} [stylesheets]
    *    new stylesheets to be processed. This parameter should be omitted
    *    for DOM modification (full reprocessing required).
    */
   queueFiltering(stylesheets)
   {
     let completion = () =>
     {
-      this._lastInvocation = this.window.performance.now();
+      this._lastInvocation = performance.now();
       this._filteringInProgress = false;
       if (this._scheduledProcessing)
       {
         let newStylesheets = this._scheduledProcessing.stylesheets;
         this._scheduledProcessing = null;
         this.queueFiltering(newStylesheets);
       }
     };
 
     if (this._scheduledProcessing)
     {
       if (!stylesheets)
         this._scheduledProcessing.stylesheets = null;
       else if (this._scheduledProcessing.stylesheets)
         this._scheduledProcessing.stylesheets.push(...stylesheets);
     }
     else if (this._filteringInProgress)
     {
       this._scheduledProcessing = {stylesheets};
     }
-    else if (this.window.performance.now() -
-             this._lastInvocation < MIN_INVOCATION_INTERVAL)
+    else if (performance.now() - this._lastInvocation < MIN_INVOCATION_INTERVAL)
     {
       this._scheduledProcessing = {stylesheets};
-      this.window.setTimeout(() =>
+      setTimeout(() =>
       {
         let newStylesheets = this._scheduledProcessing.stylesheets;
         this._filteringInProgress = true;
         this._scheduledProcessing = null;
         this._addSelectors(newStylesheets, completion);
       },
-      MIN_INVOCATION_INTERVAL -
-      (this.window.performance.now() - this._lastInvocation));
+      MIN_INVOCATION_INTERVAL - (performance.now() - this._lastInvocation));
     }
     else
     {
       this._filteringInProgress = true;
       this._addSelectors(stylesheets, completion);
     }
   },
 
   onLoad(event)
   {
     let stylesheet = event.target.sheet;
     if (stylesheet)
       this.queueFiltering([stylesheet]);
   },
 
   observe(mutations)
   {
     this.queueFiltering();
   },
 
-  apply()
+  apply(patterns)
   {
-    this.getFiltersFunc(patterns =>
+    this.patterns = [];
+    for (let pattern of patterns)
     {
-      this.patterns = [];
-      for (let pattern of patterns)
-      {
-        let selectors = this.parseSelector(pattern.selector);
-        if (selectors != null && selectors.length > 0)
-          this.patterns.push({selectors, text: pattern.text});
-      }
+      let selectors = this.parseSelector(pattern.selector);
+      if (selectors != null && selectors.length > 0)
+        this.patterns.push({selectors, text: pattern.text});
+    }
 
-      if (this.patterns.length > 0)
-      {
-        let {document} = this.window;
-        this.queueFiltering();
-        this.observer.observe(
-          document,
-          {
-            childList: true,
-            attributes: true,
-            characterData: true,
-            subtree: true
-          }
-        );
-        document.addEventListener("load", this.onLoad.bind(this), true);
-      }
-    });
+    if (this.patterns.length > 0)
+    {
+      this.queueFiltering();
+      this.observer.observe(
+        this.document,
+        {
+          childList: true,
+          attributes: true,
+          characterData: true,
+          subtree: true
+        }
+      );
+      this.document.addEventListener("load", this.onLoad.bind(this), true);
+    }
   }
 };
 
 exports.ElemHideEmulation = ElemHideEmulation;