Changeset 268877 in webkit

Timestamp:

Oct 22, 2020, 11:26:43 AM (6 years ago)

Author:

Alan Coon

Message:

Revert r268483. rdar://problem/70578639

Location:

branches/safari-611.1.4-branch/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/graphics/ca/GraphicsLayerCA.cpp (modified) (17 diffs)
• platform/graphics/ca/GraphicsLayerCA.h (modified) (7 diffs)

branches/safari-611.1.4-branch/Source/WebCore/ChangeLog

@@ +1 @@
+2020-10-22  Alan Coon  <alancoon@apple.com>
+
+        Revert r268483. rdar://problem/70578639
+
 2020-10-22  Alan Coon  <alancoon@apple.com>
 

branches/safari-611.1.4-branch/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@ -271 +271 @@
 }
 
+static String animationIdentifier(const String& animationName, AnimatedPropertyID property, int index, int subIndex)
+{
+    return makeString(animationName, '_', static_cast<unsigned>(property), '_', index, '_', subIndex);
+}
+
 static bool animationHasStepsTimingFunction(const KeyframeValueList& valueList, const Animation* anim)
 {
@@ -689 +694 @@
 void GraphicsLayerCA::moveOrCopyAnimations(MoveOrCopy operation, PlatformCALayer *fromLayer, PlatformCALayer *toLayer)
 {
-    for (auto& animation : m_animations) {
-        if ((animation.m_property == AnimatedPropertyTransform
-            || animation.m_property == AnimatedPropertyOpacity
-            || animation.m_property == AnimatedPropertyBackgroundColor
-            || animation.m_property == AnimatedPropertyFilter)
-            && (animation.m_playState == PlayState::Playing || animation.m_playState == PlayState::Paused))
-            moveOrCopyLayerAnimation(operation, animation.animationIdentifier(), fromLayer, toLayer);
+    if (!hasAnimations())
+        return;
+
+    // Look for running animations affecting this property.
+    for (const auto& it : m_animations->runningAnimations) {
+        const auto& propertyAnimations = it.value;
+        size_t numAnimations = propertyAnimations.size();
+        for (size_t i = 0; i < numAnimations; ++i) {
+            const LayerPropertyAnimation& currAnimation = propertyAnimations[i];
+
+            if (currAnimation.m_property == AnimatedPropertyTransform
+                || currAnimation.m_property == AnimatedPropertyOpacity
+                || currAnimation.m_property == AnimatedPropertyBackgroundColor
+                || currAnimation.m_property == AnimatedPropertyFilter)
+                moveOrCopyLayerAnimation(operation, animationIdentifier(currAnimation.m_name, currAnimation.m_property, currAnimation.m_index, currAnimation.m_subIndex), fromLayer, toLayer);
+        }
     }
 }
@@ -1013 +1027 @@
 }
 
-bool GraphicsLayerCA::animationIsRunning(const String& animationName) const
-{
-    auto index = m_animations.findMatching([&](LayerPropertyAnimation animation) {
-        return animation.m_name == animationName;
-    });
-    return index != notFound && m_animations[index].m_playState == PlayState::Playing;
-}
-
-static bool animationCanBeAccelerated(const KeyframeValueList& valueList, const Animation* anim)
+bool GraphicsLayerCA::animationCanBeAccelerated(const KeyframeValueList& valueList, const Animation* anim) const
 {
     if (anim->playbackRate() != 1 || !anim->directionIsForwards())
@@ -1033 +1039 @@
 
     return true;
+}
+
+void GraphicsLayerCA::addProcessingActionForAnimation(const String& animationName, AnimationProcessingAction processingAction)
+{
+    ensureLayerAnimations();
+
+    auto& processingActions = m_animations->animationsToProcess.ensure(animationName, [] {
+        return Vector<AnimationProcessingAction> { };
+    }).iterator->value;
+
+    if (!processingActions.isEmpty() && processingActions.last().action == Remove)
+        return;
+
+    processingActions.append(processingAction);
 }
 
@@ -1070 +1090 @@
     LOG_WITH_STREAM(Animations, stream << "GraphicsLayerCA " << this << " id " << primaryLayerID() << " pauseAnimation " << animationName << " (is running " << animationIsRunning(animationName) << ")");
 
-    auto index = m_animations.findMatching([&](LayerPropertyAnimation animation) {
-        return animation.m_name == animationName && !animation.m_pendingRemoval;
-    });
-
-    if (index == notFound)
-        return;
-
-    auto& animation = m_animations[index];
-    animation.m_playState = PlayState::PausePending;
-    animation.m_timeOffset = Seconds { timeOffset };
+    // Call add since if there is already a Remove in there, we don't want to overwrite it with a Pause.
+    addProcessingActionForAnimation(animationName, AnimationProcessingAction { Pause, Seconds { timeOffset } });
 
     noteLayerPropertyChanged(AnimationChanged);
@@ -1088 +1100 @@
     LOG_WITH_STREAM(Animations, stream << "GraphicsLayerCA " << this << " id " << primaryLayerID() << " removeAnimation " << animationName << " (is running " << animationIsRunning(animationName) << ")");
 
-    auto index = m_animations.findMatching([&](LayerPropertyAnimation animation) {
-        return animation.m_name == animationName && !animation.m_pendingRemoval;
-    });
-
-    if (index == notFound)
-        return;
-
-    m_animations[index].m_pendingRemoval = true;
-
+    if (!animationIsRunning(animationName)) {
+        removeFromUncommittedAnimations(animationName);
+        return;
+    }
+
+    addProcessingActionForAnimation(animationName, AnimationProcessingAction(Remove));
     noteLayerPropertyChanged(AnimationChanged | CoverageRectChanged);
 }
