Delete unused AnimatableValue code

third_party/WebKit/Source/core/animation/KeyframeEffectModelTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/KeyframeEffectModel.h"
 
 #include "core/animation/LegacyStyleInterpolation.h"
-#include "core/animation/animatable/AnimatableLength.h"
+#include "core/animation/animatable/AnimatableDouble.h"
 #include "core/animation/animatable/AnimatableUnknown.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/dom/Element.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 const double duration = 1.0;
 
 PassRefPtr<AnimatableValue> unknownAnimatableValue(double n) {
   return AnimatableUnknown::create(
       CSSPrimitiveValue::create(n, CSSPrimitiveValue::UnitType::Unknown));
 }
 
-PassRefPtr<AnimatableValue> pixelAnimatableValue(double n) {
-  return AnimatableLength::create(Length(n, Fixed), 1);
-}
-
 AnimatableValueKeyframeVector keyframesAtZeroAndOne(
     PassRefPtr<AnimatableValue> zeroValue,
     PassRefPtr<AnimatableValue> oneValue) {
   AnimatableValueKeyframeVector keyframes(2);
   keyframes[0] = AnimatableValueKeyframe::create();
   keyframes[0]->setOffset(0.0);
   keyframes[0]->setPropertyValue(CSSPropertyLeft, zeroValue.get());
   keyframes[1] = AnimatableValueKeyframe::create();
   keyframes[1]->setOffset(1.0);
   keyframes[1]->setPropertyValue(CSSPropertyLeft, oneValue.get());
   return keyframes;
 }
 
 void expectProperty(CSSPropertyID property,
                     PassRefPtr<Interpolation> interpolationValue) {
   LegacyStyleInterpolation* interpolation =
       toLegacyStyleInterpolation(interpolationValue.get());
   ASSERT_EQ(property, interpolation->id());
 }
 
 void expectDoubleValue(double expectedValue,
                        PassRefPtr<Interpolation> interpolationValue) {
   LegacyStyleInterpolation* interpolation =
       toLegacyStyleInterpolation(interpolationValue.get());
   RefPtr<AnimatableValue> value = interpolation->currentValue();
 
-  ASSERT_TRUE(value->isLength() || value->isUnknown());
+  ASSERT_TRUE(value->isDouble() || value->isUnknown());
 
   double actualValue;
-  if (value->isLength())
-    actualValue =
-        toAnimatableLength(value.get())->getLength(1, ValueRangeAll).value();
+  if (value->isDouble())
+    actualValue = toAnimatableDouble(value.get())->toDouble();
   else
     actualValue =
         toCSSPrimitiveValue(toAnimatableUnknown(value.get())->toCSSValue())
             ->getDoubleValue();
 
   EXPECT_FLOAT_EQ(static_cast<float>(expectedValue), actualValue);
 }
 
 Interpolation* findValue(Vector<RefPtr<Interpolation>>& values,
                          CSSPropertyID id) {
@@ skipping 23 matching lines @@
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(5.0, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, CompositeReplace) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeReplace);
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(3.0 * 0.4 + 5.0 * 0.6, values.at(0));
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_CompositeAdd) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeAdd);
   keyframes[1]->setComposite(EffectModel::CompositeAdd);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue((7.0 + 3.0) * 0.4 + (7.0 + 5.0) * 0.6, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, CompositeEaseIn) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeReplace);
   keyframes[0]->setEasing(CubicBezierTimingFunction::preset(
       CubicBezierTimingFunction::EaseType::EASE_IN));
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(3.8579516, values.at(0));
   effect->sample(0, 0.6, duration * 100, values);
   expectDoubleValue(3.8582394, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, CompositeCubicBezier) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeReplace);
   keyframes[0]->setEasing(CubicBezierTimingFunction::create(0.42, 0, 0.58, 1));
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(4.3363357, values.at(0));
   effect->sample(0, 0.6, duration * 1000, values);
   expectDoubleValue(4.3362322, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, ExtrapolateReplaceNonInterpolable) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
       unknownAnimatableValue(3.0), unknownAnimatableValue(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeReplace);
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 1.6, duration, values);
   expectDoubleValue(5.0, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, ExtrapolateReplace) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   keyframes[0]->setComposite(EffectModel::CompositeReplace);
   keyframes[1]->setComposite(EffectModel::CompositeReplace);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 1.6, duration, values);
   expectDoubleValue(3.0 * -0.6 + 5.0 * 1.6, values.at(0));
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_ExtrapolateAdd) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeAdd);
   keyframes[1]->setComposite(EffectModel::CompositeAdd);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 1.6, duration, values);
   expectDoubleValue((7.0 + 3.0) * -0.6 + (7.0 + 5.0) * 1.6, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, ZeroKeyframes) {
@@ skipping 19 matching lines @@
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(3.0, values.at(0));
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_SingleKeyframeAtOffsetOne) {
   AnimatableValueKeyframeVector keyframes(1);
   keyframes[0] = AnimatableValueKeyframe::create();
   keyframes[0]->setOffset(1.0);
   keyframes[0]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(5.0).get());
+                                 AnimatableDouble::create(5.0).get());
 
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(7.0 * 0.4 + 5.0 * 0.6, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, MoreThanTwoKeyframes) {
   AnimatableValueKeyframeVector keyframes(3);
@@ skipping 126 matching lines @@
   effect->sample(0, 1.0, duration, values);
   expectDoubleValue(7.0, values.at(0));
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_PerKeyframeComposite) {
   AnimatableValueKeyframeVector keyframes(2);
   keyframes[0] = AnimatableValueKeyframe::create();
   keyframes[0]->setOffset(0.0);
   keyframes[0]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(3.0).get());
+                                 AnimatableDouble::create(3.0).get());
   keyframes[1] = AnimatableValueKeyframe::create();
   keyframes[1]->setOffset(1.0);
   keyframes[1]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(5.0).get());
+                                 AnimatableDouble::create(5.0).get());
   keyframes[1]->setComposite(EffectModel::CompositeAdd);
 
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue(3.0 * 0.4 + (7.0 + 5.0) * 0.6, values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, MultipleProperties) {
@@ skipping 20 matching lines @@
   ASSERT_TRUE(leftValue);
   expectDoubleValue(5.0, leftValue);
   Interpolation* rightValue = findValue(values, CSSPropertyRight);
   ASSERT_TRUE(rightValue);
   expectDoubleValue(6.0, rightValue);
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_RecompositeCompositableValue) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(3.0), pixelAnimatableValue(5.0));
+      AnimatableDouble::create(3.0), AnimatableDouble::create(5.0));
   keyframes[0]->setComposite(EffectModel::CompositeAdd);
   keyframes[1]->setComposite(EffectModel::CompositeAdd);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.6, duration, values);
   expectDoubleValue((7.0 + 3.0) * 0.4 + (7.0 + 5.0) * 0.6, values.at(0));
   expectDoubleValue((9.0 + 3.0) * 0.4 + (9.0 + 5.0) * 0.6, values.at(1));
 }
 
 TEST(AnimationKeyframeEffectModel, MultipleIterations) {
   AnimatableValueKeyframeVector keyframes = keyframesAtZeroAndOne(
-      pixelAnimatableValue(1.0), pixelAnimatableValue(3.0));
+      AnimatableDouble::create(1.0), AnimatableDouble::create(3.0));
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0.5, duration, values);
   expectDoubleValue(2.0, values.at(0));
   effect->sample(1, 0.5, duration, values);
   expectDoubleValue(2.0, values.at(0));
   effect->sample(2, 0.5, duration, values);
   expectDoubleValue(2.0, values.at(0));
 }
 
 // FIXME: Re-enable this test once compositing of CompositeAdd is supported.
 TEST(AnimationKeyframeEffectModel, DISABLED_DependsOnUnderlyingValue) {
   AnimatableValueKeyframeVector keyframes(3);
   keyframes[0] = AnimatableValueKeyframe::create();
   keyframes[0]->setOffset(0.0);
   keyframes[0]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(1.0).get());
