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 does send pointerout/leave/over/enter
+    // only when the transition is beyond the document boundary which is specified

[mustaq, 2016/03/23 18:49:07]

The last line is not clear to me, should perhaps say what the function is doing
with it.

Should we rename the param to |setPointerPosition|?

[Navid Zolghadr, 2016/03/23 19:47:48]

I changed the wording of the last sentence. Does it look better? The variable
name used to be setPointerPosition but I changed it to this as from the caller
of this function point of view he doesn't know when the pointer needs to be set
or not. EventHandler just knows whether this is for going across the boundary of
the iframe or not. That is the decision of this class to use this information to
set the pointer event node. Is that okay?

[mustaq, 2016/03/23 20:02:33]

Yes, this is clear now.

+    // by isFrameBoundaryTransition.
+    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 and mouse
+    // if necessary.

[mustaq, 2016/03/23 18:49:07]

Comment on the |setPointerPosition| param.

[Navid Zolghadr, 2016/03/23 19:47:48]

Done.

+    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