Changeset 83386 in webkit

Timestamp:

Apr 9, 2011 7:33:19 PM (13 years ago)

Author:

Dimitri Glazkov

Message:

2011-04-02 Dimitri Glazkov <Dimitri Glazkov>

Reviewed by Ojan Vafai.

Implement proper handling of mouseover/mouseout events in regard to shadow DOM boundaries.
​https://bugs.webkit.org/show_bug.cgi?id=55515

• fast/events/shadow-boundary-crossing-expected.txt: Updated expectations.
• fast/events/shadow-boundary-crossing.html: Added new test for mouseover/mouseout handling.

2011-04-08 Dimitri Glazkov <Dimitri Glazkov>

Reviewed by Ojan Vafai.

Implement proper handling of mouseover/mouseout events in regard to shadow DOM boundaries.
​https://bugs.webkit.org/show_bug.cgi?id=55515

This implements XBL 2.0's specified handling of mouseover/mouseout events:
​http://dev.w3.org/2006/xbl2/Overview.html#the-mouseover-and-mouseout-events

To do this, we:
1) calculate lowest common ancestor between relatedTarget and target, and

the nearest boundaries around them: the outer (common) boundary, and the
inner (specific to relatedTarget) boundary. Then, we

2) ensure that events only propagate up to the common boundary (or

all the way if boundary is not found), while

3) updating relatedTarget be the inner boundary.

We also detect the most common case when no common boundary could exist
and provide a fast path to short-circuit most of the boundary detection
logic.

Test: fast/events/shadow-boundary-crossing.html

• dom/EventDispatcher.cpp: (WebCore::EventDispatcher::adjustToShadowBoundaries): Added a helper to determine lowest

common ancestor, the boundaries around it, and compute adjustments
to relatedTarget and event target ancestor chain.

(WebCore::ancestorsCrossShadowBoundaries): Added.
(WebCore::EventDispatcher::adjustRelatedTarget): Changed to calculate

inner/outer shadow DOM boundaries and adjust ancestors chain accordingly.

(WebCore::EventDispatcher::EventDispatcher): Added flag initializer
(WebCore::EventDispatcher::ensureEventAncestors): Renamed from getEventAncestors,

converted to use initialization flag, rather than testing for empty.

• dom/EventDispatcher.h: Adjusted decls.
• dom/MouseEvent.cpp: (WebCore::MouseEventDispatchMediator::dispatchEvent): Changed to send event

to adjustRelatedTarget.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/events/shadow-boundary-crossing-expected.txt (modified) (1 diff)
• LayoutTests/fast/events/shadow-boundary-crossing.html (modified) (3 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/dom/EventDispatcher.cpp (modified) (4 diffs)
• Source/WebCore/dom/EventDispatcher.h (modified) (3 diffs)
• Source/WebCore/dom/MouseEvent.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-04-02  Dimitri Glazkov  <dglazkov@chromium.org>
+
+        Reviewed by Ojan Vafai.
+
+        Implement proper handling of mouseover/mouseout events in regard to shadow DOM boundaries.
+        https://bugs.webkit.org/show_bug.cgi?id=55515
+
+        * fast/events/shadow-boundary-crossing-expected.txt: Updated expectations.
+        * fast/events/shadow-boundary-crossing.html: Added new test for mouseover/mouseout handling.
+
 2011-04-09  Dirk Pranke  <dpranke@chromium.org>
 

trunk/LayoutTests/fast/events/shadow-boundary-crossing-expected.txt

@@ -5 +5 @@
 Mutation events should not propagate out of the shadow DOM: PASS
 The selectstart event should not propagate out of the shadow DOM: PASS
+The mouseover/mouseout event between two elements inside the same shadow subtree should not propagate out of the shadow DOM: PASS
 Label should look beyond shadow boundary to detect if it encloses its associated element: PASS
 Events for default event handler should not be retargeted: PASS

trunk/LayoutTests/fast/events/shadow-boundary-crossing.html

@@ -20 +20 @@
 }
 
