Move viewport actions into an ApplyScroll callback.

third_party/WebKit/Source/core/input/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 222 matching lines @@
         PlatformTouchPoint point;
         Member<EventTarget> touchTarget;
         Member<LocalFrame> targetFrame;
         FloatPoint adjustedPagePoint;
         FloatSize adjustedRadius;
         bool knownTarget;
         bool consumed;
         String region;
     };
 
+    // TODO(bokan): This seems like it no longer belongs here.
+    void handleOverscroll(const ScrollResult&, const FloatPoint& position = FloatPoint(), const FloatSize& velocity = FloatSize());
+
 private:
     static DragState& dragState();
 
     DataTransfer* createDraggingDataTransfer() const;
 
     WebInputEventResult handleMouseMoveOrLeaveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false, bool forceLeave = false);
     WebInputEventResult handleMousePressEvent(const MouseEventWithHitTestResults&);
     WebInputEventResult handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
     WebInputEventResult handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
     WebInputEventResult handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
@@ skipping 24 matching lines @@
     void updateCursor();
 
     ScrollableArea* associatedScrollableArea(const PaintLayer*) const;
 
     // Performs a chaining scroll, within a *single* frame, starting from a
     // given node and optionally stopping on a given node.
     // granularity - The units that the  scroll delta parameter is in.
     // delta - The delta to scroll by, in the units of the granularity param
     //         (e.g. pixels, lines, pages, etc.). These are in a physical
     //         direction. i.e. Positive is down and right.
+    // position - Where the scroll originated from (e.g. touch location).
+    // velocity - The velocity of the scroll in the case of fling gestures.
     // startNode - The node to start the scroll chaining from.
     // stopNode - On input, if non-null, the node at which we should stop
     //            chaining. On output, if provided and a node was scrolled,
     //            stopNode will point to that node.
     // consumed - [OUT] Whether the scroll was consumed. This is different than
     //            ScrollResult.didScroll since we might not have scrolled but
     //            have reached the stopNode and thus don't want to continue
     //            chaining the scroll.
-    ScrollResult physicalScroll(ScrollGranularity, const FloatSize& delta, Node* startNode, Node** stopNode, bool* consumed);
+    ScrollResult physicalScroll(
+        ScrollGranularity,
+        const FloatSize& delta,
+        const FloatPoint& position,
+        const FloatSize& velocity,
+        Node* startNode,
+        Node** stopNode,
+        bool* consumed);
 
     // Performs a chaining logical scroll, within a *single* frame, starting
     // from either a provided starting node or a default based on the focused or
     // most recently clicked node, falling back to the frame.
     // Returns true if the scroll was consumed.
     // direction - The logical direction to scroll in. This will be converted to
     //             a physical direction for each LayoutBox we try to scroll
     //             based on that box's writing mode.
     // granularity - The units that the  scroll delta parameter is in.
     // startNode - Optional. If provided, start chaining from the given node.
     //             If not, use the current focus or last clicked node.
     bool logicalScroll(ScrollDirection, ScrollGranularity, Node* startNode = nullptr);
 
     void resetOverscroll(bool didScrollX, bool didScrollY);
-    void handleOverscroll(const ScrollResult&, const FloatPoint& position = FloatPoint(), const FloatSize& velocity = FloatSize());
 
+    ScrollResult scrollBox(
+        LayoutBox*,
+        ScrollGranularity,
+        const FloatSize& delta,
+        const FloatPoint& position,
+        const FloatSize& velocity,
+        bool* wasRootScroller);
+
+    bool isRootScroller(const Node&) const;
     void customizedScroll(const Node& startNode, ScrollState&);
 
     HitTestResult hitTestResultInFrame(LocalFrame*, const LayoutPoint&, HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active);
 
     void invalidateClick();
 
     Node* updateMouseEventTargetNode(Node*, const PlatformMouseEvent&);
     void updateMouseEventTargetNodeAndSendEvents(Node*, const PlatformMouseEvent&, bool isFrameBoundaryTransition = false);
 
 
@@ skipping 166 matching lines @@
     // scroll which shouldn't propagate can't cause any element to
     // scroll other than the |m_previousGestureScrolledNode|.
     bool m_deltaConsumedForScrollSequence;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::EventHandler::TouchInfo);
 
 #endif // EventHandler_h