Rename Animation -> PrimitiveAnimation

Source/core/page/animation/CompositeAnimation.cpp

 /*
  * Copyright (C) 2007 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer. 
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 71 matching lines @@
     // in the next loop and then toss the ones that didn't get marked.
     CSSPropertyTransitionsMap::const_iterator end = m_transitions.end();
     for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != end; ++it)
         it->value->setActive(false);
         
     RefPtr<RenderStyle> modifiedCurrentStyle;
     
     // Check to see if we need to update the active transitions
     if (targetStyle->transitions()) {
         for (size_t i = 0; i < targetStyle->transitions()->size(); ++i) {
-            const Animation* anim = targetStyle->transitions()->animation(i);
+            const CSSAnimationData* anim = targetStyle->transitions()->animation(i);
             bool isActiveTransition = anim->duration() || anim->delay() > 0;
 
-            Animation::AnimationMode mode = anim->animationMode();
-            if (mode == Animation::AnimateNone)
+            CSSAnimationData::AnimationMode mode = anim->animationMode();
+            if (mode == CSSAnimationData::AnimateNone)
                 continue;
 
             CSSPropertyID prop = anim->property();
 
-            bool all = mode == Animation::AnimateAll;
+            bool all = mode == CSSAnimationData::AnimateAll;
 
             // Handle both the 'all' and single property cases. For the single prop case, we make only one pass
             // through the loop.
             for (int propertyIndex = 0; propertyIndex < CSSPropertyAnimation::getNumProperties(); ++propertyIndex) {
                 if (all) {
                     // Get the next property which is not a shorthand.
                     bool isShorthand;
                     prop = CSSPropertyAnimation::getPropertyAtIndex(propertyIndex, isShorthand);
                     if (isShorthand)
                         continue;
@@ skipping 44 matching lines @@
                     // We need to start a transition if it is active and the properties don't match
                     equal = !isActiveTransition || CSSPropertyAnimation::propertiesEqual(prop, fromStyle, targetStyle);
                 }
 
                 // We can be in this loop with an inactive transition (!isActiveTransition). We need
                 // to do that to check to see if we are canceling a transition. But we don't want to
                 // start one of the inactive transitions. So short circuit that here. (See
                 // <https://bugs.webkit.org/show_bug.cgi?id=24787>
                 if (!equal && isActiveTransition) {
                     // Add the new transition
-                    m_transitions.set(prop, ImplicitAnimation::create(const_cast<Animation*>(anim), prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle));
+                    m_transitions.set(prop, ImplicitAnimation::create(const_cast<CSSAnimationData*>(anim), prop, renderer, this, modifiedCurrentStyle ? modifiedCurrentStyle.get() : fromStyle));
                 }
                 
                 // We only need one pass for the single prop case
                 if (!all)
                     break;
             }
         }
     }
 
     // Make a list of transitions to be removed
@@ skipping 36 matching lines @@
             
         // Toss the animation order map.
         m_keyframeAnimationOrderMap.clear();
 
         DEFINE_STATIC_LOCAL(const AtomicString, none, ("none", AtomicString::ConstructFromLiteral));
         
         // Now mark any still active animations as active and add any new animations.
         if (targetStyle->animations()) {
             int numAnims = targetStyle->animations()->size();
             for (int i = 0; i < numAnims; ++i) {
-                const Animation* anim = targetStyle->animations()->animation(i);
+                const CSSAnimationData* anim = targetStyle->animations()->animation(i);
                 AtomicString animationName(anim->name());
 
                 if (!anim->isValidAnimation())
                     continue;
                 
                 // See if there is a current animation for this name.
                 RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(animationName.impl());
                 
                 if (keyframeAnim) {
                     // If this animation is postActive, skip it so it gets removed at the end of this function.
                     if (keyframeAnim->postActive())
                         continue;
                     
                     // This one is still active.
 
                     // Animations match, but play states may differ. Update if needed.
                     keyframeAnim->updatePlayState(anim->playState());
                                 
                     // Set the saved animation to this new one, just in case the play state has changed.
                     keyframeAnim->setAnimation(anim);
                     keyframeAnim->setIndex(i);
                 } else if ((anim->duration() || anim->delay()) && anim->iterationCount() && animationName != none) {
-                    keyframeAnim = KeyframeAnimation::create(const_cast<Animation*>(anim), renderer, i, this, targetStyle);
+                    keyframeAnim = KeyframeAnimation::create(const_cast<CSSAnimationData*>(anim), renderer, i, this, targetStyle);
                     m_keyframeAnimations.set(keyframeAnim->name().impl(), keyframeAnim);
                 }
                 
                 // Add this to the animation order map.
                 if (keyframeAnim)
                     m_keyframeAnimationOrderMap.append(keyframeAnim->name().impl());
             }
         }
     }
     
@@ skipping 219 matching lines @@
 
 bool CompositeAnimation::pauseAnimationAtTime(const AtomicString& name, double t)
 {
     m_keyframeAnimations.checkConsistency();
 
     RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name.impl());
     if (!keyframeAnim || !keyframeAnim->running())
         return false;
 
     double count = keyframeAnim->m_animation->iterationCount();
-    if ((t >= 0.0) && ((count == Animation::IterationCountInfinite) || (t <= count * keyframeAnim->duration()))) {
+    if ((t >= 0.0) && ((count == CSSAnimationData::IterationCountInfinite) || (t <= count * keyframeAnim->duration()))) {
         keyframeAnim->freezeAtTime(t);
         return true;
     }
 
     return false;
 }
 
 bool CompositeAnimation::pauseTransitionAtTime(CSSPropertyID property, double t)
 {
     if ((property < firstCSSProperty) || (property >= firstCSSProperty + numCSSProperties))
@@ skipping 44 matching lines @@
             ImplicitAnimation* anim = it->value.get();
             if (anim->running())
                 ++count;
         }
     }
     
     return count;
 }
 
 } // namespace WebCore