[chromium] Rename opaqueContentsRegion() to visibleContentOpaqueRegion()
[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 struct CCAnimationStartedEvent;
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     const Region& nonFastScrollableRegion() { return m_nonFastScrollableRegion; }
146     void setNonFastScrollableRegion(const Region&);
147     void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; }
148
149     IntSize scrollDelta() const { return IntSize(); }
150
151     float pageScaleDelta() const { return 1; }
152
153     void setDoubleSided(bool);
154     bool doubleSided() const { return m_doubleSided; }
155
156     void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; }
157     bool preserves3D() const { return m_preserves3D; }
158
159     void setUsesLayerClipping(bool usesLayerClipping) { m_usesLayerClipping = usesLayerClipping; }
160     bool usesLayerClipping() const { return m_usesLayerClipping; }
161
162     virtual void setIsNonCompositedContent(bool);
163     bool isNonCompositedContent() const { return m_isNonCompositedContent; }
164
165     virtual void setLayerTreeHost(CCLayerTreeHost*);
166
167     void setIsDrawable(bool);
168
169     void setReplicaLayer(LayerChromium*);
170     LayerChromium* replicaLayer() const { return m_replicaLayer.get(); }
171
172     // These methods typically need to be overwritten by derived classes.
173     virtual bool drawsContent() const { return m_isDrawable; }
174     virtual void paintContentsIfDirty(const CCOcclusionTracker* /* occlusion */) { }
175     virtual void idlePaintContentsIfDirty(const CCOcclusionTracker* /* occlusion */) { }
176     virtual void updateCompositorResources(GraphicsContext3D*, CCTextureUpdater&) { }
177     virtual void setIsMask(bool) { }
178     virtual void unreserveContentsTexture() { }
179     virtual void bindContentsTexture() { }
180     virtual void protectVisibleTileTextures() { }
181     virtual bool needsContentsScale() const { return false; }
182
183     void setDebugBorderColor(const Color&);
184     void setDebugBorderWidth(float);
185     void setDebugName(const String&);
186
187     virtual void pushPropertiesTo(CCLayerImpl*);
188
189     typedef ProgramBinding<VertexShaderPos, FragmentShaderColor> BorderProgram;
190
191     void clearRenderSurface() { m_renderSurface.clear(); }
192     RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
193     void createRenderSurface();
194
195     float drawOpacity() const { return m_drawOpacity; }
196     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
197
198     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
199     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
200
201     const IntRect& clipRect() const { return m_clipRect; }
202     void setClipRect(const IntRect& clipRect) { m_clipRect = clipRect; }
203     RenderSurfaceChromium* targetRenderSurface() const { return m_targetRenderSurface; }
204     void setTargetRenderSurface(RenderSurfaceChromium* surface) { m_targetRenderSurface = surface; }
205
206     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
207     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
208     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
209     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
210
211     // This moves from layer space, with origin in the center to target space with origin in the top left
212     const TransformationMatrix& drawTransform() const { return m_drawTransform; }
213     void setDrawTransform(const TransformationMatrix& matrix) { m_drawTransform = matrix; }
214     // This moves from layer space, with origin the top left to screen space with origin in the top left
215     const TransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }
216     void setScreenSpaceTransform(const TransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }
217     const IntRect& drawableContentRect() const { return m_drawableContentRect; }
218     void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
219     float contentsScale() const { return m_contentsScale; }
220     void setContentsScale(float);
221
222     // Returns true if any of the layer's descendants has content to draw.
223     bool descendantDrawsContent();
224
225     CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost.get(); }
226
227     // Reserve any textures needed for this layer.
228     virtual void reserveTextures() { }
229
230     void setAlwaysReserveTextures(bool alwaysReserveTextures) { m_alwaysReserveTextures = alwaysReserveTextures; }
231     bool alwaysReserveTextures() const { return m_alwaysReserveTextures; }
232
233     bool addAnimation(const KeyframeValueList&, const IntSize& boxSize, const Animation*, int animationId, int groupId, double timeOffset);
234     void pauseAnimation(int animationId, double timeOffset);
235     void removeAnimation(int animationId);
236
237     void suspendAnimations(double time);
238     void resumeAnimations();
239
240     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
241     void setLayerAnimationController(PassOwnPtr<CCLayerAnimationController>);
242
243     void setLayerAnimationDelegate(CCLayerAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
244
245     bool hasActiveAnimation() const;
246
247     void notifyAnimationStarted(const CCAnimationStartedEvent&, double wallClockTime);
248
249     virtual Region visibleContentOpaqueRegion() const { return Region(); };
250
251     virtual ScrollbarLayerChromium* toScrollbarLayerChromium() { return 0; }
252
253 protected:
254     friend class CCLayerImpl;
255     friend class LayerTilerChromium;
256     friend class TreeSynchronizer;
257
258     LayerChromium();
259
260     void setNeedsCommit();
261
262     // This flag is set when layer need repainting/updating.
263     bool m_needsDisplay;
264
265     // The update rect is the region of the compositor resource that was actually updated by the compositor.
266     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
267     // is not available and the update rect will remain empty.
268     // Note this rect is in layer space (not content space).
269     FloatRect m_updateRect;
270
271     RefPtr<LayerChromium> m_maskLayer;
272
273     // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.
274     virtual PassOwnPtr<CCLayerImpl> createCCLayerImpl();
275     int m_layerId;
276
277 private:
278     void setParent(LayerChromium*);
279     bool hasAncestor(LayerChromium*) const;
280
281     size_t numChildren() const { return m_children.size(); }
282
283     // Returns the index of the child or -1 if not found.
284     int indexOfChild(const LayerChromium*);
285
286     // This should only be called from removeFromParent.
287     void removeChild(LayerChromium*);
288
289     Vector<RefPtr<LayerChromium> > m_children;
290     LayerChromium* m_parent;
291
292     RefPtr<CCLayerTreeHost> m_layerTreeHost;
293
294     OwnPtr<CCLayerAnimationController> m_layerAnimationController;
295
296     // Layer properties.
297     IntSize m_bounds;
298     IntRect m_visibleLayerRect;
299     IntPoint m_scrollPosition;
300     bool m_scrollable;
301     bool m_shouldScrollOnMainThread;
302     bool m_haveWheelEventHandlers;
303     Region m_nonFastScrollableRegion;
304     bool m_nonFastScrollableRegionChanged;
305     FloatPoint m_position;
306     FloatPoint m_anchorPoint;
307     Color m_backgroundColor;
308     bool m_backgroundCoversViewport;
309     Color m_debugBorderColor;
310     float m_debugBorderWidth;
311     String m_debugName;
312     float m_opacity;
313     FilterOperations m_filters;
314     float m_anchorPointZ;
315     bool m_isDrawable;
316     bool m_masksToBounds;
317     bool m_opaque;
318     bool m_doubleSided;
319     bool m_usesLayerClipping;
320     bool m_isNonCompositedContent;
321     bool m_preserves3D;
322     bool m_alwaysReserveTextures;
323
324     TransformationMatrix m_transform;
325     TransformationMatrix m_sublayerTransform;
326
327     // Replica layer used for reflections.
328     RefPtr<LayerChromium> m_replicaLayer;
329
330     // Transient properties.
331     OwnPtr<RenderSurfaceChromium> m_renderSurface;
332     float m_drawOpacity;
333     bool m_drawOpacityIsAnimating;
334     IntRect m_clipRect;
335     RenderSurfaceChromium* m_targetRenderSurface;
336     TransformationMatrix m_drawTransform;
337     TransformationMatrix m_screenSpaceTransform;
338     bool m_drawTransformIsAnimating;
339     bool m_screenSpaceTransformIsAnimating;
340     IntRect m_drawableContentRect;
341     float m_contentsScale;
342
343     bool m_pageScaleDirty;
344
345     CCLayerAnimationDelegate* m_layerAnimationDelegate;
346 };
347
348 void sortLayers(Vector<RefPtr<LayerChromium> >::iterator, Vector<RefPtr<LayerChromium> >::iterator, void*);
349
350 }
351 #endif // USE(ACCELERATED_COMPOSITING)
352
353 #endif