Update animation when changes in animation keyframes are detected.

Source/core/animation/css/CSSAnimations.h

 /*
  * 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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSAnimations_h
 #define CSSAnimations_h
 
 #include "core/animation/InertAnimation.h"
+#include "core/animation/Interpolation.h"
+#include "core/animation/css/CSSAnimationData.h"
 #include "core/animation/css/CSSAnimationUpdate.h"
+#include "core/css/CSSKeyframesRule.h"
 #include "core/css/StylePropertySet.h"
 #include "core/dom/Document.h"
 #include "wtf/HashMap.h"
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
 class CSSTransitionData;
 class Element;
 class StylePropertyShorthand;
 class StyleResolver;
-class StyleRuleKeyframes;
 
 class CSSAnimations final {
     WTF_MAKE_NONCOPYABLE(CSSAnimations);
     DISALLOW_ALLOCATION();
 public:
     CSSAnimations();
 
     const AtomicString getAnimationNameForInspector(const AnimationPlayer&);
     bool isTransitionAnimationForInspector(const AnimationPlayer&) const;
 
     static const StylePropertyShorthand& animatableProperties();
     static bool isAllowedAnimation(CSSPropertyID);
     static PassOwnPtrWillBeRawPtr<CSSAnimationUpdate> calculateUpdate(const Element* animatingElement, Element&, const RenderStyle&, RenderStyle* parentStyle, StyleResolver*);
 
     void setPendingUpdate(PassOwnPtrWillBeRawPtr<CSSAnimationUpdate> update) { m_pendingUpdate = update; }
     void maybeApplyPendingUpdate(Element*);
     bool isEmpty() const { return m_animations.isEmpty() && m_transitions.isEmpty() && !m_pendingUpdate; }
     void cancel();
 
     void trace(Visitor*);
 
 private:
+    class RunningAnimation : public RefCountedWillBeGarbageCollected<RunningAnimation>  {

[esprehn, 2015/02/02 00:11:20]

final

[shend, 2015/02/02 00:53:54]

Done.

+    public:
+        RunningAnimation(PassRefPtrWillBeRawPtr<AnimationPlayer> player, CSSAnimationUpdate::NewAnimation animation)
+            : player(player)
+            , specifiedTiming(animation.timing)
+            , styleRule(animation.styleRule)
+            , styleRuleVersion(animation.styleRuleVersion)
+        {
+        }
+
+        void update(CSSAnimationUpdate::UpdatedAnimation update)
+        {
+            styleRule = update.styleRule;
+            styleRuleVersion = update.styleRuleVersion;
+            specifiedTiming = update.specifiedTiming;
+        }
+
+        void trace(Visitor* visitor)
+        {
+            visitor->trace(player);
+            visitor->trace(styleRule);
+        }
+
+        RefPtrWillBeMember<AnimationPlayer> player;
+        Timing specifiedTiming;
+        RefPtrWillBeMember<StyleRuleKeyframes> styleRule;
+        unsigned styleRuleVersion;
+    };
+
     struct RunningTransition {
         ALLOW_ONLY_INLINE_ALLOCATION();
     public:
         void trace(Visitor* visitor)
         {
             visitor->trace(player);
             visitor->trace(from);
             visitor->trace(to);
         }
 
         RefPtrWillBeMember<AnimationPlayer> player;
         RawPtrWillBeMember<const AnimatableValue> from;
         RawPtrWillBeMember<const AnimatableValue> to;
     };
 
-    using AnimationMap = WillBeHeapHashMap<AtomicString, RefPtrWillBeMember<AnimationPlayer>>;
+    using AnimationMap = WillBeHeapHashMap<AtomicString, RefPtrWillBeMember<RunningAnimation>>;
     AnimationMap m_animations;
 
     using TransitionMap = WillBeHeapHashMap<CSSPropertyID, RunningTransition>;
     TransitionMap m_transitions;
 
     OwnPtrWillBeMember<CSSAnimationUpdate> m_pendingUpdate;
 
     WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation>> m_previousActiveInterpolationsForAnimations;
 
     static void calculateAnimationUpdate(CSSAnimationUpdate*, const Element* animatingElement, Element&, const RenderStyle&, RenderStyle* parentStyle, StyleResolver*);
@@ skipping 39 matching lines @@
     private:
         RawPtrWillBeMember<Element> m_target;
         const CSSPropertyID m_property;
         AnimationNode::Phase m_previousPhase;
     };
 };
 
 } // namespace blink
 
 #endif