Web Animations: Introduce String based KeyframeEffectModel

Source/core/animation/Keyframe.h

+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef Keyframe_h
+#define Keyframe_h
+
+#include "CSSPropertyNames.h"
+#include "core/animation/AnimationEffect.h"
+#include "core/animation/TimedItem.h"
+
+namespace WebCore {
+
+typedef HashSet<CSSPropertyID> PropertySet;
+
+class Keyframe : public RefCountedWillBeGarbageCollectedFinalized<Keyframe> {
+public:
+    virtual ~Keyframe() { }

[dstockwell, 2014/04/01 06:38:12]

nit: whitespace and grouping would make this a bit easier to digest

[shans, 2014/04/01 12:05:32]

Done.

+    void setOffset(double offset) { m_offset = offset; }
+    double offset() const { return m_offset; }
+    void setComposite(AnimationEffect::CompositeOperation composite) { m_composite = composite; }
+    AnimationEffect::CompositeOperation composite() const { return m_composite; }
+    void setEasing(PassRefPtr<TimingFunction> easing) { m_easing = easing; }
+    TimingFunction* easing() const { return m_easing.get(); }
+    static bool compareOffsets(const RefPtrWillBeRawPtr<Keyframe>&, const RefPtrWillBeRawPtr<Keyframe>&);
+    virtual PropertySet properties() const = 0;
+    virtual PassRefPtrWillBeRawPtr<Keyframe> clone() const = 0;
+    PassRefPtrWillBeRawPtr<Keyframe> cloneWithOffset(double offset) const
+    {
+        RefPtrWillBeRawPtr<Keyframe> theClone = clone();
+        theClone->setOffset(offset);
+        return theClone.release();
+    }
+
+    virtual bool isAnimatableValueKeyframe() const { return false; }
+    virtual bool isStringKeyframe() const { return false; }
+
+    void trace(Visitor*) { }
+
+    class PropertySpecificKeyframe : public NoBaseWillBeGarbageCollectedFinalized<PropertySpecificKeyframe> {
+    public:
+        virtual ~PropertySpecificKeyframe() { }
+        double offset() const { return m_offset; }
+        TimingFunction* easing() const { return m_easing.get(); }
+        AnimationEffect::CompositeOperation composite() const { return m_composite; }
+        virtual PassOwnPtr<PropertySpecificKeyframe> cloneWithOffset(double offset) const = 0;
+
+        virtual bool isAnimatableValuePropertySpecificKeyframe() const { return false; }
+        virtual bool isStringPropertySpecificKeyframe() const { return false; }
+
+        virtual PassOwnPtr<PropertySpecificKeyframe> neutralKeyframe(double offset, PassRefPtr<TimingFunction> easing) const = 0;
+        virtual PassRefPtr<Interpolation> createInterpolation(CSSPropertyID, WebCore::Keyframe::PropertySpecificKeyframe *end) const = 0;
+
+    protected:
+        PropertySpecificKeyframe(double offset, PassRefPtr<TimingFunction> easing, AnimationEffect::CompositeOperation);
+
+        double m_offset;
+        RefPtr<TimingFunction> m_easing;
+        AnimationEffect::CompositeOperation m_composite;
+    };
+
+    virtual PassOwnPtr<PropertySpecificKeyframe> createPropertySpecificKeyframe(CSSPropertyID) const = 0;
+
+
+protected:
+    Keyframe()

[dstockwell, 2014/04/01 06:38:12]

Would it make things much harder if we made Keyframe/PropertySpecificKeyframe
immutable?

[shans, 2014/04/01 12:05:32]

PropertySpecificKeyframe is already. I *think* we could make Keyframe immutable.
FIXME?

+        : m_offset(nullValue())
+        , m_composite(AnimationEffect::CompositeReplace)
+        , m_easing(LinearTimingFunction::preset())
+    {
+    }
+    Keyframe(double offset, AnimationEffect::CompositeOperation composite, PassRefPtr<TimingFunction> easing)
+        : m_offset(offset)
+        , m_composite(composite)
+        , m_easing(easing)
+    {
+    }
+
+    double m_offset;
+    AnimationEffect::CompositeOperation m_composite;
+    RefPtr<TimingFunction> m_easing;
+};
+
+typedef Keyframe::PropertySpecificKeyframe PropertySpecificKeyframe;
+
+}
+
+#endif