Upstream version 5.34.104.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / core / animation / KeyframeEffectModel.cpp

diff --git a/src/third_party/WebKit/Source/core/animation/KeyframeEffectModel.cpp b/src/third_party/WebKit/Source/core/animation/KeyframeEffectModel.cpp
index fcb9bb0..82afcfa 100644 (file)
--- a/src/third_party/WebKit/Source/core/animation/KeyframeEffectModel.cpp
+++ b/src/third_party/WebKit/Source/core/animation/KeyframeEffectModel.cpp
@@ -38,28 +38,6 @@ namespace {
 
 using namespace WebCore;
 
-class ReplaceCompositableValue FINAL : public AnimationEffect::CompositableValue {
-public:
-    static PassRefPtr<ReplaceCompositableValue> create(const AnimatableValue* value)
-    {
-        return adoptRef(new ReplaceCompositableValue(value));
-    }
-    virtual bool dependsOnUnderlyingValue() const OVERRIDE
-    {
-        return false;
-    }
-    virtual PassRefPtr<AnimatableValue> compositeOnto(const AnimatableValue* underlyingValue) const OVERRIDE
-    {
-        return PassRefPtr<AnimatableValue>(m_value);
-    }
-private:
-    ReplaceCompositableValue(const AnimatableValue* value)
-        : m_value(const_cast<AnimatableValue*>(value))
-    {
-    }
-    RefPtr<AnimatableValue> m_value;
-};
-
 class AddCompositableValue FINAL : public AnimationEffect::CompositableValue {
 public:
     static PassRefPtr<AddCompositableValue> create(const AnimatableValue* value)
@@ -109,6 +87,8 @@ private:
     bool m_dependsOnUnderlyingValue;
 };
 
+const double accuracyForKeyframeEasing = 0.0000001;
+
 } // namespace
 
 
@@ -122,6 +102,7 @@ Keyframe::Keyframe()
 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());
@@ -269,13 +250,14 @@ void KeyframeEffectModel::ensureKeyframeGroups() const
         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())));
+            PropertySpecificKeyframeGroup* group;
+            if (groupIter == m_keyframeGroups->end())
+                group = m_keyframeGroups->add(property, adoptPtr(new PropertySpecificKeyframeGroup)).storedValue->value.get();
+            else
+                group = groupIter->value.get();
+
+            group->appendKeyframe(adoptPtr(
+                new PropertySpecificKeyframe(keyframe->offset(), keyframe->easing(), keyframe->propertyValue(property), keyframe->composite())));
         }
     }
 
@@ -287,16 +269,18 @@ void KeyframeEffectModel::ensureKeyframeGroups() const
 }
 
 
-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 ?
-        static_cast<PassRefPtr<CompositableValue> >(ReplaceCompositableValue::create(value)) :
+        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));
@@ -304,7 +288,7 @@ KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double o
 
 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)));
 }
 
 
@@ -350,7 +334,7 @@ void KeyframeEffectModel::PropertySpecificKeyframeGroup::addSyntheticKeyframeIfR
     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
@@ -398,8 +382,11 @@ PassRefPtr<AnimationEffect::CompositableValue> KeyframeEffectModel::PropertySpec
         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