Changeset 294391 in webkit

Timestamp:

May 18, 2022, 5:54:37 AM (4 years ago)

Author:

graouts@webkit.org

Message:

[web-animations] dynamically toggle acceleration of composition animations depending on ability of animations in the effect stack to be accelerated
​https://bugs.webkit.org/show_bug.cgi?id=236708
<rdar://89029577>

Reviewed by Dean Jackson.

We currently don't have support for composite operations at the GraphicsLayerCA level. There are many situations
under which an effect depends on another effect lower in the effect stack, and if that effect fails to run accelerated,
such as due to a non-replace composite operation, we should not run any other effect for that property using
acceleration.

While we could add logic to correctly determine the cases where we actually can run effects using acceleration,
it is a relatively involved task and a simpler, less error-prone approach is to correctly run a whole effect
stack containing some non-replace composite operations without any acceleration.

We already did something similar for cases where we'd fail to run an effect targeting a transform property because
GraphicsLayerCA::addAnimation() would return false. Such situations include using a steps() timing function, a
playback rate other than 1 or providing fewer than 2 animation values.

We now use a single mechanism to deal not only with the case of animations that fail to run using GraphicsLayerCA,
but also with animations that we know GraphicsLayerCA cannot handle, such as non-replace composite operations.

To do this, we change the RunningAccelerated enum to have both "Prevented" and "Failed" values instead of the
single No value to determine the reason why an effect does not accelerated. The "Prevented" value indicates that
the effect stack or the effect itself prevented the effect from running accelerated, while the "Failed" value
indicates that while we attempted to run the animation accelerated through GraphicsLayerCA, we failed to.

We now account for the "Failed" value in preventsAcceleration() to determine that an effect should prevent other
effects from running accelerated. This method is used by KeyframeEffectStack to check that all of its effects
are able to run accelerated and to toggle acceleration based on this value.

As an effect's composite operation or keyframes is set, or when pending accelerated actions are applied, we now
instantiate a CanBeAcceleratedMutationScope which will automatically detect if the preventsAcceleration() value
changes before and after such mutations, and informs the effect stack if that is the case to make sure the effect
stack knows whether it is newly able to run or not run using acceleration.

Finally, to be able to correctly interact with GraphicsLayerCA, we must make sure to reuse the same key when creating
keyframes passed to its animation APIs, so we add a m_keyframesName member.

• Source/WebCore/animation/DocumentTimeline.cpp:

(WebCore::DocumentTimeline::applyPendingAcceleratedAnimations):

• Source/WebCore/animation/KeyframeEffect.cpp:

(WebCore::KeyframeEffect::KeyframeEffect):
(WebCore::KeyframeEffect::copyPropertiesFromSource):
(WebCore::KeyframeEffect::updateBlendingKeyframes):
(WebCore::KeyframeEffect::setBlendingKeyframes):
(WebCore::KeyframeEffect::computeCSSTransitionBlendingKeyframes):
(WebCore::KeyframeEffect::preventsAcceleration const):
(WebCore::KeyframeEffect::updateAcceleratedActions):
(WebCore::KeyframeEffect::addPendingAcceleratedAction):
(WebCore::KeyframeEffect::animationDidChangeTimingProperties):
(WebCore::KeyframeEffect::applyPendingAcceleratedActions):
(WebCore::KeyframeEffect::setComposite):
(WebCore::KeyframeEffect::effectStackNoLongerPreventsAcceleration):
(WebCore::KeyframeEffect::effectStackNoLongerAllowsAcceleration):
(WebCore::KeyframeEffect::abilityToBeAcceleratedDidChange):
(WebCore::KeyframeEffect::CanBeAcceleratedMutationScope::CanBeAcceleratedMutationScope):
(WebCore::KeyframeEffect::CanBeAcceleratedMutationScope::~CanBeAcceleratedMutationScope):
(WebCore::KeyframeEffect::stopAcceleratingTransformRelatedProperties): Deleted.

• Source/WebCore/animation/KeyframeEffect.h:
• Source/WebCore/animation/KeyframeEffectStack.cpp:

(WebCore::KeyframeEffectStack::addEffect):
(WebCore::KeyframeEffectStack::removeEffect):
(WebCore::KeyframeEffectStack::effectAbilityToBeAcceleratedDidChange):
(WebCore::KeyframeEffectStack::allowsAcceleration const):
(WebCore::KeyframeEffectStack::startAcceleratedAnimationsIfPossible):
(WebCore::KeyframeEffectStack::stopAcceleratedAnimations):
(WebCore::KeyframeEffectStack::stopAcceleratingTransformRelatedProperties): Deleted.
(WebCore::KeyframeEffectStack::containsEffectThatPreventsAccelerationOfEffect): Deleted.

• Source/WebCore/animation/KeyframeEffectStack.h:
• Source/WebCore/animation/WebAnimationTypes.h:
• LayoutTests/webanimations/accelerated-animations-and-composite-expected.txt:
• LayoutTests/webanimations/accelerated-animations-and-composite.html:

Canonical link: ​https://commits.webkit.org/250686@main

Location:

trunk

Files:

• LayoutTests/webanimations/accelerated-animations-and-composite-expected.txt (modified) (1 diff)
• LayoutTests/webanimations/accelerated-animations-and-composite.html (modified) (2 diffs)
• Source/WebCore/animation/DocumentTimeline.cpp (modified) (2 diffs)
• Source/WebCore/animation/KeyframeEffect.cpp (modified) (21 diffs)
• Source/WebCore/animation/KeyframeEffect.h (modified) (7 diffs)
• Source/WebCore/animation/KeyframeEffectStack.cpp (modified) (3 diffs)
• Source/WebCore/animation/KeyframeEffectStack.h (modified) (2 diffs)
• Source/WebCore/animation/WebAnimationTypes.h (modified) (1 diff)

trunk/LayoutTests/webanimations/accelerated-animations-and-composite-expected.txt

@@ -6 +6 @@
 PASS Setting 'composite' to 'add' on an animation lower down the stack should prevent replace animations with an implicity keyframe further up the stack to be accelerated
 PASS Setting 'composite' to 'add' on an animation lower down the stack targeting a property that isn't accelerated should allow replace animations with implicit keyframes further up the stack to be accelerated
+PASS Dynamically setting 'composite' on an effect should toggle acceleration
+PASS Dynamically setting 'composite' on a keyframe should toggle acceleration
+PASS Dynamically setting 'composite' to 'add' on an animation further up the stack should toggle acceleration on lower animations in the stack
+PASS Dynamically setting 'composite' to 'add' on an animation lower down the stack should toggle acceleration but always allow replace animations further up the stack to be accelerated
+PASS Dynamically setting 'composite' to 'add' on an animation lower down the stack should toggle acceleration on replace animations with an implicity keyframe further up the stack
+PASS Dynamically setting 'composite' to 'add' on an animation lower down the stack targeting a property that isn't accelerated shouldn't prevent acceleration of animations with implicit keyframes further up the stack to be accelerated
+PASS Adding a composing effect on top of an existing replace effect should prevent both effects from running accelerated
 

trunk/LayoutTests/webanimations/accelerated-animations-and-composite.html

@@ -84 +84 @@
     ));
     await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
-    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
 }, "Setting 'composite' to 'add' on an animation lower down the stack should allow replace animations further up the stack to be accelerated");
 
@@ -124 +124 @@
 }, "Setting 'composite' to 'add' on an animation lower down the stack targeting a property that isn't accelerated should allow replace animations with implicit keyframes further up the stack to be accelerated");
 
+// The following tests check the dynamic interruption and/or start of accelerated animations
+// after changes made to other effects in the stack.
+
+promise_test(async test => {
+    const target = createDiv(test);
+    const animation = target.animate({ transform: "translateX(100px)" }, duration);
+
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+
+    // Setting the effect composition to "add" means that the animation should
+    // no longer be accelerated.
+    animation.effect.composite = "add";
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
+
+    // Resetting the effect composition to "replace" means that the animation
+    // should be accelerated again.
+    animation.effect.composite = "replace";
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+}, "Dynamically setting 'composite' on an effect should toggle acceleration");
+
+promise_test(async test => {
+    const keyframes = composite => [{ offset: 1, composite, transform: "translateX(100px)" }];
+
+    const target = createDiv(test);
+    const animation = target.animate(keyframes("replace"), duration);
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+
+    // Setting the keyframe composition to "add" means that the animation should
+    // no longer be accelerated.
+    animation.effect.setKeyframes(keyframes("add"));
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
+
+    // Resetting the keyframe composition to "replace" means that the animation
+    // should be accelerated again.
+    animation.effect.setKeyframes(keyframes("replace"));
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+}, "Dynamically setting 'composite' on a keyframe should toggle acceleration");
+
+promise_test(async test => {
+    const target = createDiv(test);
+    const animations = [];
+
+    animations.push(target.animate({ transform: "translateX(100px)" }, duration));
+    animations.push(target.animate({ transform: "translateY(100px)" }, duration));
+
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2, "Step 1");
+
+    // Make the second animation a composing animation. This will prevent the first animation
+    // from running accelerated as well.
+    animations[1].effect.composite = "add";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0, "Step 2");
+
+    // Reset to the original state.
+    animations[1].effect.composite = "replace";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2, "Step 3");
+}, "Dynamically setting 'composite' to 'add' on an animation further up the stack should toggle acceleration on lower animations in the stack");
+
+promise_test(async test => {
+    const target = createDiv(test);
+
+    const animations = [];
+    animations.push(target.animate({ transform: "translateX(100px)" }, duration));
+    animations.push(target.animate({ transform: ["none", "translateY(100px)"] }, duration));
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2);
+
+    // Make the first animation a composing animation. This will prevent the other animation from running accelerated.
+    animations[0].effect.composite = "add";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
+
+    // Reset to the original state.
+    animations[0].effect.composite = "replace";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2);
+}, "Dynamically setting 'composite' to 'add' on an animation lower down the stack should toggle acceleration but always allow replace animations further up the stack to be accelerated");
+
+promise_test(async test => {
+    const target = createDiv(test);
+    const animations = [];
+
+    animations.push(target.animate({ transform: "translateX(100px)" }, duration));
+    animations.push(target.animate({ transform: "translateX(100px)" }, duration));
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2);
+
+    // Make the first animation a composing animation. This will prevent both animations
+    // from running accelerated since the second animation uses the first animation as
+    // input due to using an implicit 0% keyframe.
+    animations[0].effect.composite = "add";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
+
+    // Reset to the original state.
+    animations[0].effect.composite = "replace";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 2);
+}, "Dynamically setting 'composite' to 'add' on an animation lower down the stack should toggle acceleration on replace animations with an implicity keyframe further up the stack");
+
+promise_test(async test => {
+    const target = createDiv(test);
+    const animations = [];
+
+    animations.push(target.animate({ marginLeft: "100px" }, duration));
+    animations.push(target.animate({ transform: "translateX(100px)" }, duration));
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+
+    // Make the first animation a composing animation. This should not prevent the other animation from running accelerated.
+    animations[0].effect.composite = "add";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+
+    // Reset to the original state.
+    animations[0].effect.composite = "replace";
+    await Promise.all(animations.map(animation => animationReadyToAnimateAccelerated(animation)));
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+}, "Dynamically setting 'composite' to 'add' on an animation lower down the stack targeting a property that isn't accelerated shouldn't prevent acceleration of animations with implicit keyframes further up the stack to be accelerated");
+
+promise_test(async test => {
+    const target = createDiv(test);
+    const animation = target.animate({ transform: "translateX(100px)" }, duration);
+
+    await animationReadyToAnimateAccelerated(animation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 1);
+
+    const composingAnimation = target.animate(
+        { transform: "translateY(100px)" },
+        { composite: "add", duration }
+    );
+
+    await animationReadyToAnimateAccelerated(composingAnimation);
+    assert_equals(internals.acceleratedAnimationsForElement(target).length, 0);
+}, "Adding a composing effect on top of an existing replace effect should prevent both effects from running accelerated");
+
 </script>
 </body>

trunk/Source/WebCore/animation/DocumentTimeline.cpp

@@ -391 +391 @@
     m_acceleratedAnimationsPendingRunningStateChange.clear();
 
-    // Animations may fail to run accelerated for reasons private to GraphicsLayerCA. If that happens, and the animation
-    // in question targets a transform-related property, we must prevent all other transform-related animations for this
-    // element to run accelerated since we can't run some transform-related animations accelerated, and some not. To do
-    // this, we keep a list of all KeyframeEffectStack objects containing an effect that failed to start a transform-related
-    // animation so that we can return any transform-related accelerated animation to run non-accelerated.
-    HashSet<KeyframeEffectStack*> effectStacksContainingEffectThatFailedToRunAcceleratedTransformRelatedAnimation;
-
     bool hasForcedLayout = false;
     for (auto& animation : acceleratedAnimationsPendingRunningStateChange) {
@@ -407 +400 @@
         if (!hasForcedLayout)
             hasForcedLayout |= keyframeEffect.forceLayoutIfNeeded();
-        auto pendingAccelerationActionResult = keyframeEffect.applyPendingAcceleratedActions();
-        if (pendingAccelerationActionResult.contains(AcceleratedActionApplicationResult::TransformRelatedAnimationCannotBeAccelerated)) {
-            ASSERT(keyframeEffect.targetStyleable());
-            ASSERT(keyframeEffect.targetStyleable()->keyframeEffectStack());
-            effectStacksContainingEffectThatFailedToRunAcceleratedTransformRelatedAnimation.add(keyframeEffect.targetStyleable()->keyframeEffectStack());
-        }
-    }
-
-    for (auto& effectStack : effectStacksContainingEffectThatFailedToRunAcceleratedTransformRelatedAnimation)
-        effectStack->stopAcceleratingTransformRelatedProperties(UseAcceleratedAction::No);
+        keyframeEffect.applyPendingAcceleratedActions();
+    }
 }
 

trunk/Source/WebCore/animation/KeyframeEffect.cpp

@@ -550 +550 @@
 
 KeyframeEffect::KeyframeEffect(Element* target, PseudoId pseudoId)
-    : m_target(target)
+    : m_keyframesName(makeAtomString("keyframe-effect-"_s, UUID::createVersion4Weak()))
+    , m_target(target)
     , m_pseudoId(pseudoId)
 {
@@ -586 +587 @@
     updateStaticTimingProperties();
 
-    KeyframeList keyframeList(makeAtomString("keyframe-effect-"_s, UUID::createVersion4Weak()));
+    KeyframeList keyframeList(m_keyframesName);
     keyframeList.copyKeyframes(source->m_blendingKeyframes);
     setBlendingKeyframes(keyframeList);
@@ -812 +813 @@
         return;
 
-    KeyframeList keyframeList(makeAtomString("keyframe-effect-"_s, UUID::createVersion4Weak()));
+    KeyframeList keyframeList(m_keyframesName);
     auto& styleResolver = m_target->styleResolver();
 
@@ -901 +902 @@
 void KeyframeEffect::setBlendingKeyframes(KeyframeList& blendingKeyframes)
 {
+    CanBeAcceleratedMutationScope mutationScope(this);
+
     m_blendingKeyframes = WTFMove(blendingKeyframes);
     m_animatedProperties.clear();
@@ -1038 +1041 @@
         Style::loadPendingResources(*toStyle, *document(), m_target.get());
 
-    KeyframeList keyframeList(makeAtomString("keyframe-effect-"_s, UUID::createVersion4Weak()));
+    KeyframeList keyframeList(m_keyframesName);
     keyframeList.addProperty(property);
 
@@ -1601 +1604 @@
 bool KeyframeEffect::preventsAcceleration() const
 {
-    return m_acceleratedPropertiesState != AcceleratedProperties::None && !canBeAccelerated();
+    if (m_acceleratedPropertiesState == AcceleratedProperties::None)
+        return false;
+
+    return !canBeAccelerated() || m_runningAccelerated == RunningAccelerated::Failed;
 }
 
@@ -1610 +1616 @@
         return;
 
-    if (!canBeAccelerated()) {
-        // In the case where this animation is actively targeting a transform-related property and yet
-        // cannot be accelerated, we must notify the effect stack such that any running accelerated
-        // transform-related animation targeting this element reverts to running non-accelerated.
-        if (isTargetingTransformRelatedProperty()
-            && animation()->playState() == WebAnimation::PlayState::Running
-            && getComputedTiming().phase == AnimationEffectPhase::Active) {
-            ASSERT(targetStyleable());
-            ASSERT(targetStyleable()->keyframeEffectStack());
-            targetStyleable()->keyframeEffectStack()->stopAcceleratingTransformRelatedProperties(UseAcceleratedAction::Yes);
-        }
-        return;
-    }
+    if (!canBeAccelerated())
+        return;
 
     auto computedTiming = getComputedTiming();
@@ -1657 +1652 @@
 void KeyframeEffect::addPendingAcceleratedAction(AcceleratedAction action)
 {
+    if (m_runningAccelerated == RunningAccelerated::Prevented || m_runningAccelerated == RunningAccelerated::Failed)
+        return;
+
     if (action == m_lastRecordedAcceleratedAction)
         return;
@@ -1678 +1676 @@
     computeSomeKeyframesUseStepsTimingFunction();
 
-    if (isRunningAccelerated() || isAboutToRunAccelerated())
-        addPendingAcceleratedAction(canBeAccelerated() ? AcceleratedAction::UpdateTiming : AcceleratedAction::Stop);
-    else if (canBeAccelerated())
+    if (isRunningAccelerated() || isAboutToRunAccelerated()) {
+        if (canBeAccelerated())
+            addPendingAcceleratedAction(AcceleratedAction::UpdateTiming);
+        else {
+            abilityToBeAcceleratedDidChange();
+            addPendingAcceleratedAction(AcceleratedAction::Stop);
+        }
+    } else if (canBeAccelerated())
         m_runningAccelerated = RunningAccelerated::NotStarted;
 }
@@ -1722 +1725 @@
 }
 
-OptionSet<AcceleratedActionApplicationResult> KeyframeEffect::applyPendingAcceleratedActions()
-{
-    OptionSet<AcceleratedActionApplicationResult> result;
+void KeyframeEffect::applyPendingAcceleratedActions()
+{
+    CanBeAcceleratedMutationScope mutationScope(this);
 
     // Once an accelerated animation has been committed, we no longer want to force a layout.
@@ -1732 +1735 @@
 
     if (m_pendingAcceleratedActions.isEmpty())
-        return result;
+        return;
 
     auto* renderer = this->renderer();
@@ -1742 +1745 @@
             m_runningAccelerated = RunningAccelerated::NotStarted;
         }
-        return result;
+        return;
     }
 
@@ -1752 +1755 @@
 
     auto startAnimation = [&]() -> RunningAccelerated {
-        if (m_runningAccelerated == RunningAccelerated::Yes)
+        if (isRunningAccelerated())
             renderer->animationFinished(m_blendingKeyframes.animationName());
-
-        if (!m_hasImplicitKeyframeForAcceleratedProperty)
-            return renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), m_blendingKeyframes) ? RunningAccelerated::Yes : RunningAccelerated::No;
 
         ASSERT(m_target);
@@ -1762 +1762 @@
         ASSERT(effectStack);
 
-        if (effectStack->containsEffectThatPreventsAccelerationOfEffect(*this))
-            return RunningAccelerated::No;
+        if (!effectStack->allowsAcceleration())
+            return RunningAccelerated::Prevented;
+
+        if (!m_hasImplicitKeyframeForAcceleratedProperty)
+            return renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), m_blendingKeyframes) ? RunningAccelerated::Yes : RunningAccelerated::Failed;
 
         // We need to resolve all animations up to this point to ensure any forward-filling
@@ -1783 +1786 @@
         explicitKeyframes.copyKeyframes(m_blendingKeyframes);
         explicitKeyframes.fillImplicitKeyframes(*this, *underlyingStyle);
-        return renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), explicitKeyframes) ? RunningAccelerated::Yes : RunningAccelerated::No;
+        return renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), explicitKeyframes) ? RunningAccelerated::Yes : RunningAccelerated::Failed;
     };
 
@@ -1790 +1793 @@
         case AcceleratedAction::Play:
             m_runningAccelerated = startAnimation();
-            LOG_WITH_STREAM(Animations, stream << "KeyframeEffect " << this << " applyPendingAcceleratedActions " << m_blendingKeyframes.animationName() << " Play, started accelerated: " << (m_runningAccelerated == RunningAccelerated::Yes));
-            if (m_runningAccelerated == RunningAccelerated::No) {
+            LOG_WITH_STREAM(Animations, stream << "KeyframeEffect " << this << " applyPendingAcceleratedActions " << m_blendingKeyframes.animationName() << " Play, started accelerated: " << isRunningAccelerated());
+            if (!isRunningAccelerated()) {
                 m_lastRecordedAcceleratedAction = AcceleratedAction::Stop;
-                if (isTargetingTransformRelatedProperty())
-                    result.add(AcceleratedActionApplicationResult::TransformRelatedAnimationCannotBeAccelerated);
-                return result;
+                return;
             }
             break;
@@ -1803 +1804 @@
         case AcceleratedAction::UpdateTiming:
             m_runningAccelerated = startAnimation();
-            LOG_WITH_STREAM(Animations, stream << "KeyframeEffect " << this << " applyPendingAcceleratedActions " << m_blendingKeyframes.animationName() << " UpdateTiming, started accelerated: " << (m_runningAccelerated == RunningAccelerated::Yes));
+            LOG_WITH_STREAM(Animations, stream << "KeyframeEffect " << this << " applyPendingAcceleratedActions " << m_blendingKeyframes.animationName() << " UpdateTiming, started accelerated: " << isRunningAccelerated());
             if (animation()->playState() == WebAnimation::PlayState::Paused)
                 renderer->animationPaused(timeOffset, m_blendingKeyframes.animationName());
@@ -1812 +1813 @@
             if (!document()->renderTreeBeingDestroyed())
                 m_target->invalidateStyleAndLayerComposition();
-            m_runningAccelerated = canBeAccelerated() ? RunningAccelerated::NotStarted : RunningAccelerated::No;
+            m_runningAccelerated = canBeAccelerated() ? RunningAccelerated::NotStarted : RunningAccelerated::Prevented;
             break;
         case AcceleratedAction::TransformChange:
@@ -1820 +1821 @@
     }
 
-    if (m_runningAccelerated == RunningAccelerated::No && isTargetingTransformRelatedProperty())
-        result.add(AcceleratedActionApplicationResult::TransformRelatedAnimationCannotBeAccelerated);
-
-    return result;
-}
-
-void KeyframeEffect::stopAcceleratingTransformRelatedProperties(UseAcceleratedAction useAcceleratedAction)
-{
-    if (!isRunningAcceleratedTransformRelatedAnimation())
-        return;
-
-    if (useAcceleratedAction == UseAcceleratedAction::Yes) {
-        addPendingAcceleratedAction(AcceleratedAction::Stop);
-        return;
-    }
-
-    auto* renderer = this->renderer();
-    if (!renderer || !renderer->isComposited())
-        return;
-
-    ASSERT(document());
-    renderer->animationFinished(m_blendingKeyframes.animationName());
-    if (!document()->renderTreeBeingDestroyed())
-        m_target->invalidateStyleAndLayerComposition();
-
-    m_runningAccelerated = RunningAccelerated::No;
+    return;
 }
 
@@ -2138 +2114 @@
         return;
 
+    CanBeAcceleratedMutationScope mutationScope(this);
     m_compositeOperation = compositeOperation;
     invalidate();
@@ -2267 +2244 @@
 }
 
+void KeyframeEffect::effectStackNoLongerPreventsAcceleration()
+{
+    if (m_runningAccelerated == RunningAccelerated::Failed)
+        return;
+
+    if (m_runningAccelerated == RunningAccelerated::Prevented)
+        m_runningAccelerated = RunningAccelerated::NotStarted;
+
+    updateAcceleratedActions();
+}
+
+void KeyframeEffect::effectStackNoLongerAllowsAcceleration()
+{
+    addPendingAcceleratedAction(AcceleratedAction::Stop);
+}
+
+void KeyframeEffect::abilityToBeAcceleratedDidChange()
+{
+    if (!m_inTargetEffectStack)
+        return;
+
+    ASSERT(m_target);
+    if (auto* effectStack = m_target->keyframeEffectStack(m_pseudoId))
+        effectStack->effectAbilityToBeAcceleratedDidChange(*this);
+}
+
+KeyframeEffect::CanBeAcceleratedMutationScope::CanBeAcceleratedMutationScope(KeyframeEffect* effect)
+    : m_effect(effect)
+{
+    ASSERT(effect);
+    m_couldOriginallyPreventAcceleration = effect->preventsAcceleration();
+}
+
+KeyframeEffect::CanBeAcceleratedMutationScope::~CanBeAcceleratedMutationScope()
+{
+    if (m_effect && m_couldOriginallyPreventAcceleration != m_effect->preventsAcceleration())
+        m_effect->abilityToBeAcceleratedDidChange();
+}
+
 } // namespace WebCore

