Move GestureEvent to NewEventDispatcher

sky/engine/core/page/EventHandler.cpp

Index: sky/engine/core/page/EventHandler.cpp
diff --git a/sky/engine/core/page/EventHandler.cpp b/sky/engine/core/page/EventHandler.cpp
index 9d5fe271b9132653fe997073ea6ee090d086be6f..19bba272214f31d918c910ad4ec80595a3076029 100644
--- a/sky/engine/core/page/EventHandler.cpp
+++ b/sky/engine/core/page/EventHandler.cpp
@@ -60,7 +60,6 @@
 #include "sky/engine/core/rendering/RenderLayer.h"
 #include "sky/engine/core/rendering/RenderView.h"
 #include "sky/engine/core/rendering/style/RenderStyle.h"
-#include "sky/engine/platform/PlatformGestureEvent.h"
 #include "sky/engine/platform/PlatformKeyboardEvent.h"
 #include "sky/engine/platform/TraceEvent.h"
 #include "sky/engine/platform/WindowsKeyboardCodes.h"
@@ -87,10 +86,6 @@ static const int maximumCursorSize = 128;
 // dividing cursor sizes (limited above) by the scale.
 static const double minimumCursorScale = 0.001;
 
-// The minimum amount of time an element stays active after a ShowPress
-// This is roughly 9 frames, which should be long enough to be noticeable.
-static const double minimumActiveInterval = 0.15;
-
 enum NoCursorChangeType { NoCursorChange };
 
 class OptionalCursor {
@@ -137,8 +132,6 @@ EventHandler::EventHandler(LocalFrame* frame)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_mousePositionIsUnknown(true)
-    , m_scrollGestureHandlingNode(nullptr)
-    , m_lastGestureScrollOverWidget(false)
     , m_maxMouseMovedDuration(0)
     , m_didStartDrag(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
@@ -169,10 +162,6 @@ void EventHandler::clear()
     m_mousePressed = false;
     m_capturesDragging = false;
     m_previousWheelScrolledNode = nullptr;
-    m_scrollGestureHandlingNode = nullptr;
-    m_lastGestureScrollOverWidget = false;
-    m_previousGestureScrolledNode = nullptr;
-    m_scrollbarHandlingScrollGesture = nullptr;
     m_maxMouseMovedDuration = 0;
     m_didStartDrag = false;
     m_mouseDownMayStartSelect = false;
@@ -665,359 +654,6 @@ bool EventHandler::isInsideScrollbar(const IntPoint& windowPoint) const
     return false;
 }
 
-bool EventHandler::handleGestureShowPress()
-{
-    m_lastShowPressTimestamp = WTF::currentTime();
-
-    FrameView* view = m_frame->view();
-    if (!view)
-        return false;
-    const FrameView::ScrollableAreaSet* areas = view->scrollableAreas();
-    if (!areas)
-        return false;
-    for (FrameView::ScrollableAreaSet::const_iterator it = areas->begin(); it != areas->end(); ++it) {
-        ScrollableArea* sa = *it;
-        ScrollAnimator* animator = sa->existingScrollAnimator();
-        if (animator)
-            animator->cancelAnimations();
-    }
-    return false;
-}
-
-bool EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
-{
-    TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
-
-    // Scrolling-related gesture events invoke EventHandler recursively for each frame down
-    // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
-    // Perhaps we could simplify things by rewriting scroll handling to work inner frame
-    // out, and then unify with other gesture events.
-    if (gestureEvent.isScrollEvent())
-        return handleGestureScrollEvent(gestureEvent);
-
-    // Non-scrolling related gesture events instead do a single cross-frame hit-test and
-    // jump directly to the inner most frame. This matches handleMousePressEvent etc.
-
-    // Hit test across all frames and do touch adjustment as necessary for the event type.
-    GestureEventWithHitTestResults targetedEvent = targetGestureEvent(gestureEvent);
-
-    // Route to the correct frame.
-    if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
-        return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
-
-    // No hit test result, handle in root instance. Perhaps we should just return false instead?
-    return handleGestureEventInFrame(targetedEvent);
-}
-
-bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
-{
-    ASSERT(!targetedEvent.event().isScrollEvent());
-
-    RefPtr<Node> eventTarget = targetedEvent.hitTestResult().targetNode();
-    RefPtr<Scrollbar> scrollbar = targetedEvent.hitTestResult().scrollbar();
-    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-
-    if (scrollbar) {
-        bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
-        if (gestureEvent.type() == PlatformEvent::GestureTapDown && eventSwallowed)
-            m_scrollbarHandlingScrollGesture = scrollbar;
-        if (eventSwallowed)
-            return true;
-    }
-
-    if (eventTarget && eventTarget->dispatchGestureEvent(gestureEvent))
-        return true;
-
-    switch (gestureEvent.type()) {
-    case PlatformEvent::GestureTwoFingerTap: // FIXME(sky): Remove this.
-    case PlatformEvent::GestureTap:
-        return handleGestureTap(targetedEvent);
-    case PlatformEvent::GestureShowPress:
-        return handleGestureShowPress();
-    case PlatformEvent::GestureLongPress:
-        return handleGestureLongPress(targetedEvent);
-    case PlatformEvent::GestureLongTap:
-        return handleGestureLongTap(targetedEvent);
-    case PlatformEvent::GestureTapDown:
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
-    case PlatformEvent::GestureTapDownCancel:
-    case PlatformEvent::GestureTapUnconfirmed:
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
-
-    return false;
-}
-
-bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
-{
-    RefPtr<Node> eventTarget = nullptr;
-    RefPtr<Scrollbar> scrollbar;
-    if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
-        scrollbar = m_scrollbarHandlingScrollGesture.get();
-        eventTarget = m_scrollGestureHandlingNode.get();
-    }
-
-    if (!eventTarget) {
-        Document* document = m_frame->document();
-        if (!document->renderView())
-            return false;
-
-        LayoutPoint viewPoint = gestureEvent.position();
-        HitTestRequest request(HitTestRequest::ReadOnly);
-        HitTestResult result(viewPoint);
-        document->renderView()->hitTest(request, result);
-
-        eventTarget = result.innerNode();
-
-        m_lastGestureScrollOverWidget = result.isOverWidget();
-        m_scrollGestureHandlingNode = eventTarget;
-        m_previousGestureScrolledNode = nullptr;
-
-        if (!scrollbar)
-            scrollbar = result.scrollbar();
-    }
-
-    if (scrollbar) {
-        bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
-        if (gestureEvent.type() == PlatformEvent::GestureScrollEnd
-            || gestureEvent.type() == PlatformEvent::GestureFlingStart
-            || !eventSwallowed) {
-            m_scrollbarHandlingScrollGesture = nullptr;
-        }
-        if (eventSwallowed)
-            return true;
-    }
-
-    if (eventTarget && eventTarget->dispatchGestureEvent(gestureEvent))
-        return true;
-
-    switch (gestureEvent.type()) {
-    case PlatformEvent::GestureScrollBegin:
-        return handleGestureScrollBegin(gestureEvent);
-    case PlatformEvent::GestureScrollUpdate:
-    case PlatformEvent::GestureScrollUpdateWithoutPropagation:
-        return handleGestureScrollUpdate(gestureEvent);
-    case PlatformEvent::GestureScrollEnd:
-        return handleGestureScrollEnd(gestureEvent);
-    case PlatformEvent::GestureFlingStart:
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
-        return false;
-    default:
-        ASSERT_NOT_REACHED();
-        return false;
-    }
-}
-
-bool EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
-{
-    return false;
-}
-
-bool EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
-{
-    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-
-    // FIXME: Ideally we should try to remove the extra mouse-specific hit-tests here (re-using the
-    // supplied HitTestResult), but that will require some overhaul of the touch drag-and-drop code
-    // and LongPress is such a special scenario that it's unlikely to matter much in practice.
-
-    IntPoint hitTestPoint = gestureEvent.position();
-    HitTestResult result = hitTestResultAtPoint(hitTestPoint);
-    Node* innerNode = result.targetNode();
-    if (!result.isLiveLink() && innerNode && (innerNode->isContentEditable() || innerNode->isTextNode())) {
-        selectClosestWordFromHitTestResult(result, DontAppendTrailingWhitespace);
-        if (m_frame->selection().isRange()) {
-            focusDocumentView();
-            return true;
-        }
-    }
-
-    return true;
-}
-
-bool EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)
-{
-    return false;
-}
-
-bool EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, RenderObject* renderer)
-{
-    ASSERT(gestureEvent.isScrollEvent());
-
-    // FIXME(sky): Remove this.
-    return false;
-}
-
-bool EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent) {
-    RefPtr<Node> node = m_scrollGestureHandlingNode;
-    clearGestureScrollNodes();
-
-    if (node)
-        passScrollGestureEventToWidget(gestureEvent, node->renderer());
-
-    return false;
-}
-
-bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
-{
-    Document* document = m_frame->document();
-    if (!document->renderView())
-        return false;
-
-    FrameView* view = m_frame->view();
-    if (!view)
-        return false;
-
-    // If there's no renderer on the node, send the event to the nearest ancestor with a renderer.
-    // Needed for <option> and <optgroup> elements so we can touch scroll <select>s
-    while (m_scrollGestureHandlingNode && !m_scrollGestureHandlingNode->renderer())
-        m_scrollGestureHandlingNode = m_scrollGestureHandlingNode->parentOrShadowHostNode();
-
-    if (!m_scrollGestureHandlingNode)
-        return false;
-
-    passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->renderer());
-
-    return true;
-}
-
-bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
-{
-    FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
-    if (delta.isZero())
-        return false;
-
-    Node* node = m_scrollGestureHandlingNode.get();
-    if (!node)
-        return sendScrollEventToView(gestureEvent, delta);
-
-    // Ignore this event if the targeted node does not have a valid renderer.
-    RenderObject* renderer = node->renderer();
-    if (!renderer)
-        return false;
-
-    RefPtr<FrameView> protector(m_frame->view());
-
-    Node* stopNode = 0;
-    bool scrollShouldNotPropagate = gestureEvent.type() == PlatformEvent::GestureScrollUpdateWithoutPropagation;
-
-    // Try to send the event to the correct view.
-    if (passScrollGestureEventToWidget(gestureEvent, renderer)) {
-        if(scrollShouldNotPropagate)
-              m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
-
-        return true;
-    }
-
-    if (scrollShouldNotPropagate)
-        stopNode = m_previousGestureScrolledNode.get();
-
-    // First try to scroll the closest scrollable RenderBox ancestor of |node|.
-    ScrollGranularity granularity = ScrollByPixel;
-    bool horizontalScroll = scroll(ScrollLeft, granularity, node, &stopNode, delta.width());
-    bool verticalScroll = scroll(ScrollUp, granularity, node, &stopNode, delta.height());
-
-    if (scrollShouldNotPropagate)
-        m_previousGestureScrolledNode = stopNode;
-
-    if (horizontalScroll || verticalScroll) {
-        return true;
-    }
-
-    // Otherwise try to scroll the view.
-    return sendScrollEventToView(gestureEvent, delta);
-}
-
-bool EventHandler::sendScrollEventToView(const PlatformGestureEvent& gestureEvent, const FloatSize& scaledDelta)
-{
-    return false;
-}
-
-void EventHandler::clearGestureScrollNodes()
-{
-    m_scrollGestureHandlingNode = nullptr;
-    m_previousGestureScrolledNode = nullptr;
-}
-
-bool EventHandler::isScrollbarHandlingGestures() const
-{
-    return m_scrollbarHandlingScrollGesture.get();
-}
-
-GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
-{
-    // Scrolling events get hit tested per frame (like wheel events do).
-    ASSERT(!gestureEvent.isScrollEvent());
-
-    HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
-    double activeInterval = 0;
-    bool shouldKeepActiveForMinInterval = false;
-    if (readOnly) {
-        hitType |= HitTestRequest::ReadOnly;
-    } else if (gestureEvent.type() == PlatformEvent::GestureTap) {
-        // If the Tap is received very shortly after ShowPress, we want to
-        // delay clearing of the active state so that it's visible to the user
-        // for at least a couple of frames.
-        activeInterval = WTF::currentTime() - m_lastShowPressTimestamp;
-        shouldKeepActiveForMinInterval = m_lastShowPressTimestamp && activeInterval < minimumActiveInterval;
-        if (shouldKeepActiveForMinInterval)
-            hitType |= HitTestRequest::ReadOnly;
-    }
-
-    // Perform the rect-based hit-test. Note that we don't yet apply hover/active state here
-    // because we need to resolve touch adjustment first so that we apply hover/active it to
-    // the final adjusted node.
-    IntPoint hitTestPoint = gestureEvent.position();
-    IntSize touchRadius = gestureEvent.area();
-    touchRadius.scale(1.f / 2);
-    // FIXME: We should not do a rect-based hit-test if touch adjustment is disabled.
-    HitTestResult hitTestResult = hitTestResultAtPoint(hitTestPoint, hitType | HitTestRequest::ReadOnly, touchRadius);
-
-    // Now apply hover/active state to the final target.
-    // FIXME: This is supposed to send mouseenter/mouseleave events, but doesn't because we
-    // aren't passing a PlatformMouseEvent.
-    HitTestRequest request(hitType);
-
-    if (shouldKeepActiveForMinInterval) {
-        m_lastDeferredTapElement = hitTestResult.innerElement();
-        m_activeIntervalTimer.startOneShot(minimumActiveInterval - activeInterval, FROM_HERE);
-    }
-
-    return GestureEventWithHitTestResults(gestureEvent, hitTestResult);
-}
-
-HitTestRequest::HitTestRequestType EventHandler::getHitTypeForGestureType(PlatformEvent::Type type)
-{
-    HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly;
-    switch (type) {
-    case PlatformEvent::GestureShowPress:
-    case PlatformEvent::GestureTapUnconfirmed:
-        return hitType | HitTestRequest::Active;
-    case PlatformEvent::GestureTapDownCancel:
-        // A TapDownCancel received when no element is active shouldn't really be changing hover state.
-        if (!m_frame->document()->activeHoverElement())
-            hitType |= HitTestRequest::ReadOnly;
-        return hitType | HitTestRequest::Release;
-    case PlatformEvent::GestureTap:
-        return hitType | HitTestRequest::Release;
-    case PlatformEvent::GestureTapDown:
-    case PlatformEvent::GestureLongPress:
-    case PlatformEvent::GestureLongTap:
-    case PlatformEvent::GestureTwoFingerTap:
-        // FIXME: Shouldn't LongTap and TwoFingerTap clear the Active state?
-        return hitType | HitTestRequest::Active | HitTestRequest::ReadOnly;
-    default:
-        ASSERT_NOT_REACHED();
-        return hitType | HitTestRequest::Active | HitTestRequest::ReadOnly;
-    }
-}
-
 void EventHandler::scheduleHoverStateUpdate()
 {
     if (!m_hoverTimer.isActive())