+function moveOverLeftQuarterOf(element)
+{
+    if (!window.eventSender)
+        return;
+
+    var x = element.offsetLeft + element.offsetWidth / 4;
+    var y = element.offsetTop + element.offsetHeight / 2;
+    eventSender.mouseMoveTo(x, y);
+}
+
+function moveOverRightQuarterOf(element)
+{
+    if (!window.eventSender)
+        return;
+
+    var x = element.offsetLeft + element.offsetWidth * 3 / 4;
+    var y = element.offsetTop + element.offsetHeight / 2;
+    eventSender.mouseMoveTo(x, y);
+}
+
 function clickOn(element)
 {
@@ -32 +52 @@
         return;
 
-    var x = element.offsetLeft + element.offsetWidth / 4;
-    var y = element.offsetTop + element.offsetHeight / 2;
-    eventSender.mouseMoveTo(x, y);
+    moveOverLeftQuarterOf(element);
     eventSender.mouseDown();
     eventSender.mouseUp();
@@ -74 +92 @@
         textInput.parentNode.removeChild(textInput);
         document.selectstart = null;
+    },
+    mouseOverAndOutPropagation: function()
+    {
+        var count = 0;
+        var fileInput = document.body.appendChild(document.createElement('input'));
+        fileInput.setAttribute('type', 'file');
+        var countEventDispatch = function()
+        {
+            count++;
+        }
+        moveOverLeftQuarterOf(fileInput);
+
+        document.body.addEventListener('mouseover', countEventDispatch, false);
+        document.body.addEventListener('mouseout', countEventDispatch, false);
+
+        moveOverRightQuarterOf(fileInput);
+
+        log("The mouseover/mouseout event between two elements inside the same shadow subtree should not propagate out of the shadow DOM", count == 0);
+
+        document.body.removeEventListener('mouseover', countEventDispatch, false);
+        document.body.removeEventListener('mouseout', countEventDispatch, false);
+        fileInput.parentNode.removeChild(fileInput);
     },
     labelSyntheticClick: function()

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-04-08  Dimitri Glazkov  <dglazkov@chromium.org>
+
+        Reviewed by Ojan Vafai.
+
+        Implement proper handling of mouseover/mouseout events in regard to shadow DOM boundaries.
+        https://bugs.webkit.org/show_bug.cgi?id=55515
+
+        This implements XBL 2.0's specified handling of mouseover/mouseout events:
+        http://dev.w3.org/2006/xbl2/Overview.html#the-mouseover-and-mouseout-events
+
+        To do this, we:
+        1) calculate lowest common ancestor between relatedTarget and target, and
+           the nearest boundaries around them: the outer (common) boundary, and the
+           inner (specific to relatedTarget) boundary. Then, we
+        2) ensure that events only propagate up to the common boundary (or
+           all the way if boundary is not found), while
+        3) updating relatedTarget be the inner boundary.
+
+        We also detect the most common case when no common boundary could exist
+        and provide a fast path to short-circuit most of the boundary detection
+        logic.
+
+        Test: fast/events/shadow-boundary-crossing.html
+
+        * dom/EventDispatcher.cpp:
+        (WebCore::EventDispatcher::adjustToShadowBoundaries): Added a helper to determine lowest
+            common ancestor, the boundaries around it, and compute adjustments
+            to relatedTarget and event target ancestor chain.
+        (WebCore::ancestorsCrossShadowBoundaries): Added.
+        (WebCore::EventDispatcher::adjustRelatedTarget): Changed to calculate
+            inner/outer shadow DOM boundaries and adjust ancestors chain accordingly.
+        (WebCore::EventDispatcher::EventDispatcher): Added flag initializer
+        (WebCore::EventDispatcher::ensureEventAncestors): Renamed from getEventAncestors,
+            converted to use initialization flag, rather than testing for empty.
+        * dom/EventDispatcher.h: Adjusted decls.
+        * dom/MouseEvent.cpp:
+        (WebCore::MouseEventDispatchMediator::dispatchEvent): Changed to send event
+            to adjustRelatedTarget.
+
 2011-04-08  Geoffrey Garen  <ggaren@apple.com>
 

