Web Animations: Define easing for each keyframe

Source/core/animation/KeyframeEffectModel.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 69 matching lines @@
         , m_after(const_cast<AnimationEffect::CompositableValue*>(after))
         , m_fraction(fraction)
         , m_dependsOnUnderlyingValue(before->dependsOnUnderlyingValue() || after->dependsOnUnderlyingValue())
     { }
     RefPtr<AnimationEffect::CompositableValue> m_before;
     RefPtr<AnimationEffect::CompositableValue> m_after;
     double m_fraction;
     bool m_dependsOnUnderlyingValue;
 };
 
+const double accuracyForKeyframeEasing = 0.0000001;
+
 } // namespace
 
 
 namespace WebCore {
 
 Keyframe::Keyframe()
     : m_offset(nullValue())
     , m_composite(AnimationEffect::CompositeReplace)
 { }
 
 Keyframe::Keyframe(const Keyframe& copyFrom)
     : m_offset(copyFrom.m_offset)
     , m_composite(copyFrom.m_composite)
+    , m_easing(copyFrom.m_easing)
 {
     for (PropertyValueMap::const_iterator iter = copyFrom.m_propertyValues.begin(); iter != copyFrom.m_propertyValues.end(); ++iter)
         setPropertyValue(iter->key, iter->value.get());
 }
 
 void Keyframe::setPropertyValue(CSSPropertyID property, const AnimatableValue* value)
 {
     m_propertyValues.add(property, const_cast<AnimatableValue*>(value));
 }
 
@@ skipping 133 matching lines @@
         PropertySet keyframeProperties = keyframe->properties();
         for (PropertySet::const_iterator propertyIter = keyframeProperties.begin(); propertyIter != keyframeProperties.end(); ++propertyIter) {
             CSSPropertyID property = *propertyIter;
             KeyframeGroupMap::iterator groupIter = m_keyframeGroups->find(property);
             if (groupIter == m_keyframeGroups->end()) {
                 KeyframeGroupMap::AddResult result = m_keyframeGroups->add(property, adoptPtr(new PropertySpecificKeyframeGroup));
                 ASSERT(result.isNewEntry);
                 groupIter = result.iterator;
             }
             groupIter->value->appendKeyframe(adoptPtr(
-                new PropertySpecificKeyframe(keyframe->offset(), keyframe->propertyValue(property), keyframe->composite())));
+                new PropertySpecificKeyframe(keyframe->offset(), keyframe->easing(), keyframe->propertyValue(property), keyframe->composite())));
         }
     }
 
     // Add synthetic keyframes.
     for (KeyframeGroupMap::iterator iter = m_keyframeGroups->begin(); iter != m_keyframeGroups->end(); ++iter) {
         iter->value->addSyntheticKeyframeIfRequired();
         iter->value->removeRedundantKeyframes();
     }
 }
 
 
-KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, const AnimatableValue* value, CompositeOperation composite)
+KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, const AnimatableValue* value, CompositeOperation composite)
     : m_offset(offset)
+    , m_easing(easing)
     , m_value(composite == AnimationEffect::CompositeReplace ?
         AnimatableValue::takeConstRef(value) :
         static_cast<PassRefPtr<CompositableValue> >(AddCompositableValue::create(value)))
 {
 }
 
-KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, PassRefPtr<CompositableValue> value)
+KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, PassRefPtr<CompositableValue> value)
     : m_offset(offset)
+    , m_easing(easing)
     , m_value(value)
 {
     ASSERT(!isNull(m_offset));
 }
 
 PassOwnPtr<KeyframeEffectModel::PropertySpecificKeyframe> KeyframeEffectModel::PropertySpecificKeyframe::cloneWithOffset(double offset) const
 {
-    return adoptPtr(new PropertySpecificKeyframe(offset, PassRefPtr<CompositableValue>(m_value)));
+    return adoptPtr(new PropertySpecificKeyframe(offset, m_easing, PassRefPtr<CompositableValue>(m_value)));
 }
 
 
 void KeyframeEffectModel::PropertySpecificKeyframeGroup::appendKeyframe(PassOwnPtr<PropertySpecificKeyframe> keyframe)
 {
     ASSERT(m_keyframes.isEmpty() || m_keyframes.last()->offset() <= keyframe->offset());
     m_keyframes.append(keyframe);
 }
 
 void KeyframeEffectModel::PropertySpecificKeyframeGroup::removeRedundantKeyframes()
@@ skipping 25 matching lines @@
             allOffsetsEqual = false;
             break;
         }
     }
     if (!allOffsetsEqual)
         return;
 
     if (!offset)
         appendKeyframe(m_keyframes.first()->cloneWithOffset(1.0));
     else
-        m_keyframes.insert(0, adoptPtr(new PropertySpecificKeyframe(0.0, AnimatableValue::neutralValue(), CompositeAdd)));
+        m_keyframes.insert(0, adoptPtr(new PropertySpecificKeyframe(0.0, 0, AnimatableValue::neutralValue(), CompositeAdd)));
 }
 
 PassRefPtr<AnimationEffect::CompositableValue> KeyframeEffectModel::PropertySpecificKeyframeGroup::sample(int iteration, double offset) const
 {
     // FIXME: Implement accumulation.
     ASSERT_UNUSED(iteration, iteration >= 0);
     ASSERT(!isNull(offset));
 
     // Bail if offset is null, as this can lead to buffer overflow below.
     if (isNull(offset))
@@ skipping 27 matching lines @@
             ++after;
         before = after - 1;
         ASSERT((*before)->offset() <= offset);
         ASSERT((*after)->offset() > offset);
     }
 
     if ((*before)->offset() == offset)
         return const_cast<CompositableValue*>((*before)->value());
     if ((*after)->offset() == offset)
         return const_cast<CompositableValue*>((*after)->value());
-    return BlendedCompositableValue::create((*before)->value(), (*after)->value(),
-        (offset - (*before)->offset()) / ((*after)->offset() - (*before)->offset()));
+
+    double fraction = (offset - (*before)->offset()) / ((*after)->offset() - (*before)->offset());
+    if (const TimingFunction* timingFunction = (*before)->easing())
+        fraction = timingFunction->evaluate(fraction, accuracyForKeyframeEasing);
+    return BlendedCompositableValue::create((*before)->value(), (*after)->value(), fraction);
 }
 
 } // namespace