OverscrollGlow for mainThread-{BLINK CHANGES}

Source/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 214 matching lines @@
     , m_selectionInitiationState(HaveNotStartedSelection)
     , 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_unusedDelta(FloatSize())
+    , m_accumulatedRootOverscroll(FloatSize())
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_widgetIsLatched(false)
     , m_touchPressed(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_maxMouseMovedDuration(0)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
@@ skipping 671 matching lines @@
 
     return result;
 }
 
 void EventHandler::stopAutoscroll()
 {
     if (AutoscrollController* controller = autoscrollController())
         controller->stopAutoscroll();
 }
 
-bool EventHandler::scroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node** stopNode, float delta, IntPoint absolutePoint)
+ScrollResultOneDimensional EventHandler::scroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node** stopNode, float delta, IntPoint absolutePoint)
 {
     if (!delta)
-        return false;
+        return ScrollResultOneDimensional(false);
 
     Node* node = startNode;
 
     if (!node)
         node = m_frame->document()->focusedElement();
 
     if (!node)
         node = m_mousePressNode.get();
 
     if (!node || !node->layoutObject())
-        return false;
+        return ScrollResultOneDimensional(false, delta);
 
     LayoutBox* curBox = node->layoutObject()->enclosingBox();
     while (curBox && !curBox->isLayoutView()) {
         ScrollDirectionPhysical physicalDirection = toPhysicalDirection(
             direction, curBox->isHorizontalWritingMode(), curBox->style()->isFlippedBlocksWritingMode());
 
         // 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(physicalDirection, granularity, delta);
+        ScrollResultOneDimensional result = curBox->scroll(physicalDirection, granularity, delta);
 
-        if (didScroll && stopNode)
+        if (result.didScroll && stopNode)
             *stopNode = curBox->node();
 
-        if (didScroll || shouldStopBubbling) {
+        if (result.didScroll || shouldStopBubbling) {
             setFrameWasScrolledByUser();
-            return true;
+            result.didScroll = true;
+            return result;
         }
 
         curBox = curBox->containingBlock();
     }
 
-    return false;
+    return ScrollResultOneDimensional(false, delta);
 }
 
 void EventHandler::customizedScroll(const Node& startNode, ScrollState& scrollState)
 {
     if (scrollState.fullyConsumed())
         return;
 
     if (m_currentScrollChain.isEmpty())
         recomputeScrollChain(*m_frame, startNode, m_currentScrollChain);
     scrollState.setScrollChain(m_currentScrollChain);
     scrollState.distributeToScrollChainDescendant();
 }
 
 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()->updateLayoutIgnorePendingStylesheets();
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (scroll(direction, granularity, startingNode))
+    if (scroll(direction, granularity, startingNode).didScroll)
         return true;
     LocalFrame* frame = m_frame;
     FrameView* view = frame->view();
     if (view) {
         ScrollDirectionPhysical physicalDirection =
             toPhysicalDirection(direction, view->isVerticalDocument(), view->isFlippedDocument());
-        if (view->scrollableArea()->scroll(physicalDirection, granularity)) {
+        if (view->scrollableArea()->scroll(physicalDirection, granularity).didScroll) {
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
     Frame* parentFrame = frame->tree().parent();
     if (!parentFrame || !parentFrame->isLocalFrame())
         return false;
     // FIXME: Broken for OOPI.
     return toLocalFrame(parentFrame)->eventHandler().bubblingScroll(direction, granularity, m_frame->deprecatedLocalOwner());
@@ skipping 1170 matching lines @@
         if (node && !node->dispatchWheelEvent(event))
             RETURN_WHEEL_EVENT_HANDLED();
     }
 
     // We do another check on the frame view because the event handler can run
     // JS which results in the frame getting destroyed.
     view = m_frame->view();
     if (!view)
         return false;
 
-    if (view->scrollableArea()->handleWheel(event).didScroll)
+    if (view->scrollableArea()->handleWheel(event).didScroll())
         RETURN_WHEEL_EVENT_HANDLED();
 
     return false;
 #undef RETURN_WHEEL_EVENT_HANDLED
 }
 
 void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)
 {
     if (!startNode || !wheelEvent)
         return;
 
     // When the wheelEvent do not scroll, we trigger zoom in/out instead.
     if (!wheelEvent->canScroll())
         return;
 
     Node* stopNode = m_previousWheelScrolledNode.get();
     ScrollGranularity granularity = wheelGranularityToScrollGranularity(wheelEvent);
     IntPoint absolutePosition = roundedIntPoint(wheelEvent->absoluteLocation());
 
     // Break up into two scrolls if we need to.  Diagonal movement on
     // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
     if (wheelEvent->railsMode() != Event::RailsModeVertical
-        && scroll(ScrollRightIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaX(), absolutePosition))
+        && scroll(ScrollRightIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaX(), absolutePosition).didScroll)
         wheelEvent->setDefaultHandled();
 
     if (wheelEvent->railsMode() != Event::RailsModeHorizontal
-        && scroll(ScrollDownIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaY(), absolutePosition))
+        && scroll(ScrollDownIgnoringWritingMode, granularity, startNode, &stopNode, wheelEvent->deltaY(), absolutePosition).didScroll)
         wheelEvent->setDefaultHandled();
 
     if (!m_latchedWheelEventNode)
         m_previousWheelScrolledNode = stopNode;
 }
 
 bool EventHandler::handleGestureShowPress()
 {
     m_lastShowPressTimestamp = WTF::currentTime();
 
@@ skipping 421 matching lines @@
             0, 0, 0, 0, 0, /* inInertialPhase */ false, /* isBeginning */
             true, /* isEnding */ false, /* fromUserInput */ true);
         customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
     } else {
         if (m_frame->isMainFrame())
             m_frame->host()->topControls().scrollBegin();
     }
     return true;
 }
 
