Create MouseEventManager and EventHandlingUtil

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"
+#include "core/input/BoundaryEventDispatcher.h"
 #include "core/input/TouchEventManager.h"
 #include "public/platform/WebInputEventResult.h"
 #include "public/platform/WebPointerProperties.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashMap.h"
 
 namespace blink {
 
 class LocalFrame;
+class MouseEventManager;
 
 // This class takes care of dispatching all pointer events and keeps track of
 // properties of active pointer events.
 class CORE_EXPORT PointerEventManager {
     WTF_MAKE_NONCOPYABLE(PointerEventManager);
     DISALLOW_NEW();
 public:
-    explicit PointerEventManager(LocalFrame*);
+    explicit PointerEventManager(LocalFrame*, MouseEventManager*);
     ~PointerEventManager();
     DECLARE_TRACE();
 
     // Sends the mouse pointer events and the boundary events
     // that it may cause. It also sends the compat mouse events
     // and sets the newNodeUnderMouse if the capturing is set
     // in this function.
     WebInputEventResult sendMousePointerEvent(
         Node* target, const AtomicString& type,
         int clickCount, const PlatformMouseEvent&,
@@ skipping 61 matching lines @@
         bool hasRecievedOverEvent;
         EventTargetAttributes()
         : target(nullptr)
         , hasRecievedOverEvent(false) {}
         EventTargetAttributes(EventTarget* target,
             bool hasRecievedOverEvent)
         : target(target)
         , hasRecievedOverEvent(hasRecievedOverEvent) {}
     };
 
+    class PointerEventBoundaryEventDispatcher : public BoundaryEventDispatcher {
+        WTF_MAKE_NONCOPYABLE(PointerEventBoundaryEventDispatcher);
+        DISALLOW_NEW();
+
+    public:
+        DEFINE_INLINE_TRACE()
+        {
+            visitor->trace(m_pointerEvent);
+            BoundaryEventDispatcher::trace(visitor);
+        }
+        PointerEventBoundaryEventDispatcher(PointerEventManager*, PointerEvent*);
+
+    protected:
+        virtual void dispatchOut(EventTarget*, EventTarget* relatedTarget);
+        virtual void dispatchOver(EventTarget*, EventTarget* relatedTarget);
+        virtual void dispatchLeave(EventTarget*, EventTarget* relatedTarget, bool checkForListener);

[bokan, 2016/09/01 13:50:13]

Use `override` instead if `virtual`

[Navid Zolghadr, 2016/09/01 17:07:27]

Done.

+        virtual void dispatchEnter(EventTarget*, EventTarget* relatedTarget, bool checkForListener);
+        virtual AtomicString getLeaveEvent();
+        virtual AtomicString getEnterEvent();
+
+    private:
+        void dispatch(EventTarget*, EventTarget* relatedTarget, const AtomicString&, bool checkForListener);
+        PointerEventManager* m_pointerEventManager;
+        Member<PointerEvent> m_pointerEvent;
+    };
+
     // Inhibits firing of touch-type PointerEvents until unblocked by unblockTouchPointers(). Also
     // sends pointercancels for existing touch-type PointerEvents.
     // See: www.w3.org/TR/pointerevents/#declaring-candidate-regions-for-default-touch-behaviors
     void blockTouchPointers();
 
     // Enables firing of touch-type PointerEvents after they were inhibited by blockTouchPointers().
     void unblockTouchPointers();
 
     // Sends touch pointer events and sets consumed bits in TouchInfo array
     // based on the return value of pointer event handlers.
     void dispatchTouchPointerEvents(
         const PlatformTouchEvent&,
         HeapVector<TouchEventManager::TouchInfo>&);
 
     // Returns whether the event is consumed or not.
     WebInputEventResult sendTouchPointerEvent(EventTarget*, PointerEvent*);
 
     void sendBoundaryEvents(
         EventTarget* exitedTarget,
         EventTarget* enteredTarget,
-        PointerEvent*,
-        const PlatformMouseEvent& = PlatformMouseEvent(),
-        bool sendMouseEvent = false);
+        PointerEvent*);
     void setNodeUnderPointer(PointerEvent*,
         EventTarget*);
 
     // Processes the assignment of |m_pointerCaptureTarget| from |m_pendingPointerCaptureTarget|
     // and sends the got/lostpointercapture events, as per the spec:
     // https://w3c.github.io/pointerevents/#process-pending-pointer-capture
     void processPendingPointerCapture(PointerEvent*);
 
     // Processes the capture state of a pointer, updates node under
     // pointer, and sends corresponding boundary events for pointer if
@@ skipping 46 matching lines @@
     // the pointer with id=1 is only taking care of true mouse related events.
     using NodeUnderPointerMap = HeapHashMap<int, EventTargetAttributes,
         WTF::IntHash<int>, WTF::UnsignedWithZeroKeyHashTraits<int>>;
     NodeUnderPointerMap m_nodeUnderPointer;
 
     PointerCapturingMap m_pointerCaptureTarget;
     PointerCapturingMap m_pendingPointerCaptureTarget;
 
     PointerEventFactory m_pointerEventFactory;
     TouchEventManager m_touchEventManager;
+    MouseEventManager* m_mouseEventManager;
 };
 
 } // namespace blink
 
 #endif // PointerEventManager_h