Add ScrollManager class

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 11 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef EventHandler_h
 #define EventHandler_h
 
 #include "core/CoreExport.h"
 #include "core/events/TextEventInputType.h"
 #include "core/input/PointerEventManager.h"
+#include "core/input/ScrollManager.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/page/DragActions.h"
 #include "core/page/EventWithHitTestResults.h"
 #include "core/style/ComputedStyleConstants.h"
 #include "platform/Cursor.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformTouchPoint.h"
 #include "platform/Timer.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/heap/Handle.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "public/platform/WebFocusType.h"
 #include "public/platform/WebInputEventResult.h"
 #include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashTraits.h"
 #include "wtf/RefPtr.h"
-#include <deque>
 
 namespace blink {
 
-class AutoscrollController;
 class DataTransfer;
 class PaintLayer;
-class PaintLayerScrollableArea;
 class Document;
 class DragState;
 class Element;
 class Event;
 class EventTarget;
 template <typename EventType>
 class EventWithHitTestResults;
 class FloatPoint;
 class FloatQuad;
 class FrameHost;
 class HTMLFrameSetElement;
 class HitTestRequest;
 class HitTestResult;
 class KeyboardEvent;
 class LayoutObject;
 class LocalFrame;
 class Node;
 class OptionalCursor;
 class PlatformGestureEvent;
 class PlatformKeyboardEvent;
 class PlatformTouchEvent;
 class PlatformWheelEvent;
 class ScrollableArea;
 class Scrollbar;
-class ScrollState;
 class SelectionController;
 class TextEvent;
 class WheelEvent;
 class Widget;
 
 enum class DragInitiator;
 
 class CORE_EXPORT EventHandler final : public GarbageCollectedFinalized<EventHandler> {
 
     WTF_MAKE_NONCOPYABLE(EventHandler);
@@ skipping 135 matching lines @@
     WebInputEventResult handleMousePressEvent(const MouseEventWithHitTestResults&);
     WebInputEventResult handleMouseFocus(const MouseEventWithHitTestResults&, InputDeviceCapabilities* sourceCapabilities);
     WebInputEventResult handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
     WebInputEventResult handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 
     HitTestRequest::HitTestRequestType getHitTypeForGestureType(PlatformEvent::EventType);
     void applyTouchAdjustment(PlatformGestureEvent*, HitTestResult*);
     WebInputEventResult handleGestureTap(const GestureEventWithHitTestResults&);
     WebInputEventResult handleGestureLongPress(const GestureEventWithHitTestResults&);
     WebInputEventResult handleGestureLongTap(const GestureEventWithHitTestResults&);
-    WebInputEventResult handleGestureScrollUpdate(const PlatformGestureEvent&);
-    WebInputEventResult handleGestureScrollBegin(const PlatformGestureEvent&);
-    void clearGestureScrollState();
 
     void updateGestureTargetNodeForMouseEvent(const GestureEventWithHitTestResults&);
 
     bool shouldApplyTouchAdjustment(const PlatformGestureEvent&) const;
 
     OptionalCursor selectCursor(const HitTestResult&);
     OptionalCursor selectAutoCursor(const HitTestResult&, Node*, const Cursor& iBeam);
 
     void hoverTimerFired(Timer<EventHandler>*);
     void cursorUpdateTimerFired(Timer<EventHandler>*);
     void activeIntervalTimerFired(Timer<EventHandler>*);
 
     void fakeMouseMoveEventTimerFired(Timer<EventHandler>*);
     void cancelFakeMouseMoveEvent();
     bool isCursorVisible() const;
     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,
-        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);
-
-    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&);
-
     void invalidateClick();
 
     Node* updateMouseEventTargetNode(Node*, const PlatformMouseEvent&);
     void updateMouseEventTargetNodeAndSendEvents(Node*, const PlatformMouseEvent&, bool isFrameBoundaryTransition = false);
 
 
     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
 
     WebInputEventResult dispatchMouseEvent(const AtomicString& eventType, Node* target, int clickCount, const PlatformMouseEvent&);
 
@@ skipping 24 matching lines @@
     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&);
 
     void defaultSpaceEventHandler(KeyboardEvent*);
     void defaultBackspaceEventHandler(KeyboardEvent*);
     void defaultTabEventHandler(KeyboardEvent*);
     void defaultEscapeEventHandler(KeyboardEvent*);
     void defaultArrowEventHandler(WebFocusType, KeyboardEvent*);
 
     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
 
-    void setFrameWasScrolledByUser();
-
     bool capturesDragging() const { return m_capturesDragging; }
 
     WebInputEventResult handleGestureShowPress();
 
-    bool handleScrollGestureOnResizer(Node*, const PlatformGestureEvent&);
-
-    WebInputEventResult passScrollGestureEventToWidget(const PlatformGestureEvent&, LayoutObject*);
-
-    AutoscrollController* autoscrollController() const;
-    bool panScrollInProgress() const;
     void setLastKnownMousePosition(const PlatformMouseEvent&);
 
     bool shouldTopControlsConsumeScroll(FloatSize) const;
 
     // If the given element is a shadow host and its root has delegatesFocus=false flag,
     // slide focus to its inner element. Returns true if the resulting focus is different from
     // the given element.
     bool slideFocusOnShadowHostIfNecessary(const Element&);
 
     FrameHost* frameHost() const;
@@ skipping 20 matching lines @@
     // TODO(rbyers): Mouse cursor update is page-wide, not per-frame.  Page-wide state
     // should move out of EventHandler to a new PageEventHandler class. crbug.com/449649
     Timer<EventHandler> m_cursorUpdateTimer;
 
     bool m_mouseDownMayStartAutoscroll;
 
     Timer<EventHandler> m_fakeMouseMoveEventTimer;
 
     bool m_svgPan;
 
-    Member<PaintLayerScrollableArea> m_resizeScrollableArea;
-
     Member<Node> m_capturingMouseEventsNode;
     bool m_eventHandlerWillResetCapturingMouseEventsNode;
 
     // Note the difference of this and m_nodeUnderPointer in PointerEventManager
     Member<Node> m_nodeUnderMouse;
 
     Member<LocalFrame> m_lastMouseMoveEventSubframe;
     Member<Scrollbar> m_lastScrollbarUnderMouse;
 
     int m_clickCount;
     Member<Node> m_clickNode;
 
     Member<Node> m_dragTarget;
     bool m_shouldOnlyFireDragOverEvent;
 
     Member<HTMLFrameSetElement> m_frameSetBeingResized;
 
-    LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeScrollableArea.
-
     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;
 
     PointerEventManager m_pointerEventManager;
-
-    Member<Node> m_scrollGestureHandlingNode;
-    bool m_lastGestureScrollOverWidget;
-    // The most recent element to scroll natively during this scroll
-    // sequence. Null if no native element has scrolled this scroll
-    // sequence, or if the most recent element to scroll used scroll
-    // customization.
-    Member<Node> m_previousGestureScrolledNode;
-    Member<Scrollbar> m_scrollbarHandlingScrollGesture;
+    ScrollManager m_scrollManager;
 
     double m_maxMouseMovedDuration;
 
     bool m_longTapShouldInvokeContextMenu;
 
     Timer<EventHandler> m_activeIntervalTimer;
     double m_lastShowPressTimestamp;
     Member<Element> m_lastDeferredTapElement;
-
-    // Only used with the ScrollCustomization runtime enabled feature.
-    std::deque<int> m_currentScrollChain;
-    // True iff some of the delta has been consumed for the current
-    // 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