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