Report accurate Overscroll on handleWheel.

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 1764 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())
+    ScrollResult scrollResult = view->scrollableArea()->handleWheel(event);
+    if (m_frame->settings() && m_frame->settings()->elasticOverscrollEnabled())
+        handleOverscroll(scrollResult);
+    if (scrollResult.didScroll())
         RETURN_WHEEL_EVENT_HANDLED();
 
     return false;
 #undef RETURN_WHEEL_EVENT_HANDLED
 }
 
 void EventHandler::defaultWheelEventHandler(Node* startNode, WheelEvent* wheelEvent)
 {
     if (!startNode || !wheelEvent)
         return;
@@ skipping 452 matching lines @@
 }
 
 void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)
 {
     if (didScrollX)
         m_accumulatedRootOverscroll.setWidth(0);
     if (didScrollY)
         m_accumulatedRootOverscroll.setHeight(0);
 }
 
-void EventHandler::handleOverscroll(const ScrollResult& scrollResult, const PlatformGestureEvent& gestureEvent)
+void EventHandler::handleOverscroll(const ScrollResult& scrollResult, const FloatPoint& position, const FloatSize& velocity)
 {
     if (m_frame->isMainFrame() && m_frame->view() && m_frame->view()->scrollableArea()) {
         ScrollableArea* scrollablearea = m_frame->view()->scrollableArea();
-        // Set unusedDelta if axis is scrollable, else set 0 to ensure overflow is not reported on non-scrollable axes.
-        FloatSize unusedDelta(scrollablearea->scrollSize(HorizontalScrollbar) ? scrollResult.unusedScrollDeltaX : 0, scrollablearea->scrollSize(VerticalScrollbar) ? scrollResult.unusedScrollDeltaY : 0);
+        FloatSize unusedDelta;
+        if (m_frame->settings() && m_frame->settings()->elasticOverscrollEnabled()) {
+            // ElasticOverscroll should be applied even on non-Scrollable axis.

[bokan, 2015/06/25 17:50:31]

This distinction seems strange to me, we shouldn't have a difference at the
Blink level here. If we don't want to have an overscroll effect on unscrollable
axes, that should be done at the implementation - Blink should pass all the
overscroll information along anyway.

Could we move the scrollability check in the Android block to CC? That would
obviously have to be done in a separate patch (chromium side). For now the
simplest thing might just be to move the zeroing out of unscrollable delta for
Android to handleGestureScrollUpdate so it's not dependent on this flag.

[MuVen, 2015/06/26 09:55:44]

Done.

+            unusedDelta.setWidth(scrollResult.unusedScrollDeltaX);
+            unusedDelta.setHeight(scrollResult.unusedScrollDeltaY);
+        } else {
+            // In Case of android set unusedDelta if axis is scrollable, else set 0 to ensure overflow is not reported on non-scrollable axes.
+            unusedDelta.setWidth(scrollablearea->scrollSize(HorizontalScrollbar) ? scrollResult.unusedScrollDeltaX : 0);
+            unusedDelta.setHeight(scrollablearea->scrollSize(VerticalScrollbar) ? scrollResult.unusedScrollDeltaY : 0);
+        }
         resetOverscroll(scrollResult.didScrollX, scrollResult.didScrollY);
         if (unusedDelta != FloatSize()) {
             m_accumulatedRootOverscroll += unusedDelta;
-            FloatPoint position = FloatPoint(gestureEvent.position().x(), gestureEvent.position().y());
-            FloatSize velocity = FloatSize(gestureEvent.velocityX(), gestureEvent.velocityY());
             m_frame->chromeClient().didOverscroll(unusedDelta, m_accumulatedRootOverscroll, position, velocity);
         }
     }
 }
 
 bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
@@ skipping 68 matching lines @@
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
         return false;
 
     // Try to scroll the frame view.
     ScrollResult scrollResult = m_frame->applyScrollDelta(delta, false);
-    handleOverscroll(scrollResult, gestureEvent);
+    FloatPoint position = FloatPoint(gestureEvent.position().x(), gestureEvent.position().y());
+    FloatSize velocity = FloatSize(gestureEvent.velocityX(), gestureEvent.velocityY());
+    handleOverscroll(scrollResult, position, velocity);
     if (scrollResult.didScroll()) {
         setFrameWasScrolledByUser();
         return true;
     }
 
     return false;
 }
 
 void EventHandler::clearGestureScrollState()
 {
@@ skipping 1522 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink