Web Animations: Introduce String based KeyframeEffectModel

Source/core/animation/CompositorAnimations.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 40 matching lines @@
 #include "public/platform/WebTransformAnimationCurve.h"
 #include "public/platform/WebTransformKeyframe.h"
 
 #include <algorithm>
 #include <cmath>
 
 namespace WebCore {
 
 namespace {
 
-void getKeyframeValuesForProperty(const KeyframeEffectModel* effect, CSSPropertyID id, double scale, bool reverse, KeyframeVector& values)
+void getKeyframeValuesForProperty(const KeyframeEffectModelBase* effect, CSSPropertyID id, double scale, bool reverse, PropertySpecificKeyframeVector& values)
 {
     ASSERT(values.isEmpty());
-    const KeyframeVector& group = effect->getPropertySpecificKeyframes(id);
+    const PropertySpecificKeyframeVector& group = effect->getPropertySpecificKeyframes(id);
 
     if (reverse) {
         for (size_t i = group.size(); i--;) {
             double offset = (1 - group[i]->offset()) * scale;
             values.append(group[i]->cloneWithOffset(offset));
         }
     } else {
         for (size_t i = 0; i < group.size(); ++i) {
             double offset = group[i]->offset() * scale;
             values.append(group[i]->cloneWithOffset(offset));
@@ skipping 49 matching lines @@
         return PassRefPtr<TimingFunction>();
     }
 }
 
 // -----------------------------------------------------------------------
 // CompositorAnimations public API
 // -----------------------------------------------------------------------
 
 bool CompositorAnimations::isCandidateForAnimationOnCompositor(const Timing& timing, const AnimationEffect& effect)
 {
-    const KeyframeEffectModel& keyframeEffect = *toKeyframeEffectModel(&effect);
+    const AnimatableValueKeyframeEffectModel& keyframeEffect = *toAnimatableValueKeyframeEffectModel(&effect);
 
     // Are the keyframes convertible?
-    const KeyframeEffectModel::KeyframeVector frames = keyframeEffect.getFrames();
+    const KeyframeVector frames = keyframeEffect.getFrames();
     for (size_t i = 0; i < frames.size(); ++i) {
         // Only replace mode can be accelerated
         if (frames[i]->composite() != AnimationEffect::CompositeReplace)
             return false;
 
         // Check all the properties can be accelerated
         const PropertySet properties = frames[i]->properties(); // FIXME: properties creates a whole new PropertySet!
 
         if (properties.isEmpty())
             return false;
 
+        AnimatableValueKeyframe* frame = toAnimatableValueKeyframe(frames[i].get());
+
         for (PropertySet::const_iterator it = properties.begin(); it != properties.end(); ++it) {
             switch (*it) {
             case CSSPropertyOpacity:
                 continue;
             case CSSPropertyTransform:
-                if (toAnimatableTransform(frames[i]->propertyValue(CSSPropertyTransform))->transformOperations().dependsOnBoxSize())
+                if (toAnimatableTransform(frame->propertyValue(CSSPropertyTransform))->transformOperations().dependsOnBoxSize())
                     return false;
                 continue;
             case CSSPropertyWebkitFilter: {
-                const FilterOperations& operations = toAnimatableFilterOperations(frames[i]->propertyValue(CSSPropertyWebkitFilter))->operations();
+                const FilterOperations& operations = toAnimatableFilterOperations(frame->propertyValue(CSSPropertyWebkitFilter))->operations();
                 if (operations.hasFilterThatMovesPixels())
                     return false;
                 for (size_t i = 0; i < operations.size(); i++) {
                     const FilterOperation& op = *operations.at(i);
                     if (op.type() == FilterOperation::VALIDATED_CUSTOM || op.type() == FilterOperation::CUSTOM)
                         return false;
                 }
                 continue;
             }
             default:
@@ skipping 25 matching lines @@
 
     default:
         ASSERT_NOT_REACHED();
         return false;
     }
 
     if (frames.size() < 2)
         return false;
 
     // Search for any segments with StepsFunction.
-    WillBeHeapVector<RefPtrWillBeMember<Keyframe> >::const_iterator end = keyframeEffect.getFrames().end() - 1; // Ignore timing function of last frame.
-    for (WillBeHeapVector<RefPtrWillBeMember<Keyframe> >::const_iterator iter = keyframeEffect.getFrames().begin(); iter != end; ++iter) {
+    WillBeHeapVector<RefPtrWillBeMember<Keyframe> >::const_iterator end = frames.end() - 1; // Ignore timing function of last frame.
+    for (WillBeHeapVector<RefPtrWillBeMember<Keyframe> >::const_iterator iter = frames.begin(); iter != end; ++iter) {
         RELEASE_ASSERT((*iter)->easing());
         switch ((*iter)->easing()->type()) {
         case TimingFunction::LinearFunction:
         case TimingFunction::CubicBezierFunction:
             continue;
 
         case TimingFunction::StepsFunction:
             return false;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
 
     return true;
 }
 
 bool CompositorAnimations::canStartAnimationOnCompositor(const Element& element)
 {
     return element.renderer() && element.renderer()->compositingState() == PaintsIntoOwnBacking;
 }
 
 bool CompositorAnimations::startAnimationOnCompositor(const Element& element, const Timing& timing, const AnimationEffect& effect, Vector<int>& startedAnimationIds)
 {
     ASSERT(startedAnimationIds.isEmpty());
     ASSERT(isCandidateForAnimationOnCompositor(timing, effect));
     ASSERT(canStartAnimationOnCompositor(element));
 
-    const KeyframeEffectModel& keyframeEffect = *toKeyframeEffectModel(&effect);
+    const AnimatableValueKeyframeEffectModel& keyframeEffect = *toAnimatableValueKeyframeEffectModel(&effect);
 
     RenderLayer* layer = toRenderBoxModelObject(element.renderer())->layer();
     ASSERT(layer);
 
     Vector<OwnPtr<blink::WebAnimation> > animations;
     CompositorAnimationsImpl::getAnimationOnCompositor(timing, keyframeEffect, animations);
     ASSERT(!animations.isEmpty());
     for (size_t i = 0; i < animations.size(); ++i) {
         int id = animations[i]->id();
         if (!layer->compositedLayerMapping()->mainGraphicsLayer()->addAnimation(animations[i].release())) {
@@ skipping 139 matching lines @@
 
     case TimingFunction::StepsFunction:
     default:
         ASSERT_NOT_REACHED();
         return;
     }
 }
 
 } // namespace anoymous
 
-void CompositorAnimationsImpl::addKeyframesToCurve(blink::WebAnimationCurve& curve, const KeyframeVector& keyframes, bool reverse)
+void CompositorAnimationsImpl::addKeyframesToCurve(blink::WebAnimationCurve& curve, const PropertySpecificKeyframeVector& keyframes, bool reverse)
 {
     for (size_t i = 0; i < keyframes.size(); i++) {
         RefPtr<TimingFunction> reversedTimingFunction;
         const TimingFunction* keyframeTimingFunction = 0;
         if (i < keyframes.size() - 1) { // Ignore timing function of last frame.
             if (reverse) {
                 reversedTimingFunction = CompositorAnimationsTimingFunctionReverser::reverse(keyframes[i + 1]->easing());
                 keyframeTimingFunction = reversedTimingFunction.get();
             } else {
                 keyframeTimingFunction = keyframes[i]->easing();
             }
         }
 
-        const AnimatableValue* value = keyframes[i]->value();
+        const AnimatableValue* value = toAnimatableValuePropertySpecificKeyframe(keyframes[i].get())->value();
 
         switch (curve.type()) {
         case blink::WebAnimationCurve::AnimationCurveTypeFilter: {
             OwnPtr<blink::WebFilterOperations> ops = adoptPtr(blink::Platform::current()->compositorSupport()->createFilterOperations());
             bool converted = toWebFilterOperations(toAnimatableFilterOperations(value)->operations(), ops.get());
             ASSERT_UNUSED(converted, converted);
 
             blink::WebFilterKeyframe filterKeyframe(keyframes[i]->offset(), ops.release());
             blink::WebFilterAnimationCurve* filterCurve = static_cast<blink::WebFilterAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*filterCurve, filterKeyframe, keyframeTimingFunction);
@@ skipping 13 matching lines @@
             blink::WebTransformAnimationCurve* transformCurve = static_cast<blink::WebTransformAnimationCurve*>(&curve);
             addKeyframeWithTimingFunction(*transformCurve, transformKeyframe, keyframeTimingFunction);
             break;
         }
         default:
             ASSERT_NOT_REACHED();
         }
     }
 }
 
-void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, const KeyframeEffectModel& effect, Vector<OwnPtr<blink::WebAnimation> >& animations)
+void CompositorAnimationsImpl::getAnimationOnCompositor(const Timing& timing, const AnimatableValueKeyframeEffectModel& effect, Vector<OwnPtr<blink::WebAnimation> >& animations)
 {
     ASSERT(animations.isEmpty());
     CompositorTiming compositorTiming;
     bool timingValid = convertTimingForCompositor(timing, compositorTiming);
     ASSERT_UNUSED(timingValid, timingValid);
 
     RefPtr<TimingFunction> timingFunction = timing.timingFunction;
     if (compositorTiming.reverse)
         timingFunction = CompositorAnimationsTimingFunctionReverser::reverse(timingFunction.get());
 
     PropertySet properties = effect.properties();
     ASSERT(!properties.isEmpty());
     for (PropertySet::iterator it = properties.begin(); it != properties.end(); ++it) {
 
-        KeyframeVector values;
+        PropertySpecificKeyframeVector values;
         getKeyframeValuesForProperty(&effect, *it, compositorTiming.scaledDuration, compositorTiming.reverse, values);
 
         blink::WebAnimation::TargetProperty targetProperty;
         OwnPtr<blink::WebAnimationCurve> curve;
         switch (*it) {
         case CSSPropertyOpacity: {
             targetProperty = blink::WebAnimation::TargetPropertyOpacity;
 
             blink::WebFloatAnimationCurve* floatCurve = blink::Platform::current()->compositorSupport()->createFloatAnimationCurve();
             addKeyframesToCurve(*floatCurve, values, compositorTiming.reverse);
@@ skipping 25 matching lines @@
         animation->setIterations(compositorTiming.adjustedIterationCount);
         animation->setTimeOffset(compositorTiming.scaledTimeOffset);
         animation->setAlternatesDirection(compositorTiming.alternate);
 
         animations.append(animation.release());
     }
     ASSERT(!animations.isEmpty());
 }
 
 } // namespace WebCore