Changeset 269914 in webkit

Timestamp:

Nov 17, 2020 11:04:10 AM (3 years ago)

Author:

graouts@webkit.org

Message:

[Web Animations] Move all effect-specific parts of WebAnimation::timeToNextTick() to effect classes
​https://bugs.webkit.org/show_bug.cgi?id=219028

Reviewed by Antti Koivisto.

Most of WebAnimation::timeToNextTick() is code that is specific to effects. We move this code out to
KeyframeEffect and a virtual method with a default implementation on AnimationEffect. This is the first
step towards adding more smarts to this method such as avoiding style recalcs if there are no keyframes
set up on a KeyframeEffect or running fewer style recalcs when animating a discrete property.

No new tests since this we are just moving code around.

• animation/AnimationEffect.h:

(WebCore::AnimationEffect::timeToNextTick const):

• animation/KeyframeEffect.cpp:

(WebCore::KeyframeEffect::timeToNextTick const):

• animation/KeyframeEffect.h:

(WebCore::KeyframeEffect::isCompletelyAccelerated const): Make this method private since it is now only
called by KeyframeEffect.

• animation/WebAnimation.cpp:

(WebCore::WebAnimation::timeToNextTick const):
(WebCore::WebAnimation::isCompletelyAccelerated const): Deleted. This method no longer has any call sites.

• animation/WebAnimation.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• animation/AnimationEffect.h (modified) (1 diff)
• animation/KeyframeEffect.cpp (modified) (1 diff)
• animation/KeyframeEffect.h (modified) (3 diffs)
• animation/WebAnimation.cpp (modified) (3 diffs)
• animation/WebAnimation.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2020-11-17  Antoine Quint  <graouts@webkit.org>
+
+        [Web Animations] Move all effect-specific parts of WebAnimation::timeToNextTick() to effect classes
+        https://bugs.webkit.org/show_bug.cgi?id=219028
+
+        Reviewed by Antti Koivisto.
+
+        Most of WebAnimation::timeToNextTick() is code that is specific to effects. We move this code out to
+        KeyframeEffect and a virtual method with a default implementation on AnimationEffect. This is the first
+        step towards adding more smarts to this method such as avoiding style recalcs if there are no keyframes
+        set up on a KeyframeEffect or running fewer style recalcs when animating a discrete property.
+
+        No new tests since this we are just moving code around.
+
+        * animation/AnimationEffect.h:
+        (WebCore::AnimationEffect::timeToNextTick const):
+        * animation/KeyframeEffect.cpp:
+        (WebCore::KeyframeEffect::timeToNextTick const):
+        * animation/KeyframeEffect.h:
+        (WebCore::KeyframeEffect::isCompletelyAccelerated const): Make this method private since it is now only
+        called by KeyframeEffect.
+        * animation/WebAnimation.cpp:
+        (WebCore::WebAnimation::timeToNextTick const):
+        (WebCore::WebAnimation::isCompletelyAccelerated const): Deleted. This method no longer has any call sites.
+        * animation/WebAnimation.h:
+
 2020-11-17  Aditya Keerthi  <akeerthi@apple.com>
 

trunk/Source/WebCore/animation/AnimationEffect.h

@@ -103 +103 @@
     void updateStaticTimingProperties();
 
-    virtual Optional<double> progressUntilNextStep(double) const;
+    virtual Seconds timeToNextTick() const { return Seconds::infinity(); }
 
 protected:
     explicit AnimationEffect();
+
+    virtual Optional<double> progressUntilNextStep(double) const;
 
 private:

trunk/Source/WebCore/animation/KeyframeEffect.cpp

@@ -1973 +1973 @@
 }
 
+Seconds KeyframeEffect::timeToNextTick() const
+{
+    auto timing = getBasicTiming();
+    switch (timing.phase) {
+    case AnimationEffectPhase::Before:
+        // The effect is in its "before" phase, in this case we can wait until it enters its "active" phase.
+        return delay() - *timing.localTime;
+    case AnimationEffectPhase::Active:
+        if (isCompletelyAccelerated() && isRunningAccelerated()) {
+            // Fully-accelerated running CSS Animations need to trigger "animationiteration" events, in this case we must wait until the next iteration.
+            if (is<CSSAnimation>(animation())) {
+                if (auto iterationProgress = getComputedTiming().simpleIterationProgress)
+                    return iterationDuration() * (1 - *iterationProgress);
+            }
+            // Fully-accelerated running effects in the "active" phase can wait until they ended.
+            return endTime() - *timing.localTime;
+        }
+        if (auto iterationProgress = getComputedTiming().simpleIterationProgress) {
+            // In case we're in a range that uses a steps() timing function, we can compute the time until the next step starts.
+            if (auto progressUntilNextStep = this->progressUntilNextStep(*iterationProgress))
+                return iterationDuration() * *progressUntilNextStep;
+        }
+        // Other effects in the "active" phase will need to update their animated value at the immediate next opportunity.
+        return 0_s;
+    case AnimationEffectPhase::After:
+        // The effect is in its after phase, which means it will no longer update its value, so it doens't need a tick.
+        return Seconds::infinity();
+    case AnimationEffectPhase::Idle:
+        ASSERT_NOT_REACHED();
+        return Seconds::infinity();
+    }
+
+    ASSERT_NOT_REACHED();
+    return Seconds::infinity();
+}
+
 } // namespace WebCore

