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