Remove more mouse-specific code

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 103 matching lines @@
         *m_maxDuration = max(*m_maxDuration, monotonicallyIncreasingTime() - m_start);
     }
 
 private:
     double* m_maxDuration;
     double m_start;
 };
 
 EventHandler::EventHandler(LocalFrame* frame)
     : m_frame(frame)
-    , m_mousePressed(false)
     , 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_maxMouseMovedDuration(0)
     , m_didStartDrag(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
 {
 }
 
 EventHandler::~EventHandler()
 {
 }
 
 void EventHandler::clear()
 {
-    m_hoverTimer.stop();
     m_cursorUpdateTimer.stop();
     m_activeIntervalTimer.stop();
-    m_nodeUnderMouse = nullptr;
-    m_lastNodeUnderMouse = nullptr;
-    m_lastScrollbarUnderMouse = nullptr;
     m_clickCount = 0;
     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_maxMouseMovedDuration = 0;
     m_didStartDrag = false;
-    m_mouseDownMayStartSelect = false;
-    m_mouseDownMayStartDrag = false;
     m_lastShowPressTimestamp = 0;
     m_lastDeferredTapElement = nullptr;
 }
 
 void EventHandler::nodeWillBeRemoved(Node& nodeToBeRemoved)
 {
     if (!nodeToBeRemoved.containsIncludingShadowDOM(m_clickNode.get()))
         return;
     if (nodeToBeRemoved.isInShadowTree()) {
         m_clickNode = nodeToBeRemoved.parentOrShadowHostNode();
     } else {
         // We don't dispatch click events if the mousedown node is removed
         // before a mouseup event. It is compatible with IE and Firefox.
         m_clickNode = nullptr;
     }
 }
 
-static inline bool dispatchSelectStart(Node* node)
-{
-    if (!node || !node->renderer())
-        return true;
-
-    return node->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart));
-}
-
-static VisibleSelection expandSelectionToRespectUserSelectAll(Node* targetNode, const VisibleSelection& selection)
-{
-    Node* rootUserSelectAll = Position::rootUserSelectAllForNode(targetNode);
-    if (!rootUserSelectAll)
-        return selection;
-
-    VisibleSelection newSelection(selection);
-    newSelection.setBase(positionBeforeNode(rootUserSelectAll).upstream(CanCrossEditingBoundary));
-    newSelection.setExtent(positionAfterNode(rootUserSelectAll).downstream(CanCrossEditingBoundary));
-
-    return newSelection;
-}
-
-bool EventHandler::updateSelectionForMouseDownDispatchingSelectStart(Node* targetNode, const VisibleSelection& selection, TextGranularity granularity)
-{
-    if (Position::nodeIsUserSelectNone(targetNode))
-        return false;
-
-    if (!dispatchSelectStart(targetNode))
-        return false;
-
-    if (selection.isRange())
-        m_selectionInitiationState = ExtendedSelection;
-    else {
-        granularity = CharacterGranularity;
-        m_selectionInitiationState = PlacedCaret;
-    }
-
-    m_frame->selection().setNonDirectionalSelectionIfNeeded(selection, granularity);
-
-    return true;
-}
-
 void EventHandler::selectClosestWordFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.targetNode();
     VisibleSelection newSelection;
 
     if (innerNode && innerNode->renderer()) {
         VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));
         if (pos.isNotNull()) {
             newSelection = VisibleSelection(pos);
             newSelection.expandUsingGranularity(WordGranularity);
         }
 
         if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())
             newSelection.appendTrailingWhitespace();
-
-        updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
     }
 }
 
 void EventHandler::selectClosestMisspellingFromHitTestResult(const HitTestResult& result, AppendTrailingWhitespace appendTrailingWhitespace)
 {
     Node* innerNode = result.targetNode();
     VisibleSelection newSelection;
 
     if (innerNode && innerNode->renderer()) {
         VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));
         Position start = pos.deepEquivalent();
         Position end = pos.deepEquivalent();
         if (pos.isNotNull()) {
             DocumentMarkerVector markers = innerNode->document().markers().markersInRange(makeRange(pos, pos).get(), DocumentMarker::MisspellingMarkers());
             if (markers.size() == 1) {
                 start.moveToOffset(markers[0]->startOffset());
                 end.moveToOffset(markers[0]->endOffset());
                 newSelection = VisibleSelection(start, end);
             }
         }
 
         if (appendTrailingWhitespace == ShouldAppendTrailingWhitespace && newSelection.isRange())
             newSelection.appendTrailingWhitespace();
