[Shadow DOM]: Empty shadow insertion points should behave like <shadow><content *leftover*></conten…

Source/core/events/EventPath.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 186 matching lines @@
         Vector<RefPtr<Node> > nodes;
         for (size_t j = 0; j < size(); ++j) {
             if (at(j).node()->treeScope().isInclusiveAncestorOf(*currentScope))
                 nodes.append(at(j).node());
         }
         at(i).adoptEventPath(nodes);
     }
 }
 
 #ifndef NDEBUG
-static inline bool movedFromChildToParent(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
-{
-    return lastTreeScope.parentTreeScope() == &currentTreeScope;
-}
-
 static inline bool movedFromOlderToYounger(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
 {
     Node* rootNode = lastTreeScope.rootNode();
     return rootNode->isShadowRoot() && toShadowRoot(rootNode)->youngerShadowRoot() == currentTreeScope.rootNode();
 }
-#endif
-
-static inline bool movedFromParentToChild(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
-{
-    return currentTreeScope.parentTreeScope() == &lastTreeScope;
-}
 
 static inline bool movedFromYoungerToOlder(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
 {
     Node* rootNode = lastTreeScope.rootNode();
     return rootNode->isShadowRoot() && toShadowRoot(rootNode)->olderShadowRoot() == currentTreeScope.rootNode();
 }
+#endif
+
+static inline bool movedFromChildToParent(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
+{
+    return lastTreeScope.parentTreeScope() == &currentTreeScope;
+}
+
+static inline bool movedFromParentToChild(const TreeScope& lastTreeScope, const TreeScope& currentTreeScope)
+{
+    return currentTreeScope.parentTreeScope() == &lastTreeScope;
+}
 
 void EventPath::calculateAdjustedTargets()
 {
     Vector<Node*, 32> targetStack;
     const TreeScope* lastTreeScope = 0;
     bool isSVGElement = at(0).node()->isSVGElement();
 
     for (size_t i = 0; i < size(); ++i) {
         Node* current = at(i).node();
         const TreeScope& currentTreeScope = current->treeScope();
         if (targetStack.isEmpty()) {
             targetStack.append(current);
         } else if (*lastTreeScope != currentTreeScope && !isSVGElement) {
-            if (movedFromParentToChild(*lastTreeScope, currentTreeScope) || movedFromYoungerToOlder(*lastTreeScope, currentTreeScope)) {
+            if (movedFromParentToChild(*lastTreeScope, currentTreeScope)) {
                 targetStack.append(targetStack.last());
-            } else {
-                ASSERT(movedFromChildToParent(*lastTreeScope, currentTreeScope) || movedFromOlderToYounger(*lastTreeScope, currentTreeScope));
+            } else if (movedFromChildToParent(*lastTreeScope, currentTreeScope)) {
                 ASSERT(!targetStack.isEmpty());
                 targetStack.removeLast();
                 if (targetStack.isEmpty())
                     targetStack.append(current);
+            } else {
+                ASSERT(movedFromYoungerToOlder(*lastTreeScope, currentTreeScope) || movedFromOlderToYounger(*lastTreeScope, currentTreeScope));
+                ASSERT(!targetStack.isEmpty());
+                targetStack.removeLast();
+                if (targetStack.isEmpty())
+                    targetStack.append(current);
+                else
+                    targetStack.append(targetStack.last());
             }
         }
         at(i).setTarget(eventTargetRespectingTargetRules(targetStack.last()));
         lastTreeScope = &currentTreeScope;
     }
 }
 
 } // namespace