OverscrollGlow for mainThread-{BLINK CHANGES}

Source/core/page/EventHandler.h

 /*
  * Copyright (C) 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 110 matching lines @@
     void scheduleHoverStateUpdate();
     void scheduleCursorUpdate();
 
     // Return whether a mouse cursor update is currently pending.  Used for testing.
     bool cursorUpdatePending();
 
     void setResizingFrameSet(HTMLFrameSetElement*);
 
     void resizeScrollableAreaDestroyed();
 
+    FloatSize unusedDeltaForTesting() const { return m_unusedDelta; }
+    FloatSize accumulatedRootOverscrollForTesting() const { return m_accumulatedRootOverscroll; }
+

[majidvp, 2015/06/03 17:36:41]

This is minor but I am not a big fan of exposing these "Testing" functions. I
feel a better testing approach would be to
use a mock of WebViewClient similar to how other tests are implemented.

Which is  This is not a major issue and can perhaps be addressed in a follow-up
patch. bokan@ wdyt?

[bokan, 2015/06/03 19:12:19]

Agreed, this is an anti-pattern.

[MuVen, 2015/06/04 11:19:59]

Done. But when using mock WebViewClient, we cant check the reset logic
of the unusedDelta and accumulatedRootOverscroll. As Overscroll is not reported
when unusedDelta/accumulatedRootOverscroll is reset. Please let me know your
inputs on this.

[bokan, 2015/06/04 12:05:42]

The reset logic is an internal detail of EventSender so we shouldn't test it
directly. You should be testing the visible output. Another way of putting it:
if the reset logic is broken, what about the output is wrong? Find that and
setup the test so you check it.

In this case, it seems you should have someting like this: one gesture scroll
generate some overscroll, produce another scroll in the opposite direction that
should clear the accumulated delta, then try to overscroll again and confirm the
overscroll amount is what you'd expect if the middle scroll cleared the delta. 

[MuVen, 2015/06/04 14:01:19]

Done. 

     IntPoint lastKnownMousePosition() const;
 
     // Attempts to scroll the DOM tree. If that fails, scrolls the view.
     // If the view can't be scrolled either, recursively bubble to the parent frame.
     bool bubblingScroll(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
 
     bool handleMouseMoveEvent(const PlatformMouseEvent&);
     void handleMouseLeaveEvent(const PlatformMouseEvent&);
 
     bool handleMousePressEvent(const PlatformMouseEvent&);
@@ skipping 113 matching lines @@
     // False if we reached the root and couldn't scroll anything.
     // direction - The direction to scroll in. If this is a logical direction, it will be
     //             converted to the physical direction based on a node's writing mode.
     // granularity - The units that the  scroll delta parameter is in.
     // startNode - The node to start bubbling the scroll from. If a node can't scroll,
     //             the scroll bubbles up to the containing block.
     // stopNode - On input, if provided and non-null, the node at which we should stop bubbling on input.
     //            On output, if provided and a node was scrolled stopNode will point to that node.
     // delta - The delta to scroll by, in the units of the granularity parameter. (e.g. pixels, lines, pages, etc.)
     // absolutePoint - For wheel scrolls - the location, in absolute coordinates, where the event occured.
-    bool scroll(ScrollDirection, ScrollGranularity, Node* startNode = nullptr, Node** stopNode = nullptr, float delta = 1.0f, IntPoint absolutePoint = IntPoint());
+    ScrollResultOneDimensional scroll(ScrollDirection, ScrollGranularity, Node* startNode = nullptr, Node** stopNode = nullptr, float delta = 1.0f, IntPoint absolutePoint = IntPoint());
+
+    void resetOverscroll(bool didScrollX, bool didScrollY);
 
     void customizedScroll(const Node& startNode, ScrollState&);
 
     TouchAction intersectTouchAction(const TouchAction, const TouchAction);
     TouchAction computeEffectiveTouchAction(const Node&);
 
     HitTestResult hitTestResultInFrame(LocalFrame*, const LayoutPoint&, HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active);
 
     void invalidateClick();
 
@@ skipping 96 matching lines @@
     int m_clickCount;
     RefPtrWillBeMember<Node> m_clickNode;
 
     RefPtrWillBeMember<Node> m_dragTarget;
     bool m_shouldOnlyFireDragOverEvent;
 
     RefPtrWillBeMember<HTMLFrameSetElement> m_frameSetBeingResized;
 
     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeScrollableArea.
 
+    FloatSize m_unusedDelta;

[majidvp, 2015/06/03 17:36:41]

If we get rid of the *Testing functions we can remove this data member as well.

[MuVen, 2015/06/04 11:19:58]

Done.

+    FloatSize m_accumulatedRootOverscroll;
+
     bool m_mousePositionIsUnknown;
     // The last mouse movement position this frame has seen in root frame coordinates.
     IntPoint m_lastKnownMousePosition;
     IntPoint m_lastKnownMouseGlobalPosition;
     IntPoint m_mouseDownPos; // In our view's coords.
     double m_mouseDownTimestamp;
     PlatformMouseEvent m_mouseDown;
     RefPtr<UserGestureToken> m_lastMouseDownUserGestureToken;
 
     RefPtrWillBeMember<Node> m_latchedWheelEventNode;
@@ skipping 34 matching lines @@
     // scroll sequence in this frame, or any child frames. Only used
     // with ScrollCustomization. If some delta has been consumed, a
     // scroll which shouldn't propagate can't cause any element to
     // scroll other than the |m_previousGestureScrolledNode|.
     bool m_deltaConsumedForScrollSequence;
 };
 
 } // namespace blink
 
 #endif // EventHandler_h