Changeset 261637 in webkit


Ignore:
Timestamp:
May 13, 2020 12:26:58 PM (4 years ago)
Author:
commit-queue@webkit.org
Message:

[Web Animations] Calling reverse() on an accelerated animation has no effect
https://bugs.webkit.org/show_bug.cgi?id=204717
<rdar://problem/62503582>

Patch by Antoine Quint <Antoine Quint> on 2020-05-13
Reviewed by Dean Jackson.

Source/WebCore:

Test: webanimations/accelerated-animation-playback-rate.html

We completely ignored the playbackRate set on a WebAnimation object when considering whether we could run an accelerated animation.
To address this we do several things.

First, we now add a playbackRate() on Animation objects such that we can make GraphicsLayerCA aware of the originating WebAnimation's
playback rate and use this data to opt out of running CA animations for animations with a playbackRate other than 1 in
GraphicsLayerCA::animationCanBeAccelerated(). We'll be looking to add support for variable playback rates for CA animations in
https://bugs.webkit.org/show_bug.cgi?id=211839.

Then, we make sure to completely replace an accelerated animation whenever one of the properties affected timing would change. Up until
now we would onyl do this for a change in the effective currentTime, but this needs to also happen when the current time doesn't change
but the animation may have changed playback rate or any of its timing properties that could change the duration of the animation. So we
remove the "Seek" command and instead use an "UpdateTiming" command that will remove the existing animation and add a new one.

This allows us to remove any notion of seeking in GraphicsLayer since now we'll just create a new animation when its timing attributes
changed.

This revealed an issue where if we called animationFinished() and startAnimation() on a RenderLayerModelObject in succession, theanimation
removal would not occur on the GraphicsLayerCA because we disregarded any pending accelerated action for an animation we knew would be
replaced. We now ensure we honor the removal in GraphicsLayerCA::appendToUncommittedAnimations().

  • animation/AnimationEffect.cpp:

(WebCore::AnimationEffect::updateTiming):

  • animation/AnimationEffect.h:
  • animation/CSSAnimation.cpp:

(WebCore::CSSAnimation::syncPropertiesWithBackingAnimation):

  • animation/KeyframeEffect.cpp:

(WebCore::KeyframeEffect::addPendingAcceleratedAction):
(WebCore::KeyframeEffect::animationDidChangeTimingProperties):
(WebCore::KeyframeEffect::applyPendingAcceleratedActions):
(WebCore::KeyframeEffect::backingAnimationForCompositedRenderer const):
(WebCore::KeyframeEffect::animationDidSeek): Deleted.

  • animation/KeyframeEffect.h:
  • animation/WebAnimation.cpp:

(WebCore::WebAnimation::effectTimingDidChange):
(WebCore::WebAnimation::setCurrentTime):
(WebCore::WebAnimation::setPlaybackRate):
(WebCore::WebAnimation::updatePlaybackRate):
(WebCore::WebAnimation::reverse):

  • animation/WebAnimation.h:
  • platform/animation/Animation.h:

(WebCore::Animation::playbackRate const):
(WebCore::Animation::setPlaybackRate):

  • platform/graphics/GraphicsLayer.h:

(WebCore::GraphicsLayer::pauseAnimation):
(WebCore::GraphicsLayer::seekAnimation): Deleted.

  • platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayerCA::animationCanBeAccelerated const):
(WebCore::GraphicsLayerCA::updateAnimations):
(WebCore::GraphicsLayerCA::pauseCAAnimationOnLayer):
(WebCore::GraphicsLayerCA::createTransformAnimationsFromKeyframes):
(WebCore::GraphicsLayerCA::seekAnimation): Deleted.
(WebCore::GraphicsLayerCA::seekCAAnimationOnLayer): Deleted.

  • platform/graphics/ca/GraphicsLayerCA.h:
  • rendering/RenderElement.h:

(WebCore::RenderElement::animationPaused):
(WebCore::RenderElement::animationSeeked): Deleted.

  • rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::animationSeeked): Deleted.

  • rendering/RenderLayerBacking.h:
  • rendering/RenderLayerModelObject.cpp:

(WebCore::RenderLayerModelObject::animationSeeked): Deleted.

  • rendering/RenderLayerModelObject.h:

LayoutTests:

Add a test where we play an animation for an accelerated property in reverse.

  • webanimations/accelerated-animation-playback-rate-expected.html: Added.
  • webanimations/accelerated-animation-playback-rate.html: Added.
