Add TransitionInterpolation class for CSS Transition refactor

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 59 matching lines @@
       return nullptr;
     return maybeMergeSingles(std::move(start), std::move(end));
   }
 
   virtual InterpolationValue maybeConvertSingle(
       const PropertySpecificKeyframe&,
       const InterpolationEnvironment&,
       const InterpolationValue& underlying,
       ConversionCheckers&) const = 0;
 
+  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 maybeConvertUnderlyingValue(
       const InterpolationEnvironment&) const = 0;
 
   virtual void composite(UnderlyingValueOwner& underlyingValueOwner,
                          double underlyingFraction,
                          const InterpolationValue& value,
                          double interpolationFraction) const {
     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 {
-    DCHECK(!start.nonInterpolableValue);
-    DCHECK(!end.nonInterpolableValue);
-    return PairwiseInterpolationValue(std::move(start.interpolableValue),
-                                      std::move(end.interpolableValue),
-                                      nullptr);
-  }
-
   const PropertyHandle m_property;
 };
 
 }  // namespace blink
 
 #endif  // InterpolationType_h