+                                 AnimatableDouble::create(1.0).get());
   keyframes[0]->setComposite(EffectModel::CompositeAdd);
   keyframes[1] = AnimatableValueKeyframe::create();
   keyframes[1]->setOffset(0.5);
   keyframes[1]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(1.0).get());
+                                 AnimatableDouble::create(1.0).get());
   keyframes[2] = AnimatableValueKeyframe::create();
   keyframes[2]->setOffset(1.0);
   keyframes[2]->setPropertyValue(CSSPropertyLeft,
-                                 pixelAnimatableValue(1.0).get());
+                                 AnimatableDouble::create(1.0).get());
 
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   Vector<RefPtr<Interpolation>> values;
   effect->sample(0, 0, duration, values);
   EXPECT_TRUE(values.at(0));
   effect->sample(0, 0.1, duration, values);
   EXPECT_TRUE(values.at(0));
   effect->sample(0, 0.25, duration, values);
   EXPECT_TRUE(values.at(0));
   effect->sample(0, 0.4, duration, values);
   EXPECT_TRUE(values.at(0));
   effect->sample(0, 0.5, duration, values);
   EXPECT_FALSE(values.at(0));
   effect->sample(0, 0.6, duration, values);
   EXPECT_FALSE(values.at(0));
   effect->sample(0, 0.75, duration, values);
   EXPECT_FALSE(values.at(0));
   effect->sample(0, 0.8, duration, values);
   EXPECT_FALSE(values.at(0));
   effect->sample(0, 1, duration, values);
   EXPECT_FALSE(values.at(0));
 }
 
 TEST(AnimationKeyframeEffectModel, AddSyntheticKeyframes) {
-  AnimatableValueKeyframeVector keyframes(1);
-  keyframes[0] = AnimatableValueKeyframe::create();
+  StringKeyframeVector keyframes(1);
+  keyframes[0] = StringKeyframe::create();
   keyframes[0]->setOffset(0.5);
-  keyframes[0]->setPropertyValue(CSSPropertyLeft,
-                                 unknownAnimatableValue(4.0).get());
+  keyframes[0]->setCSSPropertyValue(CSSPropertyLeft, "4px", nullptr);
 
-  AnimatableValueKeyframeEffectModel* effect =
-      AnimatableValueKeyframeEffectModel::create(keyframes);
-  const AnimatableValuePropertySpecificKeyframeVector&
-      propertySpecificKeyframes =
-          effect->getPropertySpecificKeyframes(PropertyHandle(CSSPropertyLeft));
+  StringKeyframeEffectModel* effect =
+      StringKeyframeEffectModel::create(keyframes);
+  const StringPropertySpecificKeyframeVector& propertySpecificKeyframes =
+      effect->getPropertySpecificKeyframes(PropertyHandle(CSSPropertyLeft));
   EXPECT_EQ(3U, propertySpecificKeyframes.size());
   EXPECT_DOUBLE_EQ(0.0, propertySpecificKeyframes[0]->offset());
   EXPECT_DOUBLE_EQ(0.5, propertySpecificKeyframes[1]->offset());
   EXPECT_DOUBLE_EQ(1.0, propertySpecificKeyframes[2]->offset());
 }
 
 TEST(AnimationKeyframeEffectModel, ToKeyframeEffectModel) {
   AnimatableValueKeyframeVector keyframes(0);
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(keyframes);
@@ skipping 80 matching lines @@
   EXPECT_DOUBLE_EQ(0.6, result[5]->offset());
   EXPECT_DOUBLE_EQ(0.7, result[6]->offset());
   EXPECT_DOUBLE_EQ(0.8, result[7]->offset());
   EXPECT_DOUBLE_EQ(0.85, result[8]->offset());
   EXPECT_DOUBLE_EQ(0.9, result[9]->offset());
   EXPECT_DOUBLE_EQ(0.95, result[10]->offset());
   EXPECT_DOUBLE_EQ(1.0, result[11]->offset());
 }
 
 }  // namespace blink