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