Update the mouse events on tapping of gesture across frames

Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 2219 matching lines @@
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
 
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_frame->localFrameRoot());
 
     // Non-scrolling related gesture events do a single cross-frame hit-test and jump
     // directly to the inner most frame. This matches handleMousePressEvent etc.
     ASSERT(!targetedEvent.event().isScrollEvent());
 
+    // update mouseout/leave/over/enter events before jumping directly to the inner most frame
+    if (targetedEvent.event().type() == PlatformEvent::GestureTap)
+        updateGestureTargetNodeForMouseEvent(targetedEvent);
+
     // Route to the correct frame.
     if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
         return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
     return handleGestureEventInFrame(targetedEvent);
 }
 
 bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
@@ skipping 581 matching lines @@
             // we should clear the old hovered node from the old hovered frame.
             if (newHoverFrame != oldHoverFrame)
                 doc->updateHoverActiveState(request, nullptr);
         }
     }
 
     // Recursively set the new active/hover states on every frame in the chain of innerElement.
     m_frame->document()->updateHoverActiveState(request, innerElement);
 }
 
+// Update the mouseover/mouseenter/mouseout/mouseleave events across all frames for this gesture,
+// before passing the targeted gesture event directly to a hit frame.
+void EventHandler::updateGestureTargetNodeForMouseEvent(const GestureEventWithHitTestResults& targetedEvent)
+{
+    ASSERT(m_frame == m_frame->localFrameRoot());
+
+    // Behaviour of this function is as follows:
+    // - Create the chain of all entered frames.
+    // - Compare the last frame chain under the gesture to newly entered frame chain from the main frame one by one.
+    // - If the last frame doesn't match with the entered frame, then create the chain of exited frames from the last frame chain.
+    // - Dispatch mouseout/mouseleave events of the exited frames from the inside out.
+    // - Dispatch mouseover/mouseenter events of the entered frames into the inside.
+
+    // Insert the ancestors of the frame having the new target node to the entered frame chain
+    WillBeHeapVector<LocalFrame*> enteredFrameChain;
+    LocalFrame* enteredFrameInDocument = targetedEvent.hitTestResult().innerNodeFrame();
+    while (enteredFrameInDocument) {
+        enteredFrameChain.append(enteredFrameInDocument);
+        Frame* parentFrame = enteredFrameInDocument->tree().parent();
+        enteredFrameInDocument = parentFrame && parentFrame->isLocalFrame() ? toLocalFrame(parentFrame) : nullptr;
+    }
+
+    size_t indexEnteredFrameChain = enteredFrameChain.size();
+    LocalFrame* exitedFrameInDocument = m_frame;
+    WillBeHeapVector<LocalFrame*> exitedFrameChain;
+    // Insert the frame from the disagreement between last frames and entered frames
+    while (exitedFrameInDocument) {
+        Node* lastNodeUnderTap = exitedFrameInDocument->eventHandler().m_lastNodeUnderMouse.get();
+        if (!lastNodeUnderTap)
+            break;
+
+        LocalFrame* nextExitedFrameInDocument = nullptr;
+        if (lastNodeUnderTap->isFrameOwnerElement()) {
+            HTMLFrameOwnerElement* owner = toHTMLFrameOwnerElement(lastNodeUnderTap);
+            if (owner->contentFrame() && owner->contentFrame()->isLocalFrame())
+                nextExitedFrameInDocument = toLocalFrame(owner->contentFrame());
+        }
+
+        if (exitedFrameChain.size() > 0) {
+            exitedFrameChain.append(exitedFrameInDocument);
+        } else {
+            LocalFrame* enteredFrameInDocument = indexEnteredFrameChain ? enteredFrameChain[indexEnteredFrameChain-1] : nullptr;
+            // Avoid that unnecessary mouse events are fired on tapping across the frames

[mustaq, 2015/06/16 14:50:44]

Thanks Miyoung, I was thinking about a scenario exactly like this. But my
concern was different: why is only the last entry in enteredFrameChain checked
here? Let's step though your example here to emphasize the issue here:

1. At the end of enteredFrameChain loop above, we have
enteredFrameChain=[E,D,A,Main].

2. During the first iteration of this loop for exitedFrameChain, we have
exitedFrameInDoc=C, and exitedFrameChain becomes [C].

3. For all subsequent iterations of this loop, Line 2883 is true, so Line 2884
pushes frames into the list w/o looking for duplicates in enteredFrameChain.

4. Therefore, at Line 2912, we have exitedFrameChain=[C,B,A,Main]. We shouldn't
expect A & Main in the list, right?

It would be great if you could add another test with multi-level frames, exactly
like your example here.

[Miyoung Shin(c), 2015/06/20 21:08:29]

The iteration of this loop is to check frames from Main to C. loop=[Main -> A ->
B -> C]
So, we have exitedFrameChain=[B, C] and enteredFrameChain= [E, D] (because of
moving the index to D) 
I've updated the test for multi-level frames.

[mustaq, 2015/07/02 20:37:29]

Thanks for clarifying, and also for adding the elaborate test.

I think your previous comment was correct: Frame A shouldn't receive
mouseout/over.

+            // If tapping is moved x1 to x2 , the last frame chains is,
+            //   Main frame-> A frame -> B frame -> C frame
+            // and the new frame chains is,
+            //   Main frame -> A frame -> D frame -> E frame
+            //  |------Main frame--------------------|
+            //  | |----------------A---------------| |
+            //  | | |-----B-----|   |-----D------| | |
+            //  | | | |---C---| |   | |---E----| | | |
+            //  | | | |  x1   | |   | |  x2    | | | |
+            //  | | | |-------| |   | |--------| | | |
+            //  | | |-----------|   |------------| | |
+            //  | |--------------------------------| |
+            //  |------------------------------------|
+            //  For mouseout/mouseleave events, we should make the exited frame chain like B frame -> C frame.
+            //  For mouseover/mouseenter events, we should make the entered frame chain like D frame -> E frame.
+            //  And in main frame and A sub-frame we shouldn't fire any mouse events.
+            if (exitedFrameInDocument != enteredFrameInDocument)
+                exitedFrameChain.append(exitedFrameInDocument);
+            else if (nextExitedFrameInDocument && indexEnteredFrameChain)
+                --indexEnteredFrameChain;
+        }
+        exitedFrameInDocument = nextExitedFrameInDocument;
+    }
+
+    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+    unsigned modifiers = gestureEvent.modifiers();
+    PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
+        NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
+        static_cast<PlatformEvent::Modifiers>(modifiers),
+        PlatformMouseEvent::FromTouch, gestureEvent.timestamp());
+
+    // Update the mouseout/mouseleave event
+    size_t indexExitedFrameChain = exitedFrameChain.size();
+    while (indexExitedFrameChain) {
+        LocalFrame* exitedFrameInDocument = exitedFrameChain[--indexExitedFrameChain];
+        exitedFrameInDocument->eventHandler().updateMouseEventTargetNode(nullptr, fakeMouseMove, true);
+    }
+
+    // update the mouseover/mouseenter event
+    while (indexEnteredFrameChain > 1) {

[Miyoung Shin(c), 2015/06/20 21:08:29]

 After updating the test, I found A sub frame didn't update the mouseout and
mouseover events. so I changed the code here to work it.  

[mustaq, 2015/07/02 20:37:29]

The change makes sense. But this shouldn't influence A because (as you mentioned
above) you already got rid of A from the list, right?

[Miyoung Shin(c), 2015/07/05 12:39:33]

Yes I got rid of A from list, but A is the parent of D, so we should dispatch
mouseout/mouseover events on A when tapping between B and D.

[mustaq, 2015/07/06 17:14:50]

I think A shouldn't get any bubbling events from child frames. See my question
in the expected.txt file.

+        LocalFrame* enteredFrameInDocument = enteredFrameChain[--indexEnteredFrameChain];
+        Node* enteredFrameNode = enteredFrameChain[indexEnteredFrameChain-1]->deprecatedLocalOwner();
+        enteredFrameInDocument->eventHandler().updateMouseEventTargetNode(enteredFrameNode, fakeMouseMove, true);
+    }
+}
+
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
 {
     TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
     ASSERT(m_frame == m_frame->localFrameRoot());
     // Scrolling events get hit tested per frame (like wheel events do).
     ASSERT(!gestureEvent.isScrollEvent());
 
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     double activeInterval = 0;
@@ skipping 1295 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink