ChangeLog

2014-06-30  Peyton Randolph  <prandolph@apple.com>

        Add link long-press event handling using a timer.

        https://bugs.webkit.org/show_bug.cgi?id=134262

        Reviewed by NOBODY (OOPS!).

        This patch adds the link long-press gesture's event handling. There are three events we care about: starting the

        long-press [start], triggering the long-press [trigger], and cancelling the long-press before or after

        triggering [cancel].

        The general flow of the event is as follows (the event triggered at a step is placed in square brackets):

        - [start] The user mouses down over a link.

          - [trigger] The user keeps the mouse pressed on that link without moving their mouse too much for longer than

                      the specified long-press duration.

            - The user releases their mouse press.

            - [cancel] Without releasing their mouse press, the user moves their mouse outside the bounds of the link.

                       Doing so cancels the long press, much like pressing a button on OS X and then moving outside 

                       that button's bounds cancels the button press.

              - The user releases their mouse press.

              - [trigger] Without releasing their mouse press, the user hovers over the original link again. Loop back

                          to the grandparent's trigger event.

          - [cancel] The user releases their mouse press before triggering the long-press, triggering a normal mouse up.

          - [cancel] The user moves their mouse outside a small region around the original mouse press before triggering

                     the long-press.

        * page/EventHandler.h:

        Add four members to EventHandler:

          m_linkLongPressTimer  -- timer tracking the delay between mousing down on a link and triggering a long-press.

          m_linkLongPressSource -- the link element. Stores the source link element of the long-press as soon as the 

                                   mouse is pressed.

          m_didLongPressLink    -- track whether a long-press was triggered at any point.

          m_linkLongPressMouseOutside -- track whether the mouse has moved outside the long-pressed link. Used to

                                         implement OS X-style button hovering behavior, i.e. long-pressing a link and

                                         then dragging the mouse outside the link will cancel the long-press.

        * page/EventHandler.cpp:

        (WebCore::EventHandler::EventHandler):

        (WebCore::EventHandler::clear): Insert clearLinkLongPressState();

        (WebCore::EventHandler::handleMousePressEvent): Start the long-press if the mouse press is over a link.

        (WebCore::EventHandler::handleMouseReleaseEvent): Cancel the long-press when the mouse goes up.

        (WebCore::EventHandler::startLinkLongPressWithSource): 

        Added. Starts the long-press timer and stores the source of the long-press.

        (WebCore::EventHandler::triggerLinkLongPress): Added. Will send up the long-press event.

        (WebCore::EventHandler::cancelLinkLongPress): Added. Will send up the link long-press event.

        (WebCore::EventHandler::cancelLinkLongPressTimer): 

        Added. Cancel the long-press timer. Distinct from cancelLinkLongPress() because cancelLinkLongPress() will 

        send up a cancel event in a future patch.

        (WebCore::EventHandler::clearLinkLongPressState): Added. Clear member variables.

        (WebCore::EventHandler::linkLongPressTimerFired): 

        Added. Trigger the long-press and disable other actions like dragging.

        (WebCore::EventHandler::handleLinkLongPressMouseMovedEvent): 

        Added. Cancels the long-press if the mouse moves outside a specified hysteresis before triggering. Cancel the

        link long-press if triggered but the mouse moves outside the original URL element.

        (WebCore::EventHandler::handleMouseMoveEvent): Call handleLinkLongPressEvent to handle the move.

        (WebCore::EventHandler::handleDrag): Long-press and drag are mutually exclusive, so cancel long-press.

        (WebCore::EventHandler::mouseHysteresisExceeded): Added. General hysteresis function that takes an arbitrary

        mouse movement threshold. Factored out from dragHysteresisExceeded.

        (WebCore::EventHandler::dragHysteresisExceeded): Factored out the hysteresis bounds check into

        mouseHysteresisExceeded().

2014-06-30  Alex Christensen  <achristensen@webkit.org>

        Use non-thumb registers in armv7 css jit.

Source/WebCore/page/EventHandler.cpp

@@const double cursorUpdateInterval = 0.02;

const int maximumCursorSize = 128;

#endif

    
#if ENABLE(LINK_LONG_PRESS)

const double linkLongPressDelay = 0.5;

const int linkLongPressHysteresis = 5;

#endif

#if ENABLE(MOUSE_CURSOR_SCALE)

// It's pretty unlikely that a scale of less than one would ever be used. But all we really

