Fix Animations, Remove Compostior Animations.

sky/engine/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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "sky/engine/config.h"
 #include "sky/engine/core/animation/css/CSSAnimations.h"
 
 #include "gen/sky/core/StylePropertyShorthand.h"
 #include "sky/engine/core/animation/ActiveAnimations.h"
 #include "sky/engine/core/animation/AnimationTimeline.h"
-#include "sky/engine/core/animation/CompositorAnimations.h"
 #include "sky/engine/core/animation/KeyframeEffectModel.h"
 #include "sky/engine/core/animation/LegacyStyleInterpolation.h"
 #include "sky/engine/core/animation/css/CSSAnimatableValueFactory.h"
 #include "sky/engine/core/animation/css/CSSPropertyEquality.h"
 #include "sky/engine/core/css/CSSKeyframeRule.h"
 #include "sky/engine/core/css/CSSPropertyMetadata.h"
 #include "sky/engine/core/css/CSSValueList.h"
 #include "sky/engine/core/css/resolver/CSSToStyleMap.h"
 #include "sky/engine/core/css/resolver/StyleResolver.h"
 #include "sky/engine/core/dom/Element.h"
@@ skipping 281 matching lines @@
     // 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.
     HashMap<CSSPropertyID, std::pair<RefPtr<Animation>, double> > retargetedCompositorTransitions;
     for (HashSet<CSSPropertyID>::iterator iter = update->cancelledTransitions().begin(); iter != update->cancelledTransitions().end(); ++iter) {
         CSSPropertyID id = *iter;
         ASSERT(m_transitions.contains(id));
 
         RefPtr<AnimationPlayer> player = m_transitions.take(id).player;
-        Animation* animation = toAnimation(player->source());
-        if (animation->hasActiveAnimationsOnCompositor(id) && update->newTransitions().find(id) != update->newTransitions().end())
-            retargetedCompositorTransitions.add(id, std::pair<RefPtr<Animation>, double>(animation, player->startTimeInternal()));
+        // Animation* animation = toAnimation(player->source());
+        // if (animation->hasActiveAnimationsOnCompositor(id) && update->newTransitions().find(id) != update->newTransitions().end())
+        //     retargetedCompositorTransitions.add(id, std::pair<RefPtr<Animation>, double>(animation, player->startTimeInternal()));
+
+        // FIXME(rafaelw): Should we still do this?
         player->cancel();
         player->update(TimingUpdateOnDemand);
     }
 
     for (CSSAnimationUpdate::NewTransitionMap::const_iterator iter = update->newTransitions().begin(); iter != update->newTransitions().end(); ++iter) {
         const CSSAnimationUpdate::NewTransition& newTransition = iter->value;
 
         RunningTransition runningTransition;
         runningTransition.from = newTransition.from;
         runningTransition.to = newTransition.to;
 
         CSSPropertyID id = newTransition.id;
         InertAnimation* inertAnimation = newTransition.animation.get();
         OwnPtr<TransitionEventDelegate> eventDelegate = adoptPtr(new TransitionEventDelegate(element, newTransition.eventId));
 
         RefPtr<AnimationEffect> effect = inertAnimation->effect();
 
-        if (retargetedCompositorTransitions.contains(id)) {
-            const std::pair<RefPtr<Animation>, double>& oldTransition = retargetedCompositorTransitions.get(id);
-            RefPtr<Animation> oldAnimation = oldTransition.first;
-            double oldStartTime = oldTransition.second;
-            double inheritedTime = isNull(oldStartTime) ? 0 : element->document().timeline().currentTimeInternal() - oldStartTime;
+        // if (retargetedCompositorTransitions.contains(id)) {
+        //     const std::pair<RefPtr<Animation>, double>& oldTransition = retargetedCompositorTransitions.get(id);
+        //     RefPtr<Animation> oldAnimation = oldTransition.first;
+        //     double oldStartTime = oldTransition.second;
+        //     double inheritedTime = isNull(oldStartTime) ? 0 : element->document().timeline().currentTimeInternal() - oldStartTime;
 
-            AnimatableValueKeyframeEffectModel* oldEffect = toAnimatableValueKeyframeEffectModel(inertAnimation->effect());
-            const KeyframeVector& frames = oldEffect->getFrames();
+        //     AnimatableValueKeyframeEffectModel* oldEffect = toAnimatableValueKeyframeEffectModel(inertAnimation->effect());
+        //     const KeyframeVector& frames = oldEffect->getFrames();
 
-            AnimatableValueKeyframeVector newFrames;
-            newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
-            newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
+        //     AnimatableValueKeyframeVector newFrames;
+        //     newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
+        //     newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
 
-            newFrames[0]->clearPropertyValue(id);
-            RefPtr<InertAnimation> inertAnimationForSampling = InertAnimation::create(oldAnimation->effect(), oldAnimation->specifiedTiming(), false);
-            OwnPtr<Vector<RefPtr<Interpolation> > > sample = inertAnimationForSampling->sample(inheritedTime);
-            ASSERT(sample->size() == 1);
-            newFrames[0]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
+        //     newFrames[0]->clearPropertyValue(id);
+        //     RefPtr<InertAnimation> inertAnimationForSampling = InertAnimation::create(oldAnimation->effect(), oldAnimation->specifiedTiming(), false);
+        //     OwnPtr<Vector<RefPtr<Interpolation> > > sample = inertAnimationForSampling->sample(inheritedTime);
+        //     ASSERT(sample->size() == 1);
+        //     newFrames[0]->setPropertyValue(id, toLegacyStyleInterpolation(sample->at(0).get())->currentValue());
 
-            effect = AnimatableValueKeyframeEffectModel::create(newFrames);
-        }
+        //     effect = AnimatableValueKeyframeEffectModel::create(newFrames);
+        // }
 
         RefPtr<Animation> transition = Animation::create(element, effect, inertAnimation->specifiedTiming(), Animation::TransitionPriority, eventDelegate.release());
         RefPtr<AnimationPlayer> player = element->document().timeline().createAnimationPlayer(transition.get());
         player->update(TimingUpdateOnDemand);
         runningTransition.player = player;
         m_transitions.set(id, runningTransition);
         ASSERT(id != CSSPropertyInvalid);
     }
 }
 
@@ skipping 292 matching lines @@
     case CSSPropertyWebkitTransitionDuration:
     case CSSPropertyWebkitTransitionProperty:
     case CSSPropertyWebkitTransitionTimingFunction:
         return false;
     default:
         return true;
     }
 }
 
 } // namespace blink