Devtools Animations: Support multiple frames in the animation timeline

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"
@@ skipping 153 matching lines @@
         if (!keyframe.get()->isStringKeyframe())
             continue;
         const StringKeyframe* stringKeyframe = toStringKeyframe(keyframe.get());
         keyframes->addItem(buildObjectForStringKeyframe(stringKeyframe));
     }
     RefPtr<TypeBuilder::Animation::KeyframesRule> keyframesObject = TypeBuilder::Animation::KeyframesRule::create()
         .setKeyframes(keyframes);
     return keyframesObject.release();
 }
 
+static double normalizedStartTime(AnimationPlayer& player)
+{
+    ASSERT(player.timeline() && player.timeline()->playbackRate());
+    return player.startTime() / player.timeline()->playbackRate() + player.timeline()->zeroTime() * 1000;
+}
+
 PassRefPtr<TypeBuilder::Animation::AnimationPlayer> InspectorAnimationAgent::buildObjectForAnimationPlayer(AnimationPlayer& player)
 {
     // Find type of animation
     const Element* element = toAnimation(player.source())->target();
     StyleResolver& styleResolver = element->ownerDocument()->ensureStyleResolver();
     CSSAnimations& cssAnimations = element->elementAnimations()->cssAnimations();
     const AtomicString animationName = cssAnimations.getAnimationNameForInspector(player);
     RefPtr<TypeBuilder::Animation::KeyframesRule> keyframeRule = nullptr;
     AnimationType animationType;
 
@@ skipping 17 matching lines @@
 
     RefPtr<TypeBuilder::Animation::AnimationNode> animationObject = buildObjectForAnimation(toAnimation(player.source()), animationType == AnimationType::CSSTransition);
     if (keyframeRule)
         animationObject->setKeyframesRule(keyframeRule);
 
     RefPtr<TypeBuilder::Animation::AnimationPlayer> playerObject = TypeBuilder::Animation::AnimationPlayer::create()
         .setId(id)
         .setPausedState(player.paused())
         .setPlayState(player.playState())
         .setPlaybackRate(player.playbackRate())
-        .setStartTime(player.startTime())
+        .setStartTime(normalizedStartTime(player))
         .setCurrentTime(player.currentTime())
         .setSource(animationObject.release())
         .setType(animationType);
     return playerObject.release();
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationPlayer> > InspectorAnimationAgent::buildArrayForAnimationPlayers(Element& element, const WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players)
 {
     RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationPlayer> > animationPlayersArray = TypeBuilder::Array<TypeBuilder::Animation::AnimationPlayer>::create();
     for (const auto& it : players) {
@@ skipping 14 matching lines @@
     WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players;
     if (!includeSubtreeAnimations)
         players = ElementAnimation::getAnimationPlayers(*element);
     else
         players = element->ownerDocument()->timeline().getAnimationPlayers();
     animationPlayersArray = buildArrayForAnimationPlayers(*element, players);
 }
 
 void InspectorAnimationAgent::getPlaybackRate(ErrorString*, double* playbackRate)
 {
+    // All timelines should have the same playback rate
     *playbackRate = m_pageAgent->inspectedFrame()->document()->timeline().playbackRate();
 }
 
-void InspectorAnimationAgent::setPlaybackRate(ErrorString*, double playbackRate)
+void InspectorAnimationAgent::setPlaybackRate(ErrorString*, double playbackRate, RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>>& animationStartTimes)
 {
     for (Frame* frame = m_pageAgent->inspectedFrame(); frame; frame = frame->tree().traverseNext(m_pageAgent->inspectedFrame())) {
         if (frame->isLocalFrame())
             toLocalFrame(frame)->document()->timeline().setPlaybackRate(playbackRate);
     }
+    animationStartTimes = buildArrayForStartTimes();
 }
 
-void InspectorAnimationAgent::setCurrentTime(ErrorString*, double currentTime)
+void InspectorAnimationAgent::seekTimelineTo(ErrorString* errorString, double time, RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>>& animationStartTimes)
 {
-    m_pageAgent->inspectedFrame()->document()->timeline().setCurrentTime(currentTime);
+    if (!m_pageAgent->inspectedFrame()->document()->timeline().playbackRate()) {
+        *errorString = "Cannot set current time when timeline is paused";
+        return;
+    }
+    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((time - timeline.zeroTime() * 1000) * timeline.playbackRate());
+        }
+    }
+    animationStartTimes = buildArrayForStartTimes();
+}
+
+
+void InspectorAnimationAgent::seekTimelineBy(ErrorString* errorString, double timeDelta)
+{
+    if (m_pageAgent->inspectedFrame()->document()->timeline().playbackRate())
+        *errorString = "Cannot apply time delta when timeline is playing";
+    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);
+        }
+    }
+}
+
+PassRefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>> InspectorAnimationAgent::buildArrayForStartTimes()
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>> animationStartTimes = TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>::create();
+    if (!m_pageAgent->inspectedFrame()->document()->timeline().playbackRate())
+        return animationStartTimes.release();
+
+    for (const auto& pair : m_idToAnimationPlayer) {
+        const RefPtr<AnimationPlayer> player = pair.value;
+        RefPtr<TypeBuilder::Animation::AnimationStartTime> startTimeObject = TypeBuilder::Animation::AnimationStartTime::create()
+            .setId(pair.key)
+            .setStartTime(normalizedStartTime(*player.get()));
+        animationStartTimes->addItem(startTimeObject);
+    }
+    return animationStartTimes.release();
 }
 
 void InspectorAnimationAgent::setTiming(ErrorString* errorString, const String& playerId, double duration, double delay)
 {
     AnimationPlayer* player = assertAnimationPlayer(errorString, playerId);
     if (!player)
         return;
 
     AnimationType type = m_idToAnimationType.get(playerId);
     if (type == AnimationType::CSSTransition) {
@@ skipping 25 matching lines @@
 
 void InspectorAnimationAgent::didCreateAnimationPlayer(AnimationPlayer* player)
 {
     const String& playerId = String::number(player->sequenceNumber());
     if (m_idToAnimationPlayer.get(playerId))
         return;
 
     // Check threshold
     double latestStartTime = 0;
     for (const auto& p : m_idToAnimationPlayer.values())
-        latestStartTime = max(latestStartTime, p->startTime());
+        latestStartTime = max(latestStartTime, normalizedStartTime(*p));
 
     bool reset = false;
-    if (player->startTime() - latestStartTime > 1000) {
+    if (normalizedStartTime(*player) - latestStartTime > 1000) {
         reset = true;
         m_idToAnimationPlayer.clear();
         m_idToAnimationType.clear();
     }
 
     frontend()->animationPlayerCreated(buildObjectForAnimationPlayer(*player), reset);
 }
 
 void InspectorAnimationAgent::didCancelAnimationPlayer(AnimationPlayer* player)
 {
@@ skipping 18 matching lines @@
 #if ENABLE(OILPAN)
     visitor->trace(m_pageAgent);
     visitor->trace(m_domAgent);
     visitor->trace(m_idToAnimationPlayer);
     visitor->trace(m_idToAnimationType);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 }