[BlackBerry] fix confusing destruction sequence in LayerCompositingThread
[WebKit-https.git] / Source / WebCore / platform / graphics / blackberry / LayerCompositingThread.h
1 /*
2  * Copyright (C) 2010, 2011, 2012 Research In Motion Limited. All rights reserved.
3  * Copyright (C) 2010 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32
33 #ifndef LayerCompositingThread_h
34 #define LayerCompositingThread_h
35
36 #if USE(ACCELERATED_COMPOSITING)
37
38 #include "FloatQuad.h"
39 #include "LayerData.h"
40 #include "LayerRendererSurface.h"
41 #include "LayerTiler.h"
42
43 #include <BlackBerryPlatformGuardedPointer.h>
44 #include <wtf/ThreadSafeRefCounted.h>
45
46 namespace BlackBerry {
47 namespace Platform {
48 namespace Graphics {
49 class Buffer;
50 }
51 }
52 }
53
54 namespace WebCore {
55
56 class LayerRenderer;
57
58 class LayerCompositingThread : public ThreadSafeRefCounted<LayerCompositingThread>, public LayerData, public BlackBerry::Platform::GuardedPointerBase {
59 public:
60     static PassRefPtr<LayerCompositingThread> create(LayerType, PassRefPtr<LayerTiler>);
61
62     ~LayerCompositingThread();
63
64     // Thread safe
65     void setPluginView(PluginView*);
66 #if ENABLE(VIDEO)
67     void setMediaPlayer(MediaPlayer*);
68 #endif
69     void clearAnimations();
70
71     // Not thread safe
72
73     // Returns true if we have an animation
74     bool updateAnimations(double currentTime);
75     void updateTextureContentsIfNeeded();
76     void bindContentsTexture()
77     {
78         if (m_tiler)
79             m_tiler->bindContentsTexture();
80     }
81
82     const LayerCompositingThread* rootLayer() const;
83     void setSublayers(const Vector<RefPtr<LayerCompositingThread> >&);
84     const Vector<RefPtr<LayerCompositingThread> >& getSublayers() const { return m_sublayers; }
85     void setSuperlayer(LayerCompositingThread* superlayer) { m_superlayer = superlayer; }
86     LayerCompositingThread* superlayer() const { return m_superlayer; }
87
88     // The layer renderer must be set if the layer has been rendered
89     void setLayerRenderer(LayerRenderer*);
90
91     void setDrawTransform(const TransformationMatrix&);
92     const TransformationMatrix& drawTransform() const { return m_drawTransform; }
93
94     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
95     float drawOpacity() const { return m_drawOpacity; }
96
97     void createLayerRendererSurface();
98     LayerRendererSurface* layerRendererSurface() const { return m_layerRendererSurface.get(); }
99     void clearLayerRendererSurface() { m_layerRendererSurface.clear(); }
100
101     void setMaskLayer(LayerCompositingThread* maskLayer) { m_maskLayer = maskLayer; }
102     LayerCompositingThread* maskLayer() const { return m_maskLayer.get(); }
103
104     void setReplicaLayer(LayerCompositingThread* layer) { m_replicaLayer = layer; }
105     LayerCompositingThread* replicaLayer() const { return m_replicaLayer.get(); }
106
107     FloatRect getDrawRect() const { return m_drawRect; }
108     const FloatQuad& getTransformedBounds() const { return m_transformedBounds; }
109     FloatQuad getTransformedHolePunchRect() const;
110
111     void deleteTextures();
112
113     void drawTextures(int positionLocation, int texCoordLocation, const FloatRect& visibleRect);
114     bool hasMissingTextures() const { return m_tiler ? m_tiler->hasMissingTextures() : false; }
115     void drawMissingTextures(int positionLocation, int texCoordLocation, const FloatRect& visibleRect);
116     void drawSurface(const TransformationMatrix&, LayerCompositingThread* mask, int positionLocation, int texCoordLocation);
117     bool isDirty() const { return m_tiler ? m_tiler->hasDirtyTiles() : false; }
118
119     void releaseTextureResources();
120
121     // Layer visibility is determined by the LayerRenderer when drawing.
122     // So we don't have an accurate value for visibility until it's too late,
123     // but the attribute still is useful.
124     bool isVisible() const { return m_visible; }
125     void setVisible(bool);
126
127     // This will cause a commit of the whole layer tree on the WebKit thread,
128     // sometime after rendering is finished. Used when rendering results in a
129     // need for commit, for example when a dirty layer becomes visible.
130     void setNeedsCommit();
131
132     // Normally you would schedule a commit from the webkit thread, but
133     // this allows you to do it from the compositing thread.
134     void scheduleCommit();
135
136     // These two functions are used to update animated properties in LayerAnimation.
137     void setOpacity(float opacity) { m_opacity = opacity; }
138     void setTransform(const TransformationMatrix& matrix) { m_transform = matrix; }
139
140     bool hasRunningAnimations() const { return !m_runningAnimations.isEmpty(); }
141
142     bool hasVisibleHolePunchRect() const;
143
144 private:
145     LayerCompositingThread(LayerType, PassRefPtr<LayerTiler>);
146
147     friend class WTF::ThreadSafeRefCounted<WebCore::LayerCompositingThread>;
148     void destroyOnCompositingThread();
149
150     void updateTileContents(const IntRect& tile);
151
152     void removeFromSuperlayer();
153
154     size_t numSublayers() const { return m_sublayers.size(); }
155
156     // Returns the index of the sublayer or -1 if not found.
157     int indexOfSublayer(const LayerCompositingThread*);
158
159     // This should only be called from removeFromSuperlayer.
160     void removeSublayer(LayerCompositingThread*);
161
162     LayerRenderer* m_layerRenderer;
163
164     typedef Vector<RefPtr<LayerCompositingThread> > LayerList;
165     LayerList m_sublayers;
166     LayerCompositingThread* m_superlayer;
167
168     // Vertex data for the bounds of this layer
169     FloatQuad m_transformedBounds;
170     // The bounding rectangle of the transformed layer
171     FloatRect m_drawRect;
172
173     OwnPtr<LayerRendererSurface> m_layerRendererSurface;
174
175     RefPtr<LayerCompositingThread> m_maskLayer;
176     RefPtr<LayerCompositingThread> m_replicaLayer;
177
178     BlackBerry::Platform::Graphics::Buffer* m_pluginBuffer;
179
180     // The global property values, after concatenation with parent values
181     TransformationMatrix m_drawTransform;
182     float m_drawOpacity;
183
184     bool m_visible;
185     bool m_commitScheduled;
186
187     RefPtr<LayerTiler> m_tiler;
188 };
189
190 } // namespace WebCore
191
192 namespace WTF {
193
194 // LayerCompositingThread objects must be destroyed on the compositing thread.
195 // But it's possible for the last reference to be held by the WebKit thread.
196 // So we create a custom specialization of ThreadSafeRefCounted which calls a
197 // function that ensures the destructor is called on the correct thread, rather
198 // than calling delete directly.
199 template<>
200 inline void ThreadSafeRefCounted<WebCore::LayerCompositingThread>::deref()
201 {
202     if (derefBase())
203         static_cast<WebCore::LayerCompositingThread*>(this)->destroyOnCompositingThread();
204 }
205
206 } // namespace WTF
207
208
209 #endif // USE(ACCELERATED_COMPOSITING)
210
211 #endif