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());
+    return player.startTime() / player.timeline()->playbackRate() + player.timeline()->zeroTime() * 1000;

[pfeldman, 2015/04/01 13:06:45]

What time is this?

[samli, 2015/04/02 09:58:00]

We take relative timeline times and convert them to monotonic times.

[pfeldman, 2015/04/02 14:42:38]

But zeroTime is already monotonicTime, why do multiply it by 1000?

[samli, 2015/04/02 20:13:19]

Chrome's internal representations are in seconds. Public Web Animations API uses
milliseconds. As such, front end only understands milliseconds.

To clarify: zeroTime() is in seconds, startTime() is milliseconds since it's a
public API.

+}
+
 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::setCurrentTime(ErrorString*, double normalisedCurrentTime, RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>>& animationStartTimes)
 {
-    m_pageAgent->inspectedFrame()->document()->timeline().setCurrentTime(currentTime);
+    for (Frame* frame = m_pageAgent->inspectedFrame(); frame; frame = frame->tree().traverseNext(m_pageAgent->inspectedFrame())) {

[pfeldman, 2015/04/01 13:06:45]

It is strange that this synchronization takes place in the inspector code. It
seems unrelated to inspector, some timelines belonging to different documents
could just stay in sync on their own. You also need to sync the newly added
frames and I don't see this code here.

[samli, 2015/04/02 09:58:00]

This code isn't to sync timelines. This code is used to seek timelines. For
example, when 'replay' is hit or the scrubber is dragged, we want to seek back
in time. Instead of maintaining all timelines separately, the front-end only
understands monotonic time values. It then says: "take me back to time x", which
setCurrentTime() then seeks each animation timeline individually (converting
monotonic time back into timeline time).

New frames are automatically captured in this. New frames have their timeline
playback rate set in the frontend.

[pfeldman, 2015/04/02 14:42:38]

Ok, I think I understand.

+        if (frame->isLocalFrame()) {
+            AnimationTimeline& timeline = toLocalFrame(frame)->document()->timeline();
+            timeline.setCurrentTime((normalisedCurrentTime - timeline.zeroTime() * 1000) * timeline.playbackRate());

[pfeldman, 2015/04/02 14:42:38]

There is something wrong with the timeline units: you can't do
timeline.setCurrentTime(foo - timeline.zeroTime() * 1000). You should stick to
one scale within one timeline.

[samli, 2015/04/02 20:13:19]

I think this is the milliseconds confusion?

+        }
+    }
+    animationStartTimes = buildArrayForStartTimes();
+}
+
+PassRefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>> InspectorAnimationAgent::buildArrayForStartTimes()
+{
+    RefPtr<TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>> animationStartTimes = TypeBuilder::Array<TypeBuilder::Animation::AnimationStartTime>::create();
+    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;
 
     RefPtrWillBeRawPtr<AnimationNodeTiming> timing = player->source()->timing();
     UnrestrictedDoubleOrString unrestrictedDuration;
     unrestrictedDuration.setUnrestrictedDouble(duration);
     timing->setDuration(unrestrictedDuration);
     timing->setDelay(delay);
 }
 
 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);
 }
 
 }