Implement left property animation on InvalidatableStyleInterpolation

Source/core/animation/InterpolationType.h

Index: Source/core/animation/InterpolationType.h
diff --git a/Source/core/animation/InterpolationType.h b/Source/core/animation/InterpolationType.h
index 1962d8dbce584061fb83655190c75de9044b25cb..b32232d5f5d09eeec32fa15a382579b7021a4e96 100644
--- a/Source/core/animation/InterpolationType.h
+++ b/Source/core/animation/InterpolationType.h
@@ -31,20 +31,47 @@ public:
     };
     using ConversionCheckers = WillBeHeapVector<OwnPtrWillBeMember<ConversionChecker>>;
 
-    virtual PassOwnPtrWillBeRawPtr<PairwisePrimitiveInterpolation> maybeConvertPairwise(const CSSPropertySpecificKeyframe& startKeyframe, const CSSPropertySpecificKeyframe& endKeyframe, const StyleResolverState*, ConversionCheckers&) const
+    virtual PassOwnPtrWillBeRawPtr<PairwisePrimitiveInterpolation> maybeConvertPairwise(const CSSPropertySpecificKeyframe& startKeyframe, const CSSPropertySpecificKeyframe& endKeyframe, const StyleResolverState* state, ConversionCheckers& conversionCheckers) const
     {
-        return nullptr;
+        OwnPtrWillBeRawPtr<InterpolationValue> startValue = maybeConvertSingle(startKeyframe, state, conversionCheckers);
+        if (!startValue)
+            return nullptr;
+        OwnPtrWillBeRawPtr<InterpolationValue> endValue = maybeConvertSingle(endKeyframe, state, conversionCheckers);
+        if (!endValue)
+            return nullptr;
+        return PairwisePrimitiveInterpolation::create(*this, startValue->m_interpolableValue.release(), endValue->m_interpolableValue.release(), startValue->m_nonInterpolableValue.release());
     }
 
-    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertSingle(const CSSPropertySpecificKeyframe&, const StyleResolverState*, ConversionCheckers&) const = 0;
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertSingle(const CSSPropertySpecificKeyframe& keyframe, const StyleResolverState* state, ConversionCheckers& conversionCheckers) const
+    {
+        const CSSValue* value = keyframe.value();
+        if (!value)
+            return maybeConvertNeutral();
+        if (value->isInitialValue() || (value->isUnsetValue() && !CSSPropertyMetadata::isInheritedProperty(m_property)))
+            return maybeConvertInitial();
+        if (value->isInheritedValue() || (value->isUnsetValue() && CSSPropertyMetadata::isInheritedProperty(m_property)))
+            return maybeConvertInherit(state, conversionCheckers);
+        return maybeConvertValue(*value, state, conversionCheckers);
+    }
+
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertUnderlyingValue(const StyleResolverState&) const = 0;
 
     virtual void apply(const InterpolableValue&, const NonInterpolableValue*, StyleResolverState&) const = 0;
 
+    // Implement reference equality checking via pointer equality checking as these are singletons
+    bool operator==(const InterpolationType& other) const { return this == &other; }
+    bool operator!=(const InterpolationType& other) const { return this != &other; }
+
 protected:
     InterpolationType(CSSPropertyID property)
         : m_property(property)
     { }
 
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertNeutral() const { ASSERT_NOT_REACHED(); return nullptr; }
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertInitial() const { ASSERT_NOT_REACHED(); return nullptr; }
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertInherit(const StyleResolverState* state, ConversionCheckers& conversionCheckers) const { ASSERT_NOT_REACHED(); return nullptr; }
+    virtual PassOwnPtrWillBeRawPtr<InterpolationValue> maybeConvertValue(const CSSValue& value, const StyleResolverState* state, ConversionCheckers& conversionCheckers) const { ASSERT_NOT_REACHED(); return nullptr; }
+
     const CSSPropertyID m_property;
 };