ec14a51a7b49883e0e5ff7c662d0e35c97d35d50
[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 "CCLayerAnimationController.h"
38 #include "CCOcclusionTracker.h"
39 #include "CCPrioritizedTexture.h"
40 #include "FloatPoint.h"
41 #include "Region.h"
42 #include "RenderSurfaceChromium.h"
43 #include "SkColor.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     bool addAnimation(PassOwnPtr<CCActiveAnimation>);
271     void pauseAnimation(int animationId, double timeOffset);
272     void removeAnimation(int animationId);
273
274     void suspendAnimations(double monotonicTime);
275     void resumeAnimations(double monotonicTime);
276
277     CCLayerAnimationController* layerAnimationController() { return m_layerAnimationController.get(); }
278     void setLayerAnimationController(PassOwnPtr<CCLayerAnimationController>);
279     PassOwnPtr<CCLayerAnimationController> releaseLayerAnimationController();
280
281     void setLayerAnimationDelegate(WebKit::WebAnimationDelegate* layerAnimationDelegate) { m_layerAnimationDelegate = layerAnimationDelegate; }
282
283     bool hasActiveAnimation() const;
284
285     virtual void notifyAnimationStarted(const CCAnimationEvent&, double wallClockTime);
286     virtual void notifyAnimationFinished(double wallClockTime);
287
288     virtual Region visibleContentOpaqueRegion() const;
289
290     virtual ScrollbarLayerChromium* toScrollbarLayerChromium() { return 0; }
291
292 protected:
293     friend class CCLayerImpl;
294     friend class TreeSynchronizer;
295
296     LayerChromium();
297
298     void setNeedsCommit();
299
300     // This flag is set when layer need repainting/updating.
301     bool m_needsDisplay;
302
303     // Tracks whether this layer may have changed stacking order with its siblings.
304     bool m_stackingOrderChanged;
305
306     // The update rect is the region of the compositor resource that was actually updated by the compositor.
307     // For layers that may do updating outside the compositor's control (i.e. plugin layers), this information
308     // is not available and the update rect will remain empty.
309     // Note this rect is in layer space (not content space).
310     FloatRect m_updateRect;
311
312     RefPtr<LayerChromium> m_maskLayer;
313
314     // Constructs a CCLayerImpl of the correct runtime type for this LayerChromium type.
315     virtual PassOwnPtr<CCLayerImpl> createCCLayerImpl();
316     int m_layerId;
317
318 private:
319     void setParent(LayerChromium*);
320     bool hasAncestor(LayerChromium*) const;
321     bool descendantIsFixedToContainerLayer() const;
322
323     size_t numChildren() const { return m_children.size(); }
324
325     // Returns the index of the child or -1 if not found.
326     int indexOfChild(const LayerChromium*);
327
328     // This should only be called from removeFromParent.
329     void removeChild(LayerChromium*);
330
331     Vector<RefPtr<LayerChromium> > m_children;
332     LayerChromium* m_parent;
333
334     // LayerChromium instances have a weak pointer to their CCLayerTreeHost.
335     // This pointer value is nil when a LayerChromium is not in a tree and is
336     // updated via setLayerTreeHost() if a layer moves between trees.
337     CCLayerTreeHost* m_layerTreeHost;
338
339     OwnPtr<CCLayerAnimationController> m_layerAnimationController;
340
341     // Layer properties.
342     IntSize m_bounds;
343
344     // Uses layer's content space.
345     IntRect m_visibleContentRect;
346
347     IntPoint m_scrollPosition;
348     IntSize m_maxScrollPosition;
349     bool m_scrollable;
350     bool m_shouldScrollOnMainThread;
351     bool m_haveWheelEventHandlers;
352     Region m_nonFastScrollableRegion;
353     bool m_nonFastScrollableRegionChanged;
354     FloatPoint m_position;
355     FloatPoint m_anchorPoint;
356     SkColor m_backgroundColor;
357     SkColor m_debugBorderColor;
358     float m_debugBorderWidth;
359     String m_debugName;
360     float m_opacity;
361     WebKit::WebFilterOperations m_filters;
362     WebKit::WebFilterOperations m_backgroundFilters;
363     float m_anchorPointZ;
364     bool m_isContainerForFixedPositionLayers;
365     bool m_fixedToContainerLayer;
366     bool m_isDrawable;
367     bool m_masksToBounds;
368     bool m_opaque;
369     bool m_doubleSided;
370     bool m_useLCDText;
371     bool m_preserves3D;
372     bool m_useParentBackfaceVisibility;
373     bool m_drawCheckerboardForMissingTiles;
374     bool m_forceRenderSurface;
375
376     WebKit::WebTransformationMatrix m_transform;
377     WebKit::WebTransformationMatrix m_sublayerTransform;
378
379     // Replica layer used for reflections.
380     RefPtr<LayerChromium> m_replicaLayer;
381
382     // Transient properties.
383     OwnPtr<RenderSurfaceChromium> m_renderSurface;
384     float m_drawOpacity;
385     bool m_drawOpacityIsAnimating;
386
387     LayerChromium* m_renderTarget;
388
389     WebKit::WebTransformationMatrix m_drawTransform;
390     WebKit::WebTransformationMatrix m_screenSpaceTransform;
391     bool m_drawTransformIsAnimating;
392     bool m_screenSpaceTransformIsAnimating;
393
394     // Uses target surface space.
395     IntRect m_drawableContentRect;
396     float m_contentsScale;
397
398     WebKit::WebAnimationDelegate* m_layerAnimationDelegate;
399     LayerChromiumScrollDelegate* m_layerScrollDelegate;
400 };
401
402 void sortLayers(Vector<RefPtr<LayerChromium> >::iterator, Vector<RefPtr<LayerChromium> >::iterator, void*);
403
404 }
405 #endif // USE(ACCELERATED_COMPOSITING)
406
407 #endif