[WIP] Use InterpolationTypes for CSS Transitions

third_party/WebKit/Source/core/animation/PrimitiveInterpolation.h

 // 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 PrimitiveInterpolation_h
 #define PrimitiveInterpolation_h
 
+#include "core/animation/PairwiseInterpolationValue.h"
 #include "core/animation/TypedInterpolationValue.h"
 #include "platform/animation/AnimationUtilities.h"
 #include "platform/heap/Handle.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <cmath>
 #include <memory>
 
 namespace blink {
 
@@ skipping 13 matching lines @@
 
 protected:
     PrimitiveInterpolation() { }
 };
 
 // Represents a pair of keyframes that are compatible for "smooth" interpolation eg. "0px" and "100px".
 class PairwisePrimitiveInterpolation : public PrimitiveInterpolation {
 public:
     ~PairwisePrimitiveInterpolation() override { }
 
-    static std::unique_ptr<PairwisePrimitiveInterpolation> create(const InterpolationType& type, std::unique_ptr<InterpolableValue> start, std::unique_ptr<InterpolableValue> end, PassRefPtr<NonInterpolableValue> nonInterpolableValue)
+    static std::unique_ptr<PairwisePrimitiveInterpolation> create(const InterpolationType& type, PairwiseInterpolationValue&& pairwiseInterpolationValue)
     {
-        return wrapUnique(new PairwisePrimitiveInterpolation(type, std::move(start), std::move(end), nonInterpolableValue));
+        return wrapUnique(new PairwisePrimitiveInterpolation(type, std::move(pairwiseInterpolationValue)));
     }
 
     const InterpolationType& type() const { return m_type; }
 
     std::unique_ptr<TypedInterpolationValue> initialValue() const
     {
-        return TypedInterpolationValue::create(m_type, m_start->clone(), m_nonInterpolableValue);
-    }
-
-private:
-    PairwisePrimitiveInterpolation(const InterpolationType& type, std::unique_ptr<InterpolableValue> start, std::unique_ptr<InterpolableValue> end, PassRefPtr<NonInterpolableValue> nonInterpolableValue)
-        : m_type(type)
-        , m_start(std::move(start))
-        , m_end(std::move(end))
-        , m_nonInterpolableValue(nonInterpolableValue)
-    {
-        ASSERT(m_start);
-        ASSERT(m_end);
+        return TypedInterpolationValue::create(m_type, InterpolationValue(m_pairwise.startInterpolableValue->clone(), m_pairwise.nonInterpolableValue));
     }
 
     void interpolateValue(double fraction, std::unique_ptr<TypedInterpolationValue>& result) const final
     {
-        ASSERT(result);
-        ASSERT(&result->type() == &m_type);
-        ASSERT(result->getNonInterpolableValue() == m_nonInterpolableValue.get());
-        m_start->interpolate(*m_end, fraction, *result->mutableValue().interpolableValue);
+        DCHECK(result);
+        DCHECK(&result->type() == &m_type);
+        DCHECK(result->getNonInterpolableValue() == m_pairwise.nonInterpolableValue.get());
+        m_pairwise.startInterpolableValue->interpolate(
+            *m_pairwise.endInterpolableValue, fraction, *result->mutableValue().interpolableValue);
+    }
+
+private:
+    PairwisePrimitiveInterpolation(const InterpolationType& type, PairwiseInterpolationValue&& pairwiseInterpolationValue)
+        : m_type(type)
+        , m_pairwise(std::move(pairwiseInterpolationValue))
+    {
+        DCHECK(m_pairwise);
     }
 
     double interpolateUnderlyingFraction(double start, double end, double fraction) const final { return blend(start, end, fraction); }
 
     const InterpolationType& m_type;
-    std::unique_ptr<InterpolableValue> m_start;
-    std::unique_ptr<InterpolableValue> m_end;
-    RefPtr<NonInterpolableValue> m_nonInterpolableValue;
+    PairwiseInterpolationValue m_pairwise;
 };
 
 // Represents a pair of incompatible keyframes that fall back to 50% flip behaviour eg. "auto" and "0px".
 class FlipPrimitiveInterpolation : public PrimitiveInterpolation {
 public:
     ~FlipPrimitiveInterpolation() override { }
 
     static std::unique_ptr<FlipPrimitiveInterpolation> create(std::unique_ptr<TypedInterpolationValue> start, std::unique_ptr<TypedInterpolationValue> end)
     {
         return wrapUnique(new FlipPrimitiveInterpolation(std::move(start), std::move(end)));
@@ skipping 21 matching lines @@
     bool isFlip() const final { return true; }
 
     std::unique_ptr<TypedInterpolationValue> m_start;
     std::unique_ptr<TypedInterpolationValue> m_end;
     mutable double m_lastFraction;
 };
 
 } // namespace blink
 
 #endif // PrimitiveInterpolation_h