[WIP] Web Animations API: Constructing an Animation from partial keyframes throws a JS exception

Source/core/animation/AnimationTest.cpp

 // Copyright 2014 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.
 
 #include "config.h"
 #include "core/animation/Animation.h"
 
 #include "bindings/v8/Dictionary.h"
 #include "core/animation/AnimatableLength.h"
 #include "core/animation/AnimationClock.h"
@@ skipping 13 matching lines @@
         : document(Document::create())
         , element(document->createElement("foo", ASSERT_NO_EXCEPTION))
     {
         document->animationClock().resetTimeForTesting();
         document->timeline().setZeroTime(0);
         EXPECT_EQ(0, document->timeline().currentTime());
     }
 
     RefPtr<Document> document;
     RefPtr<Element> element;
+    TrackExceptionState exceptionState;
 };
 
 class AnimationAnimationV8Test : public AnimationAnimationTest {
 protected:
     AnimationAnimationV8Test()
         : m_isolate(v8::Isolate::GetCurrent())
         , m_scope(V8BindingTestScope::create(m_isolate))
     {
     }
 
     template<typename T>
-    static PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector, T timingInput)
+    static PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector, T timingInput, ExceptionState& exceptionState)
     {
-        return Animation::create(element, EffectInput::convert(element, keyframeDictionaryVector, true), timingInput);
+        return Animation::create(element, EffectInput::convert(element, keyframeDictionaryVector, exceptionState, true), timingInput);
     }
-    static PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector)
+    static PassRefPtr<Animation> createAnimation(Element* element, Vector<Dictionary> keyframeDictionaryVector, ExceptionState& exceptionState)
     {
-        return Animation::create(element, EffectInput::convert(element, keyframeDictionaryVector, true));
+        return Animation::create(element, EffectInput::convert(element, keyframeDictionaryVector, exceptionState, true));
     }
 
     v8::Isolate* m_isolate;
 
 private:
     OwnPtr<V8BindingTestScope> m_scope;
 };
 
 TEST_F(AnimationAnimationV8Test, CanCreateAnAnimation)
 {
@@ skipping 12 matching lines @@
     jsKeyframes.append(Dictionary(keyframe2, m_isolate));
 
     String value1;
     ASSERT_TRUE(jsKeyframes[0].get("width", value1));
     ASSERT_EQ("100px", value1);
 
     String value2;
     ASSERT_TRUE(jsKeyframes[1].get("width", value2));
     ASSERT_EQ("0px", value2);
 
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0, exceptionState);
+
+    EXPECT_FALSE(exceptionState.hadException());
 
     Element* target = animation->target();
     EXPECT_EQ(*element.get(), *target);
 
     const KeyframeEffectModel::KeyframeVector keyframes =
         toKeyframeEffectModel(animation->effect())->getFrames();
 
     EXPECT_EQ(0, keyframes[0]->offset());
     EXPECT_EQ(1, keyframes[1]->offset());
 
@@ skipping 10 matching lines @@
 
     EXPECT_EQ(*(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut)), *keyframes[0]->easing());
     EXPECT_EQ(*(CubicBezierTimingFunction::create(1, 1, 0.3, 0.3).get()), *keyframes[1]->easing());
 }
 
 TEST_F(AnimationAnimationV8Test, CanSetDuration)
 {
     Vector<Dictionary, 0> jsKeyframes;
     double duration = 2;
 
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, duration);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, duration, exceptionState);
 
     EXPECT_EQ(duration, animation->specifiedTiming().iterationDuration);
 }
 
 TEST_F(AnimationAnimationV8Test, CanOmitSpecifiedDuration)
 {
     Vector<Dictionary, 0> jsKeyframes;
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, exceptionState);
     EXPECT_TRUE(std::isnan(animation->specifiedTiming().iterationDuration));
 }
 
 TEST_F(AnimationAnimationV8Test, NegativeDurationIsAuto)
 {
     Vector<Dictionary, 0> jsKeyframes;
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, -2);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, -2, exceptionState);
     EXPECT_TRUE(std::isnan(animation->specifiedTiming().iterationDuration));
 }
 
