29e387e532bfb76fb16c932cf254559ab449225f
[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 "FloatPoint.h"
38 #include "Region.h"
39 #include "RenderSurfaceChromium.h"
40 #include "SkColor.h"
41 #include "cc/CCLayerAnimationController.h"
42 #include "cc/CCOcclusionTracker.h"
43 #include "cc/CCPrioritizedTexture.h"
44
45 #include <public/WebFilterOperations.h>
46 #include <public/WebTransformationMatrix.h>
47 #include <wtf/OwnPtr.h>
48 #include <wtf/PassOwnPtr.h>
49 #include <wtf/PassRefPtr.h>
50 #include <wtf/RefCounted.h>
51 #include <wtf/Vector.h>
52 #include <wtf/text/StringHash.h>
53 #include <wtf/text/WTFString.h>
54
55 namespace WebKit {
56 class WebAnimationDelegate;
57 }
58
59 namespace WebCore {
60
61 class CCActiveAnimation;
62 struct CCAnimationEvent;
63 class CCLayerAnimationDelegate;
64 class CCLayerImpl;
65 class CCLayerTreeHost;
66 class CCTextureUpdateQueue;
67 class ScrollbarLayerChromium;
68 struct CCAnimationEvent;
69 struct CCRenderingStats;
70
71 // Delegate for handling scroll input for a LayerChromium.
72 class LayerChromiumScrollDelegate {
73 public:
74     virtual void didScroll(const IntSize&) = 0;
75
76 protected:
77     virtual ~LayerChromiumScrollDelegate() { }
78 };
79
80 // Base class for composited layers. Special layer types are derived from
81 // this class.
82 class LayerChromium : public RefCounted<LayerChromium>, public CCLayerAnimationControllerClient {
83 public:
84     static PassRefPtr<LayerChromium> create();
85
86     virtual ~LayerChromium();
87
88     // CCLayerAnimationControllerClient implementation
89     virtual int id() const OVERRIDE { return m_layerId; }
90     virtual void setOpacityFromAnimation(float) OVERRIDE;
91     virtual float opacity() const OVERRIDE { return m_opacity; }
92     virtual void setTransformFromAnimation(const WebKit::WebTransformationMatrix&) OVERRIDE;
93     // A layer's transform operates layer space. That is, entirely in logical,
94     // non-page-scaled pixels (that is, they have page zoom baked in, but not page scale).
95     // The root layer is a special case -- it operates in physical pixels.
96     virtual const WebKit::WebTransformationMatrix& transform() const OVERRIDE { return m_transform; }
97
98     const LayerChromium* rootLayer() const;
99     LayerChromium* parent() const;
100     void addChild(PassRefPtr<LayerChromium>);
101     void insertChild(PassRefPtr<LayerChromium>, size_t index);
102     void replaceChild(LayerChromium* reference, PassRefPtr<LayerChromium> newLayer);
103     void removeFromParent();
104     void removeAllChildren();
105     void setChildren(const Vector<RefPtr<LayerChromium> >&);
106     const Vector<RefPtr<LayerChromium> >& children() const { return m_children; }
107
108     void setAnchorPoint(const FloatPoint&);
109     FloatPoint anchorPoint() const { return m_anchorPoint; }
110
111     void setAnchorPointZ(float);
112     float anchorPointZ() const { return m_anchorPointZ; }
113
114     void setBackgroundColor(SkColor);
115     SkColor backgroundColor() const { return m_backgroundColor; }
116
117     // A layer's bounds are in logical, non-page-scaled pixels (however, the
118     // root layer's bounds are in physical pixels).
119     void setBounds(const IntSize&);
120     const IntSize& bounds() const { return m_bounds; }
121     virtual IntSize contentBounds() const { return bounds(); }
122
123     void setMasksToBounds(bool);
124     bool masksToBounds() const { return m_masksToBounds; }
125
126     void setMaskLayer(LayerChromium*);
127     LayerChromium* maskLayer() const { return m_maskLayer.get(); }
128
129     virtual void setNeedsDisplayRect(const FloatRect& dirtyRect);
130     void setNeedsDisplay() { setNeedsDisplayRect(FloatRect(FloatPoint(), bounds())); }
131     virtual bool needsDisplay() const { return m_needsDisplay; }
132
133     void setOpacity(float);
134     bool opacityIsAnimating() const;
135
136     void setFilters(const WebKit::WebFilterOperations&);
137     const WebKit::WebFilterOperations& filters() const { return m_filters; }
138
139     // Background filters are filters applied to what is behind this layer, when they are viewed through non-opaque
140     // regions in this layer. They are used through the WebLayer interface, and are not exposed to HTML.
141     void setBackgroundFilters(const WebKit::WebFilterOperations&);
142     const WebKit::WebFilterOperations& backgroundFilters() const { return m_backgroundFilters; }
143
144     virtual void setOpaque(bool);
145     bool opaque() const { return m_opaque; }
146
147     void setPosition(const FloatPoint&);
148     FloatPoint position() const { return m_position; }
149
150     void setIsContainerForFixedPositionLayers(bool);
151     bool isContainerForFixedPositionLayers() const { return m_isContainerForFixedPositionLayers; }
152
153     void setFixedToContainerLayer(bool);
154     bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }
155
156     void setSublayerTransform(const WebKit::WebTransformationMatrix&);
157     const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
158
159     void setTransform(const WebKit::WebTransformationMatrix&);
160     bool transformIsAnimating() const;
161
162     const IntRect& visibleContentRect() const { return m_visibleContentRect; }
163     void setVisibleContentRect(const IntRect& visibleContentRect) { m_visibleContentRect = visibleContentRect; }
164
165     void setScrollPosition(const IntPoint&);
166     const IntPoint& scrollPosition() const { return m_scrollPosition; }
167
168     void setMaxScrollPosition(const IntSize&);
169     const IntSize& maxScrollPosition() const { return m_maxScrollPosition; }
170
171     void setScrollable(bool);
172     bool scrollable() const { return m_scrollable; }
173     void setShouldScrollOnMainThread(bool);
174     void setHaveWheelEventHandlers(bool);
175     const Region& nonFastScrollableRegion() { return m_nonFastScrollableRegion; }
176     void setNonFastScrollableRegion(const Region&);
177     void setNonFastScrollableRegionChanged() { m_nonFastScrollableRegionChanged = true; }
178     void setLayerScrollDelegate(LayerChromiumScrollDelegate* layerScrollDelegate) { m_layerScrollDelegate = layerScrollDelegate; }
179     void scrollBy(const IntSize&);
180
181     void setDrawCheckerboardForMissingTiles(bool);
182     bool drawCheckerboardForMissingTiles() const { return m_drawCheckerboardForMissingTiles; }
183
184     bool forceRenderSurface() const { return m_forceRenderSurface; }
185     void setForceRenderSurface(bool);
186
187     IntSize scrollDelta() const { return IntSize(); }
188
189     float pageScaleDelta() const { return 1; }
190
191     void setDoubleSided(bool);
192     bool doubleSided() const { return m_doubleSided; }
193
194     void setPreserves3D(bool preserve3D) { m_preserves3D = preserve3D; }
195     bool preserves3D() const { return m_preserves3D; }
196
197     void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; }
198     bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; }
199
200     virtual void setUseLCDText(bool);
201     bool useLCDText() const { return m_useLCDText; }
202
203     virtual void setLayerTreeHost(CCLayerTreeHost*);
204
205     void setIsDrawable(bool);
206
207     void setReplicaLayer(LayerChromium*);
208     LayerChromium* replicaLayer() const { return m_replicaLayer.get(); }
209
210     bool hasMask() const { return m_maskLayer; }
211     bool hasReplica() const { return m_replicaLayer; }
212     bool replicaHasMask() const { return m_replicaLayer && (m_maskLayer || m_replicaLayer->m_maskLayer); }
213
214     // These methods typically need to be overwritten by derived classes.
215     virtual bool drawsContent() const { return m_isDrawable; }
216     virtual void update(CCTextureUpdateQueue&, const CCOcclusionTracker*, CCRenderingStats&) { }
217     virtual bool needMoreUpdates() { return false; }
218     virtual void setIsMask(bool) { }
219     virtual void bindContentsTexture() { }
220     virtual bool needsContentsScale() const { return false; }
221
222     void setDebugBorderColor(SkColor);
223     void setDebugBorderWidth(float);
224     void setDebugName(const String&);
225
226     virtual void pushPropertiesTo(CCLayerImpl*);
227
228     void clearRenderSurface() { m_renderSurface.clear(); }
229     RenderSurfaceChromium* renderSurface() const { return m_renderSurface.get(); }
230     void createRenderSurface();
231
232     float drawOpacity() const { return m_drawOpacity; }
233     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
234
235     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
236     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
237
238     LayerChromium* renderTarget() const { ASSERT(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
239     void setRenderTarget(LayerChromium* target) { m_renderTarget = target; }
240
241     bool drawTransformIsAnimating() const { return m_drawTransformIsAnimating; }
242     void setDrawTransformIsAnimating(bool animating) { m_drawTransformIsAnimating = animating; }
243     bool screenSpaceTransformIsAnimating() const { return m_screenSpaceTransformIsAnimating; }
244     void setScreenSpaceTransformIsAnimating(bool animating) { m_screenSpaceTransformIsAnimating = animating; }
245
246     // This moves from layer space, with origin in the center to target space with origin in the top left.
247     // That is, it converts from logical, non-page-scaled, to target pixels (and if the target is the
248     // root render surface, then this converts to physical pixels).
249     const WebKit::WebTransformationMatrix& drawTransform() const { return m_drawTransform; }
250     void setDrawTransform(const WebKit::WebTransformationMatrix& matrix) { m_drawTransform = matrix; }
251     // This moves from content space, with origin the top left to screen space with origin in the top left.
252     // It converts logical, non-page-scaled pixels to physical pixels.
253     const WebKit::WebTransformationMatrix& screenSpaceTransform() const { return m_screenSpaceTransform; }
254     void setScreenSpaceTransform(const WebKit::WebTransformationMatrix& matrix) { m_screenSpaceTransform = matrix; }
255     const IntRect& drawableContentRect() const { return m_drawableContentRect; }
256     void setDrawableContentRect(const IntRect& rect) { m_drawableContentRect = rect; }
257     // The contentsScale converts from logical, non-page-scaled pixels to target pixels.
258     // The contentsScale is 1 for the root layer as it is already in physical pixels.
259     float contentsScale() const { return m_contentsScale; }
260     void setContentsScale(float);
261
262     // Returns true if any of the layer's descendants has content to draw.
263     bool descendantDrawsContent();
264
265     CCLayerTreeHost* layerTreeHost() const { return m_layerTreeHost; }
266
267     // Set the priority of all desired textures in this layer.
268     virtual void setTexturePriorities(const CCPriorityCalculator&) { }
269
270     void setAlwaysReserveTextures(bool alwaysReserveTextures) { m_alwaysReserveTextures = alwaysReserveTextures; }
271     bool alwaysReserveTextures() const { return m_alwaysReserveTextures; }
272
273     bool addAnimation(PassOwnPtr<CCActiveAnimation>);
274     void pauseAnimation(int animationId, double timeOffset);
275     void removeAnimation(int animationId);
276
277     void suspendAnimations(double monotonicTime);
278     void resumeAnimations(double monotonicTime);
279
280     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
281     void setLayerAnimationController(PassOwnPtr<CCLayerAnimationController>);
282     PassOwnPtr<CCLayerAnimationController> releaseLayerAnimationController();
283
284     void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
285
286     bool hasActiveAnimation() const;
287
288     virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime);
289     virtual void notifyAnimationFinished(double wallClockTime);
290
291     virtual Region visibleContentOpaqueRegion() const;
292
293     virtual ScrollbarLayerChromium* toScrollbarLayerChromium() { return 0; }
294
295 protected:
296     friend class CCLayerImpl;
297     friend class TreeSynchronizer;
298
299     LayerChromium();
300
301     void setNeedsCommit();
302
303     // This flag is set when layer need repainting/updating.
304     bool m_needsDisplay;
305
306     // Tracks whether this layer may have changed stacking order with its siblings.
307     bool m_stackingOrderChanged;
308
309     // The update rect is the region of the compositor resource that was actually updated by the compositor.
310     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
311     // is not available and the update rect will remain empty.
312     // Note this rect is in layer space (not content space).
313     FloatRect m_updateRect;
314
315     RefPtr<LayerChromium> m_maskLayer;
316
317     // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.
318     virtual PassOwnPtr<CCLayerImpl> createCCLayerImpl();
319     int m_layerId;
320
321 private:
322     void setParent(LayerChromium*);
323     bool hasAncestor(LayerChromium*) const;
324     bool descendantIsFixedToContainerLayer() const;
325
326     size_t numChildren() const { return m_children.size(); }
327
328     // Returns the index of the child or -1 if not found.
329     int indexOfChild(const LayerChromium*);
330
331     // This should only be called from removeFromParent.
332     void removeChild(LayerChromium*);
333
334     Vector<RefPtr<LayerChromium> > m_children;
335     LayerChromium* m_parent;
336
337     // LayerChromium instances have a weak pointer to their CCLayerTreeHost.
338     // This pointer value is nil when a LayerChromium is not in a tree and is
339     // updated via setLayerTreeHost() if a layer moves between trees.
340     CCLayerTreeHost* m_layerTreeHost;
341
342     OwnPtr<CCLayerAnimationController> m_layerAnimationController;
343
344     // Layer properties.
345     IntSize m_bounds;
346
347     // Uses layer's content space.
348     IntRect m_visibleContentRect;
349
350     IntPoint m_scrollPosition;
351     IntSize m_maxScrollPosition;
352     bool m_scrollable;
353     bool m_shouldScrollOnMainThread;
354     bool m_haveWheelEventHandlers;
355     Region m_nonFastScrollableRegion;
356     bool m_nonFastScrollableRegionChanged;
357     FloatPoint m_position;
358     FloatPoint m_anchorPoint;
359     SkColor m_backgroundColor;
360     SkColor m_debugBorderColor;
361     float m_debugBorderWidth;
362     String m_debugName;
363     float m_opacity;
364     WebKit::WebFilterOperations m_filters;
365     WebKit::WebFilterOperations m_backgroundFilters;
366     float m_anchorPointZ;
367     bool m_isContainerForFixedPositionLayers;
368     bool m_fixedToContainerLayer;
369     bool m_isDrawable;
370     bool m_masksToBounds;
371     bool m_opaque;
372     bool m_doubleSided;
373     bool m_useLCDText;
374     bool m_preserves3D;
375     bool m_useParentBackfaceVisibility;
376     bool m_alwaysReserveTextures;
377     bool m_drawCheckerboardForMissingTiles;
378     bool m_forceRenderSurface;
379
380     WebKit::WebTransformationMatrix m_transform;
381     WebKit::WebTransformationMatrix m_sublayerTransform;
382
383     // Replica layer used for reflections.
384     RefPtr<LayerChromium> m_replicaLayer;
385
386     // Transient properties.
387     OwnPtr<RenderSurfaceChromium> m_renderSurface;
388     float m_drawOpacity;
389     bool m_drawOpacityIsAnimating;
390
391     LayerChromium* m_renderTarget;
392
393     WebKit::WebTransformationMatrix m_drawTransform;
394     WebKit::WebTransformationMatrix m_screenSpaceTransform;
395     bool m_drawTransformIsAnimating;
396     bool m_screenSpaceTransformIsAnimating;
397
398     // Uses target surface space.
399     IntRect m_drawableContentRect;
400     float m_contentsScale;
401
402     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
403     LayerChromiumScrollDelegate* m_layerScrollDelegate;
404 };
405
406 void sortLayers(Vector<RefPtr<LayerChromium> >::iterator, Vector<RefPtr<LayerChromium> >::iterator, void*);
407
408 }
409 #endif // USE(ACCELERATED_COMPOSITING)
410
411 #endif