Move overscroll logic out of EventHandler.

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 66 matching lines @@
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
 #include "core/page/TouchAdjustment.h"
+#include "core/page/scrolling/OverscrollController.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "platform/Histogram.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "platform/PlatformTouchEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
@@ skipping 190 matching lines @@
 // 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;
 
 #if OS(MACOSX)
 static const double TextDragDelay = 0.15;
 #else
 static const double TextDragDelay = 0.0;
 #endif
 
-// Report Overscroll if OverscrollDelta is greater than minimumOverscrollDelta
-// to maintain consistency as did in compositor.
-static const float minimumOverscrollDelta = 0.1;
-
 enum NoCursorChangeType { NoCursorChange };
 
 enum class DragInitiator { Mouse, Touch };
 
 class OptionalCursor {
 public:
     OptionalCursor(NoCursorChangeType) : m_isCursorChange(false) { }
     OptionalCursor(const Cursor& cursor) : m_isCursorChange(true), m_cursor(cursor) { }
 
     bool isCursorChange() const { return m_isCursorChange; }
@@ skipping 12 matching lines @@
     , m_selectionController(SelectionController::create(*frame))
     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
     , m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired)
     , m_mouseDownMayStartAutoscroll(false)
     , m_fakeMouseMoveEventTimer(this, &EventHandler::fakeMouseMoveEventTimerFired)
     , m_svgPan(false)
     , m_resizeScrollableArea(nullptr)
     , m_eventHandlerWillResetCapturingMouseEventsNode(0)
     , m_clickCount(0)
     , m_shouldOnlyFireDragOverEvent(false)
-    , m_accumulatedRootOverscroll(FloatSize())
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_touchPressed(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
     , m_waitingForFirstTouchMove(false)
@@ skipping 1986 matching lines @@
     }
 
     if (mouseUpEventResult == WebInputEventResult::NotHandled)
         mouseUpEventResult = handleMouseReleaseEvent(MouseEventWithHitTestResults(fakeMouseUp, currentHitTest));
 
     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 = m_frame->page()->frameHost().visualViewport().rootFrameToViewport(tappedPosition);
+        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();
 
@@ skipping 143 matching lines @@
         scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
         ScrollState* scrollState = ScrollState::create(scrollStateData.release());
         customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
     } else {
         if (m_frame->isMainFrame())
             m_frame->host()->topControls().scrollBegin();
     }
     return WebInputEventResult::HandledSystem;
 }
 
-void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)
-{
-    if (didScrollX)
-        m_accumulatedRootOverscroll.setWidth(0);
-    if (didScrollY)
-        m_accumulatedRootOverscroll.setHeight(0);
-}
-
-static inline FloatSize adjustOverscroll(FloatSize unusedDelta)
-{
-    if (std::abs(unusedDelta.width()) < minimumOverscrollDelta)
-        unusedDelta.setWidth(0);
-    if (std::abs(unusedDelta.height()) < minimumOverscrollDelta)
-        unusedDelta.setHeight(0);
-
-    return unusedDelta;
-}
-
-void EventHandler::handleOverscroll(const ScrollResult& scrollResult, const FloatPoint& positionInRootFrame, const FloatSize& velocityInRootFrame)
-{
-    ASSERT(m_frame->isMainFrame());
-    VisualViewport& visualViewport = m_frame->page()->frameHost().visualViewport();
-
-    FloatSize unusedDelta(scrollResult.unusedScrollDeltaX, scrollResult.unusedScrollDeltaY);
-    unusedDelta = adjustOverscroll(unusedDelta);
-
-    FloatSize deltaInViewport = unusedDelta.scaledBy(visualViewport.scale());
-    FloatSize velocityInViewport = velocityInRootFrame.scaledBy(visualViewport.scale());
-    FloatPoint positionInViewport =
-        visualViewport.rootFrameToViewport(positionInRootFrame);
-
-    resetOverscroll(scrollResult.didScrollX, scrollResult.didScrollY);
-    if (deltaInViewport != FloatSize()) {
-        m_accumulatedRootOverscroll += deltaInViewport;
-        m_frame->chromeClient().didOverscroll(deltaInViewport, m_accumulatedRootOverscroll, positionInViewport, velocityInViewport);
-    }
-}
-
 bool EventHandler::isRootScroller(const Node& node) const
 {
     // The root scroller is the one Element on the page designated to perform
     // "viewport actions" like top controls movement and overscroll glow.
 
     if (!node.isElementNode() || node.document().ownerElement())
         return false;
 
     Element* scrollingElement = node.document().scrollingElement();
     return scrollingElement
@@ skipping 78 matching lines @@
                 delta,
                 FloatPoint(gestureEvent.position()),
                 velocity,
                 node,
                 &stopNode,
                 &consumed);
 
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
 
-            if (!stopNode || !isRootScroller(*stopNode))
-                resetOverscroll(result.didScrollX, result.didScrollY);
+            if ((!stopNode || !isRootScroller(*stopNode)) && frameHost()) {
+                frameHost()->overscrollController().resetAccumulated(
+                    result.didScrollX, result.didScrollY);
+            }
 
             if (consumed)
                 return WebInputEventResult::HandledSystem;
         }
     }
 
     return WebInputEventResult::NotHandled;
 }
 
 void EventHandler::clearGestureScrollState()
 {
     m_scrollGestureHandlingNode = nullptr;
     m_previousGestureScrolledNode = nullptr;
     m_deltaConsumedForScrollSequence = false;
     m_currentScrollChain.clear();
-    m_accumulatedRootOverscroll = FloatSize();
+
+    if (FrameHost* host = frameHost()) {
+        bool resetX = true;
+        bool resetY = true;
+        host->overscrollController().resetAccumulated(resetX, resetY);
+    }
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
     return m_scrollbarHandlingScrollGesture.get();
 }
 
 bool EventHandler::shouldApplyTouchAdjustment(const PlatformGestureEvent& event) const
 {
     if (m_frame->settings() && !m_frame->settings()->touchAdjustmentEnabled())
@@ skipping 348 matching lines @@
 #if OS(WIN)
     int rightAligned = ::GetSystemMetrics(SM_MENUDROPALIGNMENT);
 #else
     int rightAligned = 0;
 #endif
     IntPoint locationInRootFrame;
 
     Element* focusedElement = overrideTargetElement ? overrideTargetElement : doc->focusedElement();
     FrameSelection& selection = m_frame->selection();
     Position start = selection.selection().start();
-    VisualViewport& visualViewport = m_frame->page()->frameHost().visualViewport();
+    VisualViewport& visualViewport = frameHost()->visualViewport();
 
     if (!overrideTargetElement && start.anchorNode() && (selection.rootEditableElement() || selection.isRange())) {
         IntRect firstRect = m_frame->editor().firstRectForRange(selection.selection().toNormalizedEphemeralRange());
 
         int x = rightAligned ? firstRect.maxX() : firstRect.x();
         // In a multiline edit, firstRect.maxY() would endup on the next line, so -1.
         int y = firstRect.maxY() ? firstRect.maxY() - 1 : 0;
         locationInRootFrame = view->contentsToRootFrame(IntPoint(x, y));
     } else if (focusedElement) {
         IntRect clippedRect = focusedElement->boundsInViewport();
@@ skipping 1137 matching lines @@
 
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
+FrameHost* EventHandler::frameHost()
+{
+    if (!m_frame->page())
+        return nullptr;
+
+    return &m_frame->page()->frameHost();
+}
+
 } // namespace blink