Update CSSAnimationUpdate and CSSAnimations to handle multiple animations with a given name

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 166 matching lines @@
                 }
             }
 
             Timing timing;
             RefPtr<TimingFunction> defaultTimingFunction = timingFromAnimationData(animationData, timing);
             KeyframeAnimationEffect::KeyframeVector keyframes;
             resolver->resolveKeyframes(element, style, animationName, defaultTimingFunction.get(), keyframes, timing.timingFunction);
             if (!keyframes.isEmpty()) {
                 if (!update)
                     update = adoptPtr(new CSSAnimationUpdate());
+                HashSet<RefPtr<InertAnimation> > animations;
                 // FIXME: crbug.com/268791 - Keyframes are already normalized, perhaps there should be a flag on KeyframeAnimationEffect to skip normalization.
-                update->startAnimation(animationName, InertAnimation::create(KeyframeAnimationEffect::create(keyframes), timing).get());
+                animations.add(InertAnimation::create(KeyframeAnimationEffect::create(keyframes), timing));
+                update->startAnimation(animationName, animations);
             }
         }
     }
 
     if (!inactive.isEmpty() && !update)
         update = adoptPtr(new CSSAnimationUpdate());
     for (HashSet<AtomicString>::const_iterator iter = inactive.begin(); iter != inactive.end(); ++iter)
         update->cancelAnimation(*iter, cssAnimations->m_animations.get(*iter));
 
     return update.release();
 }
 
 void CSSAnimations::maybeApplyPendingUpdate(Element* element)
 {
     if (!element->renderer())
         m_pendingUpdate = nullptr;
 
     if (!m_pendingUpdate)
         return;
 
     OwnPtr<CSSAnimationUpdate> update = m_pendingUpdate.release();
 
-    for (Vector<AtomicString>::const_iterator iter = update->cancelledAnimationNames().begin(); iter != update->cancelledAnimationNames().end(); ++iter)
-        m_animations.take(*iter)->cancel();
+    for (Vector<AtomicString>::const_iterator iter = update->cancelledAnimationNames().begin(); iter != update->cancelledAnimationNames().end(); ++iter) {
+        const HashSet<RefPtr<Player> >& players = m_animations.take(*iter);
+        for (HashSet<RefPtr<Player> >::const_iterator iter = players.begin(); iter != players.end(); ++iter)
+            (*iter)->cancel();
+    }
 
     // FIXME: Apply updates to play-state.
 
     for (Vector<CSSAnimationUpdate::NewAnimation>::const_iterator iter = update->newAnimations().begin(); iter != update->newAnimations().end(); ++iter) {
         OwnPtr<CSSAnimations::EventDelegate> eventDelegate = adoptPtr(new EventDelegate(element, iter->name));
-        RefPtr<Animation> animation = Animation::create(element, iter->animation->effect(), iter->animation->specified(), eventDelegate.release());
-        RefPtr<Player> player = element->document().timeline()->play(animation.get());
-        m_animations.set(iter->name, player.get());
+        HashSet<RefPtr<Player> > players;
+        for (HashSet<RefPtr<InertAnimation> >::const_iterator animationsIter = iter->animations.begin(); animationsIter != iter->animations.end(); ++animationsIter) {
+            const InertAnimation* inertAnimation = animationsIter->get();
+            RefPtr<Animation> animation = Animation::create(element, inertAnimation->effect(), inertAnimation->specified(), eventDelegate.release());

[dstockwell, 2013/09/30 07:30:30]

Missed this earlier, probably needs a comment. It's important that the delegate
is only added to one of the animations.

[Steve Block, 2013/09/30 11:36:06]

Added a comment in https://codereview.chromium.org/25040006/

+            players.add(element->document().timeline()->play(animation.get()));
+        }
+        m_animations.set(iter->name, players);
     }
 }
 
 void CSSAnimations::cancel()
 {
-    for (AnimationMap::iterator iter = m_animations.begin(); iter != m_animations.end(); ++iter)
-        iter->value->cancel();
+    for (AnimationMap::iterator iter = m_animations.begin(); iter != m_animations.end(); ++iter) {
+        const HashSet<RefPtr<Player> >& players = iter->value;
+        for (HashSet<RefPtr<Player> >::const_iterator animationsIter = players.begin(); animationsIter != players.end(); ++animationsIter)
+            (*animationsIter)->cancel();
+    }
 
     m_animations.clear();
     m_pendingUpdate = nullptr;
 }
 
 void CSSAnimations::EventDelegate::maybeDispatch(Document::ListenerType listenerType, AtomicString& eventName, double elapsedTime)
 {
     if (m_target->document().hasListenerType(listenerType))
         m_target->document().timeline()->addEventToDispatch(m_target, WebKitAnimationEvent::create(eventName, m_name, elapsedTime));
 }
@@ skipping 136 matching lines @@
     case CSSPropertyWordSpacing:
     case CSSPropertyZIndex:
     case CSSPropertyZoom:
         return true;
     default:
         return false;
     }
 }
 
 } // namespace WebCore