Issue 5650 - Apply emulation filters to shadow DOMs

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 18 matching lines @@
  */
 function positionInParent(node)
 {
   let {children} = node.parentNode;
   for (let i = 0; i < children.length; i++)
     if (children[i] == node)
       return i + 1;
   return 0;
 }
 
+function isShadowRoot(node)
+{
+  return typeof ShadowRoot != "undefined" && node instanceof ShadowRoot;
+}
+
 function makeSelector(node, selector)
 {
   if (node == null)
     return null;
 
   // If this is the topmost element in a shadow DOM, climb up one more level
   // and then use a ":host" prefix.
-  if (!node.parentElement && !(node.parentNode instanceof ShadowRoot))
-  {
-    let newSelector = node instanceof ShadowRoot ? ":host" : ":root";
+  if (!node.parentElement && !isShadowRoot(node.parentNode))
+  {
+    let newSelector = isShadowRoot(node) ? ":host" : ":root";
     if (selector)
       newSelector += " > " + selector;
     return newSelector;
   }
   let idx = positionInParent(node);
   if (idx > 0)
   {
     let newSelector = `${node.tagName}:nth-child(${idx})`;
     if (selector)
       newSelector += " > " + selector;
@@ skipping 80 matching lines @@
       yield null;
     else
       yield* evaluate(chain, index + 1, selector, element, styles);
   }
   // Just in case the getSelectors() generator above had to run some heavy
   // document.querySelectorAll() call which didn't produce any results, make
   // sure there is at least one point where execution can pause.
   yield null;
 }
 
-function removeRedundantNodes(nodes)
-{
-  return nodes.filter(
-    node => !nodes.some(
-      otherNode => otherNode != node && otherNode.contains(node)
-    )
-  );
+function isDescendantOf(node, subtrees)
+{
+  return subtrees.some(subtree => subtree.contains(node));
+}
+
+function* extractAddedSubtrees(mutations)
+{
+  let knownSubtrees = [];
+
+  for (let mutation of mutations)
+  {
+    for (let node of mutation.addedNodes)
+    {
+      if (node instanceof Element && !isDescendantOf(node, knownSubtrees))
+      {
+        knownSubtrees.push(node);
+        yield node;
+      }
+    }
+  }
 }
 
 function* traverse(nodes)
 {
   for (let node of nodes)
   {
     yield* traverse(node.children);
     yield node;
   }
 }
@@ skipping 172 matching lines @@
   }
 };
 
 function isSelectorHidingOnlyPattern(pattern)
 {
   return pattern.selectors.some(s => s.preferHideWithSelector) &&
     !pattern.selectors.some(s => s.requiresHiding);
 }
 
 function ElemHideEmulation(document, root, addSelectorsFunc, hideElemsFunc,
                            shadowAttachedEventType)

[Manish Jethani, 2017/10/19 23:44:02]

This is the event type, it's a parameter now, include.preload.js should pass a
value here.

 {
   this.document = document;
   this.root = root || document;
   this.addSelectorsFunc = addSelectorsFunc;
   this.hideElemsFunc = hideElemsFunc;
   this.shadowAttachedEventType = shadowAttachedEventType;
   this.patterns = [];
   this.observer = new MutationObserver(this.observe.bind(this));
   this.shadowEmulations = new WeakMap();
 
   if (shadowAttachedEventType)
   {
     this.root.addEventListener(shadowAttachedEventType,
                                this.onShadowAttached.bind(this), true);
   }
 
   if (this.root == this.document)
     this.document.addEventListener("load", this.onLoad.bind(this), true);
   else
     this.findShadowRoots(this.root.children);

[Manish Jethani, 2017/10/19 23:44:02]

If this root is not the document (it's a shadow root), find shadow roots within
this root.

 }
 
 ElemHideEmulation.prototype = {
   isSameOrigin(stylesheet)
   {
     try
     {
       return new URL(stylesheet.href).origin == this.document.location.origin;
     }
     catch (e)
@@ skipping 232 matching lines @@
     }
     else
     {
       this._filteringInProgress = true;
       this._addSelectors(stylesheets, completion);
     }
   },
 
   onLoad(event)
   {
     this.findShadowRoots(this.root.children);

[Manish Jethani, 2017/10/19 23:44:03]

Find shadow roots on the load event.

This is not strictly necessary because we're overriding the Element.attachShadow
API before anything else happens on the page. I'm not sure we should keep this,
but I've added it for now.

 
     if (this.patterns.length == 0)
       return;
 
     let stylesheet = event.target.sheet;
     if (stylesheet)
       this.queueFiltering([stylesheet]);
   },
 
   onShadowAttached(event)
@@ skipping 12 matching lines @@
   },
 
   addShadowRoot(shadowRoot)
   {
     if (!this.shadowEmulations.has(shadowRoot))
     {
       let emulation = new ElemHideEmulation(this.document,
                                             shadowRoot,
                                             this.addSelectorsFunc,
                                             this.hideElemsFunc,
                                             this.shadowAttachedEventType);

[Manish Jethani, 2017/10/19 23:44:03]

Pass this on.

       this.shadowEmulations.set(shadowRoot, emulation);
       emulation.apply(this.patterns, true);
     }
   },
 
   findShadowRoots(nodes)
   {
     niceLoop(traverse(nodes), node =>
     {
       let shadowRoot = node.shadowRoot;
       if (shadowRoot)
         this.addShadowRoot(shadowRoot);
     });
   },
 
   observe(mutations)
   {
-    let allAddedElements = [];
-    for (let mutation of mutations)
-    {
-      for (let node of mutation.addedNodes)
-      {
-        if (node instanceof Element)
-          allAddedElements.push(node);
-      }
-    }
-
-    // Find any preattached shadows.
-    this.findShadowRoots(removeRedundantNodes(allAddedElements));
+    if (typeof ShadowRoot != "undefined")
+    {
+      // Find any preattached shadows.
+      this.findShadowRoots(extractAddedSubtrees(mutations));
+    }
 
     this.queueFiltering();
   },
 
   apply(patterns, parsed)
   {
     if (parsed)
     {
       this.patterns = patterns;
     }
@@ skipping 18 matching lines @@
           attributes: true,
           characterData: true,
           subtree: true
         }
       );
     }
   }
 };
 
 exports.ElemHideEmulation = ElemHideEmulation;