Web Animations API: Bindings for TimedItem.specified with readonly attributes

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"
 #include "core/animation/AnimationHelpers.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/KeyframeEffectModel.h"
+#include "core/animation/TimedItemTiming.h"
 #include "platform/animation/TimingFunctionTestHelper.h"
 
 #include <gtest/gtest.h>
 
 namespace WebCore {
 
 namespace {
 
 v8::Handle<v8::Value> stringToV8Value(String string)
 {
@@ skipping 128 matching lines @@
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     v8::Context::Scope contextScope(context);
 
     Vector<Dictionary, 0> jsKeyframes;
     double duration = 2;
 
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, duration);
 
-    EXPECT_EQ(duration, animation->specified().iterationDuration);
+    EXPECT_EQ(duration, animation->specifiedTiming().iterationDuration);
 }
 
 TEST_F(AnimationAnimationTest, CanOmitSpecifiedDuration)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     v8::Context::Scope contextScope(context);
 
     Vector<Dictionary, 0> jsKeyframes;
 
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes);
 
-    EXPECT_TRUE(std::isnan(animation->specified().iterationDuration));
+    EXPECT_TRUE(std::isnan(animation->specifiedTiming().iterationDuration));
 }
 
 TEST_F(AnimationAnimationTest, ClipNegativeDurationToZero)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     v8::Context::Scope contextScope(context);
 
     Vector<Dictionary, 0> jsKeyframes;
 
     RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, -2);
 
-    EXPECT_EQ(0, animation->specified().iterationDuration);
+    EXPECT_EQ(0, animation->specifiedTiming().iterationDuration);
+}
+
+TEST_F(AnimationAnimationTest, SpecifiedGetters)
+{
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::HandleScope scope(isolate);
+    v8::Local<v8::Context> context = v8::Context::New(isolate);
+    v8::Context::Scope contextScope(context);
+
+    Vector<Dictionary, 0> jsKeyframes;
+
+    v8::Handle<v8::Object> timingInput = v8::Object::New(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), isolate);
+
+    RefPtr<Animation> animation = createAnimation(element.get(), jsKeyframes, timingInputDictionary);
+
+    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(AnimationAnimationTest, SpecifiedDurationGetter)
+{
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::HandleScope scope(isolate);
+    v8::Local<v8::Context> context = v8::Context::New(isolate);
+    v8::Context::Scope contextScope(context);
+
+    Vector<Dictionary, 0> jsKeyframes;
+
+    v8::Handle<v8::Object> timingInputWithDuration = v8::Object::New(isolate);
+    setV8ObjectPropertyAsNumber(timingInputWithDuration, "duration", 2.5);
+    Dictionary timingInputDictionaryWithDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputWithDuration), isolate);
+
+    RefPtr<Animation> animationWithDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryWithDuration);
+
+    RefPtr<TimedItemTiming> specifiedWithDuration = animationWithDuration->specified();
+    bool isNumber = false;
+    double numberDuration = std::numeric_limits<double>::quiet_NaN();
+    bool isString = false;
+    String stringDuration = "";
+    specifiedWithDuration->duration("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(isolate);
+    Dictionary timingInputDictionaryNoDuration = Dictionary(v8::Handle<v8::Value>::Cast(timingInputNoDuration), isolate);
+
+    RefPtr<Animation> animationNoDuration = createAnimation(element.get(), jsKeyframes, timingInputDictionaryNoDuration);
+
+    RefPtr<TimedItemTiming> specifiedNoDuration = animationNoDuration->specified();
+    isNumber = false;
+    numberDuration = std::numeric_limits<double>::quiet_NaN();
+    isString = false;
+    stringDuration = "";
+    specifiedNoDuration->duration("duration", isNumber, numberDuration, isString, stringDuration);
+    EXPECT_FALSE(isNumber);
+    EXPECT_TRUE(std::isnan(numberDuration));
+    EXPECT_TRUE(isString);
+    EXPECT_EQ("auto", stringDuration);
 }
 
 TEST_F(AnimationAnimationTest, TimingInputStartDelay)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::HandleScope scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     v8::Context::Scope contextScope(context);
 
     Timing timing;
@@ skipping 369 matching lines @@
     EXPECT_EQ(controlTiming.fillMode, updatedTiming.fillMode);
     EXPECT_EQ(controlTiming.iterationStart, updatedTiming.iterationStart);
     EXPECT_EQ(controlTiming.iterationCount, updatedTiming.iterationCount);
     EXPECT_TRUE(std::isnan(updatedTiming.iterationDuration));
     EXPECT_EQ(controlTiming.playbackRate, updatedTiming.playbackRate);
     EXPECT_EQ(controlTiming.direction, updatedTiming.direction);
     EXPECT_EQ(*controlTiming.timingFunction.get(), *updatedTiming.timingFunction.get());
 }
 
 } // namespace WebCore