trunk/Source/WebCore/animation/KeyframeEffect.h

@@ -147 +147 @@
     // FIXME: These ignore the fact that some timing functions can prevent acceleration.
     bool isAboutToRunAccelerated() const { return m_acceleratedPropertiesState != AcceleratedProperties::None && m_lastRecordedAcceleratedAction != AcceleratedAction::Stop; }
-    bool isCompletelyAccelerated() const { return m_acceleratedPropertiesState == AcceleratedProperties::All; }
 
     bool filterFunctionListsMatch() const override { return m_filterFunctionListsMatch; }
@@ -188 +187 @@
     void addPendingAcceleratedAction(AcceleratedAction);
     bool canBeAccelerated() const;
+    bool isCompletelyAccelerated() const { return m_acceleratedPropertiesState == AcceleratedProperties::All; }
     void updateAcceleratedActions();
     void setAnimatedPropertiesInStyle(RenderStyle&, double);
@@ -201 +201 @@
     void computeAcceleratedPropertiesState();
     void setBlendingKeyframes(KeyframeList&);
+    Seconds timeToNextTick() const final;
     Optional<double> progressUntilNextStep(double) const final;
     void checkForMatchingTransformFunctionLists();

trunk/Source/WebCore/animation/WebAnimation.cpp

@@ -1206 +1206 @@
 }
 
-bool WebAnimation::isCompletelyAccelerated() const
-{
-    return is<KeyframeEffect>(m_effect) && downcast<KeyframeEffect>(*m_effect).isCompletelyAccelerated();
-}
-
 bool WebAnimation::needsTick() const
 {
@@ -1454 +1449 @@
 Seconds WebAnimation::timeToNextTick() const
 {
-    ASSERT(effect());
-
     if (pending())
         return 0_s;
@@ -1464 +1457 @@
         return Seconds::infinity();
 
-    auto& effect = *this->effect();
-    auto timing = effect.getBasicTiming();
-    switch (timing.phase) {
-    case AnimationEffectPhase::Before:
-        // The animation is in its "before" phase, in this case we can wait until it enters its "active" phase.
-        return (effect.delay() - timing.localTime.value()) / playbackRate;
-    case AnimationEffectPhase::Active:
-        if (isCompletelyAccelerated() && isRunningAccelerated()) {
-            // Fully-accelerated running CSS Animations need to trigger "animationiteration" events, in this case we must wait until the next iteration.
-            if (isCSSAnimation()) {
-                if (auto iterationProgress = effect.getComputedTiming().simpleIterationProgress)
-                    return effect.iterationDuration() * (1 - *iterationProgress);
-            }
-            // Fully-accelerated running animations in the "active" phase can wait until they ended.
-            return (effect.endTime() - timing.localTime.value()) / playbackRate;
-        }
-        if (auto iterationProgress = effect.getComputedTiming().simpleIterationProgress) {
-            // In case we're in a range that uses a steps() timing function, we can compute the time until the next step starts.
-            if (auto progressUntilNextStep = effect.progressUntilNextStep(*iterationProgress))
-                return effect.iterationDuration() * *progressUntilNextStep / playbackRate;
-        }
-        // Other animations in the "active" phase will need to update their animated value at the immediate next opportunity.
-        return 0_s;
-    case AnimationEffectPhase::After:
-        // The animation is in its after phase, which means it will no longer update its value, so it doens't need a tick.
-        return Seconds::infinity();
-    case AnimationEffectPhase::Idle:
-        ASSERT_NOT_REACHED();
-        return Seconds::infinity();
-    }
-
-    ASSERT_NOT_REACHED();
-    return Seconds::infinity();
+    ASSERT(effect());
+    return effect()->timeToNextTick() / playbackRate;
 }
 

trunk/Source/WebCore/animation/WebAnimation.h

@@ -129 +129 @@
 
     bool isRunningAccelerated() const;
-    bool isCompletelyAccelerated() const;
     bool isRelevant() const { return m_isRelevant; }
     void updateRelevance();