[chromium] LayerRendererChromium is not getting visibility messages in single threade...
[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 "Color.h"
29 #include "cc/CCAnimationEvents.h"
30 #include "cc/CCInputHandler.h"
31 #include "cc/CCLayerSorter.h"
32 #include "cc/CCRenderPass.h"
33 #include "cc/CCRenderer.h"
34 #include <wtf/PassOwnPtr.h>
35 #include <wtf/RefPtr.h>
36
37 namespace WebCore {
38
39 class CCActiveGestureAnimation;
40 class CCCompletionEvent;
41 class CCDebugRectHistory;
42 class CCFontAtlas;
43 class CCFrameRateCounter;
44 class CCHeadsUpDisplay;
45 class CCPageScaleAnimation;
46 class CCLayerImpl;
47 class CCLayerTreeHostImplTimeSourceAdapter;
48 class LayerRendererChromium;
49 class TextureAllocator;
50 struct LayerRendererCapabilities;
51
52 // CCLayerTreeHost->CCProxy callback interface.
53 class CCLayerTreeHostImplClient {
54 public:
55     virtual void didLoseContextOnImplThread() = 0;
56     virtual void onSwapBuffersCompleteOnImplThread() = 0;
57     virtual void setNeedsRedrawOnImplThread() = 0;
58     virtual void setNeedsCommitOnImplThread() = 0;
59     virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;
60 };
61
62 // CCLayerTreeHostImpl owns the CCLayerImpl tree as well as associated rendering state
63 class CCLayerTreeHostImpl : public CCInputHandlerClient, CCRendererClient {
64     WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImpl);
65     typedef Vector<CCLayerImpl*> CCLayerList;
66
67 public:
68     static PassOwnPtr<CCLayerTreeHostImpl> create(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
69     virtual ~CCLayerTreeHostImpl();
70
71     // CCInputHandlerClient implementation
72     virtual CCInputHandlerClient::ScrollStatus scrollBegin(const IntPoint&, CCInputHandlerClient::ScrollInputType);
73     virtual void scrollBy(const IntSize&);
74     virtual void scrollEnd();
75     virtual void pinchGestureBegin();
76     virtual void pinchGestureUpdate(float, const IntPoint&);
77     virtual void pinchGestureEnd();
78     virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration);
79     virtual CCActiveGestureAnimation* activeGestureAnimation() { return m_activeGestureAnimation.get(); }
80     // To clear an active animation, pass nullptr.
81     virtual void setActiveGestureAnimation(PassOwnPtr<CCActiveGestureAnimation>);
82     virtual void scheduleAnimation();
83
84     struct FrameData {
85         CCRenderPassList renderPasses;
86         CCRenderPassList skippedPasses;
87         CCLayerList* renderSurfaceLayerList;
88         CCLayerList willDrawLayers;
89     };
90
91     // Virtual for testing.
92     virtual void beginCommit();
93     virtual void commitComplete();
94     virtual void animate(double monotonicTime, double wallClockTime);
95
96     // Returns false if problems occured preparing the frame, and we should try
97     // to avoid displaying the frame. If prepareToDraw is called,
98     // didDrawAllLayers must also be called, regardless of whether drawLayers is
99     // called between the two.
100     virtual bool prepareToDraw(FrameData&);
101     virtual void drawLayers(const FrameData&);
102     // Must be called if and only if prepareToDraw was called.
103     void didDrawAllLayers(const FrameData&);
104
105     // CCRendererClient implementation
106     virtual const IntSize& deviceViewportSize() const OVERRIDE { return m_deviceViewportSize; }
107     virtual const CCLayerTreeSettings& settings() const OVERRIDE { return m_settings; }
108     virtual void didLoseContext() OVERRIDE;
109     virtual void onSwapBuffersComplete() OVERRIDE;
110     virtual void setFullRootLayerDamage() OVERRIDE;
111     virtual void releaseContentsTextures() OVERRIDE;
112     virtual void setMemoryAllocationLimitBytes(size_t) OVERRIDE;
113
114     // Implementation
115     bool canDraw();
116     CCGraphicsContext* context() const;
117
118     String layerTreeAsText() const;
119     void setFontAtlas(PassOwnPtr<CCFontAtlas>);
120
121     void finishAllRendering();
122     int frameNumber() const { return m_frameNumber; }
123
124     bool initializeLayerRenderer(PassRefPtr<CCGraphicsContext>, TextureUploaderOption);
125     bool isContextLost();
126     CCRenderer* layerRenderer() { return m_layerRenderer.get(); }
127     const LayerRendererCapabilities& layerRendererCapabilities() const;
128     TextureAllocator* contentsTextureAllocator() const;
129
130     bool swapBuffers();
131
132     void readback(void* pixels, const IntRect&);
133
134     void setRootLayer(PassOwnPtr<CCLayerImpl>);
135     CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); }
136
137     // Release ownership of the current layer tree and replace it with an empty
138     // tree. Returns the root layer of the detached tree.
139     PassOwnPtr<CCLayerImpl> detachLayerTree();
140
141     CCLayerImpl* rootScrollLayer() const { return m_rootScrollLayerImpl; }
142
143     bool visible() const { return m_visible; }
144     void setVisible(bool);
145
146     int sourceFrameNumber() const { return m_sourceFrameNumber; }
147     void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
148
149     bool contentsTexturesWerePurgedSinceLastCommit() const { return m_contentsTexturesWerePurgedSinceLastCommit; }
150     size_t memoryAllocationLimitBytes() const { return m_memoryAllocationLimitBytes; }
151
152     const IntSize& viewportSize() const { return m_viewportSize; }
153     void setViewportSize(const IntSize&);
154
155     float deviceScaleFactor() const { return m_deviceScaleFactor; }
156     void setDeviceScaleFactor(float);
157
158     float pageScale() const { return m_pageScale; }
159     void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
160
161     PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
162
163     void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec);
164
165     const Color& backgroundColor() const { return m_backgroundColor; }
166     void setBackgroundColor(const Color& color) { m_backgroundColor = color; }
167
168     bool hasTransparentBackground() const { return m_hasTransparentBackground; }
169     void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
170
171     bool needsAnimateLayers() const { return m_needsAnimateLayers; }
172     void setNeedsAnimateLayers() { m_needsAnimateLayers = true; }
173
174     void setNeedsRedraw();
175
176     CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
177     CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
178
179     // Removes all render passes for which we have cached textures, and which did not change their content.
180     static void removePassesWithCachedTextures(CCRenderPassList& passes, CCRenderPassList& skippedPasses);
181
182 protected:
183     CCLayerTreeHostImpl(const CCLayerTreeSettings&, CCLayerTreeHostImplClient*);
184
185     void animatePageScale(double monotonicTime);
186     void animateGestures(double monotonicTime);
187
188     // Exposed for testing.
189     void calculateRenderSurfaceLayerList(CCLayerList&);
190
191     // Virtual for testing.
192     virtual void animateLayers(double monotonicTime, double wallClockTime);
193
194     // Virtual for testing. Measured in seconds.
195     virtual double lowFrequencyAnimationInterval() const;
196
197     CCLayerTreeHostImplClient* m_client;
198     int m_sourceFrameNumber;
199     int m_frameNumber;
200
201 private:
202     void computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo);
203     void computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo);
204     void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
205
206     void setPageScaleDelta(float);
207     void updateMaxScrollPosition();
208     void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
209
210     // Returns false if the frame should not be displayed. This function should
211     // only be called from prepareToDraw, as didDrawAllLayers must be called
212     // if this helper function is called.
213     bool calculateRenderPasses(FrameData&);
214     void animateLayersRecursive(CCLayerImpl*, double monotonicTime, double wallClockTime, CCAnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers);
215     void setBackgroundTickingEnabled(bool);
216     IntSize contentSize() const;
217
218     static void removeRenderPassesRecursive(CCRenderPassList& passes, size_t bottomPass, const CCRenderPass* firstToRemove, CCRenderPassList& skippedPasses);
219
220     void sendDidLoseContextRecursive(CCLayerImpl*);
221     void clearRenderSurfaces();
222     bool ensureRenderSurfaceLayerList();
223     void clearCurrentlyScrollingLayer();
224
225     void dumpRenderSurfaces(TextStream&, int indent, const CCLayerImpl*) const;
226
227     RefPtr<CCGraphicsContext> m_context;
228     OwnPtr<CCRenderer> m_layerRenderer;
229     OwnPtr<CCLayerImpl> m_rootLayerImpl;
230     CCLayerImpl* m_rootScrollLayerImpl;
231     CCLayerImpl* m_currentlyScrollingLayerImpl;
232     int m_scrollingLayerIdFromPreviousTree;
233     CCLayerTreeSettings m_settings;
234     IntSize m_viewportSize;
235     IntSize m_deviceViewportSize;
236     float m_deviceScaleFactor;
237     bool m_visible;
238     bool m_contentsTexturesWerePurgedSinceLastCommit;
239     size_t m_memoryAllocationLimitBytes;
240
241     OwnPtr<CCHeadsUpDisplay> m_headsUpDisplay;
242
243     float m_pageScale;
244     float m_pageScaleDelta;
245     float m_sentPageScaleDelta;
246     float m_minPageScale, m_maxPageScale;
247
248     Color m_backgroundColor;
249     bool m_hasTransparentBackground;
250
251     // If this is true, it is necessary to traverse the layer tree ticking the animators.
252     bool m_needsAnimateLayers;
253     bool m_pinchGestureActive;
254     IntPoint m_previousPinchAnchor;
255
256     OwnPtr<CCPageScaleAnimation> m_pageScaleAnimation;
257     OwnPtr<CCActiveGestureAnimation> m_activeGestureAnimation;
258
259     // This is used for ticking animations slowly when hidden.
260     OwnPtr<CCLayerTreeHostImplTimeSourceAdapter> m_timeSourceClientAdapter;
261
262     CCLayerSorter m_layerSorter;
263
264     FloatRect m_rootScissorRect;
265
266     // List of visible layers for the most recently prepared frame. Used for
267     // rendering and input event hit testing.
268     CCLayerList m_renderSurfaceLayerList;
269
270     OwnPtr<CCFrameRateCounter> m_fpsCounter;
271     OwnPtr<CCDebugRectHistory> m_debugRectHistory;
272 };
273
274 };
275
276 #endif