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