Create GestureManager class and move related logic

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

 /*
  * Copyright (C) 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef EventHandler_h
 #define EventHandler_h
 
 #include "core/CoreExport.h"
 #include "core/events/TextEventInputType.h"
+#include "core/input/GestureManager.h"
 #include "core/input/KeyboardEventManager.h"
 #include "core/input/PointerEventManager.h"
 #include "core/input/ScrollManager.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/page/DragActions.h"
 #include "core/page/EventWithHitTestResults.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/Cursor.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformTouchPoint.h"
@@ skipping 185 matching lines @@
     // most recently clicked node, falling back to the frame.
     // Returns true if the scroll was consumed.
     // direction - The logical direction to scroll in. This will be converted to
     //             a physical direction for each LayoutBox we try to scroll
     //             based on that box's writing mode.
     // granularity - The units that the  scroll delta parameter is in.
     // startNode - Optional. If provided, start chaining from the given node.
     //             If not, use the current focus or last clicked node.
     bool logicalScroll(ScrollDirection, ScrollGranularity, Node* startNode = nullptr);
 
+    // Only called by GestureManager until further refactoring.

[mustaq, 2016/07/11 18:01:35]

I think you meant to comment on the whole block of methods below, not just the
next one. In any case, please make the scope of this comment clear.

[Navid Zolghadr, 2016/07/11 18:24:32]

I thought having all the following lines together with no break would mean that.
But I guess maybe not :). Is there a standard way of doing so?

+    WebInputEventResult dispatchMouseEvent(const AtomicString& eventType, Node* target, int clickCount, const PlatformMouseEvent&);
+    WebInputEventResult handleMousePressEvent(const MouseEventWithHitTestResults&);

[dtapuska, 2016/07/11 17:53:15]

This is kind of a weird design where the event handler handles the messages and
passes them to the GestureManager and then it calls back with some private kind
of APIs that are now exposed.

Can we not move these into the PointerEventManager perhaps? They they don't need
to be part of the exposed EventHandler API or worst case is to make
GestureManager a friend class.

[Navid Zolghadr, 2016/07/11 18:24:32]

They should be inside MouseEventManager. That change was something I was going
to do after this change. Which one do you think is a better as the first step?
Making it friend for now or making these function public?

+    WebInputEventResult handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
+    WebInputEventResult handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
+    void setClickNode(Node*);
+    static ContainerNode* parentForClickEvent(const Node&);
+    bool handleDragDropIfPossible(const GestureEventWithHitTestResults&);
+    // Resets the state that indicates the next events could cause a drag. It is called when
+    // we realize the next events should not cause drag based on the drag heuristics.
+    void clearDragHeuristicState();
+
+
 private:
     static DragState& dragState();
 
     DataTransfer* createDraggingDataTransfer() const;
 
     WebInputEventResult handleMouseMoveOrLeaveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false, bool forceLeave = false);
-    WebInputEventResult handleMousePressEvent(const MouseEventWithHitTestResults&);
-    WebInputEventResult handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
     WebInputEventResult handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
-    WebInputEventResult handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 
-    HitTestRequest::HitTestRequestType getHitTypeForGestureType(PlatformEvent::EventType);
     void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
-    WebInputEventResult handleGestureTapDown(const GestureEventWithHitTestResults&);
-    WebInputEventResult handleGestureTap(const GestureEventWithHitTestResults&);
-    WebInputEventResult handleGestureLongPress(const GestureEventWithHitTestResults&);
-    WebInputEventResult handleGestureLongTap(const GestureEventWithHitTestResults&);
 
     void updateGestureTargetNodeForMouseEvent(const GestureEventWithHitTestResults&);
 
     bool shouldApplyTouchAdjustment(const PlatformGestureEvent&) const;
 
     OptionalCursor selectCursor(const HitTestResult&);
     OptionalCursor selectAutoCursor(const HitTestResult&, Node*, const Cursor& iBeam);
 
     void hoverTimerFired(Timer<EventHandler>*);
     void cursorUpdateTimerFired(Timer<EventHandler>*);
     void activeIntervalTimerFired(Timer<EventHandler>*);
 
     void fakeMouseMoveEventTimerFired(Timer<EventHandler>*);
     void cancelFakeMouseMoveEvent();
     bool isCursorVisible() const;
     void updateCursor();
 
     ScrollableArea* associatedScrollableArea(const PaintLayer*) const;
 
     void invalidateClick();
 
     Node* updateMouseEventTargetNode(Node*, const PlatformMouseEvent&);
     void updateMouseEventTargetNodeAndSendEvents(Node*, const PlatformMouseEvent&, bool isFrameBoundaryTransition = false);
 
 
     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
 
-    WebInputEventResult dispatchMouseEvent(const AtomicString& eventType, Node* target, int clickCount, const PlatformMouseEvent&);
-
     // Dispatches ME after corresponding PE provided the PE has not been canceled. The eventType arg
     // must be a mouse event that can be gated though a preventDefaulted pointerdown (i.e., one of
     // {mousedown, mousemove, mouseup}).
     // TODO(mustaq): Can we avoid the clickCount param, instead use PlatformMouseEvent's count?
     //     Same applied to dispatchMouseEvent() above.
     WebInputEventResult updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* target,
         int clickCount, const PlatformMouseEvent&);
 
     WebInputEventResult dispatchDragEvent(const AtomicString& eventType, Node* target, const PlatformMouseEvent&, DataTransfer*);
 
     void clearDragDataTransfer();
 
     bool handleDrag(const MouseEventWithHitTestResults&, DragInitiator);
     bool tryStartDrag(const MouseEventWithHitTestResults&);
 
     // Clears drag target and related states. It is called when drag is done or canceled.
     void clearDragState();
 
-    // Resets the state that indicates the next events could cause a drag. It is called when
-    // we realize the next events should not cause drag based on the drag heuristics.
-    void clearDragHeuristicState();
-
     WebInputEventResult dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
 
     bool dragHysteresisExceeded(const IntPoint&) const;
 
     WebInputEventResult passMousePressEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe);
     WebInputEventResult passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe, HitTestResult* hoveredNode = nullptr);
     WebInputEventResult passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, LocalFrame* subframe);
 
     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&);
 
     void defaultSpaceEventHandler(KeyboardEvent*);
     void defaultBackspaceEventHandler(KeyboardEvent*);
     void defaultTabEventHandler(KeyboardEvent*);
     void defaultEscapeEventHandler(KeyboardEvent*);
     void defaultArrowEventHandler(WebFocusType, KeyboardEvent*);
 
     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
 
     bool capturesDragging() const { return m_capturesDragging; }
 
-    WebInputEventResult handleGestureShowPress();
-
     void setLastKnownMousePosition(const PlatformMouseEvent&);
 
     bool shouldTopControlsConsumeScroll(FloatSize) const;
 
     // If the given element is a shadow host and its root has delegatesFocus=false flag,
     // slide focus to its inner element. Returns true if the resulting focus is different from
     // the given element.
     bool slideFocusOnShadowHostIfNecessary(const Element&);
 
     FrameHost* frameHost() const;
@@ skipping 49 matching lines @@
     IntPoint m_lastKnownMousePosition;
     IntPoint m_lastKnownMouseGlobalPosition;
     IntPoint m_mouseDownPos; // In our view's coords.
     double m_mouseDownTimestamp;
     PlatformMouseEvent m_mouseDown;
     RefPtr<UserGestureToken> m_lastMouseDownUserGestureToken;
 
     PointerEventManager m_pointerEventManager;
     ScrollManager m_scrollManager;
     KeyboardEventManager m_keyboardEventManager;
+    GestureManager m_gestureManager;
 
     double m_maxMouseMovedDuration;
 
-    bool m_longTapShouldInvokeContextMenu;
-
     Timer<EventHandler> m_activeIntervalTimer;
-    double m_lastShowPressTimestamp;
     Member<Element> m_lastDeferredTapElement;
 
-    // Set on GestureTapDown if the |pointerdown| event corresponding to the
-    // triggering |touchstart| event was canceled. This suppresses mouse event
-    // firing for the current gesture sequence (i.e. until next GestureTapDown).
-    bool m_suppressMouseEventsFromGestures;
 };
 
 } // namespace blink
 
 #endif // EventHandler_h