[Chromium] Compositor doesn't support translucent root layers.
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCLayerTreeHost.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 CCLayerTreeHost_h
26 #define CCLayerTreeHost_h
27
28 #include "Color.h"
29 #include "GraphicsTypes3D.h"
30 #include "IntRect.h"
31 #include "LayerChromium.h"
32 #include "RateLimiter.h"
33 #include "cc/CCAnimationEvents.h"
34 #include "cc/CCGraphicsContext.h"
35 #include "cc/CCLayerTreeHostCommon.h"
36 #include "cc/CCProxy.h"
37
38 #include <limits>
39 #include <wtf/HashMap.h>
40 #include <wtf/OwnPtr.h>
41 #include <wtf/PassOwnPtr.h>
42 #include <wtf/PassRefPtr.h>
43
44 namespace WebCore {
45
46 class CCLayerTreeHostImpl;
47 class CCLayerTreeHostImplClient;
48 class CCTextureUpdater;
49 class GraphicsContext3D;
50 class LayerPainterChromium;
51 class Region;
52 class TextureAllocator;
53 class TextureManager;
54
55 class CCLayerTreeHostClient {
56 public:
57     virtual void willBeginFrame() = 0;
58     // Marks finishing compositing-related tasks on the main thread. In threaded mode, this corresponds to didCommit().
59     virtual void didBeginFrame() = 0;
60     virtual void updateAnimations(double frameBeginTime) = 0;
61     virtual void layout() = 0;
62     virtual void applyScrollAndScale(const IntSize& scrollDelta, float pageScale) = 0;
63     virtual PassRefPtr<GraphicsContext3D> createContext3D() = 0;
64     virtual void didRecreateContext(bool success) = 0;
65     virtual void willCommit() = 0;
66     virtual void didCommit() = 0;
67     virtual void didCommitAndDrawFrame() = 0;
68     virtual void didCompleteSwapBuffers() = 0;
69
70     // Used only in the single-threaded path.
71     virtual void scheduleComposite() = 0;
72
73 protected:
74     virtual ~CCLayerTreeHostClient() { }
75 };
76
77 struct CCSettings {
78     CCSettings()
79             : acceleratePainting(false)
80             , forceSoftwareCompositing(false)
81             , showFPSCounter(false)
82             , showPlatformLayerTree(false)
83             , showPaintRects(false)
84             , showPropertyChangedRects(false)
85             , showSurfaceDamageRects(false)
86             , refreshRate(0)
87             , perTilePainting(false)
88             , partialSwapEnabled(false)
89             , threadedAnimationEnabled(false)
90             , maxPartialTextureUpdates(std::numeric_limits<size_t>::max())
91             , defaultTileSize(IntSize(256, 256))
92             , maxUntiledLayerSize(IntSize(512, 512))
93             , deviceScaleFactor(1)
94     { }
95
96     bool acceleratePainting;
97     bool forceSoftwareCompositing;
98     bool showFPSCounter;
99     bool showPlatformLayerTree;
100     bool showPaintRects;
101     bool showPropertyChangedRects;
102     bool showSurfaceDamageRects;
103     double refreshRate;
104     bool perTilePainting;
105     bool partialSwapEnabled;
106     bool threadedAnimationEnabled;
107     size_t maxPartialTextureUpdates;
108     IntSize defaultTileSize;
109     IntSize maxUntiledLayerSize;
110     float deviceScaleFactor;
111 };
112
113 // Provides information on an Impl's rendering capabilities back to the CCLayerTreeHost
114 struct LayerRendererCapabilities {
115     LayerRendererCapabilities()
116         : bestTextureFormat(0)
117         , contextHasCachedFrontBuffer(false)
118         , usingPartialSwap(false)
119         , usingMapSub(false)
120         , usingAcceleratedPainting(false)
121         , usingSetVisibility(false)
122         , usingSwapCompleteCallback(false)
123         , usingTextureUsageHint(false)
124         , usingTextureStorageExtension(false)
125         , usingGpuMemoryManager(false)
126         , usingDiscardFramebuffer(false)
127         , maxTextureSize(0) { }
128
129     GC3Denum bestTextureFormat;
130     bool contextHasCachedFrontBuffer;
131     bool usingPartialSwap;
132     bool usingMapSub;
133     bool usingAcceleratedPainting;
134     bool usingSetVisibility;
135     bool usingSwapCompleteCallback;
136     bool usingTextureUsageHint;
137     bool usingTextureStorageExtension;
138     bool usingGpuMemoryManager;
139     bool usingDiscardFramebuffer;
140     int maxTextureSize;
141 };
142
143 class CCLayerTreeHost : public RateLimiterClient {
144     WTF_MAKE_NONCOPYABLE(CCLayerTreeHost);
145 public:
146     static PassOwnPtr<CCLayerTreeHost> create(CCLayerTreeHostClient*, const CCSettings&);
147     virtual ~CCLayerTreeHost();
148
149     void setSurfaceReady();
150
151     // Returns true if any CCLayerTreeHost is alive.
152     static bool anyLayerTreeHostInstanceExists();
153
154     static bool needsFilterContext() { return s_needsFilterContext; }
155     static void setNeedsFilterContext(bool needsFilterContext) { s_needsFilterContext = needsFilterContext; }
156
157     // CCLayerTreeHost interface to CCProxy.
158     void willBeginFrame() { m_client->willBeginFrame(); }
159     void didBeginFrame() { m_client->didBeginFrame(); }
160     void updateAnimations(double monotonicFrameBeginTime);
161     void layout();
162     void beginCommitOnImplThread(CCLayerTreeHostImpl*);
163     void finishCommitOnImplThread(CCLayerTreeHostImpl*);
164     void commitComplete();
165     PassRefPtr<CCGraphicsContext> createContext();
166     virtual PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHostImpl(CCLayerTreeHostImplClient*);
167     void didLoseContext();
168     enum RecreateResult {
169         RecreateSucceeded,
170         RecreateFailedButTryAgain,
171         RecreateFailedAndGaveUp,
172     };
173     RecreateResult recreateContext();
174     void willCommit() { m_client->willCommit(); }
175     void didCommitAndDrawFrame() { m_client->didCommitAndDrawFrame(); }
176     void didCompleteSwapBuffers() { m_client->didCompleteSwapBuffers(); }
177     void deleteContentsTexturesOnImplThread(TextureAllocator*);
178     virtual void acquireLayerTextures();
179     // Returns false if we should abort this frame due to initialization failure.
180     bool updateLayers(CCTextureUpdater&);
181
182     CCLayerTreeHostClient* client() { return m_client; }
183
184     int compositorIdentifier() const { return m_compositorIdentifier; }
185
186     // Only used when compositing on the main thread.
187     void composite();
188     void scheduleComposite();
189
190     // NOTE: The returned value can only be used to make GL calls or make the
191     // context current on the thread the compositor is running on!
192     CCGraphicsContext* context();
193
194     // Composites and attempts to read back the result into the provided
195     // buffer. If it wasn't possible, e.g. due to context lost, will return
196     // false.
197     bool compositeAndReadback(void *pixels, const IntRect&);
198
199     void finishAllRendering();
200
201     int frameNumber() const { return m_frameNumber; }
202
203     const LayerRendererCapabilities& layerRendererCapabilities() const;
204
205     // Test only hook
206     void loseContext(int numTimes);
207
208     void setNeedsAnimate();
209     // virtual for testing
210     virtual void setNeedsCommit();
211     void setNeedsForcedCommit();
212     void setNeedsRedraw();
213     bool commitRequested() const;
214
215     void setAnimationEvents(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime);
216     virtual void didAddAnimation();
217
218     LayerChromium* rootLayer() { return m_rootLayer.get(); }
219     const LayerChromium* rootLayer() const { return m_rootLayer.get(); }
220     void setRootLayer(PassRefPtr<LayerChromium>);
221
222     const CCSettings& settings() const { return m_settings; }
223
224     void setViewportSize(const IntSize&);
225
226     const IntSize& viewportSize() const { return m_viewportSize; }
227     // Gives the viewport size in device/content space.
228     const IntSize& deviceViewportSize() const { return m_deviceViewportSize; }
229
230     void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
231
232     void setBackgroundColor(const Color& color) { m_backgroundColor = color; }
233
234     void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
235
236     TextureManager* contentsTextureManager() const;
237     void setContentsMemoryAllocationLimitBytes(size_t);
238
239     bool visible() const { return m_visible; }
240     void setVisible(bool);
241
242     void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec);
243
244     void applyScrollAndScale(const CCScrollAndScaleSet&);
245     void startRateLimiter(GraphicsContext3D*);
246     void stopRateLimiter(GraphicsContext3D*);
247
248     // RateLimitClient implementation
249     virtual void rateLimit() OVERRIDE;
250
251     bool bufferedUpdates();
252     bool requestPartialTextureUpdate();
253     void deleteTextureAfterCommit(PassOwnPtr<ManagedTexture>);
254
255 protected:
256     CCLayerTreeHost(CCLayerTreeHostClient*, const CCSettings&);
257     bool initialize();
258
259 private:
260     typedef Vector<RefPtr<LayerChromium> > LayerList;
261     typedef Vector<OwnPtr<ManagedTexture> > TextureList;
262
263     void initializeLayerRenderer();
264
265     enum PaintType { PaintVisible, PaintIdle };
266     static void update(LayerChromium*, PaintType, CCTextureUpdater&, const CCOcclusionTracker*);
267     void paintLayerContents(const LayerList&, PaintType, CCTextureUpdater&);
268     void paintMasksForRenderSurface(LayerChromium*, PaintType, CCTextureUpdater&);
269
270     void updateLayers(LayerChromium*, CCTextureUpdater&);
271     // Pre-reserve textures for any layer marked "always reserve textures"
272     void reserveTextures(const LayerList&);
273
274     void animateLayers(double monotonicTime);
275     bool animateLayersRecursive(LayerChromium* current, double monotonicTime);
276     void setAnimationEventsRecursive(const CCAnimationEventsVector&, LayerChromium*, double wallClockTime);
277
278     int m_compositorIdentifier;
279
280     bool m_animating;
281     bool m_needsAnimateLayers;
282
283     CCLayerTreeHostClient* m_client;
284
285     int m_frameNumber;
286     bool m_frameIsForDisplay;
287
288     OwnPtr<CCProxy> m_proxy;
289     bool m_layerRendererInitialized;
290     bool m_contextLost;
291     int m_numTimesRecreateShouldFail;
292     int m_numFailedRecreateAttempts;
293
294     RefPtr<LayerChromium> m_rootLayer;
295     OwnPtr<TextureManager> m_contentsTextureManager;
296
297     CCSettings m_settings;
298
299     IntSize m_viewportSize;
300     IntSize m_deviceViewportSize;
301
302     bool m_visible;
303
304     size_t m_memoryAllocationBytes;
305     bool m_memoryAllocationIsForDisplay;
306
307     typedef HashMap<GraphicsContext3D*, RefPtr<RateLimiter> > RateLimiterMap;
308     RateLimiterMap m_rateLimiters;
309
310     float m_pageScaleFactor;
311     float m_minPageScaleFactor, m_maxPageScaleFactor;
312     bool m_triggerIdlePaints;
313     Color m_backgroundColor;
314     bool m_hasTransparentBackground;
315
316     TextureList m_deleteTextureAfterCommitList;
317     size_t m_partialTextureUpdateRequests;
318     static bool s_needsFilterContext;
319 };
320
321 }
322
323 #endif