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