Web Animations: Don't mark players as outdated upon currentTime access

Source/core/animation/Player.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 80 matching lines @@
 double Player::currentTimeWithLag() const
 {
     ASSERT(!m_held);
     double time = currentTimeWithoutLag();
     return std::isinf(time) ? time : time - m_storedTimeLag;
 }
 
 void Player::updateTimingState(double newCurrentTime)
 {
     ASSERT(!isNull(newCurrentTime));
+    bool oldHeld = m_held;
     m_held = m_paused || !m_playbackRate || limited(newCurrentTime);
     if (m_held) {
+        if (!oldHeld || m_holdTime != newCurrentTime)
+            setOutdated();
         m_holdTime = newCurrentTime;
         m_storedTimeLag = nullValue();
     } else {
         m_holdTime = nullValue();
         m_storedTimeLag = currentTimeWithoutLag() - newCurrentTime;
+        setOutdated();
     }
-    setOutdated();
 }
 
 void Player::updateCurrentTimingState()
 {
     if (m_held) {
         updateTimingState(m_holdTime);
-    } else {
-        updateTimingState(currentTimeWithLag());
-        if (m_held && limited(m_holdTime))
-            m_holdTime = m_playbackRate < 0 ? 0 : sourceEnd();
+        return;
     }
+    if (!limited(currentTimeWithLag()))
+        return;
+    m_held = true;
+    m_holdTime = m_playbackRate < 0 ? 0 : sourceEnd();
+    m_storedTimeLag = nullValue();
 }
 
 double Player::currentTime()
 {
     updateCurrentTimingState();
     if (m_held)
         return m_holdTime;
     return currentTimeWithLag();
 }
 
 void Player::setCurrentTime(double newCurrentTime)
 {
     if (!std::isfinite(newCurrentTime))
         return;
     updateTimingState(newCurrentTime);
 }
 
 void Player::setStartTime(double newStartTime)
 {
     if (!std::isfinite(newStartTime))
         return;
     updateCurrentTimingState(); // Update the value of held
     m_startTime = newStartTime;
-    if (!m_held)
-        updateCurrentTimingState();
+    if (m_held)
+        return;
+    updateCurrentTimingState();
+    setOutdated();
 }
 
 void Player::setSource(TimedItem* newSource)
 {
     if (m_content == newSource)
         return;
     double storedCurrentTime = currentTime();
     if (m_content)
         m_content->detach();
     m_content = newSource;
@@ skipping 101 matching lines @@
 }
 
 void Player::cancelAnimationOnCompositor()
 {
     if (hasActiveAnimationsOnCompositor())
         toAnimation(m_content.get())->cancelAnimationOnCompositor();
 }
 
 bool Player::update()
 {
-    if (!m_timeline)
+    m_outdated = false;
+
+    if (!m_timeline || !m_content)
         return false;
 
     double inheritedTime = isNull(m_timeline->currentTime()) ? nullValue() : currentTime();
-    m_outdated = false;
-
-    if (!m_content)
-        return false;
-
     m_content->updateInheritedTime(inheritedTime);
 
     ASSERT(!m_outdated);
     return m_content->isCurrent() || m_content->isInEffect();
 }
 
 double Player::timeToEffectChange()
 {
     ASSERT(!m_outdated);
     if (!m_content || !m_playbackRate)
@@ skipping 17 matching lines @@
 {
     RELEASE_ASSERT(!paused());
     updateTimingState(pauseTime);
     if (!m_isPausedForTesting && hasActiveAnimationsOnCompositor())
         toAnimation(m_content.get())->pauseAnimationForTestingOnCompositor(currentTime());
     m_isPausedForTesting = true;
     pause();
 }
 
 } // namespace