+void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)
+{
+    if (didScrollX) {
+        m_accumulatedRootOverscroll.setWidth(0);
+        m_unusedDelta.setWidth(0);
+    }
+    if (didScrollY) {
+        m_accumulatedRootOverscroll.setHeight(0);
+        m_unusedDelta.setHeight(0);
+    }
+}
+
 bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
         return false;
 
     Node* node = m_scrollGestureHandlingNode.get();
     if (node) {
@@ skipping 39 matching lines @@
             m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
             m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
             scrolled = scrollState->deltaX() != gestureEvent.deltaX()
                 || scrollState->deltaY() != gestureEvent.deltaY();
         } else {
             if (gestureEvent.preventPropagation())
                 stopNode = m_previousGestureScrolledNode.get();
 
             // First try to scroll the closest scrollable LayoutBox ancestor of |node|.
             ScrollGranularity granularity = ScrollByPrecisePixel;
-            bool horizontalScroll = scroll(ScrollLeftIgnoringWritingMode, granularity, node, &stopNode, delta.width());
+            m_unusedDelta = FloatSize();
+            ScrollResultOneDimensional result = scroll(ScrollLeftIgnoringWritingMode, granularity, node, &stopNode, delta.width());
+            bool horizontalScroll = result.didScroll;
             if (!gestureEvent.preventPropagation())
                 stopNode = nullptr;
-            bool verticalScroll = scroll(ScrollUpIgnoringWritingMode, granularity, node, &stopNode, delta.height());
+            result = scroll(ScrollUpIgnoringWritingMode, granularity, node, &stopNode, delta.height());
+            bool verticalScroll = result.didScroll;
             scrolled = horizontalScroll || verticalScroll;
 
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
+
+            resetOverscroll(horizontalScroll, verticalScroll);
         }
         if (scrolled) {
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
         return false;
 
     // Try to scroll the frame view.
-    if (m_frame->applyScrollDelta(delta, false)) {
+    ScrollResult resultScrollDelta = m_frame->applyScrollDelta(delta, false);

[majidvp, 2015/06/03 12:09:46]

replace resultScrollDelta with scrollResult.

[MuVen, 2015/06/03 15:54:39]

Done.

+    m_unusedDelta.setWidth(resultScrollDelta.unusedScrollDeltaX);
+    m_unusedDelta.setHeight(resultScrollDelta.unusedScrollDeltaY);

[majidvp, 2015/06/03 12:09:46]

Instead of mis-reporting unused delta in general I think it is better if we do
not set unusedDelta for overscroll on axis that are not scrollable. Something
like:

// Do not overscroll on axis that is not scrollable 
m_unusedDelta.height = m_frame.scrollSize(Horizontal) ?
scrollResult.unusedScrollDelta : 0;

Make sure to leave a comment like that to explain the reasoning.

BTW CC sometimes (i.e., when elastic overscroll is enabled) reports overscroll
even on non-scrollable axis. However that is not related to this patch so you
can ignore.

[MuVen, 2015/06/03 15:54:39]

Done.

+    resetOverscroll(resultScrollDelta.didScrollX, resultScrollDelta.didScrollY);
+    if (m_frame->isMainFrame() && m_unusedDelta != FloatSize()) {
+        m_accumulatedRootOverscroll += m_unusedDelta;
+        FloatPoint position = FloatPoint(gestureEvent.position().x(), gestureEvent.position().y());
+        FloatSize velocity = FloatSize(gestureEvent.velocityX(), gestureEvent.velocityY());
+        m_frame->chromeClient().didOverscroll(m_unusedDelta, m_accumulatedRootOverscroll, position, velocity);
+    }
+
+    if (resultScrollDelta.didScroll()) {
         setFrameWasScrolledByUser();
         return true;
     }
 
     return false;
 }
 
 void EventHandler::clearGestureScrollNodes()
 {
     m_scrollGestureHandlingNode = nullptr;
     m_previousGestureScrolledNode = nullptr;
     m_deltaConsumedForScrollSequence = false;
     m_currentScrollChain.clear();
+    m_accumulatedRootOverscroll = FloatSize();
+    m_unusedDelta = FloatSize();
 }
 
 bool EventHandler::isScrollbarHandlingGestures() const
 {
     return m_scrollbarHandlingScrollGesture.get();
 }
 
 bool EventHandler::shouldApplyTouchAdjustment(const PlatformGestureEvent& event) const
 {
     if (m_frame->settings() && !m_frame->settings()->touchAdjustmentEnabled())
@@ skipping 882 matching lines @@
 void EventHandler::defaultSpaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keypress);
 
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
     ScrollDirection direction = event->shiftKey() ? ScrollBlockDirectionBackward : ScrollBlockDirectionForward;
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (scroll(direction, ScrollByPage)) {
+    if (scroll(direction, ScrollByPage).didScroll) {
         event->setDefaultHandled();
         return;
     }
 
     FrameView* view = m_frame->view();
     if (!view)
         return;
 
     ScrollDirectionPhysical physicalDirection =
         toPhysicalDirection(direction, view->isVerticalDocument(), view->isFlippedDocument());
 
-    if (view->scrollableArea()->scroll(physicalDirection, ScrollByPage))
+    if (view->scrollableArea()->scroll(physicalDirection, ScrollByPage).didScroll)
         event->setDefaultHandled();
 }
 
 void EventHandler::defaultBackspaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keydown);
 
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
@@ skipping 502 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink