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 281 matching lines @@
     m_nodeUnderMouse = nullptr;
     m_lastNodeUnderMouse = nullptr;
     m_lastMouseMoveEventSubframe = nullptr;
     m_lastScrollbarUnderMouse = nullptr;
     m_clickCount = 0;
     m_clickNode = nullptr;
     m_frameSetBeingResized = nullptr;
     m_dragTarget = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
     m_mousePositionIsUnknown = true;
+    m_unusedDelta = IntPoint();
+    m_accumulatedRootOverscroll = IntPoint();
     m_lastKnownMousePosition = IntPoint();
     m_lastKnownMouseGlobalPosition = IntPoint();
     m_lastMouseDownUserGestureToken.clear();
     m_mousePressNode = nullptr;
     m_mousePressed = false;
     m_capturesDragging = false;
     m_capturingMouseEventsNode = nullptr;
     m_latchedWheelEventNode = nullptr;
     m_previousWheelScrolledNode = nullptr;
     m_targetForTouchID.clear();
@@ skipping 607 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)
+bool EventHandler::scroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node** stopNode, float delta, IntPoint absolutePoint, int* unusedDelta)
 {
     if (!delta)
         return false;
 
     Node* node = startNode;
 
     if (!node)
         node = m_frame->document()->focusedElement();
 
     if (!node)
         node = m_mousePressNode.get();
 
     if (!node || !node->layoutObject())
         return false;
 
     bool rootLayerScrolls = m_frame->settings() && m_frame->settings()->rootLayerScrolls();
     LayoutBox* curBox = node->layoutObject()->enclosingBox();
     while (curBox && (rootLayerScrolls || !curBox->isLayoutView())) {
         ScrollDirection 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);
+        IntPoint cbUnusedDelta = curBox->unUsedDelta();
+        if (direction == ScrollUp)
+            *unusedDelta = cbUnusedDelta.y();
+        else if (direction == ScrollLeft)
+            *unusedDelta = cbUnusedDelta.x();

[majidvp, 2015/04/23 18:25:08]

Overscroll should happen only if the document's main frame is scrolled and has
any scroll delta remaining. This logic overscrolls for all scrolling elements
which is not correct.

Also, this only covers the case where root layer scrolls. See my other comments
the other two cases where frame view maybe scrolled and thus generate unused
scroll delta.

[MuVen, 2015/04/27 12:53:46]

if (m_frame->isMainFrame()) condition will accumulate delta only on mainframe.
Share your inputs.

 
         if (didScroll && stopNode)
             *stopNode = curBox->node();
 
         if (didScroll || shouldStopBubbling) {
             setFrameWasScrolledByUser();
             return true;
         }
 
         curBox = curBox->containingBlock();
@@ skipping 25 matching lines @@
     FrameView* view = frame->view();
     if (view && view->scroll(direction, granularity))
         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());
 }
 
+IntPoint EventHandler::unusedDelta() const
+{
+    return m_unusedDelta;
+}
+
+IntPoint EventHandler::accumaltedRootOverScroll() const
+{
+    return m_accumulatedRootOverscroll;
+}
+
+void EventHandler::resetOverScrollParams()
+{
+    m_unusedDelta = m_accumulatedRootOverscroll = IntPoint();

[majidvp, 2015/04/23 18:25:08]

Scroll deltas should use |FloatSize| and not |IntPoint|

[MuVen, 2015/04/27 12:53:46]

Done.

+}
+
 IntPoint EventHandler::lastKnownMousePosition() const
 {
     return m_lastKnownMousePosition;
 }
 
 static LocalFrame* subframeForTargetNode(Node* node)
 {
     if (!node)
         return nullptr;
 
@@ skipping 1350 matching lines @@
             return true;
     }
 
     if (eventTarget) {
         bool eventSwallowed = handleScrollGestureOnResizer(eventTarget.get(), gestureEvent);
         if (!eventSwallowed)
             eventSwallowed = eventTarget->dispatchGestureEvent(gestureEvent);
         if (eventSwallowed)
             return true;
     }
-
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureScrollBegin:
         return handleGestureScrollBegin(gestureEvent);
     case PlatformEvent::GestureScrollUpdate:
         return handleGestureScrollUpdate(gestureEvent);
     case PlatformEvent::GestureScrollEnd:
         return handleGestureScrollEnd(gestureEvent);
     case PlatformEvent::GestureFlingStart:
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
@@ skipping 224 matching lines @@
         passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
             RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
                 0, 0, 0, 0, 0, gestureEvent.inertial(), /* isBeginning */
                 false, /* isEnding */ true, /* fromUserInput */ true);
             customizedScroll(*node.get(), *scrollState);
         }
     }
 
     clearGestureScrollNodes();
+    resetOverScrollParams();
     return false;
 }
 
 bool EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
 {
     Document* document = m_frame->document();
     if (!document->layoutView())
         return false;
 
     FrameView* view = m_frame->view();
     if (!view)
         return false;
 
     // If there's no renderer on the node, send the event to the nearest ancestor with a renderer.
     // Needed for <option> and <optgroup> elements so we can touch scroll <select>s
     while (m_scrollGestureHandlingNode && !m_scrollGestureHandlingNode->layoutObject())
         m_scrollGestureHandlingNode = m_scrollGestureHandlingNode->parentOrShadowHostNode();
 
     if (!m_scrollGestureHandlingNode) {
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
             m_scrollGestureHandlingNode = m_frame->document()->documentElement();
         else
             return false;
     }
     ASSERT(m_scrollGestureHandlingNode);
-
     passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
         m_currentScrollChain.clear();
         RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
             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();
     }
+
+    resetOverScrollParams();
     return true;
 }
 
 bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
         return false;
@@ skipping 34 matching lines @@
                 // The ScrollState needs to know what the current
                 // native scrolling element is, so that for an
                 // inertial scroll that shouldn't propagate, only the
                 // currently scrolling element responds.
                 ASSERT(m_previousGestureScrolledNode->isElementNode());
                 scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
             }
             customizedScroll(*node, *scrollState);
             m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
             m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
             scrolled = scrollState->deltaX() != gestureEvent.deltaX()

[majidvp, 2015/04/23 18:25:09]

We should also handle the case where scroll customization is enabled.

[majidvp, 2015/04/23 18:59:02]

Muven, I think you can ignore the Scroll customization case for now given that
it may be a while before it is fully enabled. :)

[MuVen, 2015/04/27 12:53:46]

Done.

                 || scrollState->deltaY() != gestureEvent.deltaY();
         } else {
             if (gestureEvent.preventPropagation())
                 stopNode = m_previousGestureScrolledNode.get();
 
             // First try to scroll the closest scrollable LayoutBox ancestor of |node|.
+            int uDelta;
+            m_unusedDelta = IntPoint();
             ScrollGranularity granularity = ScrollByPrecisePixel;
-            bool horizontalScroll = scroll(ScrollLeft, granularity, node, &stopNode, delta.width());
+            bool horizontalScroll = scroll(ScrollLeft, granularity, node, &stopNode, delta.width(), IntPoint(), &uDelta);
+            m_unusedDelta.setX(uDelta);
             if (!gestureEvent.preventPropagation())
                 stopNode = nullptr;
-            bool verticalScroll = scroll(ScrollUp, granularity, node, &stopNode, delta.height());
+            bool verticalScroll = scroll(ScrollUp, granularity, node, &stopNode, delta.height(), IntPoint(), &uDelta);
+            m_unusedDelta.setY(uDelta);
             scrolled = horizontalScroll || verticalScroll;
-
+            m_accumulatedRootOverscroll = m_accumulatedRootOverscroll + m_unusedDelta;
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
         }
         if (scrolled) {
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
         return false;
 
     // Try to scroll the frame view.
     if (m_frame->applyScrollDelta(delta, false)) {

[majidvp, 2015/04/23 18:25:08]

It is also possible to scroll main frame's frameview here and needs to be
covered.

         setFrameWasScrolledByUser();
         return true;
     }
 
     return false;
 }
 
 void EventHandler::clearGestureScrollNodes()
 {
     m_scrollGestureHandlingNode = nullptr;
@@ skipping 1341 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink