Changeset 190214 in webkit

Timestamp:

Sep 24, 2015 12:00:11 PM (9 years ago)

Author:

rniwa@webkit.org

Message:

Make event dispatching respect slotting
​https://bugs.webkit.org/show_bug.cgi?id=149243

Reviewed by Antti Koivisto.

Source/WebCore:

There are primarily two cases to consider: getting out of a shadow root to its host,
and moving into a slot from an assigned node.

When getting out of a shadow root, either the event originated in its shadow tree
including its nodes' shadow trees (1) or it moved into this shadow tree via a slot (2).
In (1), event.target should be set to the shadow host. In (2), it should be set to the
first node in the event path that belongs to the same tree as the shadow host. In order
to find such a node in O(1), we use a stack of event targets in each (shadow) tree. We
push event.target of the current tree whenever we move up to a slot from an assigned node
and pop it out of the stack when we move out of the shadow tree.

A follow up patch is needed to update the code to resolve related targets.

Tests: fast/shadow-dom/event-inside-shadow-tree.html

fast/shadow-dom/event-inside-slotted-node.html

• dom/EventDispatcher.cpp:

(WebCore::EventPath::EventPath):

LayoutTests:

Added tests for dispatching events inside shadow trees and nodes assigned to slots using testharness.js.

• fast/shadow-dom/event-inside-shadow-tree-expected.txt: Added.
• fast/shadow-dom/event-inside-shadow-tree.html: Added.
• fast/shadow-dom/event-inside-slotted-node-expected.txt: Added.
• fast/shadow-dom/event-inside-slotted-node.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/shadow-dom/event-inside-shadow-tree-expected.txt (added)
• LayoutTests/fast/shadow-dom/event-inside-shadow-tree.html (added)
• LayoutTests/fast/shadow-dom/event-inside-slotted-node-expected.txt (added)
• LayoutTests/fast/shadow-dom/event-inside-slotted-node.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/dom/EventDispatcher.cpp (modified) (4 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2015-09-24  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Make event dispatching respect slotting
+        https://bugs.webkit.org/show_bug.cgi?id=149243
+
+        Reviewed by Antti Koivisto.
+
+        Added tests for dispatching events inside shadow trees and nodes assigned to slots using testharness.js.
+
+        * fast/shadow-dom/event-inside-shadow-tree-expected.txt: Added.
+        * fast/shadow-dom/event-inside-shadow-tree.html: Added.
+        * fast/shadow-dom/event-inside-slotted-node-expected.txt: Added.
+        * fast/shadow-dom/event-inside-slotted-node.html: Added.
+
 2015-09-24  David Hyatt  <hyatt@apple.com>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-09-24  Ryosuke Niwa  <rniwa@webkit.org>
+
+        Make event dispatching respect slotting
+        https://bugs.webkit.org/show_bug.cgi?id=149243
+
+        Reviewed by Antti Koivisto.
+
+        There are primarily two cases to consider: getting out of a shadow root to its host,
+        and moving into a slot from an assigned node.
+
+        When getting out of a shadow root, either the event originated in its shadow tree
+        including its nodes' shadow trees (1) or it moved into this shadow tree via a slot (2).
+        In (1), event.target should be set to the shadow host. In (2), it should be set to the
+        first node in the event path that belongs to the same tree as the shadow host. In order
+        to find such a node in O(1), we use a stack of event targets in each (shadow) tree. We
+        push event.target of the current tree whenever we move up to a slot from an assigned node
+        and pop it out of the stack when we move out of the shadow tree.
+
+        A follow up patch is needed to update the code to resolve related targets.
+
+        Tests: fast/shadow-dom/event-inside-shadow-tree.html
+               fast/shadow-dom/event-inside-slotted-node.html
+
+        * dom/EventDispatcher.cpp:
+        (WebCore::EventPath::EventPath):
+
 2015-09-24  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WebCore/dom/EventDispatcher.cpp

@@ -32 +32 @@
 #include "HTMLInputElement.h"
 #include "HTMLMediaElement.h"
+#include "HTMLSlotElement.h"
 #include "InsertionPoint.h"
 #include "InspectorInstrumentation.h"
@@ -414 +415 @@
 }
 
-EventPath::EventPath(Node& targetNode, Event& event)
-{
-    bool isSVGElement = targetNode.isSVGElement();
+EventPath::EventPath(Node& originalTarget, Event& event)
+{
+#if ENABLE(SHADOW_DOM)
+    Vector<EventTarget*, 16> targetStack;
+#endif
+
     bool isMouseOrFocusEvent = event.isMouseEvent() || event.isFocusEvent();
 #if ENABLE(TOUCH_EVENTS) && !PLATFORM(IOS)
@@ -423 +427 @@
     EventTarget* target = nullptr;
 
-    Node* node = nodeOrHostIfPseudoElement(&targetNode);
+    Node* node = nodeOrHostIfPseudoElement(&originalTarget);
     while (node) {
-        if (!target || !isSVGElement) // FIXME: This code doesn't make sense once we've climbed out of the SVG subtree in a HTML document.
+        if (!target)
             target = eventTargetRespectingTargetRules(*node);
-        for (; node; node = node->parentNode()) {
+        ContainerNode* parent;
+        for (; node; node = parent) {
             EventTarget* currentTarget = eventTargetRespectingTargetRules(*node);
             if (isMouseOrFocusEvent)
@@ -439 +444 @@
             if (is<ShadowRoot>(*node))
                 break;
+            parent = node->parentNode();
+            if (!parent)
+                return;
+#if ENABLE(SHADOW_DOM)
+            if (ShadowRoot* shadowRootOfParent = parent->shadowRoot()) {
+                if (auto* assignedSlot = shadowRootOfParent->findAssignedSlot(*node)) {
+                    // node is assigned to a slot. Continue dispatching the event at this slot.
+                    targetStack.append(target);
+                    parent = assignedSlot;
+                    target = assignedSlot;
+                }
+            }
+#endif
+            node = parent;
         }
-        if (!node || !shouldEventCrossShadowBoundary(event, downcast<ShadowRoot>(*node), *target))
+
+        ShadowRoot& shadowRoot = downcast<ShadowRoot>(*node);
+        // At a shadow root. Continue dispatching the event at the shadow host.
+#if ENABLE(SHADOW_DOM)
+        if (!targetStack.isEmpty()) {
+            // Move target back to a descendant of the shadow host if the event did not originate in this shadow tree or its inner shadow trees.
+            target = targetStack.last();
+            targetStack.removeLast();
+            ASSERT(shadowRoot.host()->contains(target->toNode()));
+        } else
+            target = nullptr;
+#endif
+        if (!shouldEventCrossShadowBoundary(event, shadowRoot, originalTarget))
             return;
-        node = downcast<ShadowRoot>(*node).host();
+        node = shadowRoot.host();
     }
 }