[chromium] Move resource-releasing logic into CCProxy and cleanup setNeedsCommit
[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 "GraphicsTypes3D.h"
29 #include "IntRect.h"
30 #include "RateLimiter.h"
31 #include "TransformationMatrix.h"
32 #include "cc/CCLayerTreeHostCommon.h"
33 #include "cc/CCProxy.h"
34
35 #include <wtf/HashMap.h>
36 #include <wtf/PassOwnPtr.h>
37 #include <wtf/PassRefPtr.h>
38 #include <wtf/RefCounted.h>
39
40 #if USE(SKIA)
41 class GrContext;
42 #endif
43
44 namespace WebCore {
45
46 class CCLayerTreeHostImpl;
47 class CCTextureUpdater;
48 class GraphicsContext3D;
49 class LayerChromium;
50 class LayerPainterChromium;
51 class TextureAllocator;
52 class TextureManager;
53
54 class CCLayerTreeHostClient {
55 public:
56     virtual void animateAndLayout(double frameBeginTime) = 0;
57     virtual void applyScrollDelta(const IntSize&) = 0;
58     virtual PassRefPtr<GraphicsContext3D> createLayerTreeHostContext3D() = 0;
59     virtual void didRecreateGraphicsContext(bool success) = 0;
60     virtual void didCommitAndDrawFrame(int frameNumber) = 0;
61
62     // Used only in the single-threaded path.
63     virtual void scheduleComposite() = 0;
64
65 protected:
66     virtual ~CCLayerTreeHostClient() { }
67 };
68
69 struct CCSettings {
70     CCSettings()
71             : acceleratePainting(false)
72             , compositeOffscreen(false)
73             , enableCompositorThread(false)
74             , showFPSCounter(false)
75             , showPlatformLayerTree(false) { }
76
77     bool acceleratePainting;
78     bool compositeOffscreen;
79     bool enableCompositorThread;
80     bool showFPSCounter;
81     bool showPlatformLayerTree;
82 };
83
84 // Provides information on an Impl's rendering capabilities back to the CCLayerTreeHost
85 struct LayerRendererCapabilities {
86     LayerRendererCapabilities()
87         : bestTextureFormat(0)
88         , usingMapSub(false)
89         , usingAcceleratedPainting(false)
90         , usingSetVisibility(false)
91         , usingSwapCompleteCallback(false)
92         , maxTextureSize(0) { }
93
94     GC3Denum bestTextureFormat;
95     bool usingMapSub;
96     bool usingAcceleratedPainting;
97     bool usingSetVisibility;
98     bool usingSwapCompleteCallback;
99     int maxTextureSize;
100 };
101
102 class CCLayerTreeHost : public RefCounted<CCLayerTreeHost> {
103 public:
104     static PassRefPtr<CCLayerTreeHost> create(CCLayerTreeHostClient*, PassRefPtr<LayerChromium> rootLayer, const CCSettings&);
105     virtual ~CCLayerTreeHost();
106
107     // CCLayerTreeHost interface to CCProxy.
108     void animateAndLayout(double frameBeginTime);
109     void beginCommitOnImplThread(CCLayerTreeHostImpl*);
110     void finishCommitOnImplThread(CCLayerTreeHostImpl*);
111     void commitComplete();
112     PassRefPtr<GraphicsContext3D> createLayerTreeHostContext3D();
113     virtual PassOwnPtr<CCLayerTreeHostImpl> createLayerTreeHostImpl(CCLayerTreeHostImplClient*);
114     void didBecomeInvisibleOnImplThread(CCLayerTreeHostImpl*);
115     void didRecreateGraphicsContext(bool success);
116     void didCommitAndDrawFrame(int frameNumber) { m_client->didCommitAndDrawFrame(frameNumber); }
117     void deleteContentsTexturesOnImplThread(TextureAllocator*);
118
119     // CCLayerTreeHost interface to WebView.
120     bool animating() const { return m_animating; }
121     void setAnimating(bool animating) { m_animating = animating; } // Can be removed when non-threaded scheduling moves inside.
122
123     CCLayerTreeHostClient* client() { return m_client; }
124
125     int compositorIdentifier() const { return m_compositorIdentifier; }
126
127     // Only used when compositing on the main thread.
128     void composite();
129
130     GraphicsContext3D* context();
131
132     // Composites and attempts to read back the result into the provided
133     // buffer. If it wasn't possible, e.g. due to context lost, will return
134     // false.
135     bool compositeAndReadback(void *pixels, const IntRect&);
136
137     void finishAllRendering();
138
139     int frameNumber() const { return m_frameNumber; }
140
141     void setZoomAnimatorTransform(const TransformationMatrix&);
142
143     const LayerRendererCapabilities& layerRendererCapabilities() const;
144
145     // Test-only hook
146     void loseCompositorContext(int numTimes);
147
148     void setNeedsAnimate();
149     void setNeedsCommit();
150     void setNeedsRedraw();
151
152     LayerChromium* rootLayer() { return m_rootLayer.get(); }
153     const LayerChromium* rootLayer() const { return m_rootLayer.get(); }
154
155     const CCSettings& settings() const { return m_settings; }
156
157     void setViewport(const IntSize& viewportSize);
158
159     const IntSize& viewportSize() const { return m_viewportSize; }
160     TextureManager* contentsTextureManager() const;
161
162     bool visible() const { return m_visible; }
163     void setVisible(bool);
164     void setHaveWheelEventHandlers(bool);
165
166     void updateLayers();
167
168     void updateCompositorResources(GraphicsContext3D*, CCTextureUpdater&);
169     void applyScrollDeltas(const CCScrollUpdateSet&);
170     void startRateLimiter(GraphicsContext3D*);
171     void stopRateLimiter(GraphicsContext3D*);
172
173 protected:
174     CCLayerTreeHost(CCLayerTreeHostClient*, PassRefPtr<LayerChromium> rootLayer, const CCSettings&);
175     bool initialize();
176
177 private:
178     typedef Vector<RefPtr<LayerChromium> > LayerList;
179
180     void paintLayerContents(const LayerList&);
181     void paintMaskAndReplicaForRenderSurface(LayerChromium*);
182
183     void updateLayers(LayerChromium*);
184     void updateCompositorResources(LayerChromium*, GraphicsContext3D*, CCTextureUpdater&);
185     void clearPendingUpdate();
186
187     int m_compositorIdentifier;
188
189     bool m_animating;
190
191     CCLayerTreeHostClient* m_client;
192
193     int m_frameNumber;
194
195     OwnPtr<CCProxy> m_proxy;
196
197     RefPtr<LayerChromium> m_rootLayer;
198     OwnPtr<TextureManager> m_contentsTextureManager;
199
200     LayerList m_updateList;
201
202     CCSettings m_settings;
203
204     IntSize m_viewportSize;
205     TransformationMatrix m_zoomAnimatorTransform;
206     bool m_visible;
207     bool m_haveWheelEventHandlers;
208     typedef HashMap<GraphicsContext3D*, RefPtr<RateLimiter> > RateLimiterMap;
209     RateLimiterMap m_rateLimiters;
210 };
211
212 }
213
214 #endif