Web Animations: Use StringKeyframes for element.animate()

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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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 "config.h"
 #include "core/animation/KeyframeEffectModel.h"
 
+#include "StylePropertyShorthand.h"
 #include "core/animation/AnimatableDouble.h"
 #include "core/animation/TimedItem.h"
+#include "core/animation/css/CSSAnimations.h"
+#include "core/css/StylePropertySet.h"
+#include "core/css/resolver/StyleResolver.h"
 #include "wtf/text/StringHash.h"
 
 namespace WebCore {
 
 bool KeyframeEffectModelBase::Keyframe::compareOffsets(const RefPtrWillBeRawPtr<Keyframe>& a, const RefPtrWillBeRawPtr<Keyframe>& b)
 {
     return a->offset() < b->offset();
 }
 
 PropertySet KeyframeEffectModelBase::properties() const
@@ skipping 92 matching lines @@
     if (m_keyframeGroups)
         return;
 
     m_keyframeGroups = adoptPtr(new KeyframeGroupMap);
     const KeyframeVector keyframes = normalizedKeyframes(getFrames());
     for (KeyframeVector::const_iterator keyframeIter = keyframes.begin(); keyframeIter != keyframes.end(); ++keyframeIter) {
         const Keyframe* keyframe = keyframeIter->get();
         PropertySet keyframeProperties = keyframe->properties();
         for (PropertySet::const_iterator propertyIter = keyframeProperties.begin(); propertyIter != keyframeProperties.end(); ++propertyIter) {
             CSSPropertyID property = *propertyIter;
+            ASSERT_WITH_MESSAGE(!isExpandedShorthand(property), "Web Animations: Encountered shorthand CSS property (%d) in normalized keyframes.", property);
             KeyframeGroupMap::iterator groupIter = m_keyframeGroups->find(property);
             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(keyframe->createPropertySpecificKeyframe(property));
         }
     }
@@ skipping 90 matching lines @@
     if (property == CSSPropertyOpacity)
         return OpacityStyleInterpolation::create(toAnimatableDouble(from->value())->toDouble(), toAnimatableDouble(to->value())->toDouble());
     return LegacyStyleInterpolation::create(from->value(), to->value(), property);
 }
 
 PassOwnPtr<KeyframeEffectModelBase::PropertySpecificKeyframe> AVKeyframeEffectModel::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
     return adoptPtr(new PropertySpecificKeyframe(offset, easing, AnimatableValue::neutralValue(), CompositeAdd));
 }
 
+void SKeyframe::setPropertyValue(CSSPropertyID property, const String& value)
+{
+    ASSERT(property != CSSPropertyInvalid);
+    RefPtr<MutableStylePropertySet> propertySet = MutableStylePropertySet::create();
+    propertySet->setProperty(property, value);
+    for (size_t i = 0; i < propertySet->propertyCount(); ++i) {
+        CSSPropertyID id = propertySet->propertyAt(i).id();
+        if (CSSAnimations::isAnimatableProperty(id))
+            m_propertyValues.add(id, propertySet->getPropertyCSSValue(id));
+    }
+}
+
+static bool checkDocumentAndRenderer(Element& element)
+{
+    if (!element.inActiveDocument())
+        return false;
+    element.document().updateStyleIfNeeded();
+    return element.renderer();
+}
+
 PassRefPtr<Interpolation> SKeyframeEffectModel::createInterpolation(CSSPropertyID property, KeyframeEffectModelBase::PropertySpecificKeyframe *start, KeyframeEffectModelBase::PropertySpecificKeyframe *end) const
 {
-    PropertySpecificKeyframe *from = toPropertySpecificKeyframe(start);
-    PropertySpecificKeyframe *to = toPropertySpecificKeyframe(end);
-    ASSERT_UNUSED(from, from);
-    ASSERT_UNUSED(to, to);
-    // create Interpolation here
-    return RefPtr<Interpolation>();
+    // FIXME: This check will not be neccessary once we can avoid snapshotting computed style values for keyframes.
+    RELEASE_ASSERT(checkDocumentAndRenderer(*m_element.get()));
+
+    CSSValue* fromCSSValue = toPropertySpecificKeyframe(start)->value();
+    CSSValue* toCSSValue = toPropertySpecificKeyframe(end)->value();
+
+    RefPtr<AnimatableValue> from = StyleResolver::createAnimatableValueSnapshot(*m_element.get(), *m_renderStyle.get(), property, fromCSSValue);
+    RefPtr<AnimatableValue> to = StyleResolver::createAnimatableValueSnapshot(*m_element.get(), *m_renderStyle.get(), property, toCSSValue);
+
+    return LegacyStyleInterpolation::create(from, to, property);

[alancutter (OOO until 2018), 2014/03/11 09:45:33]

from.release(), to.release()

 }
 
 PassOwnPtr<KeyframeEffectModelBase::PropertySpecificKeyframe> SKeyframeEffectModel::neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const
 {
-    return adoptPtr(new PropertySpecificKeyframe(offset, easing, "invalid", CompositeAdd));
+    return adoptPtr(new PropertySpecificKeyframe(offset, easing, nullptr, CompositeAdd));
 }
 
 } // namespace