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