Devtools Animations: Display keyframes for CSS Animations in inspector

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/AnimationNode.h"
 #include "core/animation/AnimationPlayer.h"
 #include "core/animation/ElementAnimation.h"
+#include "core/css/CSSKeyframeRule.h"
+#include "core/css/CSSKeyframesRule.h"
 #include "core/inspector/InspectorDOMAgent.h"
+#include "core/inspector/InspectorStyleSheet.h"
 
 namespace blink {
 
 InspectorAnimationAgent::InspectorAnimationAgent(InspectorDOMAgent* domAgent)
     : InspectorBaseAgent<InspectorAnimationAgent>("Animation")
     , m_domAgent(domAgent)
     , m_frontend(0)
 {
 }
 
@@ skipping 16 matching lines @@
 {
     animationPlayersArray = TypeBuilder::Array<TypeBuilder::Animation::AnimationPlayer>::create();
     Element* element = m_domAgent->assertElement(errorString, nodeId);
     if (!element)
         return;
     m_idToAnimationPlayer.clear();
     WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players = ElementAnimation::getAnimationPlayers(*element);
     for (WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> >::iterator it = players.begin(); it != players.end(); ++it) {
         AnimationPlayer& player = *(it->get());
         m_idToAnimationPlayer.set(playerId(player), &player);
-        RefPtr<TypeBuilder::Animation::AnimationPlayer> animationPlayerObject = buildObjectForAnimationPlayer(player);
+        RefPtr<TypeBuilder::Animation::AnimationPlayer> animationPlayerObject;
+        // FIXME: Add support for web animations
+        if (element->activeAnimations()->cssAnimations().getAnimationNameForInspector(player)) {
+            RefPtr<TypeBuilder::Animation::KeyframesRule> keyframeRule = getObjectForStyleRuleKeyframes(*element, player);
+            animationPlayerObject = buildObjectForAnimationPlayer(player, keyframeRule);

[pfeldman, 2014/10/23 06:37:00]

keyframeRule.release()

[samli, 2014/10/24 05:06:19]

Done.

+        } else {
+            animationPlayerObject = buildObjectForAnimationPlayer(player);
+        }
         animationPlayersArray->addItem(animationPlayerObject);
     }
 }
 
 void InspectorAnimationAgent::pauseAnimationPlayer(ErrorString* errorString, const String& id, RefPtr<TypeBuilder::Animation::AnimationPlayer>& animationPlayer)
 {
     AnimationPlayer* player = assertAnimationPlayer(errorString, id);
     if (!player)
         return;
     player->pause();
@@ skipping 37 matching lines @@
     return player;
 }
 
 String InspectorAnimationAgent::playerId(AnimationPlayer& player)
 {
     return String::number(player.sequenceNumber());
 }
 
 PassRefPtr<TypeBuilder::Animation::AnimationPlayer> InspectorAnimationAgent::buildObjectForAnimationPlayer(AnimationPlayer& animationPlayer)
 {
+    return buildObjectForAnimationPlayer(animationPlayer, nullptr);

[pfeldman, 2014/10/23 06:37:00]

inline and simplify code above?

[samli, 2014/10/24 05:06:19]

Done.

+}
+
+PassRefPtr<TypeBuilder::Animation::AnimationPlayer> InspectorAnimationAgent::buildObjectForAnimationPlayer(AnimationPlayer& animationPlayer, PassRefPtr<TypeBuilder::Animation::KeyframesRule> keyframeRule)
+{
+    RefPtr<TypeBuilder::Animation::AnimationNode> animationObject = buildObjectForAnimationNode(animationPlayer.source());
+    if (keyframeRule)
+        animationObject->setKeyframesRule(keyframeRule);
+
     RefPtr<TypeBuilder::Animation::AnimationPlayer> playerObject = TypeBuilder::Animation::AnimationPlayer::create()
         .setId(playerId(animationPlayer))
         .setPausedState(animationPlayer.paused())
         .setPlayState(animationPlayer.playState())
         .setPlaybackRate(animationPlayer.playbackRate())
         .setStartTime(animationPlayer.startTime())
         .setCurrentTime(animationPlayer.currentTime())
-        .setSource(buildObjectForAnimationNode(*(animationPlayer.source())));
+        .setSource(animationObject.release());
     return playerObject.release();
 }
 
-PassRefPtr<TypeBuilder::Animation::AnimationNode> InspectorAnimationAgent::buildObjectForAnimationNode(AnimationNode& animationNode)
+PassRefPtr<TypeBuilder::Animation::AnimationNode> InspectorAnimationAgent::buildObjectForAnimationNode(AnimationNode* animationNode)
 {
     RefPtr<TypeBuilder::Animation::AnimationNode> animationObject = TypeBuilder::Animation::AnimationNode::create()
-        .setStartDelay(animationNode.specifiedTiming().startDelay)
-        .setPlaybackRate(animationNode.specifiedTiming().playbackRate)
-        .setIterationStart(animationNode.specifiedTiming().iterationStart)
-        .setIterationCount(animationNode.specifiedTiming().iterationCount)
-        .setDuration(animationNode.duration())
-        .setDirection(animationNode.specifiedTiming().direction)
-        .setFillMode(animationNode.specifiedTiming().fillMode)
-        .setTimeFraction(animationNode.timeFraction())
-        .setName(animationNode.name());
+        .setStartDelay(animationNode->specifiedTiming().startDelay)
+        .setPlaybackRate(animationNode->specifiedTiming().playbackRate)
+        .setIterationStart(animationNode->specifiedTiming().iterationStart)
+        .setIterationCount(animationNode->specifiedTiming().iterationCount)
+        .setDuration(animationNode->duration())
+        .setDirection(animationNode->specifiedTiming().direction)
+        .setFillMode(animationNode->specifiedTiming().fillMode)
+        .setTimeFraction(animationNode->timeFraction())
+        .setName(animationNode->name());
     return animationObject.release();
 }
 
+PassRefPtr<TypeBuilder::Animation::KeyframesRule> InspectorAnimationAgent::getObjectForStyleRuleKeyframes(const Element& element, const AnimationPlayer& player)
+{
+    StyleResolver& styleResolver = element.ownerDocument()->ensureStyleResolver();
+    // FIXME: Add support for web anim
+    CSSAnimations& cssAnimations = element.activeAnimations()->cssAnimations();
+    const AtomicString* animationName = cssAnimations.getAnimationNameForInspector(player);
+    ASSERT(animationName);
+    const StyleRuleKeyframes* keyframes = cssAnimations.matchScopedKeyframesRule(&styleResolver, &element, animationName->impl());
+
+    return buildObjectForStyleRuleKeyframes(keyframes);
+}
+
+PassRefPtr<TypeBuilder::Animation::KeyframesRule> InspectorAnimationAgent::buildObjectForStyleRuleKeyframes(const StyleRuleKeyframes* keyframesRule)
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::Animation::KeyframeStyle> > keyframes = TypeBuilder::Array<TypeBuilder::Animation::KeyframeStyle>::create();
+    const WillBeHeapVector<RefPtrWillBeMember<StyleKeyframe> >& styleKeyframes = keyframesRule->keyframes();
+    for (const auto& styleKeyframe : styleKeyframes)
+        keyframes->addItem(buildObjectForStyleKeyframe(styleKeyframe.get()));
+
+    RefPtr<TypeBuilder::Animation::KeyframesRule> keyframesObject = TypeBuilder::Animation::KeyframesRule::create()
+        .setKeyframes(keyframes);
+    keyframesObject->setName(keyframesRule->name());
+    return keyframesObject.release();
+}
+
+PassRefPtr<TypeBuilder::Animation::KeyframeStyle> InspectorAnimationAgent::buildObjectForStyleKeyframe(StyleKeyframe* keyframe)
+{
+    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), keyframe->mutableProperties().ensureCSSStyleDeclaration(), 0);
+    RefPtr<TypeBuilder::Animation::KeyframeStyle> keyframeObject = TypeBuilder::Animation::KeyframeStyle::create()
+        .setOffset(keyframe->keyText())
+        .setStyle(inspectorStyle->buildObjectForStyle());
+    return keyframeObject.release();
+}
+
 void InspectorAnimationAgent::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_idToAnimationPlayer);
     visitor->trace(m_domAgent);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 }