+TEST_F(AnimationAnimationV8Test, MismatchedKeyframePropertyRaisesException)
+{
+    Vector<Dictionary> jsKeyframes;
+    v8::Handle<v8::Object> keyframe1 = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> keyframe2 = v8::Object::New(m_isolate);
+
+    setV8ObjectPropertyAsString(keyframe1, "width", "100px");
+    setV8ObjectPropertyAsString(keyframe1, "offset", "0");
+
+    // Height property appears only in keyframe2
+    setV8ObjectPropertyAsString(keyframe2, "height", "100px");
+    setV8ObjectPropertyAsString(keyframe2, "width", "0px");
+    setV8ObjectPropertyAsString(keyframe2, "offset", "1");
+
+    jsKeyframes.append(Dictionary(keyframe1, m_isolate));
+    jsKeyframes.append(Dictionary(keyframe2, m_isolate));
+
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0, exceptionState);
+
+    EXPECT_TRUE(exceptionState.hadException());
+    EXPECT_EQ(NotSupportedError, exceptionState.code());
+}
+
+TEST_F(AnimationAnimationV8Test, MissingOffsetZero)
+{
+    Vector<Dictionary> jsKeyframes;
+    v8::Handle<v8::Object> keyframe1 = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> keyframe2 = v8::Object::New(m_isolate);
+
+    setV8ObjectPropertyAsString(keyframe1, "width", "100px");
+    setV8ObjectPropertyAsString(keyframe1, "offset", "0.1");
+    setV8ObjectPropertyAsString(keyframe2, "width", "0px");
+    setV8ObjectPropertyAsString(keyframe2, "offset", "1");
+
+    jsKeyframes.append(Dictionary(keyframe1, m_isolate));
+    jsKeyframes.append(Dictionary(keyframe2, m_isolate));
+
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0, exceptionState);
+
+    EXPECT_FALSE(exceptionState.hadException());
+}
+
+TEST_F(AnimationAnimationV8Test, MissingOffsetOne)
+{
+    Vector<Dictionary> jsKeyframes;
+    v8::Handle<v8::Object> keyframe1 = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> keyframe2 = v8::Object::New(m_isolate);
+
+    setV8ObjectPropertyAsString(keyframe1, "width", "100px");
+    setV8ObjectPropertyAsString(keyframe1, "offset", "0");
+    setV8ObjectPropertyAsString(keyframe2, "width", "0px");
+    setV8ObjectPropertyAsString(keyframe2, "offset", "0.1");
+
+    jsKeyframes.append(Dictionary(keyframe1, m_isolate));
+    jsKeyframes.append(Dictionary(keyframe2, m_isolate));
+
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0, exceptionState);
+
+    EXPECT_FALSE(exceptionState.hadException());
+}
+
+TEST_F(AnimationAnimationV8Test, MissingOffsetZeroAndOne)
+{
+    Vector<Dictionary> jsKeyframes;
+    v8::Handle<v8::Object> keyframe1 = v8::Object::New(m_isolate);
+    v8::Handle<v8::Object> keyframe2 = v8::Object::New(m_isolate);
+
+    setV8ObjectPropertyAsString(keyframe1, "width", "100px");
+    setV8ObjectPropertyAsString(keyframe1, "offset", "0.1");
+    setV8ObjectPropertyAsString(keyframe2, "width", "0px");
+    setV8ObjectPropertyAsString(keyframe2, "offset", "0.2");
+
+    jsKeyframes.append(Dictionary(keyframe1, m_isolate));
+    jsKeyframes.append(Dictionary(keyframe2, m_isolate));
+
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, 0, exceptionState);
+
+    EXPECT_FALSE(exceptionState.hadException());
+}
+
 TEST_F(AnimationAnimationV8Test, SpecifiedGetters)
 {
     Vector<Dictionary, 0> jsKeyframes;
 
     v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
     setV8ObjectPropertyAsNumber(timingInput, "delay", 2);
     setV8ObjectPropertyAsNumber(timingInput, "endDelay", 0.5);
     setV8ObjectPropertyAsString(timingInput, "fill", "backwards");
     setV8ObjectPropertyAsNumber(timingInput, "iterationStart", 2);
     setV8ObjectPropertyAsNumber(timingInput, "iterations", 10);
     setV8ObjectPropertyAsNumber(timingInput, "playbackRate", 2);
     setV8ObjectPropertyAsString(timingInput, "direction", "reverse");
     setV8ObjectPropertyAsString(timingInput, "easing", "step-start");
     Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
 
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary, exceptionState);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
     EXPECT_EQ(2, specified->delay());
     EXPECT_EQ(0.5, specified->endDelay());
     EXPECT_EQ("backwards", specified->fill());
     EXPECT_EQ(2, specified->iterationStart());
     EXPECT_EQ(10, specified->iterations());
     EXPECT_EQ(2, specified->playbackRate());
     EXPECT_EQ("reverse", specified->direction());
     EXPECT_EQ("step-start", specified->easing());
 }
 
 TEST_F(AnimationAnimationV8Test, SpecifiedDurationGetter)
 {
     Vector<Dictionary, 0> jsKeyframes;
 
     v8::Handle<v8::Object> timingInputWithDuration = v8::Object::New(m_isolate);
     setV8ObjectPropertyAsNumber(timingInputWithDuration, "duration", 2.5);
     Dictionary timingInputDictionaryWithDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputWithDuration), m_isolate);
 
-    RefPtr<Animation> animationWithDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryWithDuration);
+    RefPtr<Animation> animationWithDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryWithDuration, exceptionState);
 
     RefPtr<TimedItemTiming> specifiedWithDuration = animationWithDuration->specified();
     bool isNumber = false;
     double numberDuration = std::numeric_limits<double>::quiet_NaN();
     bool isString = false;
     String stringDuration = "";
     specifiedWithDuration->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_TRUE(isNumber);
     EXPECT_EQ(2.5, numberDuration);
     EXPECT_FALSE(isString);
     EXPECT_EQ("", stringDuration);
 
 
     v8::Handle<v8::Object> timingInputNoDuration = v8::Object::New(m_isolate);
     Dictionary timingInputDictionaryNoDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputNoDuration), m_isolate);
 
-    RefPtr<Animation> animationNoDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryNoDuration);
+    RefPtr<Animation> animationNoDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryNoDuration, exceptionState);
 
     RefPtr<TimedItemTiming> specifiedNoDuration = animationNoDuration->specified();
     isNumber = false;
     numberDuration = std::numeric_limits<double>::quiet_NaN();
     isString = false;
     stringDuration = "";
     specifiedNoDuration->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_FALSE(isNumber);
     EXPECT_TRUE(std::isnan(numberDuration));
     EXPECT_TRUE(isString);
     EXPECT_EQ("auto", stringDuration);
 }
 
 TEST_F(AnimationAnimationV8Test, SpecifiedSetters)
 {
     Vector<Dictionary, 0> jsKeyframes;
     v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
     Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary, exceptionState);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
 
     EXPECT_EQ(0, specified->delay());
     specified->setDelay(2);
     EXPECT_EQ(2, specified->delay());
 
     EXPECT_EQ(0, specified->endDelay());
     specified->setEndDelay(0.5);
     EXPECT_EQ(0.5, specified->endDelay());
@@ skipping 21 matching lines @@
     EXPECT_EQ("linear", specified->easing());
     specified->setEasing("step-start");
     EXPECT_EQ("step-start", specified->easing());
 }
 
 TEST_F(AnimationAnimationV8Test, SetSpecifiedDuration)
 {
     Vector<Dictionary, 0> jsKeyframes;
     v8::Handle<v8::Object> timingInput = v8::Object::New(m_isolate);
     Dictionary timingInputDictionary = Dictionary(v8::Handle<v8::Value>::Cast(timingInput), m_isolate);
-    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary, exceptionState);
 
     RefPtr<TimedItemTiming> specified = animation->specified();
 
     bool isNumber = false;
     double numberDuration = std::numeric_limits<double>::quiet_NaN();
     bool isString = false;
     String stringDuration = "";
     specified->getDuration("duration", isNumber, numberDuration, isString, stringDuration);
     EXPECT_FALSE(isNumber);
     EXPECT_TRUE(std::isnan(numberDuration));
@@ skipping 103 matching lines @@
     player->setCurrentTime(150);
     EXPECT_EQ(inf, animation->timeToForwardsEffectChange());
     EXPECT_EQ(0, animation->timeToReverseEffectChange());
 
     player->setCurrentTime(200);
     EXPECT_EQ(inf, animation->timeToForwardsEffectChange());
     EXPECT_EQ(50, animation->timeToReverseEffectChange());
 }
 
 } // namespace WebCore