WIP: Implement CSS transitions on top of InterpolationTypes instead of AnimatableValues

third_party/WebKit/Source/core/animation/InterpolationType.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 InterpolationType_h
 #define InterpolationType_h
 
 #include "core/animation/InterpolationValue.h"
 #include "core/animation/Keyframe.h"
 #include "core/animation/PairwiseInterpolationValue.h"
@@ skipping 42 matching lines @@
     {
         InterpolationValue start = maybeConvertSingle(startKeyframe, environment, underlying, conversionCheckers);
         if (!start)
             return nullptr;
         InterpolationValue end = maybeConvertSingle(endKeyframe, environment, underlying, conversionCheckers);
         if (!end)
             return nullptr;
         return maybeMergeSingles(std::move(start), std::move(end));
     }
 
+    virtual PairwiseInterpolationValue maybeMergeSingles(InterpolationValue&& start, InterpolationValue&& end) const
+    {
+        DCHECK(!start.nonInterpolableValue);
+        DCHECK(!end.nonInterpolableValue);
+        return PairwiseInterpolationValue(
+            std::move(start.interpolableValue),
+            std::move(end.interpolableValue),
+            nullptr);
+    }
+
     virtual InterpolationValue maybeConvertSingle(const PropertySpecificKeyframe&, const InterpolationEnvironment&, const InterpolationValue& underlying, ConversionCheckers&) const = 0;
 
     virtual InterpolationValue maybeConvertUnderlyingValue(const InterpolationEnvironment&) const = 0;
 
     virtual void composite(UnderlyingValueOwner& underlyingValueOwner, double underlyingFraction, const InterpolationValue& value, double interpolationFraction) const
     {
-        ASSERT(!underlyingValueOwner.value().nonInterpolableValue);
-        ASSERT(!value.nonInterpolableValue);
+        DCHECK(!underlyingValueOwner.value().nonInterpolableValue);
+        DCHECK(!value.nonInterpolableValue);
         underlyingValueOwner.mutableValue().interpolableValue->scaleAndAdd(underlyingFraction, *value.interpolableValue);
     }
 
     virtual void apply(const InterpolableValue&, const NonInterpolableValue*, InterpolationEnvironment&) 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(PropertyHandle property)
         : m_property(property)
     { }
 
-    virtual PairwiseInterpolationValue maybeMergeSingles(InterpolationValue&& start, InterpolationValue&& end) const
-    {
-        ASSERT(!start.nonInterpolableValue);
-        ASSERT(!end.nonInterpolableValue);
-        return PairwiseInterpolationValue(
-            std::move(start.interpolableValue),
-            std::move(end.interpolableValue),
-            nullptr);
-    }
-
     const PropertyHandle m_property;
 };
 
 } // namespace blink
 
 #endif // InterpolationType_h