Web Animations: Use a single animation clock

third_party/WebKit/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 71 matching lines @@
         m_compositorTimeline = adoptPtr(Platform::current()->compositorSupport()->createAnimationTimeline());
     }
 
     ASSERT(document);
 }
 
 AnimationTimeline::~AnimationTimeline()
 {
 }
 
+bool AnimationTimeline::isActive()
+{
+    return m_document && m_document->page();
+}
+
 void AnimationTimeline::animationAttached(Animation& animation)
 {
     ASSERT(animation.timeline() == this);
     ASSERT(!m_animations.contains(&animation));
     m_animations.add(&animation);
 }
 
 Animation* AnimationTimeline::play(AnimationEffect* child)
 {
     if (!m_document)
@@ skipping 36 matching lines @@
         animations.append(animation);
 
     std::sort(animations.begin(), animations.end(), Animation::hasLowerPriority);
 
     for (Animation* animation : animations) {
         if (!animation->update(reason))
             m_animationsNeedingUpdate.remove(animation);
     }
 
     ASSERT(m_outdatedAnimationCount == 0);
-    ASSERT(m_lastCurrentTimeInternal == currentTimeInternal());
+    ASSERT(m_lastCurrentTimeInternal == currentTimeInternal() || (std::isnan(currentTimeInternal()) && std::isnan(m_lastCurrentTimeInternal)));
 
 #if ENABLE(ASSERT)
     for (const auto& animation : m_animationsNeedingUpdate)
         ASSERT(!animation->outdated());
 #endif
 }
 
 void AnimationTimeline::scheduleNextService()
 {
     ASSERT(m_outdatedAnimationCount == 0);
@@ skipping 10 matching lines @@
     }
 }
 
 void AnimationTimeline::AnimationTimelineTiming::wakeAfter(double duration)
 {
     if (m_timer.isActive() && m_timer.nextFireInterval() < duration)
         return;
     m_timer.startOneShot(duration, BLINK_FROM_HERE);
 }
 
-void AnimationTimeline::AnimationTimelineTiming::cancelWake()
-{
-    m_timer.stop();
-}
-
 void AnimationTimeline::AnimationTimelineTiming::serviceOnNextFrame()
 {
     if (m_timeline->m_document && m_timeline->m_document->view())
         m_timeline->m_document->view()->scheduleAnimation();
 }
 
 DEFINE_TRACE(AnimationTimeline::AnimationTimelineTiming)
 {
     visitor->trace(m_timeline);
     AnimationTimeline::PlatformTiming::trace(visitor);
 }
 
 double AnimationTimeline::zeroTime()
 {
     if (!m_zeroTimeInitialized && m_document && m_document->loader()) {
         m_zeroTime = m_document->loader()->timing().referenceMonotonicTime();
         m_zeroTimeInitialized = true;
     }
     return m_zeroTime;
 }
 
+void AnimationTimeline::resetForTesting()
+{
+    m_zeroTime = 0;
+    m_zeroTimeInitialized = true;
+    m_playbackRate = 1;
+    m_lastCurrentTimeInternal = 0;
+}
+
 double AnimationTimeline::currentTime(bool& isNull)
 {
     return currentTimeInternal(isNull) * 1000;
 }
 
 double AnimationTimeline::currentTimeInternal(bool& isNull)
 {
-    if (!m_document) {
+    if (!isActive()) {
         isNull = true;
         return std::numeric_limits<double>::quiet_NaN();
     }
     double result = m_playbackRate == 0
         ? zeroTime()
         : (document()->animationClock().currentTime() - zeroTime()) * m_playbackRate;
     isNull = std::isnan(result);
     return result;
 }
 
 double AnimationTimeline::currentTime()
 {
     return currentTimeInternal() * 1000;
 }
 
 double AnimationTimeline::currentTimeInternal()
 {
     bool isNull;
     return currentTimeInternal(isNull);
 }
 
 void AnimationTimeline::setCurrentTime(double currentTime)
 {
     setCurrentTimeInternal(currentTime / 1000);
 }
 
 void AnimationTimeline::setCurrentTimeInternal(double currentTime)
 {
-    if (!document())
+    if (!isActive())
         return;
     m_zeroTime = m_playbackRate == 0
         ? currentTime
         : document()->animationClock().currentTime() - currentTime / m_playbackRate;
     m_zeroTimeInitialized = true;
 
     for (const auto& animation : m_animations) {
         // The Player needs a timing update to pick up a new time.
         animation->setOutdated();
     }
@@ skipping 14 matching lines @@
     for (const auto& animation : m_animationsNeedingUpdate)
         animation->pauseForTesting(pauseTime);
     serviceAnimations(TimingUpdateOnDemand);
 }
 
 bool AnimationTimeline::needsAnimationTimingUpdate()
 {
     if (currentTimeInternal() == m_lastCurrentTimeInternal)
         return false;
 
+    if (std::isnan(currentTimeInternal()) && std::isnan(m_lastCurrentTimeInternal))
+        return false;
+
     // We allow m_lastCurrentTimeInternal to advance here when there
     // are no animations to allow animations spawned during style
     // recalc to not invalidate this flag.
     if (m_animationsNeedingUpdate.isEmpty())
         m_lastCurrentTimeInternal = currentTimeInternal();
 
     return !m_animationsNeedingUpdate.isEmpty();
 }
 
 void AnimationTimeline::clearOutdatedAnimation(Animation* animation)
 {
     ASSERT(!animation->outdated());
     m_outdatedAnimationCount--;
 }
 
 void AnimationTimeline::setOutdatedAnimation(Animation* animation)
 {
     ASSERT(animation->outdated());
     m_outdatedAnimationCount++;
     m_animationsNeedingUpdate.add(animation);
-    if (m_document && m_document->page() && !m_document->page()->animator().isServicingAnimations())
+    if (isActive() && !m_document->page()->animator().isServicingAnimations())
         m_timing->serviceOnNextFrame();
 }
 
 void AnimationTimeline::setPlaybackRate(double playbackRate)
 {
-    if (!document())
+    if (!isActive())
         return;
     double currentTime = currentTimeInternal();
     m_playbackRate = playbackRate;
     m_zeroTime = playbackRate == 0
         ? currentTime
         : document()->animationClock().currentTime() - currentTime / playbackRate;
     m_zeroTimeInitialized = true;
 
     // Corresponding compositor animation may need to be restarted to pick up
     // the new playback rate. Marking the effect changed forces this.
@@ skipping 22 matching lines @@
 
 DEFINE_TRACE(AnimationTimeline)
 {
     visitor->trace(m_document);
     visitor->trace(m_timing);
     visitor->trace(m_animationsNeedingUpdate);
     visitor->trace(m_animations);
 }
 
 } // namespace