[chromium] Rename opaqueContentsRegion() to visibleContentOpaqueRegion()
[WebKit-https.git] / Source / WebCore / platform / graphics / chromium / cc / CCLayerImpl.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  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef CCLayerImpl_h
27 #define CCLayerImpl_h
28
29 #include "Color.h"
30 #include "FilterOperations.h"
31 #include "FloatRect.h"
32 #include "IntRect.h"
33 #include "Region.h"
34 #include "TextStream.h"
35 #include "TransformationMatrix.h"
36 #include "cc/CCLayerAnimationController.h"
37 #include "cc/CCRenderSurface.h"
38 #include "cc/CCSharedQuadState.h"
39 #include <wtf/OwnPtr.h>
40 #include <wtf/PassRefPtr.h>
41 #include <wtf/RefCounted.h>
42 #include <wtf/text/WTFString.h>
43
44 namespace WebCore {
45
46 class CCLayerSorter;
47 class CCQuadCuller;
48 class LayerChromium;
49 class LayerRendererChromium;
50
51 class CCLayerImpl : public CCLayerAnimationControllerClient {
52 public:
53     static PassOwnPtr<CCLayerImpl> create(int id)
54     {
55         return adoptPtr(new CCLayerImpl(id));
56     }
57
58     virtual ~CCLayerImpl();
59
60     // CCLayerAnimationControllerClient implementation.
61     virtual int id() const { return m_layerId; }
62     virtual void setOpacityFromAnimation(float);
63     virtual float opacity() const { return m_opacity; }
64     virtual void setTransformFromAnimation(const TransformationMatrix&);
65     virtual const TransformationMatrix& transform() const { return m_transform; }
66     virtual const IntSize& bounds() const { return m_bounds; }
67
68     // Tree structure.
69     CCLayerImpl* parent() const { return m_parent; }
70     const Vector<OwnPtr<CCLayerImpl> >& children() const { return m_children; }
71     void addChild(PassOwnPtr<CCLayerImpl>);
72     void removeFromParent();
73     void removeAllChildren();
74
75     void setMaskLayer(PassOwnPtr<CCLayerImpl>);
76     CCLayerImpl* maskLayer() const { return m_maskLayer.get(); }
77
78     void setReplicaLayer(PassOwnPtr<CCLayerImpl>);
79     CCLayerImpl* replicaLayer() const { return m_replicaLayer.get(); }
80
81 #ifndef NDEBUG
82     int debugID() const { return m_debugID; }
83 #endif
84
85     PassOwnPtr<CCSharedQuadState> createSharedQuadState() const;
86     virtual void willDraw(LayerRendererChromium*) { }
87     virtual void appendQuads(CCQuadCuller&, const CCSharedQuadState*, bool& usedCheckerboard);
88     virtual void didDraw() { }
89     void appendDebugBorderQuad(CCQuadCuller&, const CCSharedQuadState*) const;
90
91     void unreserveContentsTexture();
92     virtual void bindContentsTexture(LayerRendererChromium*);
93
94     // Returns true if this layer has content to draw.
95     void setDrawsContent(bool);
96     bool drawsContent() const { return m_drawsContent; }
97
98     // Returns true if any of the layer's descendants has content to draw.
99     bool descendantDrawsContent();
100
101     void setAnchorPoint(const FloatPoint&);
102     const FloatPoint& anchorPoint() const { return m_anchorPoint; }
103
104     void setAnchorPointZ(float);
105     float anchorPointZ() const { return m_anchorPointZ; }
106
107     void setBackgroundColor(const Color&);
108     Color backgroundColor() const { return m_backgroundColor; }
109
110     void setBackgroundCoversViewport(bool);
111     bool backgroundCoversViewport() const { return m_backgroundCoversViewport; }
112
113     void setFilters(const FilterOperations&);
114     const FilterOperations& filters() const { return m_filters; }
115
116     void setMasksToBounds(bool);
117     bool masksToBounds() const { return m_masksToBounds; }
118
119     void setOpaque(bool);
120     bool opaque() const { return m_opaque; }
121
122     void setOpacity(float);
123     bool opacityIsAnimating() const;
124
125     void setPosition(const FloatPoint&);
126     const FloatPoint& position() const { return m_position; }
127
128     void setPreserves3D(bool);
129     bool preserves3D() const { return m_preserves3D; }
130
131     void setUsesLayerClipping(bool usesLayerClipping) { m_usesLayerClipping = usesLayerClipping; }
132     bool usesLayerClipping() const { return m_usesLayerClipping; }
133
134     void setIsNonCompositedContent(bool isNonCompositedContent) { m_isNonCompositedContent = isNonCompositedContent; }
135     bool isNonCompositedContent() const { return m_isNonCompositedContent; }
136
137     void setSublayerTransform(const TransformationMatrix&);
138     const TransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
139
140     // Debug layer border - visual effect only, do not change geometry/clipping/etc.
141     void setDebugBorderColor(Color);
142     Color debugBorderColor() const { return m_debugBorderColor; }
143     void setDebugBorderWidth(float);
144     float debugBorderWidth() const { return m_debugBorderWidth; }
145     bool hasDebugBorders() const;
146
147     // Debug layer name.
148     void setDebugName(const String& debugName) { m_debugName = debugName; }
149     String debugName() const { return m_debugName; }
150
151     CCRenderSurface* renderSurface() const { return m_renderSurface.get(); }
152     void createRenderSurface();
153     void clearRenderSurface() { m_renderSurface.clear(); }
154
155     float drawOpacity() const { return m_drawOpacity; }
156     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
157
158     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
159     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
160
161     const IntRect& clipRect() const { return m_clipRect; }
162     void setClipRect(const IntRect& rect) { m_clipRect = rect; }
163     CCRenderSurface* targetRenderSurface() const { return m_targetRenderSurface; }
164     void setTargetRenderSurface(CCRenderSurface* surface) { m_targetRenderSurface = surface; }
165
166     void setBounds(const IntSize&);
167
168     const IntSize& contentBounds() const { return m_contentBounds; }
169     void setContentBounds(const IntSize&);
170
171     const IntPoint& scrollPosition() const { return m_scrollPosition; }
172     void setScrollPosition(const IntPoint&);
173
174     const IntSize& maxScrollPosition() const {return m_maxScrollPosition; }
175     void setMaxScrollPosition(const IntSize& maxScrollPosition) { m_maxScrollPosition = maxScrollPosition; }
176
177     const FloatSize& scrollDelta() const { return m_scrollDelta; }
178     void setScrollDelta(const FloatSize&);
179
180     float pageScaleDelta() const { return m_pageScaleDelta; }
181     void setPageScaleDelta(float);
182
183     const IntSize& sentScrollDelta() const { return m_sentScrollDelta; }
184     void setSentScrollDelta(const IntSize& sentScrollDelta) { m_sentScrollDelta = sentScrollDelta; }
185
186     void scrollBy(const FloatSize& scroll);
187
188     bool scrollable() const { return m_scrollable; }
189     void setScrollable(bool scrollable) { m_scrollable = scrollable; }
190
191     bool shouldScrollOnMainThread() const { return m_shouldScrollOnMainThread; }
192     void setShouldScrollOnMainThread(bool shouldScrollOnMainThread) { m_shouldScrollOnMainThread = shouldScrollOnMainThread; }
193
194     bool haveWheelEventHandlers() const { return m_haveWheelEventHandlers; }
195     void setHaveWheelEventHandlers(bool haveWheelEventHandlers) { m_haveWheelEventHandlers = haveWheelEventHandlers; }
196
197     const Region& nonFastScrollableRegion() const { return m_nonFastScrollableRegion; }
198     void setNonFastScrollableRegion(const Region& region) { m_nonFastScrollableRegion = region; }
199
200     const IntRect& visibleLayerRect() const { return m_visibleLayerRect; }
201     void setVisibleLayerRect(const IntRect& visibleLayerRect) { m_visibleLayerRect = visibleLayerRect; }
202
203     bool doubleSided() const { return m_doubleSided; }
204     void setDoubleSided(bool);
205
206     // Returns the rect containtaining this layer in the current view's coordinate system.
207     const IntRect getDrawRect() const;
208
209     void setTransform(const TransformationMatrix&);
210     bool transformIsAnimating() const;
211
212     const TransformationMatrix& drawTransform() const { return m_drawTransform; }
213     void setDrawTransform(const TransformationMatrix& matrix) { m_drawTransform = matrix; }
214     const TransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }
215     void setScreenSpaceTransform(const TransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }
216
217     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
218     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
219     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
220     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
221
222     const IntRect& drawableContentRect() const { return m_drawableContentRect; }
223     void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
224     const FloatRect& updateRect() const { return m_updateRect; }
225     void setUpdateRect(const FloatRect& updateRect) { m_updateRect = updateRect; }
226
227     String layerTreeAsText() const;
228
229     bool layerPropertyChanged() const { return m_layerPropertyChanged; }
230     void resetAllChangeTrackingForSubtree();
231
232     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
233
234     virtual Region visibleContentOpaqueRegion() const { return Region(); };
235
236     // Indicates that the context previously used to render this layer
237     // was lost and that a new one has been created. Won't be called
238     // until the new context has been created successfully.
239     virtual void didLoseContext();
240
241 protected:
242     explicit CCLayerImpl(int);
243
244     virtual void dumpLayerProperties(TextStream&, int indent) const;
245     static void writeIndent(TextStream&, int indent);
246
247     // Transformation used to transform quads provided in appendQuads.
248     virtual TransformationMatrix quadTransform() const;
249
250     void appendGutterQuads(CCQuadCuller&, const CCSharedQuadState*);
251
252 private:
253     void setParent(CCLayerImpl* parent) { m_parent = parent; }
254     friend class TreeSynchronizer;
255     void clearChildList(); // Warning: This does not preserve tree structure invariants and so is only exposed to the tree synchronizer.
256
257     void noteLayerPropertyChangedForSubtree();
258
259     // Note carefully this does not affect the current layer.
260     void noteLayerPropertyChangedForDescendants();
261
262     virtual const char* layerTypeAsString() const { return "LayerChromium"; }
263
264     void dumpLayer(TextStream&, int indent) const;
265
266     // Properties internal to CCLayerImpl
267     CCLayerImpl* m_parent;
268     Vector<OwnPtr<CCLayerImpl> > m_children;
269     // m_maskLayer can be temporarily stolen during tree sync, we need this ID to confirm newly assigned layer is still the previous one
270     int m_maskLayerId;
271     OwnPtr<CCLayerImpl> m_maskLayer;
272     int m_replicaLayerId; // ditto
273     OwnPtr<CCLayerImpl> m_replicaLayer;
274     int m_layerId;
275
276     // Properties synchronized from the associated LayerChromium.
277     FloatPoint m_anchorPoint;
278     float m_anchorPointZ;
279     IntSize m_bounds;
280     IntSize m_contentBounds;
281     IntPoint m_scrollPosition;
282     bool m_scrollable;
283     bool m_shouldScrollOnMainThread;
284     bool m_haveWheelEventHandlers;
285     Region m_nonFastScrollableRegion;
286     Color m_backgroundColor;
287     bool m_backgroundCoversViewport;
288
289     // Whether the "back" of this layer should draw.
290     bool m_doubleSided;
291
292     // Tracks if drawing-related properties have changed since last redraw.
293     bool m_layerPropertyChanged;
294
295     IntRect m_visibleLayerRect;
296     bool m_masksToBounds;
297     bool m_opaque;
298     float m_opacity;
299     FloatPoint m_position;
300     bool m_preserves3D;
301     TransformationMatrix m_sublayerTransform;
302     TransformationMatrix m_transform;
303     bool m_usesLayerClipping;
304     bool m_isNonCompositedContent;
305
306     bool m_drawsContent;
307
308     FloatSize m_scrollDelta;
309     IntSize m_sentScrollDelta;
310     IntSize m_maxScrollPosition;
311     float m_pageScaleDelta;
312
313     // Properties owned exclusively by this CCLayerImpl.
314     // Debugging.
315 #ifndef NDEBUG
316     int m_debugID;
317 #endif
318
319     // Render surface this layer draws into. This is a surface that can belong
320     // either to this layer (if m_targetRenderSurface == m_renderSurface) or
321     // to an ancestor of this layer. The target render surface determines the
322     // coordinate system the layer's transforms are relative to.
323     CCRenderSurface* m_targetRenderSurface;
324
325     // The global depth value of the center of the layer. This value is used
326     // to sort layers from back to front.
327     float m_drawDepth;
328     float m_drawOpacity;
329     bool m_drawOpacityIsAnimating;
330
331     // Debug borders.
332     Color m_debugBorderColor;
333     float m_debugBorderWidth;
334
335     // Debug layer name.
336     String m_debugName;
337
338     FilterOperations m_filters;
339
340     TransformationMatrix m_drawTransform;
341     TransformationMatrix m_screenSpaceTransform;
342     bool m_drawTransformIsAnimating;
343     bool m_screenSpaceTransformIsAnimating;
344
345     // The rect that contributes to the scissor when this layer is drawn.
346     // Inherited by the parent layer and further restricted if this layer masks
347     // to bounds.
348     IntRect m_clipRect;
349
350     // Render surface associated with this layer. The layer and its descendants
351     // will render to this surface.
352     OwnPtr<CCRenderSurface> m_renderSurface;
353
354     // Hierarchical bounding rect containing the layer and its descendants.
355     IntRect m_drawableContentRect;
356
357     // Rect indicating what was repainted/updated during update.
358     // Note that plugin layers bypass this and leave it empty.
359     FloatRect m_updateRect;
360
361     // Manages animations for this layer.
362     OwnPtr<CCLayerAnimationController> m_layerAnimationController;
363 };
364
365 void sortLayers(Vector<CCLayerImpl*>::iterator first, Vector<CCLayerImpl*>::iterator end, CCLayerSorter*);
366
367 }
368
369 #endif // CCLayerImpl_h