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 133 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 extractSubtrees(nodes)
-{
-  return nodes.filter(
-    (node, index) => !nodes.some(
-      // The index comparison is based on the fact that a node always appears
-      // in the list before any of its descendants.
-      (otherNode, otherIndex) => otherIndex < index && 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 496 matching lines @@
     niceLoop(traverse(nodes), node =>
     {
       let shadowRoot = node.shadowRoot;
       if (shadowRoot)
         this.addShadowRoot(shadowRoot);
     });
   },
 
   observe(mutations)
   {
     if (typeof ShadowRoot != "undefined")

[Manish Jethani, 2017/10/20 16:16:42]

Of course we only have to run this code on Chrome.

[hub, 2017/10/20 19:12:50]

Maybe we should set a different mutation observer based on this as the observer
is called quite often.

[Manish Jethani, 2017/10/22 20:01:35]

But both the observers would listen for the same DOM mutations, it's not like
the work would be split between the two. It would be worse because we would have
two observers doing the same work that one could do.

[hub, 2017/10/23 13:30:34]

not saying to observe twice. but when we set up the MutationObserver, we could
setup up a different one if the browser supports ShadowRoot. Feels like a micro
optimisation, maybe.

[Manish Jethani, 2017/10/23 23:04:28]

OK, I see what you mean. I think we're going to end up having to add a lot of
optimizations to that observe function, and that will involve sharing some code
between the shadow roots case and the normal case (e.g. making a list of the
newly added subtree roots). On balance it feels like it's probably best to keep
it all in one function.

If we split the observer, it would make sense to do it based on the mutation
type ("childList", "attributes", and "characterData" can each have their own
observer), but then again let's see how this code evolves as we add support for
user style sheets and so on.

     {
-      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(extractSubtrees(allAddedElements));
+      this.findShadowRoots(extractAddedSubtrees(mutations));
     }
 
     this.queueFiltering();
   },
 
   apply(patterns, parsed)
   {
     if (parsed)
     {
       this.patterns = patterns;
@@ skipping 19 matching lines @@
           attributes: true,
           characterData: true,
           subtree: true
         }
       );
     }
   }
 };
 
 exports.ElemHideEmulation = ElemHideEmulation;