Issue 6437 - Skip DOM-only patterns on initial load

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 435 matching lines @@
   {
     // Observe changes to character data only if there's a contains selector in
     // one of the patterns.
     return getCachedPropertyValue(
       this, "_dependsOnCharacterData",
       () => this.selectors.some(selector => selector.dependsOnCharacterData)
     );
   }
 };
 
-function filterPatterns(patterns, {stylesheets, mutations})
+function filterPatterns(patterns, {stylesheets, mutations}, document)
 {
   if (!stylesheets && !mutations)
+  {
+    // On initial load, skip DOM-only patterns if it's the top frame, because
+    // there's usually nothing interesting to see and we can respond to any
+    // mutations later.
+    if (typeof top != "undefined" && document.defaultView == top)

[hub, 2018/03/23 14:58:59]

Maybe I'm missing something, but where does that `top` come from?

[Manish Jethani, 2018/03/23 16:56:46]

That's a reference to the global variable window.top, perhaps I should just
access it via the window object.

[hub, 2018/03/24 01:02:14]

I think it would be better, yes, both for clarity and safety.

+      return patterns.filter(pattern => pattern.dependsOnStyles);
+
     return patterns.slice();
+  }
 
   return patterns.filter(
     pattern => (stylesheets && pattern.dependsOnStyles) ||
                (mutations && pattern.dependsOnDOM)
   );
 }
 
 function shouldObserveAttributes(patterns)
 {
   return patterns.some(pattern => pattern.maybeDependsOnAttributes);
@@ skipping 100 matching lines @@
    * @param {MutationRecord[]} [mutations]
    *    The list of DOM mutations that have been applied to the document and
    *    made reprocessing necessary. This parameter shouldn't be passed in for
    *    the initial processing, the entire document will be considered
    *    then and all rules, including the ones not dependent on the DOM.
    * @param {function} [done]
    *    Callback to call when done.
    */
   _addSelectors(stylesheets, mutations, done)
   {
-    let patterns = filterPatterns(this.patterns, {stylesheets, mutations});
+    let patterns = filterPatterns(this.patterns, {stylesheets, mutations},
+                                  this.document);
 
     let selectors = [];
     let selectorFilters = [];
 
     let elements = [];
     let elementFilters = [];
 
     let cssStyles = [];
 
     // If neither any style sheets nor any DOM mutations have been specified,
     // do full processing.
     if (!stylesheets && !mutations)
       stylesheets = this.document.styleSheets;
 
     // If there are any DOM mutations and any of the patterns depends on both
     // style sheets and the DOM (e.g. -abp-has(-abp-properties)), find all the
     // rules in every style sheet in the document, because we need to run
     // querySelectorAll afterwards. On the other hand, if we only have patterns
-    // that depend on either styles or DOM both not both
+    // that depend on either styles or DOM but not both
     // (e.g. -abp-properties or -abp-contains), we can skip this part.
     if (mutations && patterns.some(pattern => pattern.dependsOnStylesAndDOM))
       stylesheets = this.document.styleSheets;
 
     for (let stylesheet of stylesheets || [])
     {
       // Explicitly ignore third-party stylesheets to ensure consistent behavior
       // between Firefox and Chrome.
       if (!this.isSameOrigin(stylesheet))
         continue;
@@ skipping 198 matching lines @@
           characterData: shouldObserveCharacterData(this.patterns),
           subtree: true
         }
       );
       this.document.addEventListener("load", this.onLoad.bind(this), true);
     }
   }
 };
 
 exports.ElemHideEmulation = ElemHideEmulation;