Separate mouse transition events from pointerevent

third_party/WebKit/Source/core/input/PointerEventManager.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PointerEventManager_h
 #define PointerEventManager_h
 
 #include "core/CoreExport.h"
 #include "core/events/PointerEvent.h"
 #include "core/events/PointerEventFactory.h"
@@ skipping 11 matching lines @@
     DISALLOW_NEW();
 public:
     PointerEventManager();
     ~PointerEventManager();
     DECLARE_TRACE();
 
     WebInputEventResult sendMousePointerEvent(
         PassRefPtrWillBeRawPtr<Node>, const AtomicString& type,
         int clickCount, const PlatformMouseEvent&,
         PassRefPtrWillBeRawPtr<Node> relatedTarget,
-        PassRefPtrWillBeRawPtr<AbstractView>);
+        PassRefPtrWillBeRawPtr<AbstractView>,
+        PassRefPtrWillBeRawPtr<Node> lastNodeUnderMouse);
 
     // Returns whether the event is consumed or not
     WebInputEventResult sendTouchPointerEvent(
         PassRefPtrWillBeRawPtr<EventTarget>,
         const PlatformTouchPoint&, PlatformEvent::Modifiers,
         const double width, const double height,
         const double clientX, const double clientY);
 
     void sendTouchCancelPointerEvent(PassRefPtrWillBeRawPtr<EventTarget>,
         const PlatformTouchPoint&);
 
-    // Sends node transition events (pointer|mouse)(out|leave|over|enter) to the corresponding targets
-    void sendNodeTransitionEvents(PassRefPtrWillBeRawPtr<Node> exitedNode,
+    // Sends node transition events mouseout/leave/over/enter to the
+    // corresponding targets. This function sends pointerout/leave/over/enter
+    // only when isFrameBoundaryTransition is true which indicates the

[Rick Byers, 2016/03/29 16:37:14]

nit: can you add a little more detail on why the frame boundary case needs to be
treated specially?  Naively I think frame and element boundary would ideally be
implemented identically.

[Navid Zolghadr, 2016/03/29 17:44:03]

I explained a bit more here in this comment. Essentially the normal mouse events
(down/move/up) never come to this function. They will go to
sendMousePointerEvent and the transition events of those will be handled there.

+    // transition is over the document boundary and not only the elements border
+    // inside the document.
+    void sendMouseAndPossiblyPointerNodeTransitionEvents(
+        PassRefPtrWillBeRawPtr<Node> exitedNode,
         PassRefPtrWillBeRawPtr<Node> enteredNode,
         const PlatformMouseEvent&,
-        PassRefPtrWillBeRawPtr<AbstractView>);
+        PassRefPtrWillBeRawPtr<AbstractView>, bool isFrameBoundaryTransition);
 
     // Clear all the existing ids.
     void clear();
 
-    // May clear PREVENT MOUSE EVENT flag as per pointer event spec:
-    // https://w3c.github.io/pointerevents/#compatibility-mapping-with-mouse-events
-    void conditionallyEnableMouseEventForPointerTypeMouse(unsigned);
-
     void elementRemoved(EventTarget*);
     void setPointerCapture(int, EventTarget*);
     void releasePointerCapture(int, EventTarget*);
     bool isActive(const int);
 
 private:
     typedef WillBeHeapHashMap<int, RefPtrWillBeMember<EventTarget>> PointerCapturingMap;
     class EventTargetAttributes {
         DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     public:
@@ skipping 12 matching lines @@
         , hasRecievedOverEvent(hasRecievedOverEvent) {}
     };
 
     void sendNodeTransitionEvents(
         PassRefPtrWillBeRawPtr<EventTarget> exitedTarget,
         PassRefPtrWillBeRawPtr<EventTarget> enteredTarget,
         PassRefPtrWillBeRawPtr<PointerEvent>,
         const PlatformMouseEvent& = PlatformMouseEvent(),
         bool sendMouseEvent = false);
     void setNodeUnderPointer(PassRefPtrWillBeRawPtr<PointerEvent>,
-        PassRefPtrWillBeRawPtr<EventTarget>);
-    void processPendingPointerCapture(
+        PassRefPtrWillBeRawPtr<EventTarget>, bool sendEvent = true);
+
+    // Returns whether the pointer capture is changed. In this case this
+    // function will take care of transition events and setNodeUnderPointer
+    // should not send transition events.
+    bool processPendingPointerCapture(
         const PassRefPtrWillBeRawPtr<PointerEvent>,
         const PassRefPtrWillBeRawPtr<EventTarget>,
         const PlatformMouseEvent& = PlatformMouseEvent(),
         bool sendMouseEvent = false);
+
+    // Processes the capture state of a pointer, updates node under
+    // pointer, and sends corresponding transition events for pointer if
+    // setPointerPosition is true. It also sends corresponding transition events
+    // for mouse if sendMouseEvent is true.
+    void processCaptureAndPositionOfPointerEvent(
+        const PassRefPtrWillBeRawPtr<PointerEvent>,
+        const PassRefPtrWillBeRawPtr<EventTarget> hitTestTarget,
+        const PassRefPtrWillBeRawPtr<EventTarget> lastNodeUnderMouse = nullptr,
+        const PlatformMouseEvent& = PlatformMouseEvent(),
+        bool sendMouseEvent = false,
+        bool setPointerPosition = true);
+
     void removeTargetFromPointerCapturingMapping(
         PointerCapturingMap&, const EventTarget*);
     PassRefPtrWillBeRawPtr<EventTarget> getEffectiveTargetForPointerEvent(
         PassRefPtrWillBeRawPtr<EventTarget>, int);
     EventTarget* getCapturingNode(int);
     void removePointer(const PassRefPtrWillBeRawPtr<PointerEvent>);
     WebInputEventResult dispatchPointerEvent(
         PassRefPtrWillBeRawPtr<EventTarget>,
         PassRefPtrWillBeRawPtr<PointerEvent>,
         bool checkForListener = false);
@@ skipping 11 matching lines @@
     WillBeHeapHashMap<int, EventTargetAttributes> m_nodeUnderPointer;
 
     PointerCapturingMap m_pointerCaptureTarget;
     PointerCapturingMap m_pendingPointerCaptureTarget;
     PointerEventFactory m_pointerEventFactory;
 };
 
 } // namespace blink
 
 #endif // PointerEventManager_h