trunk/Source/WebCore/dom/EventDispatcher.cpp

@@ -123 +123 @@
 }
 
+PassRefPtr<EventTarget> EventDispatcher::adjustToShadowBoundaries(PassRefPtr<Node> relatedTarget, const Vector<Node*> relatedTargetAncestors)
+{
+    Vector<EventContext>::const_iterator lowestCommonBoundary = m_ancestors.end();
+    // Assume divergent boundary is the relatedTarget itself (in other words, related target ancestor chain does not cross any shadow DOM boundaries).
+    Vector<Node*>::const_iterator firstDivergentBoundary = relatedTargetAncestors.begin();
+
+    Vector<EventContext>::const_iterator targetAncestor = m_ancestors.end();
+    // Walk down from the top, looking for lowest common ancestor, also monitoring shadow DOM boundaries.
+    bool diverged = false;
+    for (Vector<Node*>::const_iterator i = relatedTargetAncestors.end() - 1; i >= relatedTargetAncestors.begin(); --i) {
+        if (diverged) {
+            if ((*i)->isShadowRoot()) {
+                firstDivergentBoundary = i + 1;
+                break;
+            }
+            continue;
+        }
+
+        if (targetAncestor == m_ancestors.begin()) {
+            diverged = true;
+            continue;
+        }
+
+        targetAncestor--;
+
+        if ((*i)->isShadowRoot())
+            lowestCommonBoundary = targetAncestor;
+
+        if ((*i) != (*targetAncestor).node())
+            diverged = true;
+    }
+
+    if (!diverged) {
+        // The relatedTarget is a parent or shadowHost of the target.
+        if (m_node->isShadowRoot())
+            lowestCommonBoundary = m_ancestors.begin();
+    } else if ((*firstDivergentBoundary) == m_node.get()) {
+        // Since ancestors does not contain target itself, we must account
+        // for the possibility that target is a shadowHost of relatedTarget
+        // and thus serves as the lowestCommonBoundary.
+        // Luckily, in this case the firstDivergentBoundary is target.
+        lowestCommonBoundary = m_ancestors.begin();
+    }
+
+    // Trim ancestors to lowestCommonBoundary to keep events inside of the common shadow DOM subtree.
+    if (lowestCommonBoundary != m_ancestors.end())
+        m_ancestors.shrink(lowestCommonBoundary - m_ancestors.begin());
+    // Set event's related target to the first encountered shadow DOM boundary in the divergent subtree.
+    return firstDivergentBoundary != relatedTargetAncestors.begin() ? *firstDivergentBoundary : relatedTarget;
+}
+
+inline static bool ancestorsCrossShadowBoundaries(const Vector<EventContext>& ancestors)
+{
+    return ancestors.isEmpty() || ancestors.first().node() == ancestors.last().node();
+}
+
 // FIXME: Once https://bugs.webkit.org/show_bug.cgi?id=52963 lands, this should
 // be greatly improved. See https://bugs.webkit.org/show_bug.cgi?id=54025.
-PassRefPtr<EventTarget> EventDispatcher::adjustRelatedTarget(PassRefPtr<EventTarget> relatedTarget)
-{
+PassRefPtr<EventTarget> EventDispatcher::adjustRelatedTarget(Event* event, PassRefPtr<EventTarget> prpRelatedTarget)
+{
+    if (!prpRelatedTarget)
+        return 0;
+
+    RefPtr<Node> relatedTarget = prpRelatedTarget->toNode();
     if (!relatedTarget)
         return 0;
 
-    Node* node = relatedTarget->toNode();
-    if (!node)
-        return relatedTarget;
-
-    Node* outermostShadowBoundary = node;
-    for (Node* n = node; n; n = n->parentOrHostNode()) {
+    Node* target = m_node.get();
+    if (!target)
+        return prpRelatedTarget;
+
+    ensureEventAncestors(event);
+
+    // Calculate early if the common boundary is even possible by looking at
+    // ancestors size and if the retargeting has occured (indicating the presence of shadow DOM boundaries).
+    // If there are no boundaries detected, the target and related target can't have a common boundary.
+    bool noCommonBoundary = ancestorsCrossShadowBoundaries(m_ancestors);
+
+    Vector<Node*> relatedTargetAncestors;
+    Node* outermostShadowBoundary = relatedTarget.get();
+    for (Node* n = outermostShadowBoundary; n; n = n->parentOrHostNode()) {
         if (n->isShadowRoot())
             outermostShadowBoundary = n->parentOrHostNode();
-    }
-    return outermostShadowBoundary;
+        if (!noCommonBoundary)
+            relatedTargetAncestors.append(n);
+    }
+
+    // Short-circuit the fast case when we know there is no need to calculate a common boundary.
+    if (noCommonBoundary)
+        return outermostShadowBoundary;
+
+    return adjustToShadowBoundaries(relatedTarget.release(), relatedTargetAncestors);
 }
 
 EventDispatcher::EventDispatcher(Node* node)
     : m_node(node)
+    , m_ancestorsInitialized(false)
 {
     ASSERT(node);
@@ -149 +225 @@
 }
 
-void EventDispatcher::getEventAncestors(EventTarget* originalTarget, EventDispatchBehavior behavior)
-{
+void EventDispatcher::ensureEventAncestors(Event* event)
+{
+    EventDispatchBehavior behavior = determineDispatchBehavior(event);
+
     if (!m_node->inDocument())
         return;
 
-    if (ancestorsInitialized())
+    if (m_ancestorsInitialized)
         return;
 
-    EventTarget* target = originalTarget;
+    m_ancestorsInitialized = true;
+
     Node* ancestor = m_node.get();
+    EventTarget* target = eventTargetRespectingSVGTargetRules(ancestor);
     bool shouldSkipNextAncestor = false;
     while (true) {
@@ -193 +273 @@
 
     RefPtr<EventTarget> originalTarget = event->target();
-    getEventAncestors(originalTarget.get(), determineDispatchBehavior(event.get()));
+    ensureEventAncestors(event.get());
 
     WindowEventContext windowContext(event.get(), m_node.get(), topEventContext());
@@ -277 +357 @@
 }
 
-
 const EventContext* EventDispatcher::topEventContext()
 {
     return m_ancestors.isEmpty() ? 0 : &m_ancestors.last();
-}
-
-bool EventDispatcher::ancestorsInitialized() const
-{
-    return m_ancestors.size();
 }
 

trunk/Source/WebCore/dom/EventDispatcher.h

@@ -55 +55 @@
 
     bool dispatchEvent(PassRefPtr<Event>);
-    PassRefPtr<EventTarget> adjustRelatedTarget(PassRefPtr<EventTarget>);
+    PassRefPtr<EventTarget> adjustRelatedTarget(Event*, PassRefPtr<EventTarget>);
     Node* node() const;
 
@@ -61 +61 @@
     EventDispatcher(Node*);
 
+    PassRefPtr<EventTarget> adjustToShadowBoundaries(PassRefPtr<Node> relatedTarget, const Vector<Node*> relatedTargetAncestors);
     EventDispatchBehavior determineDispatchBehavior(Event*);
-    void getEventAncestors(EventTarget* originalTarget, EventDispatchBehavior);
+    void ensureEventAncestors(Event*);
     const EventContext* topEventContext();
-    bool ancestorsInitialized() const;
 
     Vector<EventContext> m_ancestors;
@@ -70 +70 @@
     RefPtr<EventTarget> m_originalTarget;
     RefPtr<FrameView> m_view;
+    bool m_ancestorsInitialized;
 };
 

trunk/Source/WebCore/dom/MouseEvent.cpp

@@ -171 +171 @@
         return false; // Shouldn't happen.
 
-    RefPtr<EventTarget> relatedTarget = dispatcher->adjustRelatedTarget(event()->relatedTarget());
+    RefPtr<EventTarget> relatedTarget = dispatcher->adjustRelatedTarget(event(), event()->relatedTarget());
     event()->setRelatedTarget(relatedTarget);