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 190 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)
 {
-    *playbackRate = m_pageAgent->inspectedFrame()->document()->timeline().playbackRate();
+    *playbackRate = referenceTimeline().playbackRate();
 }
 
 void InspectorAnimationAgent::setPlaybackRate(ErrorString*, double playbackRate)
 {
     for (Frame* frame = m_pageAgent->inspectedFrame(); frame; frame = frame->tree().traverseNext(m_pageAgent->inspectedFrame())) {
         if (frame->isLocalFrame())
             toLocalFrame(frame)->document()->timeline().setPlaybackRate(playbackRate);
     }
 }
 
 void InspectorAnimationAgent::setCurrentTime(ErrorString*, double currentTime)
 {
-    m_pageAgent->inspectedFrame()->document()->timeline().setCurrentTime(currentTime);
+    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);
+        }
+    }
 }
 
 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) {
+    const double threshold = 1000;
+    if (normalizedStartTime(*player) - latestStartTime > threshold) {
         reset = true;
         m_idToAnimationPlayer.clear();
         m_idToAnimationType.clear();
     }
 
     frontend()->animationPlayerCreated(buildObjectForAnimationPlayer(*player), reset);
 }
 
 void InspectorAnimationAgent::didCancelAnimationPlayer(AnimationPlayer* player)
 {
     const String& playerId = String::number(player->sequenceNumber());
     if (!m_idToAnimationPlayer.get(playerId))
         return;
     frontend()->animationPlayerCanceled(playerId);
 }
 
+void InspectorAnimationAgent::documentAttachedToFrame(LocalFrame* frame)
+{
+    ASSERT(frame->document());
+    frame->document()->timeline().setPlaybackRate(referenceTimeline().playbackRate());
+}
+
 AnimationPlayer* InspectorAnimationAgent::assertAnimationPlayer(ErrorString* errorString, const String& id)
 {
     AnimationPlayer* player = m_idToAnimationPlayer.get(id);
     if (!player) {
         *errorString = "Could not find animation player with given id";
         return nullptr;
     }
     return player;
 }
 
+AnimationTimeline& InspectorAnimationAgent::referenceTimeline()
+{
+    return m_pageAgent->inspectedFrame()->document()->timeline();
+}
+
+double InspectorAnimationAgent::normalizedStartTime(AnimationPlayer& player)
+{
+    if (referenceTimeline().playbackRate() == 0)
+        return player.startTime() + referenceTimeline().currentTime() - player.timeline()->currentTime();
+    return player.startTime() + (player.timeline()->zeroTime() - referenceTimeline().zeroTime()) * 1000 * referenceTimeline().playbackRate();
+}
+
 DEFINE_TRACE(InspectorAnimationAgent)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_pageAgent);
     visitor->trace(m_domAgent);
     visitor->trace(m_idToAnimationPlayer);
     visitor->trace(m_idToAnimationType);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 }