trunk/Source/WebCore/animation/KeyframeEffect.h

@@ -128 +128 @@
     void transformRelatedPropertyDidChange();
     void propertyAffectingKeyframeResolutionDidChange(RenderStyle&, const Style::ResolutionContext&);
-    OptionSet<AcceleratedActionApplicationResult> applyPendingAcceleratedActions();
+    void applyPendingAcceleratedActions();
 
     void willChangeRenderer();
@@ -173 +173 @@
     bool hasImplicitKeyframes() const;
 
-    void stopAcceleratingTransformRelatedProperties(UseAcceleratedAction);
-
     void keyframesRuleDidChange();
 
+    bool canBeAccelerated() const;
     bool preventsAcceleration() const;
+    void effectStackNoLongerPreventsAcceleration();
+    void effectStackNoLongerAllowsAcceleration();
 
     static String CSSPropertyIDToIDLAttributeName(CSSPropertyID);
@@ -187 +188 @@
     enum class BlendingKeyframesSource : uint8_t { CSSAnimation, CSSTransition, WebAnimation };
     enum class AcceleratedProperties : uint8_t { None, Some, All };
-    enum class RunningAccelerated : uint8_t { NotStarted, Yes, No };
+    enum class RunningAccelerated : uint8_t { NotStarted, Yes, Prevented, Failed };
+
+    class CanBeAcceleratedMutationScope {
+        WTF_MAKE_NONCOPYABLE(CanBeAcceleratedMutationScope);
+    public:
+        CanBeAcceleratedMutationScope(KeyframeEffect*);
+        ~CanBeAcceleratedMutationScope();
+
+    private:
+        KeyframeEffect* m_effect;
+        bool m_couldOriginallyPreventAcceleration;
+    };
 
     Document* document() const;
@@ -195 +207 @@
     ExceptionOr<void> processKeyframes(JSC::JSGlobalObject&, Document&, JSC::Strong<JSC::JSObject>&&);
     void addPendingAcceleratedAction(AcceleratedAction);
-    bool canBeAccelerated() const;
     bool isCompletelyAccelerated() const { return m_acceleratedPropertiesState == AcceleratedProperties::All; }
     void updateAcceleratedActions();
@@ -221 +232 @@
     void computeHasImplicitKeyframeForAcceleratedProperty();
     void computeHasKeyframeComposingAcceleratedProperty();
+    void abilityToBeAcceleratedDidChange();
 
     // AnimationEffect
@@ -234 +246 @@
     std::optional<double> progressUntilNextStep(double) const final;
 
+    AtomString m_keyframesName;
     KeyframeList m_blendingKeyframes { emptyAtom() };
     HashSet<CSSPropertyID> m_animatedProperties;
@@ -248 +261 @@
     AcceleratedProperties m_acceleratedPropertiesState { AcceleratedProperties::None };
     AnimationEffectPhase m_phaseAtLastApplication { AnimationEffectPhase::Idle };
-    RunningAccelerated m_runningAccelerated { RunningAccelerated::No };
+    RunningAccelerated m_runningAccelerated { RunningAccelerated::NotStarted };
     bool m_needsForcedLayout { false };
     bool m_triggersStackingContext { false };

trunk/Source/WebCore/animation/KeyframeEffectStack.cpp

@@ -55 +55 @@
     m_effects.append(effect);
     m_isSorted = false;
+
+    if (m_effects.size() > 1 && effect.preventsAcceleration())
+        stopAcceleratedAnimations();
+
     return true;
 }
@@ -60 +64 @@
 void KeyframeEffectStack::removeEffect(KeyframeEffect& effect)
 {
-    m_effects.removeFirst(&effect);
+    auto removedEffect = m_effects.removeFirst(&effect);
+    if (removedEffect && !m_effects.isEmpty() && !effect.canBeAccelerated())
+        startAcceleratedAnimationsIfPossible();
 }
 
@@ -173 +179 @@
 }
 