Location:
trunk
Files:
2 added
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r261632 r261637  
     12020-05-13  Antoine Quint  <graouts@apple.com>
     2
     3        [Web Animations] Calling reverse() on an accelerated animation has no effect
     4        https://bugs.webkit.org/show_bug.cgi?id=204717
     5        <rdar://problem/62503582>
     6
     7        Reviewed by Dean Jackson.
     8
     9        Add a test where we play an animation for an accelerated property in reverse.
     10
     11        * webanimations/accelerated-animation-playback-rate-expected.html: Added.
     12        * webanimations/accelerated-animation-playback-rate.html: Added.
     13
    1142020-05-13  Simon Fraser  <simon.fraser@apple.com>
    215
  • trunk/Source/WebCore/ChangeLog

    r261636 r261637  
     12020-05-13  Antoine Quint  <graouts@apple.com>
     2
     3        [Web Animations] Calling reverse() on an accelerated animation has no effect
     4        https://bugs.webkit.org/show_bug.cgi?id=204717
     5        <rdar://problem/62503582>
     6
     7        Reviewed by Dean Jackson.
     8
     9        Test: webanimations/accelerated-animation-playback-rate.html
     10
     11        We completely ignored the playbackRate set on a WebAnimation object when considering whether we could run an accelerated animation.
     12        To address this we do several things.
     13
     14        First, we now add a playbackRate() on Animation objects such that we can make GraphicsLayerCA aware of the originating WebAnimation's
     15        playback rate and use this data to opt out of running CA animations for animations with a playbackRate other than 1 in
     16        GraphicsLayerCA::animationCanBeAccelerated(). We'll be looking to add support for variable playback rates for CA animations in
     17        https://bugs.webkit.org/show_bug.cgi?id=211839.
     18
     19        Then, we make sure to completely replace an accelerated animation whenever one of the properties affected timing would change. Up until
     20        now we would onyl do this for a change in the effective currentTime, but this needs to also happen when the current time doesn't change
     21        but the animation may have changed playback rate or any of its timing properties that could change the duration of the animation. So we
     22        remove the "Seek" command and instead use an "UpdateTiming" command that will remove the existing animation and add a new one.
     23
     24        This allows us to remove any notion of seeking in GraphicsLayer since now we'll just create a new animation when its timing attributes
     25        changed.
     26
     27        This revealed an issue where if we called animationFinished() and startAnimation() on a RenderLayerModelObject in succession, theanimation
     28        removal would not occur on the GraphicsLayerCA because we disregarded any pending accelerated action for an animation we knew would be
     29        replaced. We now ensure we honor the removal in GraphicsLayerCA::appendToUncommittedAnimations().
     30
     31        * animation/AnimationEffect.cpp:
     32        (WebCore::AnimationEffect::updateTiming):
     33        * animation/AnimationEffect.h:
     34        * animation/CSSAnimation.cpp:
     35        (WebCore::CSSAnimation::syncPropertiesWithBackingAnimation):
     36        * animation/KeyframeEffect.cpp:
     37        (WebCore::KeyframeEffect::addPendingAcceleratedAction):
     38        (WebCore::KeyframeEffect::animationDidChangeTimingProperties):
     39        (WebCore::KeyframeEffect::applyPendingAcceleratedActions):
     40        (WebCore::KeyframeEffect::backingAnimationForCompositedRenderer const):
     41        (WebCore::KeyframeEffect::animationDidSeek): Deleted.
     42        * animation/KeyframeEffect.h:
     43        * animation/WebAnimation.cpp:
     44        (WebCore::WebAnimation::effectTimingDidChange):
     45        (WebCore::WebAnimation::setCurrentTime):
     46        (WebCore::WebAnimation::setPlaybackRate):
     47        (WebCore::WebAnimation::updatePlaybackRate):
     48        (WebCore::WebAnimation::reverse):
     49        * animation/WebAnimation.h:
     50        * platform/animation/Animation.h:
     51        (WebCore::Animation::playbackRate const):
     52        (WebCore::Animation::setPlaybackRate):
     53        * platform/graphics/GraphicsLayer.h:
     54        (WebCore::GraphicsLayer::pauseAnimation):
     55        (WebCore::GraphicsLayer::seekAnimation): Deleted.
     56        * platform/graphics/ca/GraphicsLayerCA.cpp:
     57        (WebCore::GraphicsLayerCA::animationCanBeAccelerated const):
     58        (WebCore::GraphicsLayerCA::updateAnimations):
     59        (WebCore::GraphicsLayerCA::pauseCAAnimationOnLayer):
     60        (WebCore::GraphicsLayerCA::createTransformAnimationsFromKeyframes):
     61        (WebCore::GraphicsLayerCA::seekAnimation): Deleted.
     62        (WebCore::GraphicsLayerCA::seekCAAnimationOnLayer): Deleted.
     63        * platform/graphics/ca/GraphicsLayerCA.h:
     64        * rendering/RenderElement.h:
     65        (WebCore::RenderElement::animationPaused):
     66        (WebCore::RenderElement::animationSeeked): Deleted.
     67        * rendering/RenderLayerBacking.cpp:
     68        (WebCore::RenderLayerBacking::animationSeeked): Deleted.
     69        * rendering/RenderLayerBacking.h:
     70        * rendering/RenderLayerModelObject.cpp:
     71        (WebCore::RenderLayerModelObject::animationSeeked): Deleted.
     72        * rendering/RenderLayerModelObject.h:
     73
    1742020-05-13  Antti Koivisto  <antti@apple.com>
    275
  • trunk/Source/WebCore/animation/AnimationEffect.cpp

    r260671 r261637  
    370370        return { };
    371371
    372     Optional<ComputedEffectTiming> previousTiming;
    373     if (m_animation)
    374         previousTiming = getComputedTiming();
    375 
    376372    // 1. If the iterationStart member of input is present and less than zero, throw a TypeError and abort this procedure.
    377373    if (timing->iterationStart) {
     
    442438
    443439    if (m_animation)
    444         m_animation->effectTimingDidChange(previousTiming);
     440        m_animation->effectTimingDidChange();
    445441
    446442    return { };
  • trunk/Source/WebCore/animation/AnimationEffect.h

    r260671 r261637  
    6666    virtual void animationDidTick() = 0;
    6767    virtual void animationDidPlay() = 0;
    68     virtual void animationDidSeek() = 0;
     68    virtual void animationDidChangeTimingProperties() = 0;
    6969    virtual void animationWasCanceled() = 0;
    7070    virtual void animationSuspensionStateDidChange(bool) = 0;
  • trunk/Source/WebCore/animation/CSSAnimation.cpp

    r260671 r261637  
    6666    auto* animationEffect = effect();
    6767
    68     auto previousTiming = animationEffect->getComputedTiming();
    69 
    7068    if (!m_overriddenProperties.contains(Property::FillMode)) {
    7169        switch (animation.fillMode()) {
     
    114112
    115113    animationEffect->updateStaticTimingProperties();
    116     effectTimingDidChange(previousTiming);
     114    effectTimingDidChange();
    117115
    118116    // Synchronize the play state
  • trunk/Source/WebCore/animation/KeyframeEffect.cpp

    r261585 r261637  
    15091509        m_pendingAcceleratedActions.clear();
    15101510    m_pendingAcceleratedActions.append(action);
    1511     if (action != AcceleratedAction::Seek)
     1511    if (action != AcceleratedAction::UpdateTiming)
    15121512        m_lastRecordedAcceleratedAction = action;
    15131513    animation()->acceleratedStateDidChange();
     
    15261526}
    15271527
    1528 void KeyframeEffect::animationDidSeek()
    1529 {
    1530     // There is no need to seek if we're not playing an animation already. If seeking
     1528void KeyframeEffect::animationDidChangeTimingProperties()
     1529{
     1530    // There is no need to update the animation if we're not playing already. If updating timing
    15311531    // means we're moving into an active lexicalGlobalObject, we'll pick this up in apply().
    15321532    if (m_isRunningAccelerated || isAboutToRunAccelerated())
    1533         addPendingAcceleratedAction(AcceleratedAction::Seek);
     1533        addPendingAcceleratedAction(AcceleratedAction::UpdateTiming);
    15341534}
    15351535
     
    15821582        switch (action) {
    15831583        case AcceleratedAction::Play:
     1584            renderer->animationFinished(m_blendingKeyframes.animationName());
    15841585            m_isRunningAccelerated = renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), m_blendingKeyframes);
    15851586            if (!m_isRunningAccelerated) {
     
    15911592            renderer->animationPaused(timeOffset, m_blendingKeyframes.animationName());
    15921593            break;
    1593         case AcceleratedAction::Seek:
    1594             renderer->animationSeeked(timeOffset, m_blendingKeyframes.animationName());
     1594        case AcceleratedAction::UpdateTiming:
     1595            renderer->animationFinished(m_blendingKeyframes.animationName());
     1596            renderer->startAnimation(timeOffset, backingAnimationForCompositedRenderer(), m_blendingKeyframes);
     1597            if (animation()->playState() == WebAnimation::PlayState::Paused)
     1598                renderer->animationPaused(timeOffset, m_blendingKeyframes.animationName());
    15951599            break;
    15961600        case AcceleratedAction::Stop:
     
    16181622    animation->setIterationCount(iterations());
    16191623    animation->setTimingFunction(timingFunction()->clone());
     1624    animation->setPlaybackRate(effectAnimation->playbackRate());
    16201625
    16211626    switch (fill()) {
  • trunk/Source/WebCore/animation/KeyframeEffect.h

    r260705 r261637  
    125125    void animationDidTick() final;
    126126    void animationDidPlay() final;
    127     void animationDidSeek() final;
     127    void animationDidChangeTimingProperties() final;
    128128    void animationWasCanceled() final;
    129129    void animationSuspensionStateDidChange(bool) final;
     
    170170    KeyframeEffect(Element*, PseudoId);
    171171
    172     enum class AcceleratedAction : uint8_t { Play, Pause, Seek, Stop };
     172    enum class AcceleratedAction : uint8_t { Play, Pause, UpdateTiming, Stop };
    173173    enum class BlendingKeyframesSource : uint8_t { CSSAnimation, CSSTransition, WebAnimation };
    174174    enum class AcceleratedProperties : uint8_t { None, Some, All };
  • trunk/Source/WebCore/animation/WebAnimation.cpp

    r261470 r261637  
    135135}
    136136
    137 void WebAnimation::effectTimingDidChange(Optional<ComputedEffectTiming> previousTiming)
     137void WebAnimation::effectTimingDidChange()
    138138{
    139139    timingDidChange(DidSeek::No, SynchronouslyNotify::Yes);
    140140
    141     if (previousTiming) {
    142         auto* effect = this->effect();
    143         ASSERT(effect);
    144         if (previousTiming->progress != effect->getComputedTiming().progress)
    145             effect->animationDidSeek();
    146     }
     141    if (m_effect)
     142        m_effect->animationDidChangeTimingProperties();
    147143
    148144    InspectorInstrumentation::didChangeWebAnimationEffectTiming(*this);
     
    478474
    479475    if (m_effect)
    480         m_effect->animationDidSeek();
     476        m_effect->animationDidChangeTimingProperties();
    481477
    482478    invalidateEffect();
     
    509505    if (previousTime)
    510506        setCurrentTime(previousTime);
     507
     508    if (m_effect)
     509        m_effect->animationDidChangeTimingProperties();
    511510}
    512511
     
    561560        play(AutoRewind::No);
    562561    }
     562
     563    if (m_effect)
     564        m_effect->animationDidChangeTimingProperties();
    563565}
    564566
     
    11531155    }
    11541156
     1157    if (m_effect)
     1158        m_effect->animationDidChangeTimingProperties();
     1159
    11551160    return { };
    11561161}
  • trunk/Source/WebCore/animation/WebAnimation.h

    r260671 r261637  
    2727
    2828#include "ActiveDOMObject.h"
    29 #include "ComputedEffectTiming.h"
    3029#include "EventTarget.h"
    3130#include "ExceptionOr.h"
     
    133132    bool isRelevant() const { return m_isRelevant; }
    134133    void updateRelevance();
    135     void effectTimingDidChange(Optional<ComputedEffectTiming> = WTF::nullopt);
     134    void effectTimingDidChange();
    136135    void suspendEffectInvalidation();
    137136    void unsuspendEffectInvalidation();
  • trunk/Source/WebCore/platform/animation/Animation.h

    r259720 r261637  
    118118
    119119    double duration() const { return m_duration; }
     120    double playbackRate() const { return m_playbackRate; }
    120121
    121122    enum { IterationCountInfinite = -1 };
     
    131132    void setDirection(AnimationDirection d) { m_direction = d; m_directionSet = true; }
    132133    void setDuration(double d) { ASSERT(d >= 0); m_duration = d; m_durationSet = true; }
     134    void setPlaybackRate(double d) { m_playbackRate = d; }
    133135    void setFillMode(AnimationFillMode f) { m_fillMode = static_cast<unsigned>(f); m_fillModeSet = true; }
    134136    void setIterationCount(double c) { m_iterationCount = c; m_iterationCountSet = true; }
     
    170172    double m_delay;
    171173    double m_duration;
     174    double m_playbackRate { 1 };
    172175    RefPtr<TimingFunction> m_timingFunction;
    173176
  • trunk/Source/WebCore/platform/graphics/GraphicsLayer.h

    r260950 r261637  
    479479    virtual bool addAnimation(const KeyframeValueList&, const FloatSize& /*boxSize*/, const Animation*, const String& /*animationName*/, double /*timeOffset*/)  { return false; }
    480480    virtual void pauseAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
    481     virtual void seekAnimation(const String& /*animationName*/, double /*timeOffset*/) { }
    482481    virtual void removeAnimation(const String& /*animationName*/) { }
    483482
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

    r260950 r261637  
    10301030bool GraphicsLayerCA::animationCanBeAccelerated(const KeyframeValueList& valueList, const Animation* anim) const
    10311031{
     1032    if (anim->playbackRate() != 1)
     1033        return false;
     1034
    10321035    if (!anim || anim->isEmptyOrZeroDuration() || valueList.size() < 2)
    10331036        return false;
     
    10901093    // Call add since if there is already a Remove in there, we don't want to overwrite it with a Pause.
    10911094    addProcessingActionForAnimation(animationName, AnimationProcessingAction { Pause, Seconds { timeOffset } });
    1092 
    1093     noteLayerPropertyChanged(AnimationChanged);
    1094 }
    1095 
    1096 void GraphicsLayerCA::seekAnimation(const String& animationName, double timeOffset)
    1097 {
    1098     LOG_WITH_STREAM(Animations, stream << "GraphicsLayerCA " << this << " id " << primaryLayerID() << " seekAnimation " << animationName << " to " << timeOffset << " (is running " << animationIsRunning(animationName) << ")");
    1099 
    1100     // Call add since if there is already a Remove in there, we don't want to overwrite it with a Pause.
    1101     addProcessingActionForAnimation(animationName, AnimationProcessingAction { Seek, Seconds { timeOffset } });
    11021095
    11031096    noteLayerPropertyChanged(AnimationChanged);
     
    29222915                        pauseCAAnimationOnLayer(currentAnimation.m_property, currentAnimationName, currentAnimation.m_index, currentAnimation.m_subIndex, processingInfo.timeOffset);
    29232916                        break;
    2924                     case Seek:
    2925                         seekCAAnimationOnLayer(currentAnimation.m_property, currentAnimationName, currentAnimation.m_index, currentAnimation.m_subIndex, processingInfo.timeOffset);
    2926                         break;
    29272917                    }
    29282918                }
     
    30363026
    30373027    newAnim->setSpeed(0);
    3038     newAnim->setTimeOffset(timeOffset.seconds());
    3039    
    3040     layer->addAnimationForKey(animationID, *newAnim); // This will replace the running animation.
    3041 
    3042     // Pause the animations on the clones too.
    3043     if (LayerMap* layerCloneMap = animatedLayerClones(property)) {
    3044         for (auto& clone : *layerCloneMap) {
    3045             // Skip immediate replicas, since they move with the original.
    3046             if (m_replicaLayer && isReplicatedRootClone(clone.key))
    3047                 continue;
    3048             clone.value->addAnimationForKey(animationID, *newAnim);
    3049         }
    3050     }
    3051 }
    3052 
    3053 void GraphicsLayerCA::seekCAAnimationOnLayer(AnimatedPropertyID property, const String& animationName, int index, int subIndex, Seconds timeOffset)
    3054 {
    3055     // FIXME: this can be refactored a fair bit or merged with pauseCAAnimationOnLayer() with an operation flag.
    3056     PlatformCALayer* layer = animatedLayer(property);
    3057 
    3058     String animationID = animationIdentifier(animationName, property, index, subIndex);
    3059 
    3060     RefPtr<PlatformCAAnimation> currentAnimation = layer->animationForKey(animationID);
    3061     if (!currentAnimation)
    3062         return;
    3063 
    3064     // Animations on the layer are immutable, so we have to clone and modify.
    3065     RefPtr<PlatformCAAnimation> newAnim = currentAnimation->copy();
    3066 
    3067     newAnim->setBeginTime(CACurrentMediaTime());
    30683028    newAnim->setTimeOffset(timeOffset.seconds());
    30693029
     
    32333193
    32343194    // Since we're adding a new animation, make sure we clear any pending AnimationProcessingAction for this animation
    3235     // as these are applied after we've committed new animations.
    3236     m_animations->animationsToProcess.remove(animation.m_name);
     3195    // as these are applied after we've committed new animations. However, we want to check if we had a pending removal
     3196    // such that removing an animation prior to adding a new one for the same name works.
     3197    auto processingInfoIterator = m_animations->animationsToProcess.find(animation.m_name);
     3198    if (processingInfoIterator != m_animations->animationsToProcess.end()) {
     3199        auto animationIterator = m_animations->runningAnimations.find(animation.m_name);
     3200        if (animationIterator != m_animations->runningAnimations.end()) {
     3201            auto& animations = animationIterator->value;
     3202            for (const auto& processingInfo : processingInfoIterator->value) {
     3203                if (processingInfo.action == Remove) {
     3204                    for (const auto& currentAnimation : animations)
     3205                        removeCAAnimationFromLayer(currentAnimation.m_property, animation.m_name, currentAnimation.m_index, currentAnimation.m_subIndex);
     3206                    m_animations->runningAnimations.remove(animationIterator);
     3207                    break;
     3208                }
     3209            }
     3210        }
     3211        m_animations->animationsToProcess.remove(processingInfoIterator);
     3212    }
    32373213
    32383214    m_animations->uncomittedAnimations.append(WTFMove(animation));
  • trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

    r260950 r261637  
    137137    WEBCORE_EXPORT bool addAnimation(const KeyframeValueList&, const FloatSize& boxSize, const Animation*, const String& animationName, double timeOffset) override;
    138138    WEBCORE_EXPORT void pauseAnimation(const String& animationName, double timeOffset) override;
    139     WEBCORE_EXPORT void seekAnimation(const String& animationName, double timeOffset) override;
    140139    WEBCORE_EXPORT void removeAnimation(const String& animationName) override;
    141140
     
    462461    bool removeCAAnimationFromLayer(AnimatedPropertyID, const String& animationName, int index, int subINdex);
    463462    void pauseCAAnimationOnLayer(AnimatedPropertyID, const String& animationName, int index, int subIndex, Seconds timeOffset);
    464     void seekCAAnimationOnLayer(AnimatedPropertyID, const String& animationName, int index, int subIndex, Seconds timeOffset);
    465463
    466464    enum MoveOrCopy { Move, Copy };
     
    564562    void repaintLayerDirtyRects();
    565563
    566     enum Action { Remove, Pause, Seek };
     564    enum Action { Remove, Pause };
    567565    struct AnimationProcessingAction {
    568566        AnimationProcessingAction(Action action = Remove, Seconds timeOffset = 0_s)
  • trunk/Source/WebCore/rendering/RenderElement.h

    r261597 r261637  
    233233    virtual bool startAnimation(double /* timeOffset */, const Animation&, const KeyframeList&) { return false; }
    234234    virtual void animationPaused(double /* timeOffset */, const String& /* name */) { }
    235     virtual void animationSeeked(double /* timeOffset */, const String& /* name */) { }
    236235    virtual void animationFinished(const String& /* name */) { }
    237236
  • trunk/Source/WebCore/rendering/RenderLayerBacking.cpp

    r261636 r261637  
    34983498}
    34993499
    3500 void RenderLayerBacking::animationSeeked(double timeOffset, const String& animationName)
    3501 {
    3502     m_graphicsLayer->seekAnimation(animationName, timeOffset);
    3503 }
    3504 
    35053500void RenderLayerBacking::animationFinished(const String& animationName)
    35063501{
  • trunk/Source/WebCore/rendering/RenderLayerBacking.h

    r261592 r261637  
    189189    bool startAnimation(double timeOffset, const Animation&, const KeyframeList&);
    190190    void animationPaused(double timeOffset, const String& name);
    191     void animationSeeked(double timeOffset, const String& name);
    192191    void animationFinished(const String& name);
    193192
  • trunk/Source/WebCore/rendering/RenderLayerModelObject.cpp

    r257933 r261637  
    319319}
    320320
    321 void RenderLayerModelObject::animationSeeked(double timeOffset, const String& name)
    322 {
    323     if (!layer() || !layer()->backing())
    324         return;
    325     layer()->backing()->animationSeeked(timeOffset, name);
    326 }
    327 
    328321void RenderLayerModelObject::animationFinished(const String& name)
    329322{
  • trunk/Source/WebCore/rendering/RenderLayerModelObject.h

    r243151 r261637  
    7676    bool startAnimation(double timeOffset, const Animation&, const KeyframeList&) override;
    7777    void animationPaused(double timeOffset, const String& name) override;
    78     void animationSeeked(double timeOffset, const String& name) override;
    7978    void animationFinished(const String& name) override;
    8079
Note: See TracChangeset for help on using the changeset viewer.