16607ca30ffdc64ebdc90ee05d3237eeae2abb69
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / LayerChromium.h
1 /*
2  * Copyright (C) 2010 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31
32 #ifndef LayerChromium_h
33 #define LayerChromium_h
34
35 #if USE(ACCELERATED_COMPOSITING)
36
37 #include "FilterOperations.h"
38 #include "FloatPoint.h"
39 #include "GraphicsContext.h"
40 #include "PlatformString.h"
41 #include "ProgramBinding.h"
42 #include "Region.h"
43 #include "RenderSurfaceChromium.h"
44 #include "ShaderChromium.h"
45 #include "TransformationMatrix.h"
46 #include "cc/CCLayerAnimationController.h"
47 #include "cc/CCOcclusionTracker.h"
48
49 #include <wtf/OwnPtr.h>
50 #include <wtf/PassOwnPtr.h>
51 #include <wtf/PassRefPtr.h>
52 #include <wtf/RefCounted.h>
53 #include <wtf/Vector.h>
54 #include <wtf/text/StringHash.h>
55 #include <wtf/text/WTFString.h>
56
57 namespace WebCore {
58
59 class CCAnimationEvent;
60 class CCLayerAnimationDelegate;
61 class CCLayerImpl;
62 class CCLayerTreeHost;
63 class CCTextureUpdater;
64 class GraphicsContext3D;
65 class ScrollbarLayerChromium;
66
67 // Base class for composited layers. Special layer types are derived from
68 // this class.
69 class LayerChromium : public RefCounted<LayerChromium>, public CCLayerAnimationControllerClient {
70 public:
71     static PassRefPtr<LayerChromium> create();
72
73     virtual ~LayerChromium();
74
75     // CCLayerAnimationControllerClient implementation
76     virtual int id() const { return m_layerId; }
77     virtual void setOpacityFromAnimation(float);
78     virtual float opacity() const { return m_opacity; }
79     virtual void setTransformFromAnimation(const TransformationMatrix&);
80     virtual const TransformationMatrix& transform() const { return m_transform; }
81     virtual const IntSize& bounds() const { return m_bounds; }
82
83     const LayerChromium* rootLayer() const;
84     LayerChromium* parent() const;
85     void addChild(PassRefPtr<LayerChromium>);
86     void insertChild(PassRefPtr<LayerChromium>, size_t index);
87     void replaceChild(LayerChromium* reference, PassRefPtr<LayerChromium> newLayer);
88     void removeFromParent();
89     void removeAllChildren();
90     void setChildren(const Vector<RefPtr<LayerChromium> >&);
91     const Vector<RefPtr<LayerChromium> >& children() const { return m_children; }
92
93     void setAnchorPoint(const FloatPoint&);
94     FloatPoint anchorPoint() const { return m_anchorPoint; }
95
96     void setAnchorPointZ(float);
97     float anchorPointZ() const { return m_anchorPointZ; }
98
99     void setBackgroundColor(const Color&);
100     Color backgroundColor() const { return m_backgroundColor; }
101
102     void setBackgroundCoversViewport(bool);
103     bool backgroundCoversViewport() const { return m_backgroundCoversViewport; }
104
105     void setBounds(const IntSize&);
106     virtual IntSize contentBounds() const { return bounds(); }
107
108     void setMasksToBounds(bool);
109     bool masksToBounds() const { return m_masksToBounds; }
110
111     void setMaskLayer(LayerChromium*);
112     LayerChromium* maskLayer() const { return m_maskLayer.get(); }
113
114     virtual void setNeedsDisplayRect(const FloatRect& dirtyRect);
115     void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); }
116     virtual bool needsDisplay() const { return m_needsDisplay; }
117
118     void setOpacity(float);
119     bool opacityIsAnimating() const;
120
121     void setFilters(const FilterOperations&);
122     const FilterOperations& filters() const { return m_filters; }
123
124     virtual void setOpaque(bool);
125     bool opaque() const { return m_opaque; }
126
127     void setPosition(const FloatPoint&);
128     FloatPoint position() const { return m_position; }
129
130     void setSublayerTransform(const TransformationMatrix&);
131     const TransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
132
133     void setTransform(const TransformationMatrix&);
134     bool transformIsAnimating() const;
135
136     const IntRect& visibleLayerRect() const { return m_visibleLayerRect; }
137     void setVisibleLayerRect(const IntRect& visibleLayerRect) { m_visibleLayerRect = visibleLayerRect; }
138
139     void setScrollPosition(const IntPoint&);
140     const IntPoint& scrollPosition() const { return m_scrollPosition; }
141
142     void setScrollable(bool);
143     void setShouldScrollOnMainThread(bool);
144     void setHaveWheelEventHandlers(bool);
145     void setNonFastScrollableRegion(const Region&);
146
147     IntSize scrollDelta() const { return IntSize(); }
148
149     float pageScaleDelta() const { return 1; }
150
151     void setDoubleSided(bool);
152     bool doubleSided() const { return m_doubleSided; }
153
154     void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; }
155     bool preserves3D() const { return m_preserves3D; }
156
157     void setUsesLayerClipping(bool usesLayerClipping) { m_usesLayerClipping = usesLayerClipping; }
158     bool usesLayerClipping() const { return m_usesLayerClipping; }
159
160     virtual void setIsNonCompositedContent(bool);
161     bool isNonCompositedContent() const { return m_isNonCompositedContent; }
162
163     virtual void setLayerTreeHost(CCLayerTreeHost*);
164
165     void setIsDrawable(bool);
166
167     void setReplicaLayer(LayerChromium*);
168     LayerChromium* replicaLayer() const { return m_replicaLayer.get(); }
169
170     // These methods typically need to be overwritten by derived classes.
171     virtual bool drawsContent() const { return m_isDrawable; }
172     virtual void paintContentsIfDirty(const CCOcclusionTracker* /* occlusion */) { }
173     virtual void idlePaintContentsIfDirty(const CCOcclusionTracker* /* occlusion */) { }
174     virtual void updateCompositorResources(GraphicsContext3D*, CCTextureUpdater&) { }
175     virtual void setIsMask(bool) { }
176     virtual void unreserveContentsTexture() { }
177     virtual void bindContentsTexture() { }
178     virtual void protectVisibleTileTextures() { }
179     virtual bool needsContentsScale() const { return false; }
180
181     void setDebugBorderColor(const Color&);
182     void setDebugBorderWidth(float);
183     void setDebugName(const String&);
184
185     virtual void pushPropertiesTo(CCLayerImpl*);
186
187     typedef ProgramBinding<VertexShaderPos, FragmentShaderColor> BorderProgram;
188
189     void clearRenderSurface() { m_renderSurface.clear(); }
190     RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
191     void createRenderSurface();
192
193     float drawOpacity() const { return m_drawOpacity; }
194     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
195
196     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
197     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
198
199     const IntRect& clipRect() const { return m_clipRect; }
200     void setClipRect(const IntRect& clipRect) { m_clipRect = clipRect; }
201     RenderSurfaceChromium* targetRenderSurface() const { return m_targetRenderSurface; }
202     void setTargetRenderSurface(RenderSurfaceChromium* surface) { m_targetRenderSurface = surface; }
203
204     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
205     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
206     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
207     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
208
209     // This moves from layer space, with origin in the center to target space with origin in the top left
210     const TransformationMatrix& drawTransform() const { return m_drawTransform; }
211     void setDrawTransform(const TransformationMatrix& matrix) { m_drawTransform = matrix; }
212     // This moves from layer space, with origin the top left to screen space with origin in the top left
213     const TransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }
214     void setScreenSpaceTransform(const TransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }
215     const IntRect& drawableContentRect() const { return m_drawableContentRect; }
216     void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
217     float contentsScale() const { return m_contentsScale; }
218     void setContentsScale(float);
219
220     // Returns true if any of the layer's descendants has content to draw.
221     bool descendantDrawsContent();
222
223     CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost.get(); }
224
225     // Reserve any textures needed for this layer.
226     virtual void reserveTextures() { }
227
228     void setAlwaysReserveTextures(bool alwaysReserveTextures) { m_alwaysReserveTextures = alwaysReserveTextures; }
229     bool alwaysReserveTextures() const { return m_alwaysReserveTextures; }
230
231     bool addAnimation(const KeyframeValueList&, const IntSize& boxSize, const Animation*, int animationId, int groupId, double timeOffset);
232     void pauseAnimation(int animationId, double timeOffset);
233     void removeAnimation(int animationId);
234
235     void suspendAnimations(double time);
236     void resumeAnimations();
237
238     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
239     void setLayerAnimationController(PassOwnPtr<CCLayerAnimationController>);
240
241     void setLayerAnimationDelegate(CCLayerAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
242
243     bool hasActiveAnimation() const;
244
245     void setAnimationEvent(const CCAnimationEvent&, double wallClockTime);
246
247     virtual Region opaqueContentsRegion() const { return Region(); };
248
249     virtual ScrollbarLayerChromium* toScrollbarLayerChromium() { return 0; }
250
251 protected:
252     friend class CCLayerImpl;
253     friend class LayerTilerChromium;
254     friend class TreeSynchronizer;
255
256     LayerChromium();
257
258     void setNeedsCommit();
259
260     // This flag is set when layer need repainting/updating.
261     bool m_needsDisplay;
262
263     // The update rect is the region of the compositor resource that was actually updated by the compositor.
264     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
265     // is not available and the update rect will remain empty.
266     // Note this rect is in layer space (not content space).
267     FloatRect m_updateRect;
268
269     RefPtr<LayerChromium> m_maskLayer;
270
271     // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.
272     virtual PassOwnPtr<CCLayerImpl> createCCLayerImpl();
273     int m_layerId;
274
275 private:
276     void setParent(LayerChromium*);
277     bool hasAncestor(LayerChromium*) const;
278
279     size_t numChildren() const { return m_children.size(); }
280
281     // Returns the index of the child or -1 if not found.
282     int indexOfChild(const LayerChromium*);
283
284     // This should only be called from removeFromParent.
285     void removeChild(LayerChromium*);
286
287     Vector<RefPtr<LayerChromium> > m_children;
288     LayerChromium* m_parent;
289
290     RefPtr<CCLayerTreeHost> m_layerTreeHost;
291
292     OwnPtr<CCLayerAnimationController> m_layerAnimationController;
293
294     // Layer properties.
295     IntSize m_bounds;
296     IntRect m_visibleLayerRect;
297     IntPoint m_scrollPosition;
298     bool m_scrollable;
299     bool m_shouldScrollOnMainThread;
300     bool m_haveWheelEventHandlers;
301     Region m_nonFastScrollableRegion;
302     bool m_nonFastScrollableRegionChanged;
303     FloatPoint m_position;
304     FloatPoint m_anchorPoint;
305     Color m_backgroundColor;
306     bool m_backgroundCoversViewport;
307     Color m_debugBorderColor;
308     float m_debugBorderWidth;
309     String m_debugName;
310     float m_opacity;
311     FilterOperations m_filters;
312     float m_anchorPointZ;
313     bool m_isDrawable;
314     bool m_masksToBounds;
315     bool m_opaque;
316     bool m_doubleSided;
317     bool m_usesLayerClipping;
318     bool m_isNonCompositedContent;
319     bool m_preserves3D;
320     bool m_alwaysReserveTextures;
321
322     TransformationMatrix m_transform;
323     TransformationMatrix m_sublayerTransform;
324
325     // Replica layer used for reflections.
326     RefPtr<LayerChromium> m_replicaLayer;
327
328     // Transient properties.
329     OwnPtr<RenderSurfaceChromium> m_renderSurface;
330     float m_drawOpacity;
331     bool m_drawOpacityIsAnimating;
332     IntRect m_clipRect;
333     RenderSurfaceChromium* m_targetRenderSurface;
334     TransformationMatrix m_drawTransform;
335     TransformationMatrix m_screenSpaceTransform;
336     bool m_drawTransformIsAnimating;
337     bool m_screenSpaceTransformIsAnimating;
338     IntRect m_drawableContentRect;
339     float m_contentsScale;
340
341     bool m_pageScaleDirty;
342
343     CCLayerAnimationDelegate* m_layerAnimationDelegate;
344 };
345
346 void sortLayers(Vector<RefPtr<LayerChromium> >::iterator, Vector<RefPtr<LayerChromium> >::iterator, void*);
347
348 }
349 #endif // USE(ACCELERATED_COMPOSITING)
350
351 #endif