Gesture event hit test refactoring and reduction

Source/core/page/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 31 matching lines @@
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashTraits.h"
 #include "wtf/RefPtr.h"
 
 namespace WebCore {
 
 class AutoscrollController;
 class DataTransfer;
 class Document;
+class DragState;
 class Element;
 class Event;
 class EventTarget;
+template <typename EventType>
+class EventWithHitTestResults;
 class FloatPoint;
 class FloatQuad;
 class FullscreenElementStack;
-class LocalFrame;
 class HTMLFrameSetElement;
 class HitTestRequest;
 class HitTestResult;
 class KeyboardEvent;
-class MouseEventWithHitTestResults;
+class LocalFrame;
 class Node;
 class OptionalCursor;
 class PlatformGestureEvent;
 class PlatformKeyboardEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class RenderLayer;
 class RenderLayerScrollableArea;
 class RenderObject;
 class RenderWidget;
 class ScrollableArea;
 class Scrollbar;
 class TextEvent;
 class TouchEvent;
 class VisibleSelection;
 class WheelEvent;
 class Widget;
 
-class DragState;
+typedef EventWithHitTestResults<PlatformGestureEvent> GestureEventWithHitTestResults;
+typedef EventWithHitTestResults<PlatformMouseEvent> MouseEventWithHitTestResults;
 
 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
 
 class EventHandler : public NoBaseWillBeGarbageCollectedFinalized<EventHandler> {
     WTF_MAKE_NONCOPYABLE(EventHandler);
 public:
     explicit EventHandler(LocalFrame*);
     ~EventHandler();
     void trace(Visitor*);
@@ skipping 43 matching lines @@
     bool bubblingScroll(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
 
     bool handleMouseMoveEvent(const PlatformMouseEvent&);
     void handleMouseLeaveEvent(const PlatformMouseEvent&);
 
     bool handleMousePressEvent(const PlatformMouseEvent&);
     bool handleMouseReleaseEvent(const PlatformMouseEvent&);
     bool handleWheelEvent(const PlatformWheelEvent&);
     void defaultWheelEventHandler(Node*, WheelEvent*);
 
+    // Called on the local root frame exactly once per gesture event.
     bool handleGestureEvent(const PlatformGestureEvent&);
+
+    // Hit-test the provided (non-scroll) gesture event, applying touch-adjustment and updating
+    // hover/active state across all frames if necessary. This should be called at most once
+    // per gesture event, and called on the local root frame.
+    // Note: This is similar to (the less clearly named) prepareMouseEvent.
+    // FIXME: Remove readOnly param when there is only ever a single call to this.
+    GestureEventWithHitTestResults targetGestureEvent(const PlatformGestureEvent&, bool readOnly = false);
+
+    // Handle the provided non-scroll gesture event. Should be called only on the inner frame.
+    bool handleGestureEventInFrame(const GestureEventWithHitTestResults&);
+
+    // Handle the provided scroll gesture event, propagating down to child frames as necessary.
+    bool handleGestureScrollEvent(const PlatformGestureEvent&);
     bool handleGestureScrollEnd(const PlatformGestureEvent&);
     bool isScrollbarHandlingGestures() const;
 
-    bool bestClickableNodeForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntPoint& targetPoint, Node*& targetNode);
-    bool bestContextMenuNodeForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntPoint& targetPoint, Node*& targetNode);
+    bool bestClickableNodeForHitTestResult(const HitTestResult&, IntPoint& targetPoint, Node*& targetNode);
+    bool bestContextMenuNodeForHitTestResult(const HitTestResult&, IntPoint& targetPoint, Node*& targetNode);
+    // FIXME: This doesn't appear to be used outside tests anymore, what path are we using now and is it tested?
     bool bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode);
 
-    void adjustGesturePosition(const PlatformGestureEvent&, IntPoint& adjustedPoint);
-
     bool sendContextMenuEvent(const PlatformMouseEvent&);
     bool sendContextMenuEventForKey();
-    bool sendContextMenuEventForGesture(const PlatformGestureEvent&);
+    bool sendContextMenuEventForGesture(const GestureEventWithHitTestResults&);
 
     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
 
     static unsigned accessKeyModifiers();
     bool handleAccessKey(const PlatformKeyboardEvent&);
     bool keyEvent(const PlatformKeyboardEvent&);
     void defaultKeyboardEventHandler(KeyboardEvent*);
 
     bool handleTextInputEvent(const String& text, Event* underlyingEvent = 0, TextEventInputType = TextEventInputKeyboard);
     void defaultTextInputEventHandler(TextEvent*);
