Create GestureManager class and move related logic

third_party/WebKit/Source/core/input/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 176 matching lines @@
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_pointerEventManager(frame)
     , m_scrollManager(frame)
     , m_keyboardEventManager(frame, &m_scrollManager)
-    , m_longTapShouldInvokeContextMenu(false)
+    , m_gestureManager(frame, &m_scrollManager, &m_pointerEventManager, m_selectionController)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
-    , m_lastShowPressTimestamp(0)
-    , m_suppressMouseEventsFromGestures(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
     visitor->trace(m_frame);
     visitor->trace(m_mousePressNode);
     visitor->trace(m_capturingMouseEventsNode);
     visitor->trace(m_nodeUnderMouse);
     visitor->trace(m_lastMouseMoveEventSubframe);
     visitor->trace(m_lastScrollbarUnderMouse);
     visitor->trace(m_clickNode);
     visitor->trace(m_dragTarget);
     visitor->trace(m_frameSetBeingResized);
     visitor->trace(m_lastDeferredTapElement);
     visitor->trace(m_selectionController);
     visitor->trace(m_pointerEventManager);
     visitor->trace(m_scrollManager);
     visitor->trace(m_keyboardEventManager);
+    visitor->trace(m_gestureManager);
 }
 
 DragState& EventHandler::dragState()
 {
     DEFINE_STATIC_LOCAL(DragState, state, (new DragState));
     return state;
 }
 
 void EventHandler::clear()
 {
@@ skipping 12 matching lines @@
     m_mousePositionIsUnknown = true;
     m_lastKnownMousePosition = IntPoint();
     m_lastKnownMouseGlobalPosition = IntPoint();
     m_lastMouseDownUserGestureToken.clear();
     m_mousePressNode = nullptr;
     m_mousePressed = false;
     m_capturesDragging = false;
     m_capturingMouseEventsNode = nullptr;
     m_pointerEventManager.clear();
     m_scrollManager.clear();
+    m_gestureManager.clear();
     m_mouseDownMayStartDrag = false;
-    m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
     m_mouseDownMayStartAutoscroll = false;
     m_svgPan = false;
     m_mouseDownPos = IntPoint();
     m_mouseDownTimestamp = 0;
-    m_longTapShouldInvokeContextMenu = false;
     m_dragStartPos = LayoutPoint();
     m_mouseDown = PlatformMouseEvent();
-    m_suppressMouseEventsFromGestures = false;
 }
 
 WebInputEventResult EventHandler::mergeEventResult(
     WebInputEventResult resultA, WebInputEventResult resultB)
 {
     // The ordering of the enumeration is specific. There are times that
     // multiple events fire and we need to combine them into a single
     // result code. The enumeration is based on the level of consumption that
     // is most significant. The enumeration is ordered with smaller specified
     // numbers first. Examples of merged results are:
@@ skipping 800 matching lines @@
 
     return handleMouseDraggedEvent(mev);
 }
 
 void EventHandler::invalidateClick()
 {
     m_clickCount = 0;
     m_clickNode = nullptr;
 }
 
-static ContainerNode* parentForClickEvent(const Node& node)
+ContainerNode* EventHandler::parentForClickEvent(const Node& node)
 {
     // IE doesn't dispatch click events for mousedown/mouseup events across form
     // controls.
     if (node.isHTMLElement() && toHTMLElement(node).isInteractiveContent())
         return nullptr;
 
     return FlatTreeTraversal::parent(node);
 }
 
 WebInputEventResult EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
@@ skipping 403 matching lines @@
         || mouseEventType == EventTypeNames::mousemove
         || mouseEventType == EventTypeNames::mouseup);
 
     Node* lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
 
     return m_pointerEventManager.sendMousePointerEvent(
         m_nodeUnderMouse, mouseEventType, clickCount, mouseEvent, nullptr,
         lastNodeUnderMouse);
 }
 
+void EventHandler::setClickNode(Node* node)
+{
+    m_clickNode = node;
+}
+
 WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
     if (targetedEvent.hitTestResult().scrollbar() && !m_frame->contentLayoutItem().isNull()) {
         if (targetedEvent.hitTestResult().scrollbar()->getScrollableArea() == m_frame->contentLayoutItem().getScrollableArea())
             return WebInputEventResult::NotHandled;
     }
 
     // The layout needs to be up to date to determine if an element is focusable.
     m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
@@ skipping 117 matching lines @@
     if (node) {
         WheelEvent* domEvent = WheelEvent::create(event, node->document().domWindow());
         DispatchEventResult domEventResult = node->dispatchEvent(domEvent);
         if (domEventResult != DispatchEventResult::NotCanceled)
             return toWebInputEventResult(domEventResult);
     }
 
     return WebInputEventResult::NotHandled;
 }
 
-WebInputEventResult EventHandler::handleGestureShowPress()
-{
-    m_lastShowPressTimestamp = WTF::monotonicallyIncreasingTime();
-
-    FrameView* view = m_frame->view();
-    if (!view)
-        return WebInputEventResult::NotHandled;
-    if (ScrollAnimatorBase* scrollAnimator = view->existingScrollAnimator())
-        scrollAnimator->cancelAnimation();
-    const FrameView::ScrollableAreaSet* areas = view->scrollableAreas();
-    if (!areas)
-        return WebInputEventResult::NotHandled;
-    for (const ScrollableArea* scrollableArea : *areas) {
-        ScrollAnimatorBase* animator = scrollableArea->existingScrollAnimator();
-        if (animator)
-            animator->cancelAnimation();
-    }
-    return WebInputEventResult::NotHandled;
-}
-
 WebInputEventResult EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 {
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_frame->localFrameRoot());
 
     // Scrolling-related gesture events invoke EventHandler recursively for each frame down
     // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
     // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
     if (gestureEvent.isScrollEvent())
         return handleGestureScrollEvent(gestureEvent);
@@ skipping 17 matching lines @@
 
     // update mouseout/leave/over/enter events before jumping directly to the inner most frame
     if (targetedEvent.event().type() == PlatformEvent::GestureTap)
         updateGestureTargetNodeForMouseEvent(targetedEvent);
 
     // 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);
+    return m_gestureManager.handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
-    ASSERT(!targetedEvent.event().isScrollEvent());
-
-    Node* eventTarget = targetedEvent.hitTestResult().innerNode();
-    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-
-    if (m_scrollManager.canHandleGestureEvent(targetedEvent))
-        return WebInputEventResult::HandledSuppressed;
-
-    if (eventTarget) {
-        GestureEvent* gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
-        if (gestureDomEvent) {
-            DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
-            if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
-                ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
-                return toWebInputEventResult(gestureDomEventResult);
-            }
-        }
-    }
-
-    switch (gestureEvent.type()) {
-    case PlatformEvent::GestureTapDown:
-        return handleGestureTapDown(targetedEvent);
-    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::GestureTwoFingerTap:
-        return sendContextMenuEventForGesture(targetedEvent);
-    case PlatformEvent::GesturePinchBegin:
-    case PlatformEvent::GesturePinchEnd:
-    case PlatformEvent::GesturePinchUpdate:
-    case PlatformEvent::GestureTapDownCancel:
-    case PlatformEvent::GestureTapUnconfirmed:
-        break;
-    default:
-        ASSERT_NOT_REACHED();
-    }
-
-    return WebInputEventResult::NotHandled;
+    return m_gestureManager.handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
 
     return m_scrollManager.handleGestureScrollEvent(gestureEvent);
 }
 
-WebInputEventResult EventHandler::handleGestureTapDown(const GestureEventWithHitTestResults& targetedEvent)
-{
-    m_suppressMouseEventsFromGestures =
-        m_pointerEventManager.primaryPointerdownCanceled(targetedEvent.event().uniqueTouchEventId());
-    return WebInputEventResult::NotHandled;
-}
-
-WebInputEventResult EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
-{
-    FrameView* frameView(m_frame->view());
-    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-    HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
-    uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
-    uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
-
-    UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
-
-    HitTestResult currentHitTest = targetedEvent.hitTestResult();
-
-    // We use the adjusted position so the application isn't surprised to see a event with
-    // co-ordinates outside the target's bounds.
-    IntPoint adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
-
-    const unsigned modifiers = gestureEvent.getModifiers();
-
-    if (!m_suppressMouseEventsFromGestures) {
-        PlatformMouseEvent fakeMouseMove(gestureEvent.position(), gestureEvent.globalPosition(),
-            NoButton, PlatformEvent::MouseMoved, /* clickCount */ 0,
-            static_cast<PlatformEvent::Modifiers>(modifiers),
-            PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-        dispatchMouseEvent(EventTypeNames::mousemove, currentHitTest.innerNode(), 0, fakeMouseMove);
-    }
-
-    // Do a new hit-test in case the mousemove event changed the DOM.
-    // Note that if the original hit test wasn't over an element (eg. was over a scrollbar) we
-    // don't want to re-hit-test because it may be in the wrong frame (and there's no way the page
-    // could have seen the event anyway).
-    // Also note that the position of the frame may have changed, so we need to recompute the content
-    // co-ordinates (updating layout/style as hitTestResultAtPoint normally would).
-    // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
-    if (currentHitTest.innerNode()) {
-        LocalFrame* mainFrame = m_frame->localFrameRoot();
-        if (mainFrame && mainFrame->view())
-            mainFrame->view()->updateLifecycleToCompositingCleanPlusScrolling();
-        adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
-        currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
-    }
-    m_clickNode = currentHitTest.innerNode();
-
-    // Capture data for showUnhandledTapUIIfNeeded.
-    Node* tappedNode = m_clickNode;
-    IntPoint tappedPosition = gestureEvent.position();
-
-    if (m_clickNode && m_clickNode->isTextNode())
-        m_clickNode = FlatTreeTraversal::parent(*m_clickNode);
-
-    PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
-        LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
-        static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
-        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-
-    // TODO(mustaq): We suppress MEs plus all it's side effects. What would that
-    // mean for for TEs?  What's the right balance here? crbug.com/617255
-    WebInputEventResult mouseDownEventResult = WebInputEventResult::HandledSuppressed;
-    if (!m_suppressMouseEventsFromGestures) {
-        mouseDownEventResult = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
-        selectionController().initializeSelectionState();
-        if (mouseDownEventResult == WebInputEventResult::NotHandled)
-            mouseDownEventResult = handleMouseFocus(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest), InputDeviceCapabilities::firesTouchEventsSourceCapabilities());
-        if (mouseDownEventResult == WebInputEventResult::NotHandled)
-            mouseDownEventResult = handleMousePressEvent(MouseEventWithHitTestResults(fakeMouseDown, currentHitTest));
-    }
-
-    if (currentHitTest.innerNode()) {
-        ASSERT(gestureEvent.type() == PlatformEvent::GestureTap);
-        HitTestResult result = currentHitTest;
-        result.setToShadowHostIfInUserAgentShadowRoot();
-        m_frame->chromeClient().onMouseDown(result.innerNode());
-    }
-
-    // FIXME: Use a hit-test cache to avoid unnecessary hit tests. http://crbug.com/398920
-    if (currentHitTest.innerNode()) {
-        LocalFrame* mainFrame = m_frame->localFrameRoot();
-        if (mainFrame && mainFrame->view())
-            mainFrame->view()->updateAllLifecyclePhases();
-        adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
-        currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
-    }
-
-    PlatformMouseEvent fakeMouseUp(gestureEvent.position(), gestureEvent.globalPosition(),
-        LeftButton, PlatformEvent::MouseReleased, gestureEvent.tapCount(),
-        static_cast<PlatformEvent::Modifiers>(modifiers),
-        PlatformMouseEvent::FromTouch, gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
-    WebInputEventResult mouseUpEventResult = m_suppressMouseEventsFromGestures
-        ? WebInputEventResult::HandledSuppressed
-        : dispatchMouseEvent(EventTypeNames::mouseup, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseUp);
-
-    WebInputEventResult clickEventResult = WebInputEventResult::NotHandled;
-    if (m_clickNode) {
-        if (currentHitTest.innerNode()) {
-            // Updates distribution because a mouseup (or mousedown) event listener can make the
-            // tree dirty at dispatchMouseEvent() invocation above.
-            // Unless distribution is updated, commonAncestor would hit ASSERT.
-            // Both m_clickNode and currentHitTest.innerNode()) don't need to be updated
-            // because commonAncestor() will exit early if their documents are different.
-            m_clickNode->updateDistribution();
-            Node* clickTargetNode = currentHitTest.innerNode()->commonAncestor(*m_clickNode, parentForClickEvent);
-            clickEventResult = dispatchMouseEvent(EventTypeNames::click, clickTargetNode, gestureEvent.tapCount(), fakeMouseUp);
-        }
-        m_clickNode = nullptr;
-    }
-
-    if (mouseUpEventResult == WebInputEventResult::NotHandled)
-        mouseUpEventResult = handleMouseReleaseEvent(MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
-    clearDragHeuristicState();
-
-    WebInputEventResult eventResult = mergeEventResult(mergeEventResult(mouseDownEventResult, mouseUpEventResult), clickEventResult);
-    if (eventResult == WebInputEventResult::NotHandled && tappedNode && m_frame->page()) {
-        bool domTreeChanged = preDispatchDomTreeVersion != m_frame->document()->domTreeVersion();
-        bool styleChanged = preDispatchStyleVersion != m_frame->document()->styleVersion();
-
-        IntPoint tappedPositionInViewport = frameHost()->visualViewport().rootFrameToViewport(tappedPosition);
-        m_frame->chromeClient().showUnhandledTapUIIfNeeded(tappedPositionInViewport, tappedNode, domTreeChanged || styleChanged);
-    }
-    return eventResult;
-}
-
-WebInputEventResult EventHandler::handleGestureLongPress(const GestureEventWithHitTestResults& targetedEvent)
-{
-    const PlatformGestureEvent& gestureEvent = targetedEvent.event();
-    IntPoint adjustedPoint = gestureEvent.position();
-
-    unsigned modifiers = gestureEvent.getModifiers();
-
-    // 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.
-
-    m_longTapShouldInvokeContextMenu = false;
-    if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
-        // TODO(mustaq): Suppressing long-tap MouseEvents could break
-        // drag-drop. Will do separately because of the risk. crbug.com/606938.
-        PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
-            static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
-            PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
-        m_mouseDown = mouseDownEvent;
-
-        PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
-            static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
-            PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
-        HitTestRequest request(HitTestRequest::ReadOnly);
-        MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
-        m_mouseDownMayStartDrag = true;
-        dragState().m_dragSrc = nullptr;
-        m_mouseDownPos = m_frame->view()->rootFrameToContents(mouseDragEvent.position());
-        if (handleDrag(mev, DragInitiator::Touch)) {
-            m_longTapShouldInvokeContextMenu = true;
-            return WebInputEventResult::HandledSystem;
-        }
-    }
-
-    IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(gestureEvent.position());
-    HitTestResult result = hitTestResultAtPoint(hitTestPoint);
-    if (selectionController().handleGestureLongPress(gestureEvent, result)) {
-        focusDocumentView();
-        return WebInputEventResult::HandledSystem;
-    }
-
-    return sendContextMenuEventForGesture(targetedEvent);
-}
-
-WebInputEventResult EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)
-{
-#if !OS(ANDROID)
-    if (m_longTapShouldInvokeContextMenu) {
-        m_longTapShouldInvokeContextMenu = false;
-        return sendContextMenuEventForGesture(targetedEvent);
-    }
-#endif
-    return WebInputEventResult::NotHandled;
-}
-
 WebInputEventResult EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
 {
     return m_scrollManager.handleGestureScrollEnd(gestureEvent);
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
     return m_scrollManager.isScrollbarHandlingGestures();
 }
 
