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