@@ skipping 28 matching lines @@
     bool handleMousePressEvent(const MouseEventWithHitTestResults&);
     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
     bool handleMouseFocus(const PlatformMouseEvent&);
     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
     bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 
     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
 
-    bool handleGestureTap(const PlatformGestureEvent&, const IntPoint& adjustedPoint);
-    bool handleGestureLongPress(const PlatformGestureEvent&, const IntPoint& adjustedPoint);
-    bool handleGestureLongTap(const PlatformGestureEvent&, const IntPoint& adjustedPoint);
-    bool handleGestureTwoFingerTap(const PlatformGestureEvent&, const IntPoint& adjustedPoint);
+    HitTestRequest::HitTestRequestType getHitTypeForGestureType(PlatformEvent::Type);
+    void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
+    bool handleGestureTap(const GestureEventWithHitTestResults&);
+    bool handleGestureLongPress(const GestureEventWithHitTestResults&);
+    bool handleGestureLongTap(const GestureEventWithHitTestResults&);
     bool handleGestureScrollUpdate(const PlatformGestureEvent&);
     bool handleGestureScrollBegin(const PlatformGestureEvent&);
     void clearGestureScrollNodes();
 
     bool shouldApplyTouchAdjustment(const PlatformGestureEvent&) const;
 
     OptionalCursor selectCursor(const HitTestResult&);
     OptionalCursor selectAutoCursor(const HitTestResult&, Node*, const Cursor& iBeam);
 
     void hoverTimerFired(Timer<EventHandler>*);
@@ skipping 71 matching lines @@
     void setFrameWasScrolledByUser();
 
     bool capturesDragging() const { return m_capturesDragging; }
 
     bool isKeyEventAllowedInFullScreen(FullscreenElementStack*, const PlatformKeyboardEvent&) const;
 
     bool handleGestureShowPress();
 
     bool handleScrollGestureOnResizer(Node*, const PlatformGestureEvent&);
 
-    bool passGestureEventToWidget(const PlatformGestureEvent&, Widget*);
-    bool passGestureEventToWidgetIfPossible(const PlatformGestureEvent&, RenderObject*);
+    bool passScrollGestureEventToWidget(const PlatformGestureEvent&, RenderObject*);
     bool sendScrollEventToView(const PlatformGestureEvent&, const FloatSize&);
-    LocalFrame* getSubFrameForGestureEvent(const IntPoint& touchAdjustedPoint, const PlatformGestureEvent&);
 
     AutoscrollController* autoscrollController() const;
     bool panScrollInProgress() const;
     void setLastKnownMousePosition(const PlatformMouseEvent&);
 
     LocalFrame* const m_frame;
 
     bool m_mousePressed;
     bool m_capturesDragging;
     RefPtrWillBeMember<Node> m_mousePressNode;
@@ skipping 54 matching lines @@
     typedef WillBeHeapHashMap<unsigned, RefPtrWillBeMember<EventTarget>, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned> > TouchTargetMap;
     TouchTargetMap m_targetForTouchID;
 
     // If set, the document of the active touch sequence. Unset if no touch sequence active.
     RefPtrWillBeMember<Document> m_touchSequenceDocument;
     RefPtr<UserGestureToken> m_touchSequenceUserGestureToken;
 
     bool m_touchPressed;
 
     RefPtrWillBeMember<Node> m_scrollGestureHandlingNode;
-    bool m_lastHitTestResultOverWidget;
+    bool m_lastGestureScrollOverWidget;
     RefPtrWillBeMember<Node> m_previousGestureScrolledNode;
     RefPtr<Scrollbar> m_scrollbarHandlingScrollGesture;
 
     double m_maxMouseMovedDuration;
-    PlatformEvent::Type m_baseEventType;
     bool m_didStartDrag;
 
     bool m_longTapShouldInvokeContextMenu;
 
     Timer<EventHandler> m_activeIntervalTimer;
     double m_lastShowPressTimestamp;
     RefPtrWillBeMember<Element> m_lastDeferredTapElement;
 };
 
 } // namespace WebCore
 
 #endif // EventHandler_h