Animations: Allow document animation timelines to have a playback rate

Source/core/animation/AnimationTimeline.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 45 matching lines @@
 
 
 PassRefPtrWillBeRawPtr<AnimationTimeline> AnimationTimeline::create(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
 {
     return adoptRefWillBeNoop(new AnimationTimeline(document, timing));
 }
 
 AnimationTimeline::AnimationTimeline(Document* document, PassOwnPtrWillBeRawPtr<PlatformTiming> timing)
     : m_document(document)
     , m_zeroTime(0)
+    , m_lastCurrentTime(0)
+    , m_lastRealTime(0)
+    , m_playbackRate(1)
 {
     if (!timing)
         m_timing = adoptPtrWillBeNoop(new AnimationTimelineTiming(this));
     else
         m_timing = timing;
 
     ASSERT(document);
 }
 
 AnimationTimeline::~AnimationTimeline()
@@ skipping 84 matching lines @@
 }
 
 void AnimationTimeline::AnimationTimelineTiming::trace(Visitor* visitor)
 {
     visitor->trace(m_timeline);
     AnimationTimeline::PlatformTiming::trace(visitor);
 }
 
 double AnimationTimeline::zeroTime()
 {
-    if (!m_zeroTime && m_document && m_document->loader()) {

[dstockwell, 2014/11/12 03:39:42]

Don't reformat code.

[samli, 2014/11/12 20:01:13]

Done.

+    if (!m_zeroTime && m_document && m_document->loader())
         m_zeroTime = m_document->loader()->timing()->referenceMonotonicTime();
-    }
     return m_zeroTime;
 }
 
 double AnimationTimeline::currentTime(bool& isNull)
 {
     return currentTimeInternal(isNull) * 1000;
 }
 
 double AnimationTimeline::currentTimeInternal(bool& isNull)
 {
     if (!m_document) {
         isNull = true;
         return std::numeric_limits<double>::quiet_NaN();
     }
-    double result = m_document->animationClock().currentTime() - zeroTime();
+    double result = m_lastCurrentTime + (m_document->animationClock().currentTime() - m_lastRealTime - zeroTime()) * playbackRateForInspector();
     isNull = std::isnan(result);
     return result;
 }
 
 double AnimationTimeline::currentTime()
 {
     return currentTimeInternal() * 1000;
 }
 
 double AnimationTimeline::currentTimeInternal()
@@ skipping 25 matching lines @@
 }
 
 void AnimationTimeline::setOutdatedAnimationPlayer(AnimationPlayer* player)
 {
     ASSERT(player->outdated());
     m_playersNeedingUpdate.add(player);
     if (m_document && m_document->page() && !m_document->page()->animator().isServicingAnimations())
         m_timing->serviceOnNextFrame();
 }
 
+void AnimationTimeline::setPlaybackRateForInspector(double playbackRate)

[dstockwell, 2014/11/12 03:39:42]

Add a fixme, needs to invalidate compositor animations.

[samli, 2014/11/12 20:01:13]

Done.

+{
+    m_lastCurrentTime = currentTimeInternal();

[dstockwell, 2014/11/12 03:39:42]

I'm not sure you need both lastCurrentTime and lastRealTime. Seems you just need
to shift the animationClock's currentTime.

eg. in the currentTime() calcuation above, something like:

return (m_document->animationClock().currentTime() + m_delta - zeroTime()) *
playbackRate();

Should be able to recover a delta value here.

[samli, 2014/11/12 20:01:13]

(m_document->animationClock().currentTime() + m_delta - zeroTime()) *
playbackRate()) doesn't work. Simple case: play for a bit and set playback rate
to 0, this would return current time is now 0. You need to store 2 pieces of
information at minimum: a snapshotted value of what the animationClock's
currentTime from the last change in playback rate and a delta/offset of how that
maps across to the currentTime (when I change the playback rate multiple times).

This method here just snapshots the raw currentTime with no changes and one with
an offset instead of having to calculate what that offset value would be.
Something like finding delta * playbackRate. Current time calculation in this
case is: last snapshotted current time value + time thats elapsed since then
(need to use animationClock time here) * playbackRate. eg if playback rate is 0,
the delta evaluates to 0 and we return the base value of when it was paused.

The variable names probably make this a bit unclear so I'll try think of
something better.

[dstockwell, 2014/11/12 22:49:44]

Can we just special case playback rate 0, like in the Web Animations spec and as
we do for Animation Player?

rate 0 would store or clear m_holdTime, currentTime() would return m_holdTime if
it's not NaN. For other rates we would use the delta.

+    m_lastRealTime = m_document->animationClock().currentTime() - zeroTime();
+    m_playbackRate = playbackRate;
+}
+
+double AnimationTimeline::playbackRateForInspector() const
+{
+    return m_playbackRate;
+}
+
 #if !ENABLE(OILPAN)
 void AnimationTimeline::detachFromDocument()
 {
     // FIXME: AnimationTimeline should keep Document alive.
     m_document = nullptr;
 }
 #endif
 
 void AnimationTimeline::trace(Visitor* visitor)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_document);
     visitor->trace(m_timing);
     visitor->trace(m_playersNeedingUpdate);
     visitor->trace(m_players);
 #endif
 }
 
 } // namespace