Devtools Animations: Add cubic bezier easing editor for animations

Source/core/inspector/InspectorAnimationAgent.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/inspector/InspectorAnimationAgent.h"
 
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationEffect.h"
 #include "core/animation/AnimationEffectTiming.h"
+#include "core/animation/AnimationInputHelpers.h"
 #include "core/animation/ComputedTimingProperties.h"
 #include "core/animation/EffectModel.h"
 #include "core/animation/ElementAnimation.h"
 #include "core/animation/KeyframeEffect.h"
 #include "core/animation/KeyframeEffectModel.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/DOMNodeIds.h"
@@ skipping 123 matching lines @@
     CSSAnimations& cssAnimations = element->elementAnimations()->cssAnimations();
     RefPtr<TypeBuilder::Animation::KeyframesRule> keyframeRule = nullptr;
     AnimationType animationType;
 
     if (cssAnimations.isTransitionAnimationForInspector(player)) {
         // CSS Transitions
         animationType = AnimationType::CSSTransition;
     } else {
         // Keyframe based animations
         keyframeRule = buildObjectForAnimationKeyframes(toKeyframeEffect(player.source()));
-        animationType = cssAnimations.isAnimationForInspector(player) ? AnimationType::WebAnimation : AnimationType::CSSAnimation;
+        animationType = cssAnimations.isAnimationForInspector(player) ? AnimationType::CSSAnimation : AnimationType::WebAnimation;

[dgozman, 2015/05/28 11:04:03]

What I meant is to add tests that cover the functionality. For example,
|setTiming| method didn't work for WebAnimation (because it was marked as
CSSAnimation), right? We should cover existing functionality first before adding
more methods, since it will be harder to test everything later.

     }
 
     String id = String::number(player.sequenceNumber());
     m_idToAnimation.set(id, &player);
     m_idToAnimationType.set(id, animationType);
 
     RefPtr<TypeBuilder::Animation::AnimationNode> animationObject = buildObjectForAnimation(toKeyframeEffect(player.source()), animationType == AnimationType::CSSTransition);
     if (keyframeRule)
         animationObject->setKeyframesRule(keyframeRule);
 
@@ skipping 52 matching lines @@
 {
     double timeDelta = currentTime - referenceTimeline().currentTime();
     for (Frame* frame = m_pageAgent->inspectedFrame(); frame; frame = frame->tree().traverseNext(m_pageAgent->inspectedFrame())) {
         if (frame->isLocalFrame()) {
             AnimationTimeline& timeline = toLocalFrame(frame)->document()->timeline();
             timeline.setCurrentTime(timeline.currentTime() + timeDelta);
         }
     }
 }
 
+static KeyframeVector cloneTransitionFrames(KeyframeEffectModelBase* model)
+{
+    const AnimatableValueKeyframeEffectModel* oldModel = toAnimatableValueKeyframeEffectModel(model);
+    // Refer to CSSAnimations::calculateTransitionUpdateForProperty() for the structure of transitions.
+    const KeyframeVector& frames = oldModel->getFrames();
+    ASSERT(frames.size() == 3);
+    KeyframeVector newFrames;
+    for (int i = 0; i < 3; i++)
+        newFrames.append(toAnimatableValueKeyframe(frames[i]->clone().get()));
+    return newFrames;
+}
+
 void InspectorAnimationAgent::setTiming(ErrorString* errorString, const String& playerId, double duration, double delay)
 {
     Animation* animation = assertAnimation(errorString, playerId);
     if (!animation)
         return;
 
     AnimationType type = m_idToAnimationType.get(playerId);
     if (type == AnimationType::CSSTransition) {
         KeyframeEffect* effect = toKeyframeEffect(animation->source());
         KeyframeEffectModelBase* model = toKeyframeEffectModelBase(effect->model());
-        const AnimatableValueKeyframeEffectModel* oldModel = toAnimatableValueKeyframeEffectModel(model);
-        // Refer to CSSAnimations::calculateTransitionUpdateForProperty() for the structure of transitions.
-        const KeyframeVector& frames = oldModel->getFrames();
-        ASSERT(frames.size() == 3);
-        KeyframeVector newFrames;
-        for (int i = 0; i < 3; i++)
-            newFrames.append(toAnimatableValueKeyframe(frames[i]->clone().get()));
+        KeyframeVector newFrames = cloneTransitionFrames(model);
         // Update delay, represented by the distance between the first two keyframes.
         newFrames[1]->setOffset(delay / (delay + duration));
         model->setFrames(newFrames);
 
         RefPtrWillBeRawPtr<AnimationEffectTiming> timing = animation->source()->timing();
         UnrestrictedDoubleOrString unrestrictedDuration;
         unrestrictedDuration.setUnrestrictedDouble(duration + delay);
         timing->setDuration(unrestrictedDuration);
     } else if (type == AnimationType::WebAnimation) {
         RefPtrWillBeRawPtr<AnimationEffectTiming> timing = animation->source()->timing();
         UnrestrictedDoubleOrString unrestrictedDuration;
         unrestrictedDuration.setUnrestrictedDouble(duration);
         timing->setDuration(unrestrictedDuration);
         timing->setDelay(delay);
     }
 }
 
+void InspectorAnimationAgent::setEasing(ErrorString* errorString, const String& playerId, const String& easing)
+{
+    Animation* animation = assertAnimation(errorString, playerId);
+    if (!animation)
+        return;
+
+    AnimationType type = m_idToAnimationType.get(playerId);
+    if (type == AnimationType::CSSTransition) {
+        KeyframeEffect* effect = toKeyframeEffect(animation->source());
+        KeyframeEffectModelBase* model = toKeyframeEffectModelBase(effect->model());
+        KeyframeVector newFrames = cloneTransitionFrames(model);
+        // Update easing of the transition, represented by the second keyframe.
+        if (RefPtr<TimingFunction> timingFunction = AnimationInputHelpers::parseTimingFunction(easing)) {
+            newFrames[1]->setEasing(timingFunction);
+        } else {
+            *errorString = "Could not parse timing function.";
+            return;
+        }
+        model->setFrames(newFrames);
+    } else if (type == AnimationType::WebAnimation) {
+        RefPtrWillBeRawPtr<AnimationEffectTiming> timing = animation->source()->timing();
+        timing->setEasing(easing);
+    } else {
+        *errorString = "Given animation is not a transition or web animation.";

[dgozman, 2015/05/28 11:04:03]

I think, we should have similar error reporting everywhere in protocol methods.

[samli, 2015/05/29 04:32:11]

Acknowledged.

+    }
+}
+
 void InspectorAnimationAgent::didCreateAnimation(Animation* player)
 {
     const String& playerId = String::number(player->sequenceNumber());
     if (m_idToAnimation.get(playerId))
         return;
 
     double threshold = 1000;
     bool reset = normalizedStartTime(*player) - threshold > m_latestStartTime;
     m_latestStartTime = normalizedStartTime(*player);
     if (reset) {
@@ skipping 47 matching lines @@
 #if ENABLE(OILPAN)
     visitor->trace(m_pageAgent);
     visitor->trace(m_domAgent);
     visitor->trace(m_idToAnimation);
     visitor->trace(m_idToAnimationType);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 }