ec3dd6e0766537b53ac3a475e968b11697eca77f
[WebKit-https.git] / Source / WebCore / page / scrolling / ScrollingTree.h
1 /*
2  * Copyright (C) 2012-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #if ENABLE(ASYNC_SCROLLING)
29
30 #include "PlatformWheelEvent.h"
31 #include "Region.h"
32 #include "ScrollingCoordinator.h"
33 #include "TouchAction.h"
34 #include "WheelEventTestTrigger.h"
35 #include <wtf/HashMap.h>
36 #include <wtf/Lock.h>
37 #include <wtf/ThreadSafeRefCounted.h>
38 #include <wtf/TypeCasts.h>
39
40 namespace WebCore {
41
42 class IntPoint;
43 class ScrollingStateTree;
44 class ScrollingStateNode;
45 class ScrollingTreeNode;
46 class ScrollingTreeScrollingNode;
47
48 class ScrollingTree : public ThreadSafeRefCounted<ScrollingTree> {
49 public:
50     WEBCORE_EXPORT ScrollingTree();
51     WEBCORE_EXPORT virtual ~ScrollingTree();
52
53     enum EventResult {
54         DidNotHandleEvent,
55         DidHandleEvent,
56         SendToMainThread
57     };
58     
59     virtual bool isThreadedScrollingTree() const { return false; }
60     virtual bool isRemoteScrollingTree() const { return false; }
61     virtual bool isScrollingTreeIOS() const { return false; }
62
63     bool visualViewportEnabled() const { return m_visualViewportEnabled; }
64
65     virtual EventResult tryToHandleWheelEvent(const PlatformWheelEvent&) = 0;
66     WEBCORE_EXPORT bool shouldHandleWheelEventSynchronously(const PlatformWheelEvent&);
67     
68     void setMainFrameIsRubberBanding(bool);
69     bool isRubberBandInProgress();
70     void setMainFrameIsScrollSnapping(bool);
71     bool isScrollSnapInProgress();
72
73     virtual void invalidate() { }
74     WEBCORE_EXPORT virtual void commitTreeState(std::unique_ptr<ScrollingStateTree>);
75
76     void setMainFramePinState(bool pinnedToTheLeft, bool pinnedToTheRight, bool pinnedToTheTop, bool pinnedToTheBottom);
77
78     virtual Ref<ScrollingTreeNode> createScrollingTreeNode(ScrollingNodeType, ScrollingNodeID) = 0;
79
80     // Called after a scrolling tree node has handled a scroll and updated its layers.
81     // Updates FrameView/RenderLayer scrolling state and GraphicsLayers.
82     virtual void scrollingTreeNodeDidScroll(ScrollingNodeID, const FloatPoint& scrollPosition, const Optional<FloatPoint>& layoutViewportOrigin, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync) = 0;
83
84     // Called for requested scroll position updates.
85     virtual void scrollingTreeNodeRequestsScroll(ScrollingNodeID, const FloatPoint& /*scrollPosition*/, bool /*representsProgrammaticScroll*/) { }
86
87     // Delegated scrolling/zooming has caused the viewport to change, so update viewport-constrained layers
88     // (but don't cause scroll events to be fired).
89     WEBCORE_EXPORT virtual void viewportChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatRect& fixedPositionRect, double scale);
90
91     // Delegated scrolling has scrolled a node. Update layer positions on descendant tree nodes,
92     // and call scrollingTreeNodeDidScroll().
93     WEBCORE_EXPORT virtual void scrollPositionChangedViaDelegatedScrolling(ScrollingNodeID, const WebCore::FloatPoint& scrollPosition, bool inUserInteraction);
94
95     virtual void reportSynchronousScrollingReasonsChanged(MonotonicTime, SynchronousScrollingReasons) { }
96     virtual void reportExposedUnfilledArea(MonotonicTime, unsigned /* unfilledArea */) { }
97
98     FloatPoint mainFrameScrollPosition();
99     
100 #if PLATFORM(IOS_FAMILY)
101     virtual FloatRect fixedPositionRect() = 0;
102     virtual void scrollingTreeNodeWillStartPanGesture() { }
103     virtual void scrollingTreeNodeWillStartScroll() { }
104     virtual void scrollingTreeNodeDidEndScroll() { }
105 #endif
106
107     WEBCORE_EXPORT TrackingType eventTrackingTypeForPoint(const AtomicString& eventName, IntPoint);
108 #if ENABLE(POINTER_EVENTS)
109     WEBCORE_EXPORT Optional<TouchActionData> touchActionDataAtPoint(IntPoint) const;
110 #endif
111
112 #if PLATFORM(MAC)
113     virtual void handleWheelEventPhase(PlatformWheelEventPhase) = 0;
114     virtual void setActiveScrollSnapIndices(ScrollingNodeID, unsigned /*horizontalIndex*/, unsigned /*verticalIndex*/) { }
115     virtual void deferTestsForReason(WheelEventTestTrigger::ScrollableAreaIdentifier, WheelEventTestTrigger::DeferTestTriggerReason) { }
116     virtual void removeTestDeferralForReason(WheelEventTestTrigger::ScrollableAreaIdentifier, WheelEventTestTrigger::DeferTestTriggerReason) { }
117 #endif
118
119 #if PLATFORM(COCOA)
120     WEBCORE_EXPORT virtual void currentSnapPointIndicesDidChange(ScrollingNodeID, unsigned horizontal, unsigned vertical) = 0;
121 #endif
122
123     // Can be called from any thread. Will update what edges allow rubber-banding.
124     WEBCORE_EXPORT void setCanRubberBandState(bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom);
125
126     bool rubberBandsAtLeft();
127     bool rubberBandsAtRight();
128     bool rubberBandsAtTop();
129     bool rubberBandsAtBottom();
130     bool isHandlingProgrammaticScroll();
131     
132     void setScrollPinningBehavior(ScrollPinningBehavior);
133     ScrollPinningBehavior scrollPinningBehavior();
134
135     WEBCORE_EXPORT bool willWheelEventStartSwipeGesture(const PlatformWheelEvent&);
136
137     WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool flag);
138     bool scrollingPerformanceLoggingEnabled();
139
140     ScrollingTreeNode* rootNode() const { return m_rootNode.get(); }
141
142     ScrollingNodeID latchedNode();
143     void setLatchedNode(ScrollingNodeID);
144     void clearLatchedNode();
145
146     bool hasLatchedNode() const { return m_latchedNodeID; }
147     void setOrClearLatchedNode(const PlatformWheelEvent&, ScrollingNodeID);
148
149     bool hasFixedOrSticky() const { return !!m_fixedOrStickyNodeCount; }
150     void fixedOrStickyNodeAdded() { ++m_fixedOrStickyNodeCount; }
151     void fixedOrStickyNodeRemoved()
152     {
153         ASSERT(m_fixedOrStickyNodeCount);
154         --m_fixedOrStickyNodeCount;
155     }
156     
157     WEBCORE_EXPORT String scrollingTreeAsText();
158     
159 protected:
160     void setMainFrameScrollPosition(FloatPoint);
161     void setVisualViewportEnabled(bool b) { m_visualViewportEnabled = b; }
162
163     WEBCORE_EXPORT virtual void handleWheelEvent(const PlatformWheelEvent&);
164
165 private:
166     using OrphanScrollingNodeMap = HashMap<ScrollingNodeID, RefPtr<ScrollingTreeNode>>;
167     void updateTreeFromStateNode(const ScrollingStateNode*, OrphanScrollingNodeMap&, HashSet<ScrollingNodeID>& unvisitedNodes);
168
169     ScrollingTreeNode* nodeForID(ScrollingNodeID) const;
170
171     RefPtr<ScrollingTreeNode> m_rootNode;
172
173     using ScrollingTreeNodeMap = HashMap<ScrollingNodeID, ScrollingTreeNode*>;
174     ScrollingTreeNodeMap m_nodeMap;
175
176     Lock m_mutex;
177     EventTrackingRegions m_eventTrackingRegions;
178     FloatPoint m_mainFrameScrollPosition;
179
180     Lock m_swipeStateMutex;
181     ScrollPinningBehavior m_scrollPinningBehavior { DoNotPin };
182     ScrollingNodeID m_latchedNodeID { 0 };
183
184     unsigned m_fixedOrStickyNodeCount { 0 };
185
186     bool m_rubberBandsAtLeft { true };
187     bool m_rubberBandsAtRight { true };
188     bool m_rubberBandsAtTop { true };
189     bool m_rubberBandsAtBottom { true };
190     bool m_mainFramePinnedToTheLeft { true };
191     bool m_mainFramePinnedToTheRight { true };
192     bool m_mainFramePinnedToTheTop { true };
193     bool m_mainFramePinnedToTheBottom { true };
194     bool m_mainFrameIsRubberBanding { false };
195     bool m_mainFrameIsScrollSnapping { false };
196     bool m_scrollingPerformanceLoggingEnabled { false };
197     bool m_isHandlingProgrammaticScroll { false };
198     bool m_visualViewportEnabled { false };
199 };
200     
201 } // namespace WebCore
202
203 #define SPECIALIZE_TYPE_TRAITS_SCROLLING_TREE(ToValueTypeName, predicate) \
204 SPECIALIZE_TYPE_TRAITS_BEGIN(ToValueTypeName) \
205     static bool isType(const WebCore::ScrollingTree& tree) { return tree.predicate; } \
206 SPECIALIZE_TYPE_TRAITS_END()
207 #endif // ENABLE(ASYNC_SCROLLING)