[BlackBerry] Implement ScrollingCoordinator::frameViewLayoutUpdated()
[WebKit-https.git] / Source / WebCore / platform / graphics / blackberry / LayerWebKitThread.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 LayerWebKitThread_h
34 #define LayerWebKitThread_h
35
36 #if USE(ACCELERATED_COMPOSITING)
37
38 #include "GraphicsLayerBlackBerry.h"
39 #include "LayerAnimation.h"
40 #include "LayerData.h"
41 #include "LayerTiler.h"
42
43 #include <wtf/OwnPtr.h>
44 #include <wtf/PassRefPtr.h>
45 #include <wtf/RefCounted.h>
46 #include <wtf/Vector.h>
47
48 namespace WebCore {
49
50 class LayerCompositingThread;
51
52 class LayerWebKitThread : public RefCounted<LayerWebKitThread>, public LayerData {
53 public:
54     static PassRefPtr<LayerWebKitThread> create(LayerType, GraphicsLayerBlackBerry* owner = 0);
55
56     virtual ~LayerWebKitThread();
57
58     void addSublayer(PassRefPtr<LayerWebKitThread>);
59     void insertSublayer(PassRefPtr<LayerWebKitThread> layer, size_t index) { insert(m_sublayers, layer, index); }
60     void replaceSublayer(LayerWebKitThread* reference, PassRefPtr<LayerWebKitThread> newLayer);
61     void removeFromSuperlayer();
62
63     void addOverlay(PassRefPtr<LayerWebKitThread>);
64
65     void setAnchorPoint(const FloatPoint& anchorPoint) { m_anchorPoint = anchorPoint; setNeedsCommit(); }
66
67     void setAnchorPointZ(float anchorPointZ) { m_anchorPointZ = anchorPointZ; setNeedsCommit(); }
68
69     void setBackgroundColor(const Color& color) { m_backgroundColor = color; setNeedsCommit(); }
70
71     void setBorderColor(const Color& color) { m_borderColor = color; setNeedsCommit(); }
72
73     void setBorderWidth(float width) { m_borderWidth = width; setNeedsCommit(); }
74
75     void setBounds(const IntSize&);
76
77     void setSizeIsScaleInvariant(bool invariant) { m_sizeIsScaleInvariant = invariant; setNeedsCommit(); }
78
79     void setDoubleSided(bool doubleSided) { m_doubleSided = doubleSided; setNeedsCommit(); }
80
81     void setFrame(const FloatRect&);
82
83     void setMasksToBounds(bool masksToBounds) { m_masksToBounds = masksToBounds; }
84
85     void setMaskLayer(LayerWebKitThread* maskLayer) { m_maskLayer = maskLayer; }
86     LayerWebKitThread* maskLayer() const { return m_maskLayer.get(); }
87
88     bool isMask() const { return m_isMask; }
89     void setIsMask(bool);
90
91     void setReplicaLayer(LayerWebKitThread* layer) { m_replicaLayer = layer; }
92     LayerWebKitThread* replicaLayer() { return m_replicaLayer.get(); }
93
94     // FIXME: Move to a new subclass, ContentLayerWebKitThread. This is only used for layers that draw content
95     void setNeedsDisplayInRect(const FloatRect& dirtyRect);
96
97     virtual void setNeedsDisplay();
98
99     void setNeedsDisplayOnBoundsChange(bool needsDisplay) { m_needsDisplayOnBoundsChange = needsDisplay; }
100
101     void setOpacity(float opacity) { m_opacity = opacity; setNeedsCommit(); }
102
103 #if ENABLE(CSS_FILTERS)
104     void setFilters(const FilterOperations& filters) { m_filters = filters; m_filtersChanged = true; setNeedsCommit(); }
105     static bool filtersCanBeComposited(const FilterOperations& filters);
106 #endif
107
108     void setOpaque(bool isOpaque) { m_isOpaque = isOpaque; setNeedsCommit(); }
109
110     void setPosition(const FloatPoint& position) { m_position = position; setNeedsCommit(); }
111
112     const LayerWebKitThread* rootLayer() const;
113
114     void removeAllSublayers() { removeAll(m_sublayers); }
115
116     void setSublayers(const Vector<RefPtr<LayerWebKitThread> >&);
117
118     const Vector<RefPtr<LayerWebKitThread> >& getSublayers() const { return m_sublayers; }
119
120     void setSublayerTransform(const TransformationMatrix& transform) { m_sublayerTransform = transform; setNeedsCommit(); }
121
122     LayerWebKitThread* superlayer() const { return m_superlayer; }
123
124     void setTransform(const TransformationMatrix& transform) { m_transform = transform; setNeedsCommit(); }
125
126     void setPreserves3D(bool preserves3D) { m_preserves3D = preserves3D; setNeedsCommit(); }
127
128     void setFixedPosition(bool fixed)
129     {
130         if (m_isFixedPosition == fixed)
131             return;
132         m_isFixedPosition = fixed;
133         setNeedsCommit();
134     }
135
136     void setHasFixedContainer(bool fixed) { m_hasFixedContainer = fixed; setNeedsCommit(); }
137     void setHasFixedAncestorInDOMTree(bool fixed) { m_hasFixedAncestorInDOMTree = fixed; setNeedsCommit(); }
138
139     void setIsContainerForFixedPositionLayers(bool fixed)
140     {
141         if (m_isContainerForFixedPositionLayers == fixed)
142             return;
143         m_isContainerForFixedPositionLayers = fixed;
144         setNeedsCommit();
145     }
146
147     void setFixedToTop(bool fixedToTop)
148     {
149         if (m_isFixedToTop == fixedToTop)
150             return;
151         m_isFixedToTop = fixedToTop;
152         setNeedsCommit();
153     }
154
155     void setFixedToLeft(bool fixedToLeft)
156     {
157         if (m_isFixedToLeft == fixedToLeft)
158             return;
159         m_isFixedToLeft = fixedToLeft;
160         setNeedsCommit();
161     }
162
163     void setFrameVisibleRect(const IntRect& rect)
164     {
165         if (m_frameVisibleRect == rect)
166             return;
167         m_frameVisibleRect = rect;
168         setNeedsCommit();
169     }
170
171     void setFrameContentsSize(const IntSize& size)
172     {
173         if (m_frameContentsSize == size)
174             return;
175         m_frameContentsSize = size;
176         setNeedsCommit();
177     }
178
179     void setContents(Image*);
180     Image* contents() const { return m_contents.get(); }
181
182     void setOwner(GraphicsLayerBlackBerry* owner) { m_owner = owner; }
183     // NOTE: Can be 0.
184     GraphicsLayerBlackBerry* owner() const { return m_owner; }
185
186     bool drawsContent() const { return m_owner && m_owner->drawsContent(); }
187     void setDrawable(bool);
188
189     // 1. Commit on WebKit thread
190     void commitOnWebKitThread(double scale);
191
192     // 2. Commit on Compositing thread
193     void commitOnCompositingThread();
194     bool startAnimations(double time);
195
196     // 3. Notify when returning to WebKit thread
197     void notifyAnimationsStarted(double time);
198
199     LayerCompositingThread* layerCompositingThread() const { return m_layerCompositingThread.get(); }
200
201     // Only used when this layer is the root layer of a frame.
202     void setAbsoluteOffset(const FloatSize& offset) { m_absoluteOffset = offset; }
203
204     void paintContents(BlackBerry::Platform::Graphics::Buffer*, const IntRect& transformedContentsRect, double scale);
205
206     void setNeedsCommit();
207
208     void setRunningAnimations(const Vector<RefPtr<LayerAnimation> >&);
209     void setSuspendedAnimations(const Vector<RefPtr<LayerAnimation> >&);
210
211     // Allows you to clear the LayerCompositingThread::overrides from the WK thread
212     void clearOverride() { m_clearOverrideOnCommit = true; setNeedsCommit(); }
213
214     void releaseLayerResources();
215
216     static IntRect mapFromTransformed(const IntRect&, double scale);
217
218 protected:
219     LayerWebKitThread(LayerType, GraphicsLayerBlackBerry* owner);
220
221     void setNeedsTexture(bool needsTexture) { m_needsTexture = needsTexture; }
222     void setLayerProgram(LayerData::LayerProgram layerProgram) { m_layerProgram = layerProgram; }
223     bool isDrawable() const { return m_isDrawable; }
224
225     void updateVisibility();
226     void updateTextureContents(double scale);
227
228     virtual void boundsChanged() { }
229     virtual void updateTextureContentsIfNeeded();
230     virtual void commitPendingTextureUploads();
231     virtual void deleteTextures() { }
232
233 private:
234     void updateLayerHierarchy();
235
236     void setSuperlayer(LayerWebKitThread* superlayer) { m_superlayer = superlayer; }
237
238     // This should only be called from removeFromSuperlayer.
239     void removeSublayerOrOverlay(LayerWebKitThread*);
240     void remove(Vector<RefPtr<LayerWebKitThread> >&, LayerWebKitThread*);
241     void removeAll(Vector<RefPtr<LayerWebKitThread> >&);
242     void insert(Vector<RefPtr<LayerWebKitThread> >&, PassRefPtr<LayerWebKitThread>, size_t index);
243
244     GraphicsLayerBlackBerry* m_owner;
245
246     Vector<RefPtr<LayerAnimation> > m_runningAnimations;
247     Vector<RefPtr<LayerAnimation> > m_suspendedAnimations;
248
249     Vector<RefPtr<LayerWebKitThread> > m_sublayers;
250     Vector<RefPtr<LayerWebKitThread> > m_overlays;
251     LayerWebKitThread* m_superlayer;
252     RefPtr<LayerWebKitThread> m_maskLayer;
253     RefPtr<LayerWebKitThread> m_replicaLayer;
254
255     RefPtr<Image> m_contents;
256
257     RefPtr<LayerCompositingThread> m_layerCompositingThread;
258     RefPtr<LayerTiler> m_tiler;
259     FloatSize m_absoluteOffset;
260     unsigned m_isDrawable : 1;
261     unsigned m_isMask : 1;
262     unsigned m_animationsChanged : 1;
263     unsigned m_clearOverrideOnCommit : 1;
264 #if ENABLE(CSS_FILTERS)
265     unsigned m_filtersChanged : 1;
266 #endif
267     unsigned m_didStartAnimations : 1;
268 };
269
270 }
271
272 #endif // USE(ACCELERATED_COMPOSITING)
273
274 #endif