@@ -1103 +1112 @@
 {
     LOG_WITH_STREAM(Animations, stream << "GraphicsLayerCA " << this << " id " << primaryLayerID() << " platformCALayerAnimationStarted " << animationKey);
-
-    auto index = m_animations.findMatching([&](LayerPropertyAnimation animation) {
-        return animation.animationIdentifier() == animationKey && !animation.m_beginTime;
-    });
-
-    if (index != notFound)
-        m_animations[index].m_beginTime = startTime.secondsSinceEpoch();
-
     client().notifyAnimationStarted(this, animationKey, startTime);
 }
@@ -2852 +2853 @@
 void GraphicsLayerCA::updateAnimations()
 {
-    // Remove all animations so far.
-    for (auto& animation : m_animations)
-        removeCAAnimationFromLayer(animation);
-
-    // Remove all animations from the list that were pending removal.
-    m_animations.removeAllMatching([&](LayerPropertyAnimation animation) {
-        return animation.m_pendingRemoval;
-    });
-
-    // Add all remaining animations.
-    for (auto& animation : m_animations) {
-        setAnimationOnLayer(animation);
-        if (animation.m_playState == PlayState::PausePending || animation.m_playState == PlayState::Paused) {
-            pauseCAAnimationOnLayer(animation);
-            animation.m_playState = PlayState::Paused;
-        } else
-            animation.m_playState = PlayState::Playing;
+    if (!hasAnimations())
+        return;
+
+    size_t numAnimations;
+    if ((numAnimations = m_animations->uncomittedAnimations.size())) {
+        for (size_t i = 0; i < numAnimations; ++i) {
+            const LayerPropertyAnimation& pendingAnimation = m_animations->uncomittedAnimations[i];
+            setAnimationOnLayer(*pendingAnimation.m_animation, pendingAnimation.m_property, pendingAnimation.m_name, pendingAnimation.m_index, pendingAnimation.m_subIndex, pendingAnimation.m_timeOffset);
+
+            AnimationsMap::iterator it = m_animations->runningAnimations.find(pendingAnimation.m_name);
+            if (it == m_animations->runningAnimations.end()) {
+                Vector<LayerPropertyAnimation> animations;
+                animations.append(pendingAnimation);
+                m_animations->runningAnimations.add(pendingAnimation.m_name, animations);
+            } else {
+                Vector<LayerPropertyAnimation>& animations = it->value;
+                animations.append(pendingAnimation);
+            }
+        }
+        m_animations->uncomittedAnimations.clear();
+    }
+
+    if (m_animations->animationsToProcess.size()) {
+        for (const auto& it : m_animations->animationsToProcess) {
+            const String& currentAnimationName = it.key;
+            auto animationIterator = m_animations->runningAnimations.find(currentAnimationName);
+            if (animationIterator == m_animations->runningAnimations.end())
+                continue;
+
+            for (const auto& processingInfo : it.value) {
+                const Vector<LayerPropertyAnimation>& animations = animationIterator->value;
+                for (const auto& currentAnimation : animations) {
+                    switch (processingInfo.action) {
+                    case Remove:
+                        removeCAAnimationFromLayer(currentAnimation.m_property, currentAnimationName, currentAnimation.m_index, currentAnimation.m_subIndex);
+                        break;
+                    case Pause:
+                        pauseCAAnimationOnLayer(currentAnimation.m_property, currentAnimationName, currentAnimation.m_index, currentAnimation.m_subIndex, processingInfo.timeOffset);
+                        break;
+                    }
+                }
+
+                if (processingInfo.action == Remove)
+                    m_animations->runningAnimations.remove(currentAnimationName);
+            }
+        }
+
+        m_animations->animationsToProcess.clear();
     }
 }
@@ -2874 +2906 @@
 bool GraphicsLayerCA::isRunningTransformAnimation() const
 {
-    return m_animations.findMatching([&](LayerPropertyAnimation animation) {
-        return animation.m_property == AnimatedPropertyTransform && animation.m_playState == PlayState::Playing;
-    }) != notFound;
-}
-
-void GraphicsLayerCA::setAnimationOnLayer(LayerPropertyAnimation& animation)
-{
-    auto property = animation.m_property;
+    if (!hasAnimations())
+        return false;
+
+    for (const auto& it : m_animations->runningAnimations) {
+        const auto& propertyAnimations = it.value;
+        size_t numAnimations = propertyAnimations.size();
+        for (size_t i = 0; i < numAnimations; ++i) {
+            const LayerPropertyAnimation& currAnimation = propertyAnimations[i];
+            if (currAnimation.m_property == AnimatedPropertyTransform)
+                return true;
+        }
+    }
+    return false;
+}
+
+void GraphicsLayerCA::ensureLayerAnimations()
+{
+    if (!m_animations)
+        m_animations = makeUnique<LayerAnimations>();
+}
+
+void GraphicsLayerCA::setAnimationOnLayer(PlatformCAAnimation& caAnim, AnimatedPropertyID property, const String& animationName, int index, int subIndex, Seconds timeOffset)
+{
     PlatformCALayer* layer = animatedLayer(property);
 
-    auto& caAnim = *animation.m_animation;
-
-    if (animation.m_timeOffset) {
-        // In case we have an offset, we need to record the beginTime now since we have to pass in an explicit
-        // value in the first place.
-        if (!animation.m_beginTime)
-            animation.m_beginTime = Seconds(CACurrentMediaTime());
-        caAnim.setBeginTime((animation.m_beginTime - animation.m_timeOffset).seconds());
-    } else if (animation.m_beginTime) {
-        // If we already have a begin time, then we already started in the past and must ensure we use that same
-        // begin time. Any other case will get use the CA transaction's time as its begin time and will be recorded
-        // in platformCALayerAnimationStarted().
-        caAnim.setBeginTime(animation.m_beginTime.seconds());
-    }
-
-    String animationID = animation.animationIdentifier();
+    if (timeOffset)
+        caAnim.setBeginTime(CACurrentMediaTime() - timeOffset.seconds());
+
+    String animationID = animationIdentifier(animationName, property, index, subIndex);
 
     layer->removeAnimationForKey(animationID);
@@ -2930 +2965 @@
 }
 
-bool GraphicsLayerCA::removeCAAnimationFromLayer(LayerPropertyAnimation& animation)
-{
-    PlatformCALayer* layer = animatedLayer(animation.m_property);
-
-    String animationID = animation.animationIdentifier();
+bool GraphicsLayerCA::removeCAAnimationFromLayer(AnimatedPropertyID property, const String& animationName, int index, int subIndex)
+{
+    PlatformCALayer* layer = animatedLayer(property);
+
+    String animationID = animationIdentifier(animationName, property, index, subIndex);
 
     if (!layer->animationForKey(animationID))
@@ -2942 +2977 @@
     bug7311367Workaround(m_structuralLayer.get(), transform());
 
-    if (LayerMap* layerCloneMap = animatedLayerClones(animation.m_property)) {
+    if (LayerMap* layerCloneMap = animatedLayerClones(property)) {
         for (auto& clone : *layerCloneMap) {
             // Skip immediate replicas, since they move with the original.
@@ -2954 +2989 @@
 }
 
-void GraphicsLayerCA::pauseCAAnimationOnLayer(LayerPropertyAnimation& animation)
-{
-    PlatformCALayer* layer = animatedLayer(animation.m_property);
-
-    String animationID = animation.animationIdentifier();
+void GraphicsLayerCA::pauseCAAnimationOnLayer(AnimatedPropertyID property, const String& animationName, int index, int subIndex, Seconds timeOffset)
+{
+    PlatformCALayer* layer = animatedLayer(property);
+
+    String animationID = animationIdentifier(animationName, property, index, subIndex);
 
     RefPtr<PlatformCAAnimation> curAnim = layer->animationForKey(animationID);
@@ -2968 +3003 @@
 
     newAnim->setSpeed(0);
-    newAnim->setTimeOffset(animation.m_timeOffset.seconds());
+    newAnim->setTimeOffset(timeOffset.seconds());
 
     layer->addAnimationForKey(animationID, *newAnim); // This will replace the running animation.
 
     // Pause the animations on the clones too.
-    if (LayerMap* layerCloneMap = animatedLayerClones(animation.m_property)) {
+    if (LayerMap* layerCloneMap = animatedLayerClones(property)) {
         for (auto& clone : *layerCloneMap) {
             // Skip immediate replicas, since they move with the original.
@@ -3034 +3069 @@
         return false;
 
-    m_animations.append(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, 0, timeOffset));
+    appendToUncommittedAnimations(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, 0, timeOffset));
 
     return true;
@@ -3065 +3100 @@
         return false;
 
-    m_animations.append(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, 0, timeOffset));
+    appendToUncommittedAnimations(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, 0, timeOffset));
     return true;
 }
@@ -3125 +3160 @@
         ASSERT(valuesOK);
 
-        m_animations.append(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, internalFilterPropertyIndex, timeOffset));
+        appendToUncommittedAnimations(LayerPropertyAnimation(caAnimation.releaseNonNull(), animationName, valueList.property(), animationIndex, internalFilterPropertyIndex, timeOffset));
     }
 
     return true;
+}
+
+void GraphicsLayerCA::appendToUncommittedAnimations(LayerPropertyAnimation&& animation)
+{
+    ensureLayerAnimations();
+
+    // Since we're adding a new animation, make sure we clear any pending AnimationProcessingAction for this animation
+    // as these are applied after we've committed new animations. However, we want to check if we had a pending removal
+    // such that removing an animation prior to adding a new one for the same name works.
+    auto processingInfoIterator = m_animations->animationsToProcess.find(animation.m_name);
+    if (processingInfoIterator != m_animations->animationsToProcess.end()) {
+        auto animationIterator = m_animations->runningAnimations.find(animation.m_name);
+        if (animationIterator != m_animations->runningAnimations.end()) {
+            auto& animations = animationIterator->value;
+            for (const auto& processingInfo : processingInfoIterator->value) {
+                if (processingInfo.action == Remove) {
+                    for (const auto& currentAnimation : animations)
+                        removeCAAnimationFromLayer(currentAnimation.m_property, animation.m_name, currentAnimation.m_index, currentAnimation.m_subIndex);
+                    m_animations->runningAnimations.remove(animationIterator);
+                    break;
+                }
+            }
+        }
+        m_animations->animationsToProcess.remove(processingInfoIterator);
+    }
+
+    m_animations->uncomittedAnimations.append(WTFMove(animation));
+}
+
+void GraphicsLayerCA::removeFromUncommittedAnimations(const String& animationName)
+{
+    if (!m_animations)
+        return;
+
+    m_animations->uncomittedAnimations.removeFirstMatching([&animationName] (auto& current) {
+        return current.m_name == animationName;
+    });
 }
 
@@ -4237 +4309 @@
     Vector<std::pair<String, double>> animations;
 
-    for (auto& animation : m_animations) {
-        auto caAnimation = animatedLayer(animation.m_property)->animationForKey(animation.animationIdentifier());
-        animations.append({ animatedPropertyIDAsString(animation.m_property), caAnimation->speed() });
+    if (hasAnimations()) {
+        for (auto it : m_animations->runningAnimations) {
+            auto& propertyAnimations = it.value;
+            size_t numAnimations = propertyAnimations.size();
+            for (size_t i = 0; i < numAnimations; ++i) {
+                const LayerPropertyAnimation& currAnimation = propertyAnimations[i];
+                auto caAnimation = animatedLayer(currAnimation.m_property)->animationForKey(animationIdentifier(currAnimation.m_name, currAnimation.m_property, currAnimation.m_index, currAnimation.m_subIndex));
+                animations.append({ animatedPropertyIDAsString(currAnimation.m_property), caAnimation->speed() });
+            }
+        }
     }
 

branches/safari-611.1.4-branch/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@ -184 +184 @@
     WEBCORE_EXPORT void setOpacityInternal(float) override;
     
+    WEBCORE_EXPORT bool animationCanBeAccelerated(const KeyframeValueList&, const Animation*) const;
+
 private:
     bool isGraphicsLayerCA() const override { return true; }
@@ -274 +276 @@
     WEBCORE_EXPORT bool backingStoreAttachedForTesting() const override;
 
-    bool hasAnimations() const { return !m_animations.isEmpty(); }
-    bool animationIsRunning(const String& animationName) const;
+    bool hasAnimations() const { return m_animations.get(); }
+    bool animationIsRunning(const String& animationName) const
+    {
+        return m_animations && m_animations->runningAnimations.contains(animationName);
+    }
 
     void commitLayerChangesBeforeSublayers(CommitState&, float pageScaleFactor, const FloatPoint& positionRelativeToBase, bool& layerTypeChanged);
@@ -448 +453 @@
     bool ensureStructuralLayer(StructuralLayerPurpose);
     StructuralLayerPurpose structuralLayerPurpose() const;
+    
+    void ensureLayerAnimations();
+
+    void setAnimationOnLayer(PlatformCAAnimation&, AnimatedPropertyID, const String& animationName, int index, int subIndex, Seconds timeOffset);
+    bool removeCAAnimationFromLayer(AnimatedPropertyID, const String& animationName, int index, int subINdex);
+    void pauseCAAnimationOnLayer(AnimatedPropertyID, const String& animationName, int index, int subIndex, Seconds timeOffset);
+
+    enum MoveOrCopy { Move, Copy };
+    static void moveOrCopyLayerAnimation(MoveOrCopy, const String& animationIdentifier, PlatformCALayer *fromLayer, PlatformCALayer *toLayer);
+    void moveOrCopyAnimations(MoveOrCopy, PlatformCALayer* fromLayer, PlatformCALayer* toLayer);
+
+    void moveAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
+    {
+        moveOrCopyAnimations(Move, fromLayer, toLayer);
+    }
+    void copyAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
+    {
+        moveOrCopyAnimations(Copy, fromLayer, toLayer);
+    }
 
     // This represents the animation of a single property. There may be multiple transform animations for
     // a single transition or keyframe animation, so index is used to distinguish these.
-    enum class PlayState { Playing, PlayPending, Paused, PausePending };
     struct LayerPropertyAnimation {
         LayerPropertyAnimation(Ref<PlatformCAAnimation>&& caAnimation, const String& animationName, AnimatedPropertyID property, int index, int subIndex, Seconds timeOffset)
@@ -462 +485 @@
         { }
 
-        String animationIdentifier() const { return makeString(m_name, '_', static_cast<unsigned>(m_property), '_', m_index, '_', m_subIndex); }
-
         RefPtr<PlatformCAAnimation> m_animation;
         String m_name;
@@ -469 +490 @@
         int m_index;
         int m_subIndex;
-        Seconds m_timeOffset { 0_s };
-        Seconds m_beginTime { 0_s };
-        PlayState m_playState { PlayState::PlayPending };
-        bool m_pendingRemoval { false };
-    };
-
-    void setAnimationOnLayer(LayerPropertyAnimation&);
-    bool removeCAAnimationFromLayer(LayerPropertyAnimation&);
-    void pauseCAAnimationOnLayer(LayerPropertyAnimation&);
-
-    enum MoveOrCopy { Move, Copy };
-    static void moveOrCopyLayerAnimation(MoveOrCopy, const String& animationIdentifier, PlatformCALayer *fromLayer, PlatformCALayer *toLayer);
-    void moveOrCopyAnimations(MoveOrCopy, PlatformCALayer* fromLayer, PlatformCALayer* toLayer);
-
-    void moveAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
-    {
-        moveOrCopyAnimations(Move, fromLayer, toLayer);
-    }
-    void copyAnimations(PlatformCALayer* fromLayer, PlatformCALayer* toLayer)
-    {
-        moveOrCopyAnimations(Copy, fromLayer, toLayer);
-    }
+        Seconds m_timeOffset;
+    };
 
     bool appendToUncommittedAnimations(const KeyframeValueList&, const TransformOperations*, const Animation*, const String& animationName, const FloatSize& boxSize, int animationIndex, Seconds timeOffset, bool isMatrixAnimation);
     bool appendToUncommittedAnimations(const KeyframeValueList&, const FilterOperation*, const Animation*, const String& animationName, int animationIndex, Seconds timeOffset);
+    void appendToUncommittedAnimations(LayerPropertyAnimation&&);
+    void removeFromUncommittedAnimations(const String&);
 
     enum LayerChange : uint64_t {
@@ -557 +560 @@
     void repaintLayerDirtyRects();
 
+    enum Action { Remove, Pause };
+    struct AnimationProcessingAction {
+        AnimationProcessingAction(Action action = Remove, Seconds timeOffset = 0_s)
+            : action(action)
+            , timeOffset(timeOffset)
+        {
+        }
+        Action action;
+        Seconds timeOffset; // Only used for pause.
+    };
+    void addProcessingActionForAnimation(const String&, AnimationProcessingAction);
+
     LayerChangeFlags m_uncommittedChanges { 0 };
 
@@ -597 +612 @@
     RetainPtr<CGImageRef> m_pendingContentsImage;
     
-    Vector<LayerPropertyAnimation> m_animations;
+    typedef HashMap<String, Vector<AnimationProcessingAction>> AnimationsToProcessMap;
+    typedef HashMap<String, Vector<LayerPropertyAnimation>> AnimationsMap;
+    struct LayerAnimations {
+        WTF_MAKE_STRUCT_FAST_ALLOCATED;
+        Vector<LayerPropertyAnimation> uncomittedAnimations;
+        AnimationsToProcessMap animationsToProcess;
+        AnimationsMap runningAnimations;
+    };
+    
+    std::unique_ptr<LayerAnimations> m_animations;
 
     Vector<FloatRect> m_dirtyRects;