Web Animations: Use StringKeyframes for element.animate()

Source/core/animation/KeyframeEffectModel.h

 /*
  * 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 18 matching lines @@
  */
 
 #ifndef KeyframeEffectModel_h
 #define KeyframeEffectModel_h
 
 #include "core/animation/AnimatableDouble.h"
 #include "core/animation/AnimatableValue.h"
 #include "core/animation/AnimationEffect.h"
 #include "core/animation/InterpolationEffect.h"
 #include "core/animation/TimedItem.h"
+#include "core/dom/Element.h"
+#include "core/rendering/style/RenderStyle.h"
+#include "core/rendering/style/StyleInheritedData.h"
 #include "heap/Handle.h"
 #include "platform/animation/TimingFunction.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
@@ skipping 213 matching lines @@
         return static_cast<PropertySpecificKeyframe*>(keyframe);
     }
 
     virtual PassRefPtr<Interpolation> createInterpolation(CSSPropertyID, KeyframeEffectModelBase::PropertySpecificKeyframe *start, KeyframeEffectModelBase::PropertySpecificKeyframe *end) const;
 
 private:
     AVKeyframeEffectModel(const KeyframeVector& keyframes)
     {
         m_keyframes.appendVector(keyframes);
     }
-
-    AVKeyframeEffectModel(PassRefPtr<InterpolationEffect>);
 };
 
 
 class SKeyframeEffectModel FINAL : public KeyframeEffectModelBase {
 public:
     class Keyframe : public KeyframeEffectModelBase::Keyframe {
     public:
         static PassRefPtr<Keyframe> create()
         {
             return adoptRef(new Keyframe);
         }
-        void setPropertyValue(CSSPropertyID property, const String& value)
+
+        // This string setter will accept shorthand properties and expand them internally.
+        void setPropertyValue(CSSPropertyID, const String& value);
+        void setPropertyValue(CSSPropertyID property, PassRefPtr<CSSValue> value)
         {
             m_propertyValues.add(property, value);
         }
         void clearPropertyValue(CSSPropertyID property) { m_propertyValues.remove(property); }
-        String propertyValue(CSSPropertyID property) const
+        CSSValue* propertyValue(CSSPropertyID property) const
         {
             ASSERT(m_propertyValues.contains(property));
             return m_propertyValues.get(property);
         }
 
         virtual PropertySet properties() const
         {
             // This is not used in time-critical code, so we probably don't need to
             // worry about caching this result.
             PropertySet properties;
@@ skipping 12 matching lines @@
         Keyframe()
             : KeyframeEffectModelBase::Keyframe()
         { }
         Keyframe(const Keyframe& copyFrom)
             : KeyframeEffectModelBase::Keyframe(copyFrom.m_offset, copyFrom.m_composite, copyFrom.m_easing)
         {
             for (typename PropertyValueMap::const_iterator iter = copyFrom.m_propertyValues.begin(); iter != copyFrom.m_propertyValues.end(); ++iter)
                 setPropertyValue(iter->key, iter->value);
         }
 
-        typedef HashMap<CSSPropertyID, String> PropertyValueMap;
+        typedef HashMap<CSSPropertyID, RefPtr<CSSValue> > PropertyValueMap;
         PropertyValueMap m_propertyValues;
     };
 
     typedef WillBeHeapVector<RefPtrWillBeMember<Keyframe> > KeyframeVector;
     // FIXME: Implement accumulation.
-    static PassRefPtrWillBeRawPtr<SKeyframeEffectModel > create(const KeyframeVector& keyframes)
+    static PassRefPtrWillBeRawPtr<SKeyframeEffectModel > create(Element& element, const KeyframeVector& keyframes)
     {
-        return adoptRefWillBeNoop(new SKeyframeEffectModel(keyframes));
+        return adoptRefWillBeNoop(new SKeyframeEffectModel(element, keyframes));
     }
 
     virtual bool affects(CSSPropertyID property) OVERRIDE
     {
         ensureKeyframeGroups();
         return m_keyframeGroups->contains(property);
     }
 
     // Represents the keyframes set through the API.
     class PropertySpecificKeyframe : public KeyframeEffectModelBase::PropertySpecificKeyframe {
     public:
-        PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, const String& value, CompositeOperation op)
+        PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, PassRefPtr<CSSValue> value, CompositeOperation op)
             : KeyframeEffectModelBase::PropertySpecificKeyframe(offset, easing, op)
             , m_value(value)
         { }
 
-        const String& value() const { return m_value; }
+        CSSValue* value() const { return m_value.get(); }
 
         virtual PassOwnPtr<KeyframeEffectModelBase::PropertySpecificKeyframe> cloneWithOffset(double offset) const
         {
             KeyframeEffectModelBase::PropertySpecificKeyframe *theClone = new PropertySpecificKeyframe(offset, m_easing, m_value);
             return adoptPtr(theClone);
         }
 
     private:
 
         // Used by cloneWithOffset().
-        PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, const String& value)
+        PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, PassRefPtr<CSSValue> value)
             : KeyframeEffectModelBase::PropertySpecificKeyframe(offset, easing, AnimationEffect::CompositeReplace)
             , m_value(value)
         {
             ASSERT(!isNull(m_offset));
         }
-        String m_value;
+        RefPtr<CSSValue> m_value;
     };
 
     virtual PassOwnPtr<KeyframeEffectModelBase::PropertySpecificKeyframe> neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const;
 
     static PropertySpecificKeyframe* toPropertySpecificKeyframe(KeyframeEffectModelBase::PropertySpecificKeyframe* keyframe)
     {
         return static_cast<PropertySpecificKeyframe*>(keyframe);
     }
 
     virtual PassRefPtr<Interpolation> createInterpolation(CSSPropertyID, KeyframeEffectModelBase::PropertySpecificKeyframe *start, KeyframeEffectModelBase::PropertySpecificKeyframe *end) const;
 
 private:
-    SKeyframeEffectModel(const KeyframeVector& keyframes)
+    SKeyframeEffectModel(Element& element, const KeyframeVector& keyframes)
+        : m_element(&element)
+        , m_renderStyle(RenderStyle::create())
     {
         m_keyframes.appendVector(keyframes);
     }
 
-    SKeyframeEffectModel(PassRefPtr<InterpolationEffect>);
+    // FIXME: Remove the need to snapshot computed style values, this will remove the dependency on Element and RenderStyle.
+    RefPtr<Element> m_element;
+    RefPtr<RenderStyle> m_renderStyle;
 };
 
 DEFINE_TYPE_CASTS(KeyframeEffectModelBase, AnimationEffect, value, value->isKeyframeEffectModel(), value.isKeyframeEffectModel());
 
 typedef KeyframeEffectModelBase::Keyframe Keyframe;
 typedef KeyframeEffectModelBase::KeyframeVector KeyframeVector;
 typedef KeyframeEffectModelBase::PropertySpecificKeyframeVector PropertySpecificKeyframeVector;
 
 typedef AVKeyframeEffectModel::Keyframe AVKeyframe;
 typedef AVKeyframeEffectModel::KeyframeVector AVKeyframeVector;
@@ skipping 13 matching lines @@
     return static_cast<AVKeyframeEffectModel*>(effect);
 }
 inline AVKeyframeEffectModel::Keyframe* toAVKeyframe(KeyframeEffectModelBase::Keyframe* keyframe)
 {
     return static_cast<AVKeyframeEffectModel::Keyframe*>(keyframe);
 }
 
 } // namespace WebCore
 
 #endif // KeyframeEffectModel_h