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