-
-        updateSelectionForMouseDownDispatchingSelectStart(innerNode, expandSelectionToRespectUserSelectAll(innerNode, newSelection), WordGranularity);
     }
 }
 
-void EventHandler::updateSelectionForMouseDrag()
-{
-    FrameView* view = m_frame->view();
-    if (!view)
-        return;
-    RenderView* renderer = m_frame->contentRenderer();
-    if (!renderer)
-        return;
-
-    HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::Move);
-    HitTestResult result(m_lastKnownMousePosition);
-    renderer->hitTest(request, result);
-    updateSelectionForMouseDrag(result);
-}
-
-void EventHandler::updateSelectionForMouseDrag(const HitTestResult& hitTestResult)
-{
-    if (!m_mouseDownMayStartSelect)
-        return;
-
-    Node* target = hitTestResult.targetNode();
-    if (!target)
-        return;
-
-    VisiblePosition targetPosition = m_frame->selection().selection().visiblePositionRespectingEditingBoundary(hitTestResult.localPoint(), target);
-    // Don't modify the selection if we're not on a node.
-    if (targetPosition.isNull())
-        return;
-
-    // Restart the selection if this is the first mouse move. This work is usually
-    // done in handleMousePressEvent, but not if the mouse press was on an existing selection.
-    VisibleSelection newSelection = m_frame->selection().selection();
-
-    if (m_selectionInitiationState == HaveNotStartedSelection && !dispatchSelectStart(target))
-        return;
-
-    if (m_selectionInitiationState != ExtendedSelection) {
-        // Always extend selection here because it's caused by a mouse drag
-        m_selectionInitiationState = ExtendedSelection;
-        newSelection = VisibleSelection(targetPosition);
-    }
-
-    if (RuntimeEnabledFeatures::userSelectAllEnabled()) {
-        Node* rootUserSelectAllForMousePressNode = Position::rootUserSelectAllForNode(m_mousePressNode.get());
-        if (rootUserSelectAllForMousePressNode && rootUserSelectAllForMousePressNode == Position::rootUserSelectAllForNode(target)) {
-            newSelection.setBase(positionBeforeNode(rootUserSelectAllForMousePressNode).upstream(CanCrossEditingBoundary));
-            newSelection.setExtent(positionAfterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
-        } else {
-            // Reset base for user select all when base is inside user-select-all area and extent < base.
-            if (rootUserSelectAllForMousePressNode && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
-                newSelection.setBase(positionAfterNode(rootUserSelectAllForMousePressNode).downstream(CanCrossEditingBoundary));
-
-            Node* rootUserSelectAllForTarget = Position::rootUserSelectAllForNode(target);
-            if (rootUserSelectAllForTarget && m_mousePressNode->renderer() && comparePositions(target->renderer()->positionForPoint(hitTestResult.localPoint()), m_mousePressNode->renderer()->positionForPoint(m_dragStartPos)) < 0)
-                newSelection.setExtent(positionBeforeNode(rootUserSelectAllForTarget).upstream(CanCrossEditingBoundary));
-            else if (rootUserSelectAllForTarget && m_mousePressNode->renderer())
-                newSelection.setExtent(positionAfterNode(rootUserSelectAllForTarget).downstream(CanCrossEditingBoundary));
-            else
-                newSelection.setExtent(targetPosition);
-        }
-    } else {
-        newSelection.setExtent(targetPosition);
-    }
-
-    if (m_frame->selection().granularity() != CharacterGranularity)
-        newSelection.expandUsingGranularity(m_frame->selection().granularity());
-
-    m_frame->selection().setNonDirectionalSelectionIfNeeded(newSelection, m_frame->selection().granularity(),
-        FrameSelection::AdjustEndpointsAtBidiBoundary);
-}
-
 AutoscrollController* EventHandler::autoscrollController() const
 {
     if (Page* page = m_frame->page())
         return &page->autoscrollController();
     return 0;
 }
 
 HitTestResult EventHandler::hitTestResultAtPoint(const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType, const LayoutSize& padding)
 {
     TRACE_EVENT0("blink", "EventHandler::hitTestResultAtPoint");
@@ skipping 15 matching lines @@
 
     return result;
 }
 
 void EventHandler::stopAutoscroll()
 {
     if (AutoscrollController* controller = autoscrollController())
         controller->stopAutoscroll();
 }
 
-Node* EventHandler::mousePressNode() const
-{
-    return m_mousePressNode.get();
-}
-
 bool EventHandler::scroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node** stopNode, float delta, IntPoint absolutePoint)
 {
     if (!delta)
         return false;
 
     Node* node = startNode;
 
     if (!node)
         node = m_frame->document()->focusedElement();
 
-    if (!node)
-        node = m_mousePressNode.get();
-
     if (!node || !node->renderer())
         return false;
 
     RenderBox* curBox = node->renderer()->enclosingBox();
     while (curBox && !curBox->isRenderView()) {
         // If we're at the stopNode, we should try to scroll it but we shouldn't bubble past it
         bool shouldStopBubbling = stopNode && *stopNode && curBox->node() == *stopNode;
         bool didScroll = curBox->scroll(direction, granularity, delta);
 
         if (didScroll && stopNode)
@@ skipping 12 matching lines @@
 bool EventHandler::bubblingScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
     // The layout needs to be up to date to determine if we can scroll. We may be
     // here because of an onLoad event, in which case the final layout hasn't been performed yet.
     m_frame->document()->updateLayout();
     if (scroll(direction, granularity, startingNode))
         return true;
     return false;
 }
 
-IntPoint EventHandler::lastKnownMousePosition() const
-{
-    return m_lastKnownMousePosition;
-}
-
 bool EventHandler::useHandCursor(Node* node, bool isOverLink)
 {
     if (!node)
         return false;
 
     return isOverLink && !node->hasEditableStyle();
 }
 
 void EventHandler::cursorUpdateTimerFired(Timer<EventHandler>*)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->document());
 
     updateCursor();
 }
 
 void EventHandler::updateCursor()
 {
-    if (m_mousePositionIsUnknown)
-        return;
-
-    FrameView* view = m_frame->view();
-    if (!view || !view->shouldSetCursor())
-        return;
-
-    RenderView* renderView = view->renderView();
-    if (!renderView)
-        return;
-
-    m_frame->document()->updateLayout();
-
-    HitTestRequest request(HitTestRequest::ReadOnly);
-    HitTestResult result(m_lastKnownMousePosition);
-    renderView->hitTest(request, result);
-
-    OptionalCursor optionalCursor = selectCursor(result);
-    if (optionalCursor.isCursorChange()) {
-        m_currentMouseCursor = optionalCursor.cursor();
-        view->setCursor(m_currentMouseCursor);
-    }
 }
 
 OptionalCursor EventHandler::selectCursor(const HitTestResult& result)
 {
     Page* page = m_frame->page();
     if (!page)
         return NoCursorChange;
 
     Node* node = result.innerPossiblyPseudoNode();
     if (!node)
@@ skipping 123 matching lines @@
     return pointerCursor();
 }
 
 OptionalCursor EventHandler::selectAutoCursor(const HitTestResult& result, Node* node, const Cursor& iBeam)
 {
     bool editable = (node && node->hasEditableStyle());
 
     if (useHandCursor(node, result.isOverLink()))
         return handCursor();
 
-    // During selection, use an I-beam no matter what we're over.
-    // If a drag may be starting or we're capturing mouse events for a particular node, don't treat this as a selection.
-    if (m_mousePressed && m_mouseDownMayStartSelect
-        && !m_mouseDownMayStartDrag
-        && m_frame->selection().isCaretOrRange()) {
-        return iBeam;
-    }
-
     RenderObject* renderer = node ? node->renderer() : 0;
     if ((editable || (renderer && renderer->isText() && node->canStartSelection())) && !result.scrollbar())
         return iBeam;
     return pointerCursor();
 }
 
 ScrollableArea* EventHandler::associatedScrollableArea(const RenderLayer* layer) const
 {
     if (RenderLayerScrollableArea* scrollableArea = layer->scrollableArea()) {
         if (scrollableArea->scrollsOverflow())
@@ skipping 14 matching lines @@
     if (RenderView* renderView = m_frame->contentRenderer()) {
         HitTestRequest request(HitTestRequest::ReadOnly);
         HitTestResult result(windowPoint);
         renderView->hitTest(request, result);
         return result.scrollbar();
     }
 
     return false;
 }
 
-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);
 }
 
 bool EventHandler::isCursorVisible() const
 {
     return m_frame->page()->isCursorVisible();
 }
 