-void KeyframeEffectStack::stopAcceleratingTransformRelatedProperties(UseAcceleratedAction useAcceleratedAction)
-{
+void KeyframeEffectStack::clearInvalidCSSAnimationNames()
+{
+    m_invalidCSSAnimationNames.clear();
+}
+
+bool KeyframeEffectStack::hasInvalidCSSAnimationNames() const
+{
+    return !m_invalidCSSAnimationNames.isEmpty();
+}
+
+bool KeyframeEffectStack::containsInvalidCSSAnimationName(const String& name) const
+{
+    return m_invalidCSSAnimationNames.contains(name);
+}
+
+void KeyframeEffectStack::addInvalidCSSAnimationName(const String& name)
+{
+    m_invalidCSSAnimationNames.add(name);
+}
+
+void KeyframeEffectStack::effectAbilityToBeAcceleratedDidChange(const KeyframeEffect& effect)
+{
+    ASSERT(m_effects.contains(&effect));
+    if (effect.preventsAcceleration())
+        stopAcceleratedAnimations();
+    else
+        startAcceleratedAnimationsIfPossible();
+}
+
+bool KeyframeEffectStack::allowsAcceleration() const
+{
+    // We could try and be a lot smarter here and do this on a per-property basis and
+    // account for fully replacing effects which could co-exist with effects that
+    // don't support acceleration lower in the stack, etc. But, if we are not able to run
+    // all effects that could support acceleration using acceleration, then we might
+    // as well not run any at all since we'll be updating effects for this stack
+    // for each animation frame. So for now, we simply return false if any effect in the
+    // stack is unable to be accelerated.
+    for (auto& effect : m_effects) {
+        if (effect->preventsAcceleration())
+            return false;
+    }
+    return true;
+}
+
+void KeyframeEffectStack::startAcceleratedAnimationsIfPossible()
+{
+    if (!allowsAcceleration())
+        return;
+
     for (auto& effect : m_effects)
-        effect->stopAcceleratingTransformRelatedProperties(useAcceleratedAction);
-}
-
-void KeyframeEffectStack::clearInvalidCSSAnimationNames()
-{
-    m_invalidCSSAnimationNames.clear();
-}
-
-bool KeyframeEffectStack::hasInvalidCSSAnimationNames() const
-{
-    return !m_invalidCSSAnimationNames.isEmpty();
-}
-
-bool KeyframeEffectStack::containsInvalidCSSAnimationName(const String& name) const
-{
-    return m_invalidCSSAnimationNames.contains(name);
-}
-
-void KeyframeEffectStack::addInvalidCSSAnimationName(const String& name)
-{
-    m_invalidCSSAnimationNames.add(name);
-}
-
-bool KeyframeEffectStack::containsEffectThatPreventsAccelerationOfEffect(const KeyframeEffect& potentiallyAcceleratedEffect)
-{
-    ensureEffectsAreSorted();
-
-    for (auto& effect : m_effects) {
-        if (effect.get() == &potentiallyAcceleratedEffect)
-            continue;
-        if (effect->preventsAcceleration())
-            return true;
-    }
-
-    return false;
+        effect->effectStackNoLongerPreventsAcceleration();
+}
+
+void KeyframeEffectStack::stopAcceleratedAnimations()
+{
+    for (auto& effect : m_effects)
+        effect->effectStackNoLongerAllowsAcceleration();
 }
 

trunk/Source/WebCore/animation/KeyframeEffectStack.h

@@ -58 +58 @@
     bool hasEffectWithImplicitKeyframes() const;
 
-    bool containsEffectThatPreventsAccelerationOfEffect(const KeyframeEffect&);
-
-    void stopAcceleratingTransformRelatedProperties(UseAcceleratedAction);
+    void effectAbilityToBeAcceleratedDidChange(const KeyframeEffect&);
+    bool allowsAcceleration() const;
 
     void clearInvalidCSSAnimationNames();
@@ -70 +69 @@
     void ensureEffectsAreSorted();
 
+    void startAcceleratedAnimationsIfPossible();
+    void stopAcceleratedAnimations();
+
     Vector<WeakPtr<KeyframeEffect>> m_effects;
     HashSet<String> m_invalidCSSAnimationNames;

trunk/Source/WebCore/animation/WebAnimationTypes.h

@@ -56 +56 @@
 };
 
-enum class AcceleratedActionApplicationResult {
-    TransformRelatedAnimationCannotBeAccelerated  = 1 << 0
-};
-
 enum class UseAcceleratedAction : uint8_t { Yes, No };