Unreviewed, rolling out r137006.
[WebKit-https.git] / Source / WebCore / platform / graphics / GraphicsLayer.h
1 /*
2  * Copyright (C) 2009 Apple 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  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef GraphicsLayer_h
27 #define GraphicsLayer_h
28
29 #if USE(ACCELERATED_COMPOSITING)
30
31 #include "Animation.h"
32 #include "Color.h"
33 #if ENABLE(CSS_FILTERS)
34 #include "FilterOperations.h"
35 #endif
36 #include "FloatPoint.h"
37 #include "FloatPoint3D.h"
38 #include "FloatSize.h"
39 #include "GraphicsLayerClient.h"
40 #include "IntRect.h"
41 #include "PlatformLayer.h"
42 #include "TransformationMatrix.h"
43 #include "TransformOperations.h"
44 #include <wtf/OwnPtr.h>
45 #include <wtf/PassOwnPtr.h>
46
47 enum LayerTreeAsTextBehaviorFlags {
48     LayerTreeAsTextBehaviorNormal = 0,
49     LayerTreeAsTextDebug = 1 << 0, // Dump extra debugging info like layer addresses.
50     LayerTreeAsTextIncludeVisibleRects = 1 << 1,
51     LayerTreeAsTextIncludeTileCaches = 1 << 2,
52     LayerTreeAsTextIncludeRepaintRects = 1 << 3
53 };
54 typedef unsigned LayerTreeAsTextBehavior;
55
56 namespace WebCore {
57
58 class FloatPoint3D;
59 class FloatRect;
60 class GraphicsContext;
61 class GraphicsLayerFactory;
62 class Image;
63 class TextStream;
64 class TiledBacking;
65 class TimingFunction;
66
67 // Base class for animation values (also used for transitions). Here to
68 // represent values for properties being animated via the GraphicsLayer,
69 // without pulling in style-related data from outside of the platform directory.
70 class AnimationValue {
71     WTF_MAKE_FAST_ALLOCATED;
72 public:
73     AnimationValue(float keyTime, PassRefPtr<TimingFunction> timingFunction = 0)
74         : m_keyTime(keyTime)
75     {
76         if (timingFunction)
77             m_timingFunction = timingFunction;
78     }
79     
80     virtual ~AnimationValue() { }
81
82     float keyTime() const { return m_keyTime; }
83     const TimingFunction* timingFunction() const { return m_timingFunction.get(); }
84     virtual AnimationValue* clone() const = 0;
85
86 private:
87     float m_keyTime;
88     RefPtr<TimingFunction> m_timingFunction;
89 };
90
91 // Used to store one float value of an animation.
92 class FloatAnimationValue : public AnimationValue {
93 public:
94     FloatAnimationValue(float keyTime, float value, PassRefPtr<TimingFunction> timingFunction = 0)
95         : AnimationValue(keyTime, timingFunction)
96         , m_value(value)
97     {
98     }
99     virtual AnimationValue* clone() const { return new FloatAnimationValue(*this); }
100
101     float value() const { return m_value; }
102
103 private:
104     float m_value;
105 };
106
107 // Used to store one transform value in a keyframe list.
108 class TransformAnimationValue : public AnimationValue {
109 public:
110     TransformAnimationValue(float keyTime, const TransformOperations* value = 0, PassRefPtr<TimingFunction> timingFunction = 0)
111         : AnimationValue(keyTime, timingFunction)
112     {
113         if (value)
114             m_value = *value;
115     }
116     virtual AnimationValue* clone() const { return new TransformAnimationValue(*this); }
117
118     const TransformOperations* value() const { return &m_value; }
119
120 private:
121     TransformOperations m_value;
122 };
123
124 #if ENABLE(CSS_FILTERS)
125 // Used to store one filter value in a keyframe list.
126 class FilterAnimationValue : public AnimationValue {
127 public:
128     FilterAnimationValue(float keyTime, const FilterOperations* value = 0, PassRefPtr<TimingFunction> timingFunction = 0)
129         : AnimationValue(keyTime, timingFunction)
130     {
131         if (value)
132             m_value = *value;
133     }
134     virtual AnimationValue* clone() const { return new FilterAnimationValue(*this); }
135
136     const FilterOperations* value() const { return &m_value; }
137
138 private:
139     FilterOperations m_value;
140 };
141 #endif
142
143 // Used to store a series of values in a keyframe list. Values will all be of the same type,
144 // which can be inferred from the property.
145 class KeyframeValueList {
146 public:
147
148     KeyframeValueList(AnimatedPropertyID property)
149         : m_property(property)
150     {
151     }
152
153     KeyframeValueList(const KeyframeValueList& other)
154         : m_property(other.property())
155     {
156         for (size_t i = 0; i < other.m_values.size(); ++i)
157             m_values.append(other.m_values[i]->clone());
158     }
159
160     ~KeyframeValueList()
161     {
162         deleteAllValues(m_values);
163     }
164
165     KeyframeValueList& operator=(const KeyframeValueList& other)
166     {
167         KeyframeValueList copy(other);
168         swap(copy);
169         return *this;
170     }
171
172     void swap(KeyframeValueList& other)
173     {
174         std::swap(m_property, other.m_property);
175         m_values.swap(other.m_values);
176     }
177
178     AnimatedPropertyID property() const { return m_property; }
179
180     size_t size() const { return m_values.size(); }
181     const AnimationValue* at(size_t i) const { return m_values.at(i); }
182     
183     // Insert, sorted by keyTime. Takes ownership of the pointer.
184     void insert(const AnimationValue*);
185     
186 protected:
187     Vector<const AnimationValue*> m_values;
188     AnimatedPropertyID m_property;
189 };
190
191
192
193 // GraphicsLayer is an abstraction for a rendering surface with backing store,
194 // which may have associated transformation and animations.
195
196 class GraphicsLayer {
197     WTF_MAKE_NONCOPYABLE(GraphicsLayer); WTF_MAKE_FAST_ALLOCATED;
198 public:
199     static PassOwnPtr<GraphicsLayer> create(GraphicsLayerFactory*, GraphicsLayerClient*);
200
201     // FIXME: Replace all uses of this create function with the one that takes a GraphicsLayerFactory.
202     static PassOwnPtr<GraphicsLayer> create(GraphicsLayerClient*);
203     
204     virtual ~GraphicsLayer();
205
206     GraphicsLayerClient* client() const { return m_client; }
207
208     // Layer name. Only used to identify layers in debug output
209     const String& name() const { return m_name; }
210     virtual void setName(const String& name) { m_name = name; }
211
212     GraphicsLayer* parent() const { return m_parent; };
213     void setParent(GraphicsLayer*); // Internal use only.
214     
215     // Returns true if the layer has the given layer as an ancestor (excluding self).
216     bool hasAncestor(GraphicsLayer*) const;
217     
218     const Vector<GraphicsLayer*>& children() const { return m_children; }
219     // Returns true if the child list changed.
220     virtual bool setChildren(const Vector<GraphicsLayer*>&);
221
222     // Add child layers. If the child is already parented, it will be removed from its old parent.
223     virtual void addChild(GraphicsLayer*);
224     virtual void addChildAtIndex(GraphicsLayer*, int index);
225     virtual void addChildAbove(GraphicsLayer* layer, GraphicsLayer* sibling);
226     virtual void addChildBelow(GraphicsLayer* layer, GraphicsLayer* sibling);
227     virtual bool replaceChild(GraphicsLayer* oldChild, GraphicsLayer* newChild);
228
229     void removeAllChildren();
230     virtual void removeFromParent();
231
232     GraphicsLayer* maskLayer() const { return m_maskLayer; }
233     virtual void setMaskLayer(GraphicsLayer* layer) { m_maskLayer = layer; }
234     
235     // The given layer will replicate this layer and its children; the replica renders behind this layer.
236     virtual void setReplicatedByLayer(GraphicsLayer*);
237     // Whether this layer is being replicated by another layer.
238     bool isReplicated() const { return m_replicaLayer; }
239     // The layer that replicates this layer (if any).
240     GraphicsLayer* replicaLayer() const { return m_replicaLayer; }
241
242     const FloatPoint& replicatedLayerPosition() const { return m_replicatedLayerPosition; }
243     void setReplicatedLayerPosition(const FloatPoint& p) { m_replicatedLayerPosition = p; }
244
245     enum ShouldSetNeedsDisplay {
246         DontSetNeedsDisplay,
247         SetNeedsDisplay
248     };
249
250     // Offset is origin of the renderer minus origin of the graphics layer (so either zero or negative).
251     IntSize offsetFromRenderer() const { return m_offsetFromRenderer; }
252     void setOffsetFromRenderer(const IntSize&, ShouldSetNeedsDisplay = SetNeedsDisplay);
253
254     // The position of the layer (the location of its top-left corner in its parent)
255     const FloatPoint& position() const { return m_position; }
256     virtual void setPosition(const FloatPoint& p) { m_position = p; }
257
258     // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
259     virtual void syncPosition(const FloatPoint& p) { m_position = p; }
260     
261     // Anchor point: (0, 0) is top left, (1, 1) is bottom right. The anchor point
262     // affects the origin of the transforms.
263     const FloatPoint3D& anchorPoint() const { return m_anchorPoint; }
264     virtual void setAnchorPoint(const FloatPoint3D& p) { m_anchorPoint = p; }
265
266     // The size of the layer.
267     const FloatSize& size() const { return m_size; }
268     virtual void setSize(const FloatSize& size) { m_size = size; }
269
270     // The boundOrigin affects the offset at which content is rendered, and sublayers are positioned.
271     const FloatPoint& boundsOrigin() const { return m_boundsOrigin; }
272     virtual void setBoundsOrigin(const FloatPoint& origin) { m_boundsOrigin = origin; }
273
274     const TransformationMatrix& transform() const { return m_transform; }
275     virtual void setTransform(const TransformationMatrix& t) { m_transform = t; }
276
277     const TransformationMatrix& childrenTransform() const { return m_childrenTransform; }
278     virtual void setChildrenTransform(const TransformationMatrix& t) { m_childrenTransform = t; }
279
280     bool preserves3D() const { return m_preserves3D; }
281     virtual void setPreserves3D(bool b) { m_preserves3D = b; }
282     
283     bool masksToBounds() const { return m_masksToBounds; }
284     virtual void setMasksToBounds(bool b) { m_masksToBounds = b; }
285     
286     bool drawsContent() const { return m_drawsContent; }
287     virtual void setDrawsContent(bool b) { m_drawsContent = b; }
288
289     bool contentsAreVisible() const { return m_contentsVisible; }
290     virtual void setContentsVisible(bool b) { m_contentsVisible = b; }
291
292     bool acceleratesDrawing() const { return m_acceleratesDrawing; }
293     virtual void setAcceleratesDrawing(bool b) { m_acceleratesDrawing = b; }
294
295     // The color used to paint the layer backgrounds
296     const Color& backgroundColor() const { return m_backgroundColor; }
297     virtual void setBackgroundColor(const Color&);
298     virtual void clearBackgroundColor();
299     bool backgroundColorSet() const { return m_backgroundColorSet; }
300
301     // opaque means that we know the layer contents have no alpha
302     bool contentsOpaque() const { return m_contentsOpaque; }
303     virtual void setContentsOpaque(bool b) { m_contentsOpaque = b; }
304
305     bool backfaceVisibility() const { return m_backfaceVisibility; }
306     virtual void setBackfaceVisibility(bool b) { m_backfaceVisibility = b; }
307
308     float opacity() const { return m_opacity; }
309     virtual void setOpacity(float opacity) { m_opacity = opacity; }
310
311 #if ENABLE(CSS_FILTERS)
312     const FilterOperations& filters() const { return m_filters; }
313     
314     // Returns true if filter can be rendered by the compositor
315     virtual bool setFilters(const FilterOperations& filters) { m_filters = filters; return true; }
316 #endif
317
318     // Some GraphicsLayers paint only the foreground or the background content
319     GraphicsLayerPaintingPhase paintingPhase() const { return m_paintingPhase; }
320     void setPaintingPhase(GraphicsLayerPaintingPhase phase) { m_paintingPhase = phase; }
321
322     virtual void setNeedsDisplay() = 0;
323     // mark the given rect (in layer coords) as needing dispay. Never goes deep.
324     virtual void setNeedsDisplayInRect(const FloatRect&) = 0;
325
326     virtual void setContentsNeedsDisplay() { };
327
328     // Set that the position/size of the contents (image or video).
329     IntRect contentsRect() const { return m_contentsRect; }
330     virtual void setContentsRect(const IntRect& r) { m_contentsRect = r; }
331     
332     // Transitions are identified by a special animation name that cannot clash with a keyframe identifier.
333     static String animationNameForTransition(AnimatedPropertyID);
334     
335     // Return true if the animation is handled by the compositing system. If this returns
336     // false, the animation will be run by AnimationController.
337     // These methods handle both transitions and keyframe animations.
338     virtual bool addAnimation(const KeyframeValueList&, const IntSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
339     virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
340     virtual void removeAnimation(const String& /*animationName*/) { }
341
342     virtual void suspendAnimations(double time);
343     virtual void resumeAnimations();
344     
345     // Layer contents
346     virtual void setContentsToImage(Image*) { }
347     virtual bool shouldDirectlyCompositeImage(Image*) const { return true; }
348     virtual void setContentsToMedia(PlatformLayer*) { } // video or plug-in
349     virtual void setContentsToBackgroundColor(const Color&) { }
350     virtual void setContentsToCanvas(PlatformLayer*) { }
351     virtual bool hasContentsLayer() const { return false; }
352
353     // Callback from the underlying graphics system to draw layer contents.
354     void paintGraphicsLayerContents(GraphicsContext&, const IntRect& clip);
355     // Callback from the underlying graphics system when the layer has been displayed
356     virtual void layerDidDisplay(PlatformLayer*) { }
357     
358     // For hosting this GraphicsLayer in a native layer hierarchy.
359     virtual PlatformLayer* platformLayer() const { return 0; }
360     
361     enum CompositingCoordinatesOrientation { CompositingCoordinatesTopDown, CompositingCoordinatesBottomUp };
362
363     // Flippedness of the contents of this layer. Does not affect sublayer geometry.
364     virtual void setContentsOrientation(CompositingCoordinatesOrientation orientation) { m_contentsOrientation = orientation; }
365     CompositingCoordinatesOrientation contentsOrientation() const { return m_contentsOrientation; }
366
367     void dumpLayer(TextStream&, int indent = 0, LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
368
369     virtual void setShowDebugBorder(bool show) { m_showDebugBorder = show; }
370     bool isShowingDebugBorder() const { return m_showDebugBorder; }
371
372     virtual void setShowRepaintCounter(bool show) { m_showRepaintCounter = show; }
373     bool isShowingRepaintCounter() const { return m_showRepaintCounter; }
374
375     // FIXME: this is really a paint count.
376     int repaintCount() const { return m_repaintCount; }
377     int incrementRepaintCount() { return ++m_repaintCount; }
378
379     virtual void setDebugBackgroundColor(const Color&) { }
380     virtual void setDebugBorder(const Color&, float /*borderWidth*/) { }
381
382     // z-position is the z-equivalent of position(). It's only used for debugging purposes.
383     virtual float zPosition() const { return m_zPosition; }
384     virtual void setZPosition(float);
385
386     virtual void distributeOpacity(float);
387     virtual float accumulatedOpacity() const;
388
389     virtual void setMaintainsPixelAlignment(bool maintainsAlignment) { m_maintainsPixelAlignment = maintainsAlignment; }
390     virtual bool maintainsPixelAlignment() const { return m_maintainsPixelAlignment; }
391     
392     virtual void setAppliesPageScale(bool appliesScale = true) { m_appliesPageScale = appliesScale; }
393     virtual bool appliesPageScale() const { return m_appliesPageScale; }
394
395     float pageScaleFactor() const { return m_client ? m_client->pageScaleFactor() : 1; }
396     float deviceScaleFactor() const { return m_client ? m_client->deviceScaleFactor() : 1; }
397
398     virtual void deviceOrPageScaleFactorChanged() { }
399     void noteDeviceOrPageScaleFactorChangedIncludingDescendants();
400
401     // Some compositing systems may do internal batching to synchronize compositing updates
402     // with updates drawn into the window. These methods flush internal batched state on this layer
403     // and descendant layers, and this layer only.
404     virtual void flushCompositingState(const FloatRect& /* clipRect */) { }
405     virtual void flushCompositingStateForThisLayerOnly() { }
406     
407     // Return a string with a human readable form of the layer tree, If debug is true 
408     // pointers for the layers and timing data will be included in the returned string.
409     String layerTreeAsText(LayerTreeAsTextBehavior = LayerTreeAsTextBehaviorNormal) const;
410
411     // Return an estimate of the backing store memory cost (in bytes). May be incorrect for tiled layers.
412     virtual double backingStoreMemoryEstimate() const;
413
414     bool usingTiledLayer() const { return m_usingTiledLayer; }
415
416     virtual TiledBacking* tiledBacking() const { return 0; }
417
418     void resetTrackedRepaints();
419     void addRepaintRect(const FloatRect&);
420
421 #if PLATFORM(QT) || PLATFORM(GTK) || PLATFORM(EFL)
422     // This allows several alternative GraphicsLayer implementations in the same port,
423     // e.g. if a different GraphicsLayer implementation is needed in WebKit1 vs. WebKit2.
424     typedef PassOwnPtr<GraphicsLayer> GraphicsLayerFactoryCallback(GraphicsLayerClient*);
425     static void setGraphicsLayerFactory(GraphicsLayerFactoryCallback);
426 #endif
427
428     void updateDebugIndicators();
429
430 protected:
431     // Should be called from derived class destructors. Should call willBeDestroyed() on super.
432     virtual void willBeDestroyed();
433
434 #if ENABLE(CSS_FILTERS)
435     // This method is used by platform GraphicsLayer classes to clear the filters
436     // when compositing is not done in hardware. It is not virtual, so the caller
437     // needs to notifiy the change to the platform layer as needed.
438     void clearFilters() { m_filters.clear(); }
439
440     // Given a KeyframeValueList containing filterOperations, return true if the operations are valid.
441     static int validateFilterOperations(const KeyframeValueList&);
442 #endif
443
444     // Given a list of TransformAnimationValues, see if all the operations for each keyframe match. If so
445     // return the index of the KeyframeValueList entry that has that list of operations (it may not be
446     // the first entry because some keyframes might have an empty transform and those match any list).
447     // If the lists don't match return -1. On return, if hasBigRotation is true, functions contain 
448     // rotations of >= 180 degrees
449     static int validateTransformOperations(const KeyframeValueList&, bool& hasBigRotation);
450
451     virtual void setOpacityInternal(float) { }
452
453     // The layer being replicated.
454     GraphicsLayer* replicatedLayer() const { return m_replicatedLayer; }
455     virtual void setReplicatedLayer(GraphicsLayer* layer) { m_replicatedLayer = layer; }
456
457     GraphicsLayer(GraphicsLayerClient*);
458
459     static void writeIndent(TextStream&, int indent);
460
461     void dumpProperties(TextStream&, int indent, LayerTreeAsTextBehavior) const;
462     virtual void dumpAdditionalProperties(TextStream&, int /*indent*/, LayerTreeAsTextBehavior) const { }
463
464     virtual void getDebugBorderInfo(Color&, float& width) const;
465
466     GraphicsLayerClient* m_client;
467     String m_name;
468     
469     // Offset from the owning renderer
470     IntSize m_offsetFromRenderer;
471     
472     // Position is relative to the parent GraphicsLayer
473     FloatPoint m_position;
474     FloatPoint3D m_anchorPoint;
475     FloatSize m_size;
476     FloatPoint m_boundsOrigin;
477
478     TransformationMatrix m_transform;
479     TransformationMatrix m_childrenTransform;
480
481     Color m_backgroundColor;
482     float m_opacity;
483     float m_zPosition;
484     
485 #if ENABLE(CSS_FILTERS)
486     FilterOperations m_filters;
487 #endif
488
489     bool m_backgroundColorSet : 1;
490     bool m_contentsOpaque : 1;
491     bool m_preserves3D: 1;
492     bool m_backfaceVisibility : 1;
493     bool m_usingTiledLayer : 1;
494     bool m_masksToBounds : 1;
495     bool m_drawsContent : 1;
496     bool m_contentsVisible : 1;
497     bool m_acceleratesDrawing : 1;
498     bool m_maintainsPixelAlignment : 1;
499     bool m_appliesPageScale : 1; // Set for the layer which has the page scale applied to it.
500     bool m_showDebugBorder : 1;
501     bool m_showRepaintCounter : 1;
502     
503     GraphicsLayerPaintingPhase m_paintingPhase;
504     CompositingCoordinatesOrientation m_contentsOrientation; // affects orientation of layer contents
505
506     Vector<GraphicsLayer*> m_children;
507     GraphicsLayer* m_parent;
508
509     GraphicsLayer* m_maskLayer; // Reference to mask layer. We don't own this.
510
511     GraphicsLayer* m_replicaLayer; // A layer that replicates this layer. We only allow one, for now.
512                                    // The replica is not parented; this is the primary reference to it.
513     GraphicsLayer* m_replicatedLayer; // For a replica layer, a reference to the original layer.
514     FloatPoint m_replicatedLayerPosition; // For a replica layer, the position of the replica.
515
516     IntRect m_contentsRect;
517
518     int m_repaintCount;
519
520 #if PLATFORM(QT) || PLATFORM(GTK) || PLATFORM(EFL)
521     static GraphicsLayer::GraphicsLayerFactoryCallback* s_graphicsLayerFactory;
522 #endif
523 };
524
525
526 } // namespace WebCore
527
528 #ifndef NDEBUG
529 // Outside the WebCore namespace for ease of invocation from gdb.
530 void showGraphicsLayerTree(const WebCore::GraphicsLayer* layer);
531 #endif
532
533 #endif // USE(ACCELERATED_COMPOSITING)
534
535 #endif // GraphicsLayer_h