[chromium] Convert screen space scroll gestures to layer space
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCLayerTreeHostImpl.h
1 /*
2  * Copyright (C) 2011 Google 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'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #ifndef CCLayerTreeHostImpl_h
26 #define CCLayerTreeHostImpl_h
27
28 #include "CCAnimationEvents.h"
29 #include "CCInputHandler.h"
30 #include "CCLayerSorter.h"
31 #include "CCRenderPass.h"
32 #include "CCRenderer.h"
33 #include "SkColor.h"
34 #include <public/WebCompositorOutputSurfaceClient.h>
35 #include <wtf/PassOwnPtr.h>
36 #include <wtf/RefPtr.h>
37
38 namespace WebCore {
39
40 class CCActiveGestureAnimation;
41 class CCCompletionEvent;
42 class CCDebugRectHistory;
43 class CCFrameRateCounter;
44 class CCLayerImpl;
45 class CCLayerTreeHostImplTimeSourceAdapter;
46 class CCPageScaleAnimation;
47 class CCRenderPassDrawQuad;
48 class CCResourceProvider;
49 class LayerRendererChromium;
50 struct LayerRendererCapabilities;
51 struct CCRenderingStats;
52
53 // CCLayerTreeHost->CCProxy callback interface.
54 class CCLayerTreeHostImplClient {
55 public:
56     virtual void didLoseContextOnImplThread() = 0;
57     virtual void onSwapBuffersCompleteOnImplThread() = 0;
58     virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) = 0;
59     virtual void setNeedsRedrawOnImplThread() = 0;
60     virtual void setNeedsCommitOnImplThread() = 0;
61     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;
62 };
63
64 // CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state
65 class CCLayerTreeHostImpl : public CCInputHandlerClient,
66                             public CCRendererClient,
67                             public WebKit::WebCompositorOutputSurfaceClient {
68     WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImpl);
69     typedef Vector<CCLayerImpl*> CCLayerList;
70
71 public:
72     static PassOwnPtr<CCLayerTreeHostImpl> create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
73     virtual ~CCLayerTreeHostImpl();
74
75     // CCInputHandlerClient implementation
76     virtual CCInputHandlerClient::ScrollStatus scrollBegin(const IntPoint&, CCInputHandlerClient::ScrollInputType) OVERRIDE;
77     virtual void scrollBy(const IntPoint&, const IntSize&) OVERRIDE;
78     virtual void scrollEnd() OVERRIDE;
79     virtual void pinchGestureBegin() OVERRIDE;
80     virtual void pinchGestureUpdate(float, const IntPoint&) OVERRIDE;
81     virtual void pinchGestureEnd() OVERRIDE;
82     virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) OVERRIDE;
83     virtual CCActiveGestureAnimation* activeGestureAnimation() OVERRIDE { return m_activeGestureAnimation.get(); }
84     // To clear an active animation, pass nullptr.
85     virtual void setActiveGestureAnimation(PassOwnPtr<CCActiveGestureAnimation>) OVERRIDE;
86     virtual void scheduleAnimation() OVERRIDE;
87
88     struct FrameData {
89         Vector<IntRect> occludingScreenSpaceRects;
90         CCRenderPassList renderPasses;
91         CCRenderPassIdHashMap renderPassesById;
92         CCLayerList* renderSurfaceLayerList;
93         CCLayerList willDrawLayers;
94     };
95
96     // Virtual for testing.
97     virtual void beginCommit();
98     virtual void commitComplete();
99     virtual void animate(double monotonicTime, double wallClockTime);
100
101     // Returns false if problems occured preparing the frame, and we should try
102     // to avoid displaying the frame. If prepareToDraw is called,
103     // didDrawAllLayers must also be called, regardless of whether drawLayers is
104     // called between the two.
105     virtual bool prepareToDraw(FrameData&);
106     virtual void drawLayers(const FrameData&);
107     // Must be called if and only if prepareToDraw was called.
108     void didDrawAllLayers(const FrameData&);
109
110     // CCRendererClient implementation
111     virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_deviceViewportSize; }
112     virtual const CCLayerTreeSettings& settings() const OVERRIDE { return m_settings; }
113     virtual void didLoseContext() OVERRIDE;
114     virtual void onSwapBuffersComplete() OVERRIDE;
115     virtual void setFullRootLayerDamage() OVERRIDE;
116     virtual void releaseContentsTextures() OVERRIDE;
117     virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE;
118
119     // WebCompositorOutputSurfaceClient implementation.
120     virtual void onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds) OVERRIDE;
121
122     // Implementation
123     bool canDraw();
124     CCGraphicsContext* context() const;
125
126     String layerTreeAsText() const;
127
128     void finishAllRendering();
129     int sourceAnimationFrameNumber() const;
130
131     bool initializeLayerRenderer(PassOwnPtr<CCGraphicsContext>, TextureUploaderOption);
132     bool isContextLost();
133     CCRenderer* layerRenderer() { return m_layerRenderer.get(); }
134     const LayerRendererCapabilities& layerRendererCapabilities() const;
135
136     bool swapBuffers();
137
138     void readback(void* pixels, const IntRect&);
139
140     void setRootLayer(PassOwnPtr<CCLayerImpl>);
141     CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); }
142
143     // Release ownership of the current layer tree and replace it with an empty
144     // tree. Returns the root layer of the detached tree.
145     PassOwnPtr<CCLayerImpl> detachLayerTree();
146
147     CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; }
148
149     bool visible() const { return m_visible; }
150     void setVisible(bool);
151
152     int sourceFrameNumber() const { return m_sourceFrameNumber; }
153     void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
154
155     bool contentsTexturesPurged() const { return m_contentsTexturesPurged; }
156     void resetContentsTexturesPurged() { m_contentsTexturesPurged = false; }
157     size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
158
159     void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize);
160     const IntSize& layoutViewportSize() const { return m_layoutViewportSize; }
161
162     float deviceScaleFactor() const { return m_deviceScaleFactor; }
163     void setDeviceScaleFactor(float);
164
165     float pageScale() const { return m_pageScale; }
166     void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
167
168     PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
169
170     void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec);
171
172     SkColor backgroundColor() const { return m_backgroundColor; }
173     void setBackgroundColor(SkColor color) { m_backgroundColor = color; }
174
175     bool hasTransparentBackground() const { return m_hasTransparentBackground; }
176     void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
177
178     bool needsAnimateLayers() const { return m_needsAnimateLayers; }
179     void setNeedsAnimateLayers() { m_needsAnimateLayers = true; }
180
181     void setNeedsRedraw();
182
183     void renderingStats(CCRenderingStats&) const;
184
185     CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
186     CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
187     CCResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
188
189     class CullRenderPassesWithCachedTextures {
190     public:
191         bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const;
192
193         // Iterates from the root first, in order to remove the surfaces closest
194         // to the root with cached textures, and all surfaces that draw into
195         // them.
196         size_t renderPassListBegin(const CCRenderPassList& list) const { return list.size() - 1; }
197         size_t renderPassListEnd(const CCRenderPassList&) const { return 0 - 1; }
198         size_t renderPassListNext(size_t it) const { return it - 1; }
199
200         CullRenderPassesWithCachedTextures(CCRenderer& renderer) : m_renderer(renderer) { }
201     private:
202         CCRenderer& m_renderer;
203     };
204
205     class CullRenderPassesWithNoQuads {
206     public:
207         bool shouldRemoveRenderPass(const CCRenderPassDrawQuad&, const FrameData&) const;
208
209         // Iterates in draw order, so that when a surface is removed, and its
210         // target becomes empty, then its target can be removed also.
211         size_t renderPassListBegin(const CCRenderPassList&) const { return 0; }
212         size_t renderPassListEnd(const CCRenderPassList& list) const { return list.size(); }
213         size_t renderPassListNext(size_t it) const { return it + 1; }
214     };
215
216     template<typename RenderPassCuller>
217     static void removeRenderPasses(RenderPassCuller, FrameData&);
218
219 protected:
220     CCLayerTreeHostImpl(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
221
222     void animatePageScale(double monotonicTime);
223     void animateGestures(double monotonicTime);
224     void animateScrollbars(double monotonicTime);
225
226     // Exposed for testing.
227     void calculateRenderSurfaceLayerList(CCLayerList&);
228
229     // Virtual for testing.
230     virtual void animateLayers(double monotonicTime, double wallClockTime);
231
232     // Virtual for testing. Measured in seconds.
233     virtual double lowFrequencyAnimationInterval() const;
234
235     CCLayerTreeHostImplClient* m_client;
236     int m_sourceFrameNumber;
237
238 private:
239     void computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo);
240     void computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo);
241     void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
242
243     void setPageScaleDelta(float);
244     void updateMaxScrollPosition();
245     void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
246
247     // Returns false if the frame should not be displayed. This function should
248     // only be called from prepareToDraw, as didDrawAllLayers must be called
249     // if this helper function is called.
250     bool calculateRenderPasses(FrameData&);
251     void animateLayersRecursive(CCLayerImpl*, double monotonicTime, double wallClockTime, CCAnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers);
252     void setBackgroundTickingEnabled(bool);
253     IntSize contentSize() const;
254
255     void sendDidLoseContextRecursive(CCLayerImpl*);
256     void clearRenderSurfaces();
257     bool ensureRenderSurfaceLayerList();
258     void clearCurrentlyScrollingLayer();
259
260     void animateScrollbarsRecursive(CCLayerImpl*, double monotonicTime);
261
262     void dumpRenderSurfaces(TextStream&, int indent, const CCLayerImpl*) const;
263
264     OwnPtr<CCGraphicsContext> m_context;
265     OwnPtr<CCResourceProvider> m_resourceProvider;
266     OwnPtr<CCRenderer> m_layerRenderer;
267     OwnPtr<CCLayerImpl> m_rootLayerImpl;
268     CCLayerImpl* m_rootScrollLayerImpl;
269     CCLayerImpl* m_currentlyScrollingLayerImpl;
270     int m_scrollingLayerIdFromPreviousTree;
271     bool m_scrollDeltaIsInScreenSpace;
272     CCLayerTreeSettings m_settings;
273     IntSize m_layoutViewportSize;
274     IntSize m_deviceViewportSize;
275     float m_deviceScaleFactor;
276     bool m_visible;
277     bool m_contentsTexturesPurged;
278     size_t m_memoryAllocationLimitBytes;
279
280     float m_pageScale;
281     float m_pageScaleDelta;
282     float m_sentPageScaleDelta;
283     float m_minPageScale, m_maxPageScale;
284
285     SkColor m_backgroundColor;
286     bool m_hasTransparentBackground;
287
288     // If this is true, it is necessary to traverse the layer tree ticking the animators.
289     bool m_needsAnimateLayers;
290     bool m_pinchGestureActive;
291     IntPoint m_previousPinchAnchor;
292
293     OwnPtr<CCPageScaleAnimation> m_pageScaleAnimation;
294     OwnPtr<CCActiveGestureAnimation> m_activeGestureAnimation;
295
296     // This is used for ticking animations slowly when hidden.
297     OwnPtr<CCLayerTreeHostImplTimeSourceAdapter> m_timeSourceClientAdapter;
298
299     CCLayerSorter m_layerSorter;
300
301     // List of visible layers for the most recently prepared frame. Used for
302     // rendering and input event hit testing.
303     CCLayerList m_renderSurfaceLayerList;
304
305     OwnPtr<CCFrameRateCounter> m_fpsCounter;
306     OwnPtr<CCDebugRectHistory> m_debugRectHistory;
307 };
308
309 };
310
311 #endif