Add foundation for removing AnimatableValues from StyleInterpolation

Source/core/animation/AnimationConversion.h

Index: Source/core/animation/AnimationConversion.h
diff --git a/Source/core/animation/AnimationConversion.h b/Source/core/animation/AnimationConversion.h
new file mode 100644
index 0000000000000000000000000000000000000000..c93f1fa578f2b6ac11e67e44dac7aeca659dce51
--- /dev/null
+++ b/Source/core/animation/AnimationConversion.h
@@ -0,0 +1,159 @@
+// Copyright 2015 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 AnimationConversion_h
+#define AnimationConversion_h
+
+#include "core/animation/AnimationValue.h"
+#include "platform/heap/Handle.h"
+#include "wtf/Vector.h"
+#include <cmath>
+
+namespace blink {
+
+class StyleResolverState;
+
+class AnimationConversion : public NoBaseWillBeGarbageCollectedFinalized<AnimationConversion> {
+public:
+    virtual ~AnimationConversion() { }
+
+    bool isInvalid(const StyleResolverState& state) const
+    {
+        for (const auto& invalidator : m_invalidators) {
+            if (invalidator->isInvalid(state))
+                return true;
+        }
+        return false;
+    }
+
+    virtual void interpolate(double fraction, AnimationValue& result) const = 0;
+
+    DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_invalidators); }
+
+    class Invalidator : public NoBaseWillBeGarbageCollectedFinalized<Invalidator> {
+    public:
+        virtual ~Invalidator() { }
+        virtual bool isInvalid(const StyleResolverState&) const = 0;
+        DEFINE_INLINE_VIRTUAL_TRACE() { }
+    };
+    using Invalidators = WillBeHeapVector<OwnPtrWillBeMember<Invalidator>>;
+
+protected:
+    AnimationConversion(WillBeHeapVector<OwnPtrWillBeMember<Invalidator>>& invalidators)
+    {
+        m_invalidators.swap(invalidators);
+    }
+
+    Invalidators m_invalidators;
+};
+
+class PairwiseAnimationConversion : public AnimationConversion {
+public:
+    virtual ~PairwiseAnimationConversion() { }
+
+    static PassOwnPtrWillBeRawPtr<PairwiseAnimationConversion> create(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, PassRefPtrWillBeRawPtr<NonInterpolableValue> nonInterpolableValue, Invalidators& invalidators)
+    {
+        return adoptPtrWillBeNoop(new PairwiseAnimationConversion(start, end, nonInterpolableValue, invalidators));
+    }
+
+    void initialiseAnimationValue(AnimationValue& value)
+    {
+        value.interpolableValue = m_start->clone();
+        value.nonInterpolableValue = m_nonInterpolableValue;
+    }
+
+private:
+    virtual void interpolate(double fraction, AnimationValue& result) const override final
+    {
+        ASSERT(result.nonInterpolableValue == m_nonInterpolableValue);
+        m_start->interpolate(*m_end, fraction, *result.interpolableValue);
+    }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        AnimationConversion::trace(visitor);
+        visitor->trace(m_start);
+        visitor->trace(m_end);
+        visitor->trace(m_nonInterpolableValue);
+    }
+
+    PairwiseAnimationConversion(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end, PassRefPtrWillBeRawPtr<NonInterpolableValue> nonInterpolableValue, Invalidators& invalidators)
+        : AnimationConversion(invalidators)
+        , m_start(start)
+        , m_end(end)
+        , m_nonInterpolableValue(nonInterpolableValue)
+    { }
+    OwnPtrWillBeRawPtr<InterpolableValue> m_start;
+    OwnPtrWillBeRawPtr<InterpolableValue> m_end;
+    RefPtrWillBeRawPtr<NonInterpolableValue> m_nonInterpolableValue;
+};
+
+struct AnimationConversionHalf : public NoBaseWillBeGarbageCollectedFinalized<AnimationConversionHalf> {

[shans, 2015/06/04 00:15:15]

Not sure about this name.

[alancutter (OOO until 2018), 2015/06/11 04:15:13]

Renamed:
AnimationConversion -> InterpolationPrimitive
PairwiseAnimationConversion -> PairwiseInterpolationPrimitive
DefaultAnimationConversion -> FlipInterpolationPrimitive

Moved AnimationConversionHalf to inside FlipInterpolationPrimitive (since its
sole purpose is to make passing data into the constructor cleaner) and renamed
as Side.

+    const AnimationType* type;
+    OwnPtrWillBeMember<InterpolableValue> interpolableValue;
+    RefPtrWillBeMember<NonInterpolableValue> nonInterpolableValue;
+    AnimationConversion::Invalidators invalidators;
+
+    static PassOwnPtrWillBeRawPtr<AnimationConversionHalf> create() { return adoptPtrWillBeNoop(new AnimationConversionHalf()); }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(interpolableValue);
+        visitor->trace(nonInterpolableValue);
+        visitor->trace(invalidators);
+    }
+
+private:
+    AnimationConversionHalf()
+        : type(nullptr)
+    { }
+};
+
+class DefaultAnimationConversion : public AnimationConversion {
+public:
+    virtual ~DefaultAnimationConversion() { }
+
+    static PassOwnPtrWillBeRawPtr<DefaultAnimationConversion> create(PassOwnPtrWillBeRawPtr<AnimationConversionHalf> start, PassOwnPtrWillBeRawPtr<AnimationConversionHalf> end)
+    {
+        ASSERT(start->type);
+        ASSERT(end->type);
+        Invalidators invalidators;
+        for (auto& invalidator : start->invalidators)
+            invalidators.append(invalidator.release());
+        for (auto& invalidator : end->invalidators)
+            invalidators.append(invalidator.release());
+        return adoptPtrWillBeNoop(new DefaultAnimationConversion(start, end, invalidators));
+    }
+
+private:
+    virtual void interpolate(double fraction, AnimationValue& result) const override final
+    {
+        if (!std::isnan(m_lastFraction) && (fraction < 0.5) == (m_lastFraction < 0.5))
+            return;
+        result.copy((fraction < 0.5) ? m_start : m_end);
+        m_lastFraction = fraction;
+    }
+
+    DEFINE_INLINE_VIRTUAL_TRACE()
+    {
+        AnimationConversion::trace(visitor);
+        visitor->trace(m_start);
+        visitor->trace(m_end);
+    }
+
+    DefaultAnimationConversion(PassOwnPtrWillBeRawPtr<AnimationConversionHalf> start, PassOwnPtrWillBeRawPtr<AnimationConversionHalf> end, Invalidators& invalidators)
+        : AnimationConversion(invalidators)
+        , m_start(start->type, start->interpolableValue.release(), start->nonInterpolableValue.release())
+        , m_end(end->type, end->interpolableValue.release(), end->nonInterpolableValue.release())
+        , m_lastFraction(std::numeric_limits<double>::quiet_NaN())
+    { }
+
+    AnimationValue m_start;
+    AnimationValue m_end;
+    mutable double m_lastFraction;
+};
+
+} // namespace blink
+
+#endif // AnimationConversion_h