-void EventHandler::hoverTimerFired(Timer<EventHandler>*)
-{
-    m_hoverTimer.stop();
-
-    ASSERT(m_frame);
-    ASSERT(m_frame->document());
-
-    if (RenderView* renderer = m_frame->contentRenderer()) {
-        HitTestRequest request(HitTestRequest::Move);
-        HitTestResult result(m_lastKnownMousePosition);
-        renderer->hitTest(request, result);
-    }
-}
-
 void EventHandler::activeIntervalTimerFired(Timer<EventHandler>*)
 {
     m_activeIntervalTimer.stop();
     m_lastDeferredTapElement = nullptr;
 }
 
 void EventHandler::notifyElementActivated()
 {
     // Since another element has been set to active, stop current timer and clear reference.
     if (m_activeIntervalTimer.isActive())
@@ skipping 79 matching lines @@
     }
 }
 
 bool EventHandler::dragHysteresisExceeded(const FloatPoint& floatDragViewportLocation) const
 {
     return dragHysteresisExceeded(flooredIntPoint(floatDragViewportLocation));
 }
 
 bool EventHandler::dragHysteresisExceeded(const IntPoint& dragViewportLocation) const
 {
-    FrameView* view = m_frame->view();
-    if (!view)
-        return false;
-    IntPoint dragLocation = dragViewportLocation;
-    IntSize delta = dragLocation - m_mouseDownPos;
-
-    int threshold = 3;
-
-    return abs(delta.width()) >= threshold || abs(delta.height()) >= threshold;
+    return false;
 }
 
 bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, TextEventInputType inputType)
 {
     // Platforms should differentiate real commands like selectAll from text input in disguise (like insertNewline),
     // and avoid dispatching text input events from keydown default handlers.
     ASSERT(!underlyingEvent || !underlyingEvent->isKeyboardEvent() || toKeyboardEvent(underlyingEvent)->type() == EventTypeNames::keypress);
 
     if (!m_frame)
         return false;
@@ skipping 20 matching lines @@
 }
 
 void EventHandler::defaultTabEventHandler(KeyboardEvent* event)
 {
 }
 
 void EventHandler::capsLockStateMayHaveChanged()
 {
 }
 
-// If scrollbar (under mouse) is different from last, send a mouse exited. Set
-// last to scrollbar if setLast is true; else set last to 0.
-void EventHandler::updateLastScrollbarUnderMouse(Scrollbar* scrollbar, bool setLast)
-{
-    if (m_lastScrollbarUnderMouse != scrollbar) {
-        // Send mouse exited to the old scrollbar.
-        if (m_lastScrollbarUnderMouse)
-            m_lastScrollbarUnderMouse->mouseExited();
-
-        // Send mouse entered if we're setting a new scrollbar.
-        if (scrollbar && setLast)
-            scrollbar->mouseEntered();
-
-        m_lastScrollbarUnderMouse = setLast ? scrollbar : 0;
-    }
-}
-
 HitTestResult EventHandler::hitTestResultInFrame(LocalFrame* frame, const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType)
 {
     HitTestResult result(point);
 
     if (!frame || !frame->contentRenderer())
         return result;
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect();
         if (!rect.contains(roundedIntPoint(point)))
             return result;
@@ skipping 40 matching lines @@
 
 void EventHandler::focusDocumentView()
 {
     Page* page = m_frame->page();
     if (!page)
         return;
     page->focusController().focusDocumentView(m_frame);
 }
 
 } // namespace blink