[iOS WK2] REGRESSION (r242687): Programmatic scroll of overflow scroll results in...
[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     virtual bool isThreadedScrollingTree() const { return false; }
54     virtual bool isRemoteScrollingTree() const { return false; }
55     virtual bool isScrollingTreeIOS() const { return false; }
56
57     // This implies that we'll do hit-testing in the scrolling tree.
58     bool asyncFrameOrOverflowScrollingEnabled() const { return m_asyncFrameOrOverflowScrollingEnabled; }
59     void setAsyncFrameOrOverflowScrollingEnabled(bool);
60
61     virtual ScrollingEventResult tryToHandleWheelEvent(const PlatformWheelEvent&) = 0;
62     WEBCORE_EXPORT bool shouldHandleWheelEventSynchronously(const PlatformWheelEvent&);
63     
64     void setMainFrameIsRubberBanding(bool);
65     bool isRubberBandInProgress();
66     void setMainFrameIsScrollSnapping(bool);
67     bool isScrollSnapInProgress();
68
69     virtual void invalidate() { }
70     WEBCORE_EXPORT virtual void commitTreeState(std::unique_ptr<ScrollingStateTree>);
71     
72     WEBCORE_EXPORT virtual void applyLayerPositions();
73
74     virtual Ref<ScrollingTreeNode> createScrollingTreeNode(ScrollingNodeType, ScrollingNodeID) = 0;
75     
76     WEBCORE_EXPORT ScrollingTreeNode* nodeForID(ScrollingNodeID) const;
77
78     // Called after a scrolling tree node has handled a scroll and updated its layers.
79     // Updates FrameView/RenderLayer scrolling state and GraphicsLayers.
80     virtual void scrollingTreeNodeDidScroll(ScrollingTreeScrollingNode&, ScrollingLayerPositionAction = ScrollingLayerPositionAction::Sync) = 0;
81
82     // Called for requested scroll position updates.
83     virtual void scrollingTreeNodeRequestsScroll(ScrollingNodeID, const FloatPoint& /*scrollPosition*/, bool /*representsProgrammaticScroll*/) { }
84
85     // Delegated scrolling/zooming has caused the viewport to change, so update viewport-constrained layers
86     // (but don't cause scroll events to be fired).
87     WEBCORE_EXPORT virtual void mainFrameViewportChangedViaDelegatedScrolling(const FloatPoint& scrollPosition, const WebCore::FloatRect& layoutViewport, double scale);
88
89     void notifyRelatedNodesAfterScrollPositionChange(ScrollingTreeScrollingNode& changedNode);
90
91     virtual void reportSynchronousScrollingReasonsChanged(MonotonicTime, SynchronousScrollingReasons) { }
92     virtual void reportExposedUnfilledArea(MonotonicTime, unsigned /* unfilledArea */) { }
93
94 #if PLATFORM(IOS_FAMILY)
95     virtual void scrollingTreeNodeWillStartPanGesture() { }
96     virtual void scrollingTreeNodeWillStartScroll() { }
97     virtual void scrollingTreeNodeDidEndScroll() { }
98 #endif
99
100     WEBCORE_EXPORT TrackingType eventTrackingTypeForPoint(const AtomicString& eventName, IntPoint);
101 #if ENABLE(POINTER_EVENTS)
102     WEBCORE_EXPORT Optional<TouchActionData> touchActionDataAtPoint(IntPoint) const;
103 #endif
104
105 #if PLATFORM(MAC)
106     virtual void handleWheelEventPhase(PlatformWheelEventPhase) = 0;
107     virtual void setActiveScrollSnapIndices(ScrollingNodeID, unsigned /*horizontalIndex*/, unsigned /*verticalIndex*/) { }
108     virtual void deferTestsForReason(WheelEventTestTrigger::ScrollableAreaIdentifier, WheelEventTestTrigger::DeferTestTriggerReason) { }
109     virtual void removeTestDeferralForReason(WheelEventTestTrigger::ScrollableAreaIdentifier, WheelEventTestTrigger::DeferTestTriggerReason) { }
110 #endif
111
112 #if PLATFORM(COCOA)
113     WEBCORE_EXPORT virtual void currentSnapPointIndicesDidChange(ScrollingNodeID, unsigned horizontal, unsigned vertical) = 0;
114 #endif
115
116     void setMainFramePinState(bool pinnedToTheLeft, bool pinnedToTheRight, bool pinnedToTheTop, bool pinnedToTheBottom);
117
118     // Can be called from any thread. Will update what edges allow rubber-banding.
119     WEBCORE_EXPORT void setCanRubberBandState(bool canRubberBandAtLeft, bool canRubberBandAtRight, bool canRubberBandAtTop, bool canRubberBandAtBottom);
120
121     bool isHandlingProgrammaticScroll() const { return m_isHandlingProgrammaticScroll; }
122     void setIsHandlingProgrammaticScroll(bool isHandlingProgrammaticScroll) { m_isHandlingProgrammaticScroll = isHandlingProgrammaticScroll; }
123     
124     void setScrollPinningBehavior(ScrollPinningBehavior);
125     WEBCORE_EXPORT ScrollPinningBehavior scrollPinningBehavior();
126
127     WEBCORE_EXPORT bool willWheelEventStartSwipeGesture(const PlatformWheelEvent&);
128
129     WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool flag);
130     bool scrollingPerformanceLoggingEnabled();
131
132     ScrollingTreeNode* rootNode() const { return m_rootNode.get(); }
133
134     ScrollingNodeID latchedNode();
135     void setLatchedNode(ScrollingNodeID);
136     void clearLatchedNode();
137
138     bool hasLatchedNode() const { return m_treeState.latchedNodeID; }
139     void setOrClearLatchedNode(const PlatformWheelEvent&, ScrollingNodeID);
140
141     bool hasFixedOrSticky() const { return !!m_fixedOrStickyNodeCount; }
142     void fixedOrStickyNodeAdded() { ++m_fixedOrStickyNodeCount; }
143     void fixedOrStickyNodeRemoved()
144     {
145         ASSERT(m_fixedOrStickyNodeCount);
146         --m_fixedOrStickyNodeCount;
147     }
148
149     // A map of overflow scrolling nodes to positioned nodes which need to be updated
150     // when the scroller changes, but are not descendants.
151     using RelatedNodesMap = HashMap<ScrollingNodeID, Vector<ScrollingNodeID>>;
152     RelatedNodesMap& overflowRelatedNodes() { return m_overflowRelatedNodesMap; }
153
154     HashSet<ScrollingNodeID>& positionedNodesWithRelatedOverflow() { return m_positionedNodesWithRelatedOverflow; }
155
156     WEBCORE_EXPORT String scrollingTreeAsText(ScrollingStateTreeAsTextBehavior = ScrollingStateTreeAsTextBehaviorNormal);
157
158 protected:
159     void setMainFrameScrollPosition(FloatPoint);
160
161     WEBCORE_EXPORT virtual ScrollingEventResult handleWheelEvent(const PlatformWheelEvent&);
162
163 private:
164     using OrphanScrollingNodeMap = HashMap<ScrollingNodeID, RefPtr<ScrollingTreeNode>>;
165     void updateTreeFromStateNode(const ScrollingStateNode*, OrphanScrollingNodeMap&, HashSet<ScrollingNodeID>& unvisitedNodes);
166
167     void applyLayerPositionsRecursive(ScrollingTreeNode&, FloatRect layoutViewport, FloatSize cumulativeDelta);
168
169     void notifyRelatedNodesRecursive(ScrollingTreeScrollingNode& changedNode, ScrollingTreeNode& currNode, const FloatRect& layoutViewport, FloatSize cumulativeDelta);
170
171     Lock m_treeMutex; // Protects the scrolling tree.
172
173     RefPtr<ScrollingTreeNode> m_rootNode;
174
175     using ScrollingTreeNodeMap = HashMap<ScrollingNodeID, ScrollingTreeNode*>;
176     ScrollingTreeNodeMap m_nodeMap;
177
178     RelatedNodesMap m_overflowRelatedNodesMap;
179     HashSet<ScrollingNodeID> m_positionedNodesWithRelatedOverflow;
180
181     struct TreeState {
182         ScrollingNodeID latchedNodeID { 0 };
183         EventTrackingRegions eventTrackingRegions;
184         FloatPoint mainFrameScrollPosition;
185         bool mainFrameIsRubberBanding { false };
186         bool mainFrameIsScrollSnapping { false };
187     };
188     
189     Lock m_treeStateMutex;
190     TreeState m_treeState;
191
192     struct SwipeState {
193         ScrollPinningBehavior scrollPinningBehavior { DoNotPin };
194         bool rubberBandsAtLeft { true };
195         bool rubberBandsAtRight { true };
196         bool rubberBandsAtTop { true };
197         bool rubberBandsAtBottom { true };
198         bool mainFramePinnedToTheLeft { true };
199         bool mainFramePinnedToTheRight { true };
200         bool mainFramePinnedToTheTop { true };
201         bool mainFramePinnedToTheBottom { true };
202     };
203
204     Lock m_swipeStateMutex;
205     SwipeState m_swipeState;
206
207     unsigned m_fixedOrStickyNodeCount { 0 };
208     bool m_isHandlingProgrammaticScroll { false };
209     bool m_scrollingPerformanceLoggingEnabled { false };
210     bool m_asyncFrameOrOverflowScrollingEnabled { false };
211 };
212     
213 } // namespace WebCore
214
215 #define SPECIALIZE_TYPE_TRAITS_SCROLLING_TREE(ToValueTypeName, predicate) \
216 SPECIALIZE_TYPE_TRAITS_BEGIN(ToValueTypeName) \
217     static bool isType(const WebCore::ScrollingTree& tree) { return tree.predicate; } \
218 SPECIALIZE_TYPE_TRAITS_END()
219 #endif // ENABLE(ASYNC_SCROLLING)