Update animation when changes in animation keyframes are detected.

Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 238 matching lines @@
 
 #if !ENABLE(ASSERT)
     // If we're in an animation style change, no animations can have started, been cancelled or changed play state.
     // When ASSERT is enabled, we verify this optimization.
     if (activeAnimations && activeAnimations->isAnimationStyleChange())
         return;
 #endif
 
     const CSSAnimationData* animationData = style.animations();
     const CSSAnimations* cssAnimations = activeAnimations ? &activeAnimations->cssAnimations() : nullptr;
+    const Element* elementForScoping = animatingElement ? animatingElement : &element;
 
     HashSet<AtomicString> inactive;
     if (cssAnimations) {
         for (const auto& entry : cssAnimations->m_animations)
             inactive.add(entry.key);
     }
 
     if (style.display() != NONE) {
         for (size_t i = 0; animationData && i < animationData->nameList().size(); ++i) {
             AtomicString animationName(animationData->nameList()[i]);
             if (animationName == CSSAnimationData::initialName())
                 continue;
 
             const bool isPaused = CSSTimingData::getRepeated(animationData->playStateList(), i) == AnimPlayStatePaused;
 
             Timing timing = animationData->convertToTiming(i);
+            Timing newTiming = timing;
             RefPtr<TimingFunction> keyframeTimingFunction = timing.timingFunction;
             timing.timingFunction = Timing::defaults().timingFunction;
 
             if (cssAnimations) {
                 AnimationMap::const_iterator existing(cssAnimations->m_animations.find(animationName));
                 if (existing != cssAnimations->m_animations.end()) {
                     inactive.remove(animationName);
 
                     AnimationPlayer* player = existing->value.get();
 
-                    // FIXME: Should handle changes in the timing function.
-                    if (timing != player->source()->specifiedTiming()) {
-                        ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
+                    const StyleRuleKeyframes* keyframesRule = CSSAnimations::matchScopedKeyframesRule(resolver, elementForScoping, animationName.impl());
+                    ASSERT(keyframesRule);
 
+                    auto prevTiming = cssAnimations->m_timings.find(animationName);
+                    ASSERT(prevTiming != cssAnimations->m_timings.end());
+
+                    if (keyframesRule->styleChangeCounter() > player->source()->styleChangeCounter() || prevTiming->value != newTiming) {
                         AnimatableValueKeyframeVector resolvedKeyframes;
                         resolveKeyframes(resolver, animatingElement, element, style, parentStyle, animationName, keyframeTimingFunction.get(), resolvedKeyframes);
 
-                        update->updateAnimationTiming(player, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes),
-                            timing, isPaused, player->currentTimeInternal()), timing);
+                        update->updateAnimation(player, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes),
+                            timing, isPaused, player->currentTimeInternal()), newTiming, keyframesRule->styleChangeCounter());
                     }
 
                     if (isPaused != player->paused()) {
                         ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
                         update->toggleAnimationPaused(animationName);
                     }
 
                     continue;
                 }
             }
 
             AnimatableValueKeyframeVector resolvedKeyframes;
             resolveKeyframes(resolver, animatingElement, element, style, parentStyle, animationName, keyframeTimingFunction.get(), resolvedKeyframes);
             if (!resolvedKeyframes.isEmpty()) {
                 ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
-                update->startAnimation(animationName, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes), timing, isPaused, 0));
+                update->startAnimation(animationName, InertAnimation::create(AnimatableValueKeyframeEffectModel::create(resolvedKeyframes), timing, isPaused, 0), newTiming);
             }
         }
     }
 
     ASSERT(inactive.isEmpty() || cssAnimations);
     for (const AtomicString& animationName : inactive) {
         ASSERT(!activeAnimations || !activeAnimations->isAnimationStyleChange());
         update->cancelAnimation(animationName, *cssAnimations->m_animations.get(animationName));
     }
 }
@@ skipping 23 matching lines @@
     for (const AtomicString& animationName : update->animationsWithPauseToggled()) {
         AnimationPlayer* player = m_animations.get(animationName);
         if (player->paused())
             player->unpause();
         else
             player->pause();
         if (player->outdated())
             player->update(TimingUpdateOnDemand);
     }
 
-    for (const auto& timingUpdate : update->animationsWithTimingUpdates()) {
-        timingUpdate.player->source()->updateSpecifiedTiming(timingUpdate.newTiming);
-        timingUpdate.player->update(TimingUpdateOnDemand);
+    for (const auto& entry : update->animationsWithUpdates()) {
+        ASSERT(entry.player->source()->isAnimation());
+        Animation* animation = static_cast<Animation*>(entry.player->source());
+
+        animation->setEffect(entry.animation->effect());
+        animation->updateSpecifiedTiming(entry.animation->specifiedTiming());
+        animation->updateStyleChangeCounter(entry.styleChangeCounter);
+        m_timings.set(AtomicString(entry.player->source()->name()), entry.newTiming);
     }
 
     for (const auto& entry : update->newAnimations()) {
         const InertAnimation* inertAnimation = entry.animation.get();
         OwnPtrWillBeRawPtr<AnimationEventDelegate> eventDelegate = adoptPtrWillBeNoop(new AnimationEventDelegate(element, entry.name));
         RefPtrWillBeRawPtr<Animation> animation = Animation::create(element, inertAnimation->effect(), inertAnimation->specifiedTiming(), Animation::DefaultPriority, eventDelegate.release());
         animation->setName(inertAnimation->name());
         RefPtrWillBeRawPtr<AnimationPlayer> player = element->document().timeline().createAnimationPlayer(animation.get());
         if (inertAnimation->paused())
             player->pause();
         player->update(TimingUpdateOnDemand);
         m_animations.set(entry.name, player.get());
+        m_timings.set(entry.name, entry.newTiming);
     }
 
     // Transitions that are run on the compositor only update main-thread state
     // lazily. However, we need the new state to know what the from state shoud
     // be when transitions are retargeted. Instead of triggering complete style
     // recalculation, we find these cases by searching for new transitions that
     // have matching cancelled animation property IDs on the compositor.
     WillBeHeapHashMap<CSSPropertyID, std::pair<RefPtrWillBeMember<Animation>, double>> retargetedCompositorTransitions;
     for (CSSPropertyID id : update->cancelledTransitions()) {
         ASSERT(m_transitions.contains(id));
@@ skipping 197 matching lines @@
 
     if (update->newAnimations().isEmpty() && update->suppressedAnimationAnimationPlayers().isEmpty()) {
         WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation>> activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, 0, 0, Animation::DefaultPriority, timelineCurrentTime));
         update->adoptActiveInterpolationsForAnimations(activeInterpolationsForAnimations);
         return;
     }
 
     WillBeHeapVector<RawPtrWillBeMember<InertAnimation>> newAnimations;
     for (const auto& newAnimation : update->newAnimations())
         newAnimations.append(newAnimation.animation.get());
-    for (const auto& updatedAnimation : update->animationsWithTimingUpdates())
-        newAnimations.append(updatedAnimation.animation.get()); // Animations with timing updates use a temporary InertAnimation for the current frame.
+    for (const auto& updatedAnimation : update->animationsWithUpdates())
+        newAnimations.append(updatedAnimation.animation.get()); // Animations with updates use a temporary InertAnimation for the current frame.
 
     WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation>> activeInterpolationsForAnimations(AnimationStack::activeInterpolations(animationStack, &newAnimations, &update->suppressedAnimationAnimationPlayers(), Animation::DefaultPriority, timelineCurrentTime));
     update->adoptActiveInterpolationsForAnimations(activeInterpolationsForAnimations);
 }
 
 void CSSAnimations::calculateTransitionActiveInterpolations(CSSAnimationUpdate* update, const Element* animatingElement, double timelineCurrentTime)
 {
     ActiveAnimations* activeAnimations = animatingElement ? animatingElement->activeAnimations() : nullptr;
     AnimationStack* animationStack = activeAnimations ? &activeAnimations->defaultStack() : nullptr;
 
@@ skipping 165 matching lines @@
 }
 
 void CSSAnimationUpdate::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_newTransitions);
     visitor->trace(m_activeInterpolationsForAnimations);
     visitor->trace(m_activeInterpolationsForTransitions);
     visitor->trace(m_newAnimations);
     visitor->trace(m_suppressedAnimationPlayers);
-    visitor->trace(m_animationsWithTimingUpdates);
+    visitor->trace(m_animationsWithUpdates);
 #endif
 }
 
 } // namespace blink