Take into account scaling operations when deciding backingStore scale factor

Author: magomez

Source/WebCore/platform/graphics/nicosia/NicosiaAnimation.cpp

@@ -21,6 +21,7 @@
 #include "NicosiaAnimation.h"
 
 #include "LayoutSize.h"
+#include "ScaleTransformOperation.h"
 #include "TranslateTransformOperation.h"
 #include <wtf/Scope.h>
 
@@ -481,4 +482,28 @@ bool Animations::hasRunningTransformAnimations() const
         });
 }
 
+float Animations::maximumScaleFactor() const
+{
+    // Traverse all the keyframes keeping the max values used for scaling.
+    double scale = 1;
+    for (auto& animation : m_animations) {
+        auto& keyframes = animation.keyframes();
+
+        if (keyframes.property() != AnimatedProperty::Transform)
+            continue;
+
+        for (size_t i = 0; i < keyframes.size(); i++) {
+            const auto& transformOperations = static_cast<const TransformAnimationValue&>(keyframes.at(i)).value();
+            for (size_t j = 0; j < transformOperations.size(); j++) {
+                auto* transformOperation = transformOperations.at(j);
+                if (TransformOperation::isScaleTransformOperationType(transformOperation->type())) {
+                    auto* scaleTransformOperation = static_cast<const ScaleTransformOperation*>(transformOperation);
+                    scale = std::max(scale, std::max(scaleTransformOperation->x(), scaleTransformOperation->y()));
+                }
+            }
+        }
+    }
+    return scale;
+}
+
 } // namespace Nicosia

Source/WebCore/platform/graphics/nicosia/NicosiaAnimation.h

@@ -103,6 +103,7 @@ class Animations {
     Vector<Animation>& animations() { return m_animations; }
 
     bool hasActiveAnimationsOfType(WebCore::AnimatedProperty type) const;
+    float maximumScaleFactor() const;
 
     bool hasRunningAnimations() const;
     bool hasRunningTransformAnimations() const;

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@ -860,6 +860,10 @@ void CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly()
 
     // Determine the backing store presence. Content is painted later, in the updateContentBuffers() traversal.
     if (shouldHaveBackingStore()) {
+        // The layer has a backingStore. Check whether we need to apply a concrete scale factor to it
+        // because of some animation or transformation. If we don't do this, the backingStore will always
+        // have a factor of 1, which will produce blurry results when the layer is scaled up.
+        updateAnimationOrTransformScaleFactor();
         if (!m_nicosia.backingStore) {
             m_nicosia.backingStore = Nicosia::BackingStore::create();
             m_nicosia.delta.backingStoreChanged = true;
@@ -1077,7 +1081,7 @@ void CoordinatedGraphicsLayer::deviceOrPageScaleFactorChanged()
 
 float CoordinatedGraphicsLayer::effectiveContentsScale()
 {
-    return selfOrAncestorHaveNonAffineTransforms() ? 1 : deviceScaleFactor() * pageScaleFactor();
+    return selfOrAncestorHaveNonAffineTransforms() ? 1 : deviceScaleFactor() * pageScaleFactor() * m_animationOrTransformScaleFactor;
 }
 
 IntRect CoordinatedGraphicsLayer::transformedVisibleRect()
@@ -1437,6 +1441,12 @@ bool CoordinatedGraphicsLayer::addAnimation(const KeyframeValueList& valueList,
     m_animations.add(Nicosia::Animation(keyframesName, valueList, boxSize, *anim, m_lastAnimationStartTime, 0_s, Nicosia::Animation::AnimationState::Playing));
     m_animationStartedTimer.startOneShot(0_s);
     didChangeAnimations();
+
+    // If the animation is of type AnimatedProperty::Transform, it may be a scale animation. Check whether
+    // we need to update the scale factor due to a new scale animation being added.
+    if (valueList.property() == AnimatedProperty::Transform)
+        updateAnimationScaleFactor();
+
     return true;
 }
 
@@ -1450,6 +1460,9 @@ void CoordinatedGraphicsLayer::removeAnimation(const String& animationName, std:
 {
     m_animations.remove(animationName);
     didChangeAnimations();
+    // An animation has been removed, and it could be a scale animation, so check whether
+    // we need to update the animation scale factor.
+    updateAnimationScaleFactor();
 }
 
 void CoordinatedGraphicsLayer::suspendAnimations(MonotonicTime time)
@@ -1492,6 +1505,34 @@ PlatformLayer* CoordinatedGraphicsLayer::platformLayer() const
 }
 #endif
 
+void CoordinatedGraphicsLayer::updateAnimationScaleFactor()
+{
+    m_animationScaleFactor = m_animations.maximumScaleFactor();
+}
+
+void CoordinatedGraphicsLayer::updateAnimationOrTransformScaleFactor()
+{
+    TransformationMatrix::Decomposed2Type decomposed2;
+
+    float parentScale = 1.0;
+    if (parent()) {
+        if (!downcast<CoordinatedGraphicsLayer>(*parent()).m_layerTransform.combinedForChildren().decompose2(decomposed2))
+            return;
+        parentScale = std::max(decomposed2.scaleX, decomposed2.scaleY);
+    }
+
+    if (!transform().decompose2(decomposed2))
+        return;
+    float localScale = std::max(decomposed2.scaleX, decomposed2.scaleY);
+
+    float newScale = parentScale * std::max(m_animationScaleFactor, localScale);
+
+    if (newScale != m_animationOrTransformScaleFactor) {
+        m_animationOrTransformScaleFactor = newScale;
+        m_pendingContentsScaleAdjustment = true;
+    }
+}
+
 static void dumpInnerLayer(TextStream& textStream, const String& label, CoordinatedGraphicsLayer* layer, OptionSet<LayerTreeAsTextOptions> options)
 {
     if (!layer)

Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h

@@ -230,6 +230,9 @@ class WEBCORE_EXPORT CoordinatedGraphicsLayer : public GraphicsLayer {
     RefPtr<BitmapTexture> acquireTextureForAcceleratedBuffer(const IntSize&);
 #endif
 
+    void updateAnimationScaleFactor();
+    void updateAnimationOrTransformScaleFactor();
+
     Nicosia::PlatformLayer::LayerID m_id;
     GraphicsLayerTransform m_layerTransform;
     TransformationMatrix m_cachedInverseTransform;
@@ -279,6 +282,9 @@ class WEBCORE_EXPORT CoordinatedGraphicsLayer : public GraphicsLayer {
 
     RefPtr<AnimatedBackingStoreHost> m_animatedBackingStoreHost;
     RefPtr<CoordinatedGraphicsLayer> m_backdropLayer;
+
+    float m_animationScaleFactor { 1.0 };
+    float m_animationOrTransformScaleFactor { 1.0 };
 };
 
 } // namespace WebCore