OverscrollGlow for mainThread-{BLINK CHANGES}

Source/core/frame/RootFrameViewport.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/frame/RootFrameViewport.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/ScrollAlignment.h"
 #include "platform/geometry/DoubleRect.h"
@@ skipping 73 matching lines @@
         return;
 
     DoublePoint clampedPosition = clampScrollPosition(position);
     scrollToOffsetWithoutAnimation(toFloatPoint(clampedPosition));
 }
 
 ScrollResult RootFrameViewport::handleWheel(const PlatformWheelEvent& event)
 {
     updateScrollAnimator();
 
-    ScrollResult viewScrollResult(false);
+    ScrollResult viewScrollResult;
     if (layoutViewport().isScrollable())
         viewScrollResult = layoutViewport().handleWheel(event);
 
     // The visual viewport will only accept pixel scrolls.
     if (!event.canScroll() || event.granularity() == ScrollByPageWheelEvent)
         return viewScrollResult;
 
     // Move the location by the negative of the remaining scroll delta.
     DoublePoint oldOffset = visualViewport().scrollPositionDouble();
     DoublePoint locationDelta;
-    if (viewScrollResult.didScroll) {
+    if (viewScrollResult.didScroll()) {
         locationDelta = -DoublePoint(viewScrollResult.unusedScrollDeltaX, viewScrollResult.unusedScrollDeltaY);
     } else {
         if (event.railsMode() != PlatformEvent::RailsModeVertical)
             locationDelta.setX(-event.deltaX());
         if (event.railsMode() != PlatformEvent::RailsModeHorizontal)
             locationDelta.setY(-event.deltaY());
     }
 
     DoublePoint targetPosition = visualViewport().adjustScrollPositionWithinRange(
         visualViewport().scrollPositionDouble() + toDoubleSize(locationDelta));
     visualViewport().scrollToOffsetWithoutAnimation(FloatPoint(targetPosition));
 
     DoublePoint usedLocationDelta(visualViewport().scrollPositionDouble() - oldOffset);
-    if (!viewScrollResult.didScroll && usedLocationDelta == DoublePoint::zero())
-        return ScrollResult(false);
+    if (!viewScrollResult.didScroll() && usedLocationDelta == DoublePoint::zero())
+        return ScrollResult();
 
     DoubleSize unusedLocationDelta(locationDelta - usedLocationDelta);
-    return ScrollResult(true, -unusedLocationDelta.width(), -unusedLocationDelta.height());
+    bool didScrollX = viewScrollResult.didScrollX || unusedLocationDelta.width();
+    bool didScrollY = viewScrollResult.didScrollY || unusedLocationDelta.height();
+    return ScrollResult(didScrollX, didScrollY, -unusedLocationDelta.width(), -unusedLocationDelta.height());
 }
 
 LayoutRect RootFrameViewport::scrollIntoView(const LayoutRect& rectInContent, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
     // We want to move the rect into the viewport that excludes the scrollbars so we intersect
     // the pinch viewport with the scrollbar-excluded frameView content rect. However, we don't
     // use visibleContentRect directly since it floors the scroll position. Instead, we use
     // FrameView::scrollPositionDouble and construct a LayoutRect from that (the FrameView size
     // is always integer sized.
 
@@ skipping 135 matching lines @@
 GraphicsLayer* RootFrameViewport::layerForHorizontalScrollbar() const
 {
     return layoutViewport().layerForHorizontalScrollbar();
 }
 
 GraphicsLayer* RootFrameViewport::layerForVerticalScrollbar() const
 {
     return layoutViewport().layerForVerticalScrollbar();
 }
 
-bool RootFrameViewport::userScroll(ScrollDirectionPhysical direction, ScrollGranularity granularity, float delta)
+ScrollResultOneDimensional RootFrameViewport::userScroll(ScrollDirectionPhysical direction, ScrollGranularity granularity, float delta)
 {
     updateScrollAnimator();
 
     ScrollbarOrientation orientation;
 
     if (direction == ScrollUp || direction == ScrollDown)
         orientation = VerticalScrollbar;
     else
         orientation = HorizontalScrollbar;
 
     if (layoutViewport().userInputScrollable(orientation) && visualViewport().userInputScrollable(orientation))
         return ScrollableArea::userScroll(direction, granularity, delta);
 
     if (visualViewport().userInputScrollable(orientation))
         return visualViewport().userScroll(direction, granularity, delta);
 
     if (layoutViewport().userInputScrollable(orientation))
         return layoutViewport().userScroll(direction, granularity, delta);
 
-    return false;
+    return ScrollResultOneDimensional(false, delta);
 }
 
 bool RootFrameViewport::scrollAnimatorEnabled() const
 {
     return layoutViewport().scrollAnimatorEnabled();
 }
 
 HostWindow* RootFrameViewport::hostWindow() const
 {
     return layoutViewport().hostWindow();
 }
 
 void RootFrameViewport::serviceScrollAnimations(double monotonicTime)
 {
     ScrollableArea::serviceScrollAnimations(monotonicTime);
     layoutViewport().serviceScrollAnimations(monotonicTime);
 }
 
 void RootFrameViewport::updateCompositorScrollAnimations()
 {
     ScrollableArea::updateCompositorScrollAnimations();
     layoutViewport().updateCompositorScrollAnimations();
 }
 
 
 } // namespace blink