@@EventHandler::EventHandler(Frame& frame)

#if ENABLE(CURSOR_SUPPORT)

    , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)

#endif

#if ENABLE(LINK_LONG_PRESS)

    , m_linkLongPressTimer(this, &EventHandler::linkLongPressTimerFired)

    , m_linkLongPressSource(nullptr)

    , m_didLongPressLink(false)

    , m_linkLongPressMouseOutside(false)

#endif

    , m_autoscrollController(std::make_unique<AutoscrollController>())

    , m_mouseDownMayStartAutoscroll(false)

    , m_mouseDownWasInSubframe(false)

@@void EventHandler::clear()

#if ENABLE(CURSOR_VISIBILITY)

    cancelAutoHideCursorTimer();

#endif

#if ENABLE(LINK_LONG_PRESS)

    clearLinkLongPressState();

#endif

    m_resizeLayer = 0;

    m_elementUnderMouse = nullptr;

    m_lastElementUnderMouse = nullptr;

@@bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& eve

    // Careful that the drag starting logic stays in sync with eventMayStartDrag()

    m_mouseDownMayStartDrag = singleClick;

#endif

    
#if ENABLE(LINK_LONG_PRESS)

    if (event.isOverLink() && event.event().button() == LeftButton)

        startLinkLongPressWithSource(event.hitTestResult().URLElement());

#endif

    m_mouseDownWasSingleClickInSelection = false;

@@bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& e

    m_mouseDownWasInSubframe = false;

    bool handled = false;

    
#if ENABLE(LINK_LONG_PRESS)

    if (event.event().button() == LeftButton) {

        cancelLinkLongPress();

        clearLinkLongPressState();

    }

#endif

    // Clear the selection if the mouse didn't move after the last mouse

    // press and it's not a context menu click.  We do this so when clicking

@@void EventHandler::autoHideCursorTimerFired(Timer<EventHandler>& timer)

        view->setCursor(m_currentMouseCursor);

}

#endif

    
#if ENABLE(LINK_LONG_PRESS)

void EventHandler::startLinkLongPressWithSource(Element* element)

{

    clearLinkLongPressState();

    m_linkLongPressSource = element;

    m_linkLongPressTimer.startOneShot(linkLongPressDelay);

    // FIXME: send link information up to UI process.

}

void EventHandler::triggerLinkLongPress()

{

    // FIXME: send link information up to UI process.

}

void EventHandler::cancelLinkLongPress()

{

    if (!m_linkLongPressSource.get())

        return;

    // Moving the mouse outside of the source element will cancel the long-press, so we return early if that's already happened.

    if (m_linkLongPressMouseOutside)

        return;

    cancelLinkLongPressTimer();

    // FIXME: send link information up to UI process.

}

void EventHandler::cancelLinkLongPressTimer()

{

    if (m_linkLongPressTimer.isActive())

        m_linkLongPressTimer.stop();

}

void EventHandler::clearLinkLongPressState()

{

    cancelLinkLongPressTimer();

    m_linkLongPressSource = nullptr;

    m_didLongPressLink = false;

    m_linkLongPressMouseOutside = false;

}

void EventHandler::linkLongPressTimerFired(Timer<EventHandler>& timer)

{

    ASSERT_UNUSED(timer, &timer == &m_linkLongPressTimer);

    m_didLongPressLink = true;

    // Clear mouse state to avoid initiating a drag.

    m_mousePressed = false;

    invalidateClick();

    triggerLinkLongPress();

}

void EventHandler::handleLinkLongPressMouseMovedEvent(const WebCore::MouseEventWithHitTestResults &mev)

{

    bool exceededHysteresis = mouseHysteresisExceeded(mev.event().position(), linkLongPressHysteresis);

    if (!m_didLongPressLink) {

        if (exceededHysteresis) {

            cancelLinkLongPress();

            clearLinkLongPressState();

        }

        return;

    }

    bool mouseInside = m_linkLongPressSource.get() == mev.hitTestResult().URLElement() || !exceededHysteresis;

    if (!mouseInside && !m_linkLongPressMouseOutside) {

        cancelLinkLongPress();

        m_linkLongPressMouseOutside = true;

    } else if (mouseInside && m_linkLongPressMouseOutside) {

        triggerLinkLongPress();

        m_linkLongPressMouseOutside = false;

    }

}

#endif // ENABLE(LINK_LONG_PRESS)

static LayoutPoint documentPointForWindowPoint(Frame& frame, const IntPoint& windowPoint)

{

@@bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& mouseEvent, Hi

        return true;

    swallowEvent = !dispatchMouseEvent(eventNames().mousemoveEvent, mev.targetNode(), false, 0, mouseEvent, true);

#if ENABLE(LINK_LONG_PRESS)

    if (!swallowEvent && mev.event().button() == LeftButton)

        handleLinkLongPressMouseMovedEvent(mev);

#endif

#if ENABLE(DRAG_SUPPORT)

    if (!swallowEvent)

        swallowEvent = handleMouseDraggedEvent(mev);

@@bool EventHandler::dragHysteresisExceeded(const IntPoint& floatDragViewportLocat

bool EventHandler::dragHysteresisExceeded(const FloatPoint& dragViewportLocation) const

{

    FrameView* view = m_frame.view();

    if (!view)

        return false;

    IntPoint dragLocation = view->windowToContents(flooredIntPoint(dragViewportLocation));

    IntSize delta = dragLocation - m_mouseDownPos;

    int threshold = GeneralDragHysteresis;

    switch (dragState().type) {

    case DragSourceActionSelection:

@@bool EventHandler::dragHysteresisExceeded(const FloatPoint& dragViewportLocation

        ASSERT_NOT_REACHED();

    }

3205 return abs(delt~~a.width()) >=~~ threshold ~~|| abs(delta.height()) >= threshold~~;

3312 return mouseHysteresisExceeded(dragViewportLocation, threshold);

}

void EventHandler::freeDataTransfer()

@@bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event, CheckDr

        // In WebKit2 we could re-enter this code and start another drag.

        // On OS X this causes problems with the ownership of the pasteboard and the promised types.

        if (m_didStartDrag) {

#if ENABLE(LINK_LONG_PRESS)

            cancelLinkLongPress();

            clearLinkLongPressState();

#endif

            m_mouseDownMayStartDrag = false;

            return true;

        }

@@cleanupDrag:

    return true;

}

#endif // ENABLE(DRAG_SUPPORT)

    
#if ENABLE(DRAG_SUPPORT) || ENABLE(LINK_LONG_PRESS)

bool EventHandler::mouseHysteresisExceeded(const FloatPoint& viewportLocation, const int threshold) const

{

    FrameView* view = m_frame.view();

    if (!view)

        return false;

    IntPoint location = view->windowToContents(flooredIntPoint(viewportLocation));

    IntSize delta = location - m_mouseDownPos;

    return abs(delta.width()) >= threshold || abs(delta.height()) >= threshold;

}

#endif // ENABLE(DRAG_SUPPORT) || ENABLE(LINK_LONG_PRESS)

  
bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, TextEventInputType inputType)

{

Source/WebCore/page/EventHandler.h

@@private:

    bool dragHysteresisExceeded(const FloatPoint&) const;

    bool dragHysteresisExceeded(const IntPoint&) const;

#endif // ENABLE(DRAG_SUPPORT)

    
#if ENABLE(DRAG_SUPPORT) || ENABLE(LINK_LONG_PRESS)

    bool mouseHysteresisExceeded(const FloatPoint&, const int) const;

#endif

    bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);

    bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = 0);

@@private:

    void autoHideCursorTimerFired(Timer<EventHandler>&);

#endif

#if ENABLE(LINK_LONG_PRESS)

    void startLinkLongPressWithSource(Element*);

    void triggerLinkLongPress();

    void cancelLinkLongPress();

    bool linkLongPressHysteresisExceeded();

    void clearLinkLongPressState();

    void linkLongPressTimerFired(Timer<EventHandler>&);

    void cancelLinkLongPressTimer();

    void handleLinkLongPressMouseMovedEvent(const MouseEventWithHitTestResults&);

#endif

    void clearLatchedState();

    Frame& m_frame;

@@private:

#if ENABLE(CURSOR_SUPPORT)

    Timer<EventHandler> m_cursorUpdateTimer;

#endif

#if ENABLE(LINK_LONG_PRESS)

    Timer<EventHandler> m_linkLongPressTimer;

    RefPtr<Element> m_linkLongPressSource;

    bool m_didLongPressLink;

    bool m_linkLongPressMouseOutside;

#endif

    std::unique_ptr<AutoscrollController> m_autoscrollController;

    bool m_mouseDownMayStartAutoscroll;