@@ skipping 185 matching lines @@
 }
 
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
 {
     TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
     ASSERT(m_frame == m_frame->localFrameRoot());
     // Scrolling events get hit tested per frame (like wheel events do).
     ASSERT(!gestureEvent.isScrollEvent());
 
-    HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
+    HitTestRequest::HitTestRequestType hitType = m_gestureManager.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::monotonicallyIncreasingTime() - m_lastShowPressTimestamp;
-        shouldKeepActiveForMinInterval = m_lastShowPressTimestamp && activeInterval < minimumActiveInterval;
+        activeInterval = WTF::monotonicallyIncreasingTime() - m_gestureManager.getLastShowPressTimestamp();
+        shouldKeepActiveForMinInterval = m_gestureManager.getLastShowPressTimestamp() && activeInterval < minimumActiveInterval;
         if (shouldKeepActiveForMinInterval)
             hitType |= HitTestRequest::ReadOnly;
     }
 
     GestureEventWithHitTestResults eventWithHitTestResults = hitTestResultForGestureEvent(gestureEvent, hitType);
     // Now apply hover/active state to the final target.
     HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
     if (!request.readOnly())
         updateGestureHoverActiveState(request, eventWithHitTestResults.hitTestResult().innerElement());
 
@@ skipping 37 matching lines @@
         hitTestResult = hitTestResultInFrame(hitFrame, hitFrame->view()->rootFrameToContents(adjustedEvent.position()), (hitType | HitTestRequest::ReadOnly) & ~HitTestRequest::ListBased);
     }
 
     // If we did a rect-based hit test it must be resolved to the best single node by now to
     // ensure consumers don't accidentally use one of the other candidates.
     ASSERT(!hitTestResult.isRectBasedTest());
 
     return GestureEventWithHitTestResults(adjustedEvent, hitTestResult);
 }
 
-HitTestRequest::HitTestRequestType EventHandler::getHitTypeForGestureType(PlatformEvent::EventType type)
-{
-    HitTestRequest::HitTestRequestType hitType = HitTestRequest::TouchEvent;
-    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::applyTouchAdjustment(PlatformGestureEvent* gestureEvent, HitTestResult* hitTestResult)
 {
     if (!shouldApplyTouchAdjustment(*gestureEvent))
         return;
 
     Node* adjustedNode = nullptr;
     IntPoint adjustedPoint = gestureEvent->position();
     bool adjusted = false;
     switch (gestureEvent->type()) {
     case PlatformEvent::GestureTap:
@@ skipping 354 matching lines @@
     if (dragState().m_dragSrc && !dragState().m_dragSrc->inShadowIncludingDocument())
         dragState().m_dragSrc = rootEditableElement;
 }
 
 // returns if we should continue "default processing", i.e., whether eventhandler canceled
 WebInputEventResult EventHandler::dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent& event)
 {
     return dispatchDragEvent(eventType, dragState().m_dragSrc.get(), event, dragState().m_dragDataTransfer.get());
 }
 
+bool EventHandler::handleDragDropIfPossible(const GestureEventWithHitTestResults& targetedEvent)
+{
+    if (m_frame->settings() && m_frame->settings()->touchDragDropEnabled() && m_frame->view()) {
+        const PlatformGestureEvent& gestureEvent = targetedEvent.event();
+        IntPoint adjustedPoint = gestureEvent.position();
+        unsigned modifiers = gestureEvent.getModifiers();
+
+        // TODO(mustaq): Suppressing long-tap MouseEvents could break
+        // drag-drop. Will do separately because of the risk. crbug.com/606938.
+        PlatformMouseEvent mouseDownEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MousePressed, 1,
+            static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
+            PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
+        m_mouseDown = mouseDownEvent;
+
+        PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
+            static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
+            PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
+        HitTestRequest request(HitTestRequest::ReadOnly);
+        MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
+        m_mouseDownMayStartDrag = true;
+        dragState().m_dragSrc = nullptr;
+        m_mouseDownPos = m_frame->view()->rootFrameToContents(mouseDragEvent.position());
+        return handleDrag(mev, DragInitiator::Touch);
+    }
+    return false;
+}
+
 bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event, DragInitiator initiator)
 {
     ASSERT(event.event().type() == PlatformEvent::MouseMoved);
     // Callers must protect the reference to FrameView, since this function may dispatch DOM
     // events, causing page/FrameView to go away.
     ASSERT(m_frame);
     ASSERT(m_frame->view());
     if (!m_frame->page())
         return false;
 
@@ skipping 223 matching lines @@
 
 FrameHost* EventHandler::frameHost() const
 {
     if (!m_frame->page())
         return nullptr;
 
     return &m_frame->page()->frameHost();
 }
 
 } // namespace blink