Move GestureEvent to NewEventDispatcher

sky/engine/core/page/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * 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.
@@ skipping 42 matching lines @@
 #include "sky/engine/core/page/ChromeClient.h"
 #include "sky/engine/core/page/EditorClient.h"
 #include "sky/engine/core/page/EventWithHitTestResults.h"
 #include "sky/engine/core/page/FocusController.h"
 #include "sky/engine/core/page/Page.h"
 #include "sky/engine/core/rendering/HitTestRequest.h"
 #include "sky/engine/core/rendering/HitTestResult.h"
 #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"
 #include "sky/engine/platform/geometry/FloatPoint.h"
 #include "sky/engine/platform/graphics/Image.h"
 #include "sky/engine/platform/heap/Handle.h"
 #include "sky/engine/platform/scroll/ScrollAnimator.h"
 #include "sky/engine/platform/scroll/Scrollbar.h"
 #include "sky/engine/wtf/Assertions.h"
 #include "sky/engine/wtf/CurrentTime.h"
 #include "sky/engine/wtf/StdLibExtras.h"
 #include "sky/engine/wtf/TemporaryChange.h"
 
 namespace blink {
 
 // The amount of time to wait for a cursor update on style and layout changes
 // Set to 50Hz, no need to be faster than common screen refresh rate
 static const double cursorUpdateInterval = 0.02;
 
 static const int maximumCursorSize = 128;
 
 // It's pretty unlikely that a scale of less than one would ever be used. But all we really
 // need to ensure here is that the scale isn't so small that integer overflow can occur when
 // 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 {
 public:
     OptionalCursor(NoCursorChangeType) : m_isCursorChange(false) { }
     OptionalCursor(const Cursor& cursor) : m_isCursorChange(true), m_cursor(cursor) { }
 
     bool isCursorChange() const { return m_isCursorChange; }
     const Cursor& cursor() const { ASSERT(m_isCursorChange); return m_cursor; }
 
@@ skipping 26 matching lines @@
     , m_capturesDragging(false)
     , m_mouseDownMayStartSelect(false)
     , m_mouseDownMayStartDrag(false)
     , m_selectionInitiationState(HaveNotStartedSelection)
     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
     , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
     , m_mouseDownMayStartAutoscroll(false)
     , 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)
     , m_lastShowPressTimestamp(0)
 {
 }
 
 EventHandler::~EventHandler()
 {
 }
@@ skipping 10 matching lines @@
     m_clickNode = nullptr;
     m_dragTarget = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
     m_mousePositionIsUnknown = true;
     m_lastKnownMousePosition = IntPoint();
     m_lastKnownMouseGlobalPosition = IntPoint();
     m_mousePressNode = nullptr;
     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;
     m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
 }
 
 void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)
 {
@@ skipping 472 matching lines @@
     if (RenderView* renderView = m_frame->contentRenderer()) {
         HitTestRequest request(HitTestRequest::ReadOnly);
         HitTestResult result(windowPoint);
         renderView->hitTest(request, result);
         return result.scrollbar();
     }
 
     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())
         m_hoverTimer.startOneShot(0, FROM_HERE);
 }
 
 void EventHandler::scheduleCursorUpdate()
 {
     if (!m_cursorUpdateTimer.isActive())
         m_cursorUpdateTimer.startOneShot(cursorUpdateInterval, FROM_HERE);
@@ skipping 236 matching lines @@
 
 void EventHandler::focusDocumentView()
 {
     Page* page = m_frame->page();
     if (!page)
         return;
     page->focusController().focusDocumentView(m_frame);
 }
 
 } // namespace blink