[wip] interpolable value refactor. NOT FOR LANDING.

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 20 matching lines @@
 #include "config.h"
 #include "core/animation/KeyframeEffectModel.h"
 
 #include "core/animation/TimedItem.h"
 #include "wtf/text/StringHash.h"
 
 namespace {
 
 using namespace WebCore;
 
-class ReplaceCompositableValue : public AnimationEffect::CompositableValue {
-public:
-    static PassRefPtr<ReplaceCompositableValue> create(const AnimatableValue* value)
-    {
-        return adoptRef(new ReplaceCompositableValue(value));
-    }
-    virtual bool dependsOnUnderlyingValue() const
-    {
-        return false;
-    }
-    virtual PassRefPtr<AnimatableValue> compositeOnto(const AnimatableValue* underlyingValue) const
-    {
-        return PassRefPtr<AnimatableValue>(m_value);
-    }
-private:
-    ReplaceCompositableValue(const AnimatableValue* value)
-        : m_value(const_cast<AnimatableValue*>(value))
-    {
-    }
-    RefPtr<AnimatableValue> m_value;
-};
-
 class AddCompositableValue : public AnimationEffect::CompositableValue {
 public:
     static PassRefPtr<AddCompositableValue> create(const AnimatableValue* value)
     {
         return adoptRef(new AddCompositableValue(value));
     }
     virtual bool dependsOnUnderlyingValue() const
     {
         return true;
     }
@@ skipping 101 matching lines @@
     result = m_keyframes[0]->properties();
     for (size_t i = 1; i < m_keyframes.size(); i++) {
         PropertySet extras = m_keyframes[i]->properties();
         for (PropertySet::const_iterator it = extras.begin(); it != extras.end(); ++it) {
             result.add(*it);
         }
     }
     return result;
 }
 
-PassOwnPtr<AnimationEffect::CompositableValueList> KeyframeEffectModel::sample(int iteration, double fraction) const
+PassOwnPtr<Vector<RefPtr<Interpolation> > > KeyframeEffectModel::sample(int iteration, double fraction) const
 {
     ASSERT(iteration >= 0);
     ASSERT(!isNull(fraction));
-    const_cast<KeyframeEffectModel*>(this)->ensureKeyframeGroups();
-    OwnPtr<CompositableValueList> map = adoptPtr(new CompositableValueList());
-    for (KeyframeGroupMap::const_iterator iter = m_keyframeGroups->begin(); iter != m_keyframeGroups->end(); ++iter)
-        map->append(std::make_pair(iter->key, iter->value->sample(iteration, fraction)));
-    return map.release();
+    ensureKeyframeGroups();
+    ensureInterpolationEffect();
+
+    return m_interpolationEffect->getActiveInterpolations(fraction);
 }
 
 KeyframeEffectModel::KeyframeVector KeyframeEffectModel::normalizedKeyframes() const
 {
     KeyframeVector keyframes = getFrames();
 
     // Set offsets at 0.0 and 1.0 at ends if unset.
     if (keyframes.size() >= 2) {
         Keyframe* firstKeyframe = keyframes.first().get();
         if (isNull(firstKeyframe->offset()))
@@ skipping 37 matching lines @@
         }
     }
 
     // Add synthetic keyframes.
     for (KeyframeGroupMap::iterator iter = m_keyframeGroups->begin(); iter != m_keyframeGroups->end(); ++iter) {
         iter->value->addSyntheticKeyframeIfRequired();
         iter->value->removeRedundantKeyframes();
     }
 }
 
+void KeyframeEffectModel::ensureInterpolationEffect() const
+{
+    if (m_interpolationEffect)
+        return;
+    m_interpolationEffect = InterpolationEffect::create();
+
+    for (KeyframeGroupMap::const_iterator iter = m_keyframeGroups->begin(); iter != m_keyframeGroups->end(); ++iter)
+    {
+        const PropertySpecificKeyframeVector& keyframes = iter->value->keyframes();
+        ASSERT(keyframes[0]->value()->isAnimatableValue());
+        const AnimatableValue* start;
+        const AnimatableValue* end = toAnimatableValue(keyframes[0]->value());
+        for (size_t i = 0; i < keyframes.size() - 1; i++) {
+            ASSERT(keyframes[i+1]->value()->isAnimatableValue());
+            start = end;
+            end = toAnimatableValue(keyframes[i+1]->value());
+            m_interpolationEffect->addInterpolation(
+                LegacyStyleInterpolation::create(
+                    AnimatableValue::takeConstRef(start),
+                    AnimatableValue::takeConstRef(end), iter->key),
+                keyframes[i]->offset(), keyframes[i+1]->offset());
+        }
+    }
+}
 
 KeyframeEffectModel::PropertySpecificKeyframe::PropertySpecificKeyframe(double offset, const AnimatableValue* value, CompositeOperation composite)
     : m_offset(offset)
     , 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)
     : m_offset(offset)
     , m_value(value)
 {
     ASSERT(!isNull(m_offset));
 }
@@ skipping 92 matching lines @@
 
     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()));
 }
 
 } // namespace