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