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