Improve HTMLMediaElement::currentTime()

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/HTMLMediaElement.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
+#include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/HTMLNames.h"
 #include "core/css/MediaList.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ElementVisibilityObserver.h"
 #include "core/dom/Fullscreen.h"
@@ skipping 60 matching lines @@
 #ifndef BLINK_MEDIA_LOG
 #define BLINK_MEDIA_LOG DVLOG(3)
 #endif
 
 #ifndef LOG_MEDIA_EVENTS
 // Default to not logging events because so many are generated they can
 // overwhelm the rest of the logging.
 #define LOG_MEDIA_EVENTS 0
 #endif
 
-#ifndef LOG_CACHED_TIME_WARNINGS
-// Default to not logging warnings about excessive drift in the cached media
-// time because it adds a fair amount of overhead and logging.
-#define LOG_CACHED_TIME_WARNINGS 0
+#ifndef LOG_OFFICIAL_TIME_STATUS
+// Default to not logging status of official time because it adds a fair amount
+// of overhead and logging.
+#define LOG_OFFICIAL_TIME_STATUS 0
 #endif
 
 namespace blink {
 
 using namespace HTMLNames;
 
 using WeakMediaElementSet = HeapHashSet<WeakMember<HTMLMediaElement>>;
 using DocumentElementSetMap =
     HeapHashMap<WeakMember<Document>, Member<WeakMediaElementSet>>;
 
@@ skipping 291 matching lines @@
       m_playbackRate(1.0f),
       m_defaultPlaybackRate(1.0f),
       m_networkState(kNetworkEmpty),
       m_readyState(kHaveNothing),
       m_readyStateMaximum(kHaveNothing),
       m_volume(1.0f),
       m_lastSeekTime(0),
       m_previousProgressTime(std::numeric_limits<double>::max()),
       m_duration(std::numeric_limits<double>::quiet_NaN()),
       m_lastTimeUpdateEventWallTime(0),
-      m_lastTimeUpdateEventMovieTime(0),
+      m_lastTimeUpdateEventMediaTime(std::numeric_limits<double>::quiet_NaN()),
       m_defaultPlaybackStartPosition(0),
       m_loadState(WaitingForSource),
       m_deferredLoadState(NotDeferred),
       m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired),
       m_webLayer(nullptr),
       m_displayMode(Unknown),
-      m_cachedTime(std::numeric_limits<double>::quiet_NaN()),
+      m_officialPlaybackPosition(0),
+      m_officialPlaybackPositionNeedsUpdate(true),
       m_fragmentEndTime(std::numeric_limits<double>::quiet_NaN()),
       m_pendingActionFlags(0),
       m_lockedPendingUserGesture(false),
       m_playing(false),
       m_shouldDelayLoadEvent(false),
       m_haveFiredLoadedData(false),
       m_autoplaying(true),
       m_muted(false),
       m_paused(true),
       m_seeking(false),
@@ skipping 393 matching lines @@
           "The play() request was interrupted by a new load request.");
     }
 
     // 4.7 - If seeking is true, set it to false.
     m_seeking = false;
 
     // 4.8 - Set the current playback position to 0.
     //       Set the official playback position to 0.
     //       If this changed the official playback position, then queue a task
     //       to fire a simple event named timeupdate at the media element.
-    // FIXME: Add support for firing this event.
-
     // 4.9 - Set the initial playback position to 0.
-    // FIXME: Make this less subtle. The position only becomes 0 because the
-    // ready state is HAVE_NOTHING.
-    invalidateCachedTime();
+    setOfficialPlaybackPosition(0);
+    scheduleTimeupdateEvent(false);
 
     // 4.10 - Set the timeline offset to Not-a-Number (NaN).
     // 4.11 - Update the duration attribute to Not-a-Number (NaN).
 
     cueTimeline().updateActiveCues(0);
   } else if (!m_paused) {
     // TODO(foolip): There is a proposal to always reset the paused state
     // in the media element load algorithm, to avoid a bogus play() promise
     // rejection: https://github.com/whatwg/html/issues/869
     // This is where that change would have an effect, and it is measured to
@@ skipping 765 matching lines @@
     // attribute to change to a value lower than kHaveFutureData, then a waiting
     // will be fired at the element.
     if (wasPotentiallyPlaying && m_readyState < kHaveFutureData)
       scheduleEvent(EventTypeNames::waiting);
 
     // 4.8.10.9 steps 12-14
     if (m_readyState >= kHaveCurrentData)
       finishSeek();
   } else {
     if (wasPotentiallyPlaying && m_readyState < kHaveFutureData) {
+      // Force an update to official playback position. Automatic updates from
+      // currentPlaybackPosition() will be blocked while m_readyState remains
+      // < kHaveFutureData. This blocking is desired after 'waiting' has been
+      // fired, but its good to update it one final time to accurately reflect
+      // media time at the moment we ran out of data to play.
+      setOfficialPlaybackPosition(currentPlaybackPosition());
+
       // 4.8.10.8
       scheduleTimeupdateEvent(false);
       scheduleEvent(EventTypeNames::waiting);
     }
   }
 
+  // Once enough of the media data has been fetched to determine the duration of
+  // the media resource, its dimensions, and other metadata...
   if (m_readyState >= kHaveMetadata && oldState < kHaveMetadata) {
     createPlaceholderTracksIfNecessary();
 
     selectInitialTracksIfNecessary();
 
     MediaFragmentURIParser fragmentParser(m_currentSrc);
     m_fragmentEndTime = fragmentParser.endTime();
 
+    // Set the current playback position and the official playback position to
+    // the earliest possible position.
+    setOfficialPlaybackPosition(earliestPossiblePosition());
+
     m_duration = duration();
     scheduleEvent(EventTypeNames::durationchange);
 
     if (isHTMLVideoElement())
       scheduleEvent(EventTypeNames::resize);
     scheduleEvent(EventTypeNames::loadedmetadata);
 
     bool jumped = false;
     if (m_defaultPlaybackStartPosition > 0) {
       seek(m_defaultPlaybackStartPosition);
@@ skipping 15 matching lines @@
     if (mediaControls())
       mediaControls()->reset();
     if (layoutObject())
       layoutObject()->updateFromElement();
   }
 
   bool shouldUpdateDisplayState = false;
 
   if (m_readyState >= kHaveCurrentData && oldState < kHaveCurrentData &&
       !m_haveFiredLoadedData) {
+    // Force an update to official playback position to catch non-zero start
+    // times that were not known at kHaveMetadata, but are known now that the
+    // first packets have been demuxed.
+    setOfficialPlaybackPosition(currentPlaybackPosition());
+
     m_haveFiredLoadedData = true;
     shouldUpdateDisplayState = true;
     scheduleEvent(EventTypeNames::loadeddata);
     setShouldDelayLoadEvent(false);
   }
 
   bool isPotentiallyPlaying = potentiallyPlaying();
   if (m_readyState == kHaveFutureData && oldState <= kHaveCurrentData &&
       tracksAreReady) {
     scheduleEvent(EventTypeNames::canplay);
@@ skipping 26 matching lines @@
           // creating a new one in this case.
           if (!m_autoplayVisibilityObserver) {
             m_autoplayVisibilityObserver = new ElementVisibilityObserver(
                 this,
                 WTF::bind(&HTMLMediaElement::onVisibilityChangedForAutoplay,
                           wrapWeakPersistent(this)));
             m_autoplayVisibilityObserver->start();
           }
         } else {
           m_paused = false;
-          invalidateCachedTime();
           scheduleEvent(EventTypeNames::play);
           scheduleNotifyPlaying();
           m_autoplaying = false;
         }
       }
     }
 
     scheduleEvent(EventTypeNames::canplaythrough);
 
     shouldUpdateDisplayState = true;
@@ skipping 55 matching lines @@
   // m_webMediaPlayer is going out of sync with readystate.
   // m_webMediaPlayer is cleared but readystate is not set to HAVE_NOTHING.
   if (!m_webMediaPlayer || m_readyState == kHaveNothing)
     return;
 
   // Ignore preload none and start load if necessary.
   setIgnorePreloadNone();
 
   // Get the current time before setting m_seeking, m_lastSeekTime is returned
   // once it is set.
-  refreshCachedTime();
-  // This is needed to avoid getting default playback start position from
-  // currentTime().
-  double now = m_cachedTime;
+  double now = currentTime();
 
   // 3 - If the element's seeking IDL attribute is true, then another instance
   // of this algorithm is already running. Abort that other instance of the
   // algorithm without waiting for the step that it is running to complete.
   // Nothing specific to be done here.
 
   // 4 - Set the seeking IDL attribute to true.
   // The flag will be cleared when the engine tells us the time has actually
   // changed.
   m_seeking = true;
 
   // 6 - If the new playback position is later than the end of the media
   // resource, then let it be the end of the media resource instead.
   time = std::min(time, duration());
 
   // 7 - If the new playback position is less than the earliest possible
   // position, let it be that position instead.
-  time = std::max(time, 0.0);
+  time = std::max(time, earliestPossiblePosition());
 
   // Ask the media engine for the time value in the movie's time scale before
   // comparing with current time. This is necessary because if the seek time is
   // not equal to currentTime but the delta is less than the movie's time scale,
   // we will ask the media engine to "seek" to the current movie time, which may
   // be a noop and not generate a timechanged callback. This means m_seeking
   // will never be cleared and we will never fire a 'seeked' event.
   double mediaTime = webMediaPlayer()->mediaTimeForTimeValue(time);
   if (time != mediaTime) {
     BLINK_MEDIA_LOG << "seek(" << (void*)this << ", " << time
@@ skipping 29 matching lines @@
   // 14-17 are handled, if necessary, when the engine signals a readystate
   // change or otherwise satisfies seek completion and signals a time change.
 }
 
 void HTMLMediaElement::finishSeek() {
   BLINK_MEDIA_LOG << "finishSeek(" << (void*)this << ")";
 
   // 14 - Set the seeking IDL attribute to false.
   m_seeking = false;
 
+  // Force an update to officialPlaybackPosition. Periodic updates generally
+  // handle this, but may be skipped paused or waiting for data.
+  setOfficialPlaybackPosition(currentPlaybackPosition());
+
   // 16 - Queue a task to fire a simple event named timeupdate at the element.
   scheduleTimeupdateEvent(false);
 
   // 17 - Queue a task to fire a simple event named seeked at the element.
   scheduleEvent(EventTypeNames::seeked);
 
   setDisplayMode(Video);
 }
 
 HTMLMediaElement::ReadyState HTMLMediaElement::getReadyState() const {
   return m_readyState;
 }
 
 bool HTMLMediaElement::hasVideo() const {
   return webMediaPlayer() && webMediaPlayer()->hasVideo();
 }
 
 bool HTMLMediaElement::hasAudio() const {
   return webMediaPlayer() && webMediaPlayer()->hasAudio();
 }
 
 bool HTMLMediaElement::seeking() const {
   return m_seeking;
 }
 
-void HTMLMediaElement::refreshCachedTime() const {
-  if (!webMediaPlayer() || m_readyState < kHaveMetadata)
-    return;
+// https://www.w3.org/TR/html51/semantics-embedded-content.html#earliest-possible-position
+// The earliest possible position is not explicitly exposed in the API; it
+// corresponds to the start time of the first range in the seekable attribute’s
+// TimeRanges object, if any, or the current playback position otherwise.
+double HTMLMediaElement::earliestPossiblePosition() const {
+  TimeRanges* seekableRanges = seekable();
+  if (seekableRanges && seekableRanges->length() > 0)
+    return seekableRanges->start(0, ASSERT_NO_EXCEPTION);
 
-  m_cachedTime = webMediaPlayer()->currentTime();
+  return currentPlaybackPosition();
 }
 
-void HTMLMediaElement::invalidateCachedTime() {
-  BLINK_MEDIA_LOG << "invalidateCachedTime(" << (void*)this << ")";
-  m_cachedTime = std::numeric_limits<double>::quiet_NaN();
+double HTMLMediaElement::currentPlaybackPosition() const {
+  // "Official" playback position won't take updates from "current" playback
+  // position until m_readyState > kHaveMetadata, but other callers (e.g.
+  // pauseInternal) may still request currentPlaybackPosition at any time.
+  // From spec: "Media elements have a current playback position, which must
+  // initially (i.e., in the absence of media data) be zero seconds."
+  if (m_readyState == kHaveNothing)
+    return 0;
+
+  if (webMediaPlayer())
+    return webMediaPlayer()->currentTime();
+
+  if (m_readyState >= kHaveMetadata) {
+    LOG(WARNING) << __func__ << " readyState = " << m_readyState
+                 << " but no webMeidaPlayer to provide currentPlaybackPosition";
+  }
+
+  return 0;
 }
 
-// playback state
+double HTMLMediaElement::officialPlaybackPosition() const {
+  // Hold updates to official playback position while paused or waiting for more
+  // data. The underlying media player may continue to make small advances in
+  // currentTime (e.g. as samples in the last rendered audio buffer are played
+  // played out), but advancing currentTime while paused/waiting sends a mixed
+  // signal about the state of playback.
+  bool waitingForData = m_readyState <= kHaveCurrentData;
+  if (m_officialPlaybackPositionNeedsUpdate && !m_paused && !waitingForData) {
+    // Internal player position may advance slightly beyond duration because
+    // many files use imprecise duration. Clamp official position to duration.
+    double newPosition = std::min(duration(), currentPlaybackPosition());
+    setOfficialPlaybackPosition(newPosition);
+  }
+
+#if LOG_OFFICIAL_TIME_STATUS
+  static const double minCachedDeltaForWarning = 0.01;
+  double delta =
+      std::abs(m_officialPlaybackPosition - currentPlaybackPosition());
+  if (delta > minCachedDeltaForWarning) {
+    BLINK_MEDIA_LOG << "currentTime(" << (void*)this
+                    << ") - WARNING, cached time is " << delta
+                    << "seconds off of media time when paused/waiting";
+  }
+#endif
+
+  return m_officialPlaybackPosition;
+}
+
+void HTMLMediaElement::setOfficialPlaybackPosition(double position) const {
+#if LOG_OFFICIAL_TIME_STATUS
+  BLINK_MEDIA_LOG << "setOfficialPlaybackPosition(" << (void*)this
+                  << ") was:" << m_officialPlaybackPosition
+                  << " now:" << position;
+#endif
+
+  m_officialPlaybackPosition = position;
+
+  // Once set, official playback position should hold steady until the next
+  // stable state. We approximate this by using a microtask to mark the
+  // need for an update after the current (micro)task has completed. When
+  // needed, the update is applied in the next call to
+  // officialPlaybackPosition().
+  m_officialPlaybackPositionNeedsUpdate = false;
+  Microtask::enqueueMicrotask(
+      WTF::bind(&HTMLMediaElement::requireOfficialPlaybackPositionUpdate,
+                wrapWeakPersistent(this)));
+}
+
+void HTMLMediaElement::requireOfficialPlaybackPositionUpdate() const {
+  m_officialPlaybackPositionNeedsUpdate = true;
+}
+
 double HTMLMediaElement::currentTime() const {
   if (m_defaultPlaybackStartPosition)
     return m_defaultPlaybackStartPosition;
 
-  if (m_readyState == kHaveNothing)
-    return 0;
-
   if (m_seeking) {
     BLINK_MEDIA_LOG << "currentTime(" << (void*)this
                     << ") - seeking, returning " << m_lastSeekTime;
     return m_lastSeekTime;
   }
 
-  if (!std::isnan(m_cachedTime) && m_paused) {
-#if LOG_CACHED_TIME_WARNINGS
-    static const double minCachedDeltaForWarning = 0.01;
-    double delta = m_cachedTime - webMediaPlayer()->currentTime();
-    if (delta > minCachedDeltaForWarning)
-      BLINK_MEDIA_LOG << "currentTime(" << (void*)this
-                      << ") - WARNING, cached time is " << delta
-                      << "seconds off of media time when paused";
-#endif
-    return m_cachedTime;
-  }
-
-  refreshCachedTime();
-
-  return m_cachedTime;
+  return officialPlaybackPosition();
 }
 
 void HTMLMediaElement::setCurrentTime(double time) {
   // If the media element's readyState is kHaveNothing, then set the default
   // playback start position to that time.
   if (m_readyState == kHaveNothing) {
     m_defaultPlaybackStartPosition = time;
     return;
   }
 
@@ skipping 41 matching lines @@
 
 double HTMLMediaElement::playbackRate() const {
   return m_playbackRate;
 }
 
 void HTMLMediaElement::setPlaybackRate(double rate) {
   BLINK_MEDIA_LOG << "setPlaybackRate(" << (void*)this << ", " << rate << ")";
 
   if (m_playbackRate != rate) {
     m_playbackRate = rate;
-    invalidateCachedTime();
     scheduleEvent(EventTypeNames::ratechange);
   }
 
   updatePlaybackRate();
 }
 
 HTMLMediaElement::DirectionOfPlayback HTMLMediaElement::getDirectionOfPlayback()
     const {
   return m_playbackRate >= 0 ? Forward : Backward;
 }
@@ skipping 186 matching lines @@
     invokeResourceSelectionAlgorithm();
 
   // Generally "ended" and "looping" are exclusive. Here, the loop attribute
   // is ignored to seek back to start in case loop was set after playback
   // ended. See http://crbug.com/364442
   if (endedPlayback(LoopCondition::Ignored))
     seek(0);
 
   if (m_paused) {
     m_paused = false;
-    invalidateCachedTime();
     scheduleEvent(EventTypeNames::play);
 
     if (m_readyState <= kHaveCurrentData)
       scheduleEvent(EventTypeNames::waiting);
     else if (m_readyState >= kHaveFutureData)
       scheduleNotifyPlaying();
   } else if (m_readyState >= kHaveFutureData) {
     scheduleResolvePlayPromises();
   }
 
@@ skipping 22 matching lines @@
     invokeResourceSelectionAlgorithm();
 
   m_autoplayHelper->pauseMethodCalled();
 
   m_autoplaying = false;
 
   if (!m_paused) {
     m_paused = true;
     scheduleTimeupdateEvent(false);
     scheduleEvent(EventTypeNames::pause);
+
+    // Force an update to official playback position. Automatic updates from
+    // currentPlaybackPosition() will be blocked while m_paused = true. This
+    // blocking is desired while paused, but its good to update it one final
+    // time to accurately reflect movie time at the moment we paused.
+    setOfficialPlaybackPosition(currentPlaybackPosition());
+
     scheduleRejectPlayPromises(AbortError);
   }
 
   updatePlayState();
 }
 
 void HTMLMediaElement::requestRemotePlayback() {
   if (webMediaPlayer())
     webMediaPlayer()->requestRemotePlayback();
 }
@@ skipping 164 matching lines @@
   if (!playbackRate())
     return;
 
   if (!m_paused && mediaControls())
     mediaControls()->playbackProgressed();
 
   cueTimeline().updateActiveCues(currentTime());
 }
 
 void HTMLMediaElement::scheduleTimeupdateEvent(bool periodicEvent) {
+  // Per spec, consult current playback position to check for changing time.
+  double mediaTime = currentPlaybackPosition();
   double now = WTF::currentTime();
-  double movieTime = currentTime();
 
   bool haveNotRecentlyFiredTimeupdate =
       (now - m_lastTimeUpdateEventWallTime) >= maxTimeupdateEventFrequency;
-  bool movieTimeHasProgressed = movieTime != m_lastTimeUpdateEventMovieTime;
+  bool mediaTimeHasProgressed = mediaTime != m_lastTimeUpdateEventMediaTime;
 
   // Non-periodic timeupdate events must always fire as mandated by the spec,
   // otherwise we shouldn't fire duplicate periodic timeupdate events when the
   // movie time hasn't changed.
   if (!periodicEvent ||
-      (haveNotRecentlyFiredTimeupdate && movieTimeHasProgressed)) {
+      (haveNotRecentlyFiredTimeupdate && mediaTimeHasProgressed)) {
     scheduleEvent(EventTypeNames::timeupdate);
     m_lastTimeUpdateEventWallTime = now;
-    m_lastTimeUpdateEventMovieTime = movieTime;
+    m_lastTimeUpdateEventMediaTime = mediaTime;
   }
 }
 
 void HTMLMediaElement::togglePlayState() {
   if (paused())
     play();
   else
     pause();
 }
 
@@ skipping 511 matching lines @@
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this
                     << ") - m_currentSourceNode set to 0";
   }
 }
 
 void HTMLMediaElement::timeChanged() {
   BLINK_MEDIA_LOG << "timeChanged(" << (void*)this << ")";
 
   cueTimeline().updateActiveCues(currentTime());
 
-  invalidateCachedTime();
-
   // 4.8.10.9 steps 12-14. Needed if no ReadyState change is associated with the
   // seek.
   if (m_seeking && m_readyState >= kHaveCurrentData &&
       !webMediaPlayer()->seeking())
     finishSeek();
 
   // Always call scheduleTimeupdateEvent when the media engine reports a time
   // discontinuity, it will only queue a 'timeupdate' event if we haven't
   // already posted one at the current movie time.
   scheduleTimeupdateEvent(false);
 
-  double now = currentTime();
+  double now = currentPlaybackPosition();
   double dur = duration();
 
   // When the current playback position reaches the end of the media resource
   // when the direction of playback is forwards, then the user agent must follow
   // these steps:
   if (!std::isnan(dur) && dur && now >= dur &&
       getDirectionOfPlayback() == Forward) {
     // If the media element has a loop attribute specified
     if (loop()) {
       //  then seek to the earliest possible position of the media resource and
       //  abort these steps.
-      seek(0);
+      seek(earliestPossiblePosition());
     } else {
       // If the media element has still ended playback, and the direction of
       // playback is still forwards, and paused is false,
       if (!m_paused) {
         // changes paused to true and fires a simple event named pause at the
         // media element.
         m_paused = true;
         scheduleEvent(EventTypeNames::pause);
         scheduleRejectPlayPromises(AbortError);
       }
       // Queue a task to fire a simple event named ended at the media element.
       scheduleEvent(EventTypeNames::ended);
     }
   }
   updatePlayState();
 }
 
 void HTMLMediaElement::durationChanged() {
   BLINK_MEDIA_LOG << "durationChanged(" << (void*)this << ")";
-  // FIXME: Change WebMediaPlayer to convey the currentTime
-  // when the duration change occured. The current WebMediaPlayer
-  // implementations always clamp currentTime() to duration()
-  // so the requestSeek condition here is always false.
-  durationChanged(duration(), currentTime() > duration());
+  // If the duration is changed such that the *current playback position* ends
+  // up being greater than the time of the end of the media resource, then the
+  // user agent must also seek to the time of the end of the media resource.
+  durationChanged(duration(), currentPlaybackPosition() > duration());
 }
 
 void HTMLMediaElement::durationChanged(double duration, bool requestSeek) {
   BLINK_MEDIA_LOG << "durationChanged(" << (void*)this << ", " << duration
                   << ", " << boolString(requestSeek) << ")";
 
   // Abort if duration unchanged.
   if (m_duration == duration)
     return;
 
@@ skipping 142 matching lines @@
   // 4.8.10.8 Playing the media resource
 
   // A media element is said to have ended playback when the element's
   // readyState attribute is HAVE_METADATA or greater,
   if (m_readyState < kHaveMetadata)
     return false;
 
   // and the current playback position is the end of the media resource and the
   // direction of playback is forwards, Either the media element does not have a
   // loop attribute specified,
-  double now = currentTime();
+  double now = currentPlaybackPosition();
   if (getDirectionOfPlayback() == Forward)
     return dur > 0 && now >= dur &&
            (loopCondition == LoopCondition::Ignored || !loop());
 
   // or the current playback position is the earliest possible position and the
   // direction of playback is backwards
   DCHECK_EQ(getDirectionOfPlayback(), Backward);
-  return now <= 0;
+  return now <= earliestPossiblePosition();
 }
 
 bool HTMLMediaElement::stoppedDueToErrors() const {
   if (m_readyState >= kHaveMetadata && m_error) {
     TimeRanges* seekableRanges = seekable();
     if (!seekableRanges->contain(currentTime()))
       return true;
   }
 
   return false;
 }
 
 void HTMLMediaElement::updatePlayState() {
   bool isPlaying = webMediaPlayer() && !webMediaPlayer()->paused();
   bool shouldBePlaying = potentiallyPlaying();
 
   BLINK_MEDIA_LOG << "updatePlayState(" << (void*)this
                   << ") - shouldBePlaying = " << boolString(shouldBePlaying)
                   << ", isPlaying = " << boolString(isPlaying);
 
   if (shouldBePlaying) {
     setDisplayMode(Video);
-    invalidateCachedTime();
 
     if (!isPlaying) {
       // Set rate, muted before calling play in case they were set before the
       // media engine was setup.  The media engine should just stash the rate
       // and muted values since it isn't already playing.
       webMediaPlayer()->setRate(playbackRate());
       updateVolume();
       webMediaPlayer()->play();
       m_autoplayHelper->playbackStarted();
     }
 
     if (mediaControls())
       mediaControls()->playbackStarted();
     startPlaybackProgressTimer();
     m_playing = true;
 
   } else {  // Should not be playing right now
     if (isPlaying) {
       webMediaPlayer()->pause();
       m_autoplayHelper->playbackStopped();
     }
 
-    refreshCachedTime();
-
     m_playbackProgressTimer.stop();
     m_playing = false;
     double time = currentTime();
     if (time > m_lastSeekTime)
       addPlayedRange(m_lastSeekTime, time);
 
     if (mediaControls())
       mediaControls()->playbackStopped();
   }
 
@@ skipping 50 matching lines @@
   cancelPendingEventsAndCallbacks();
   m_asyncEventQueue->close();
 
   // Clear everything in the Media Element
   clearMediaPlayer();
   m_readyState = kHaveNothing;
   m_readyStateMaximum = kHaveNothing;
   setNetworkState(kNetworkEmpty);
   setShouldDelayLoadEvent(false);
   m_currentSourceNode = nullptr;
-  invalidateCachedTime();
+  m_officialPlaybackPosition = 0;
+  m_officialPlaybackPositionNeedsUpdate = true;
   cueTimeline().updateActiveCues(0);
   m_playing = false;
   m_paused = true;
   m_seeking = false;
 
   if (layoutObject())
     layoutObject()->updateFromElement();
 
   stopPeriodicTimers();
 
@@ skipping 626 matching lines @@
                       ("Media.Controls.Show.Audio", MediaControlsShowMax));
   return histogram;
 }
 
 void HTMLMediaElement::onVisibilityChangedForAutoplay(bool isVisible) {
   if (!isVisible)
     return;
 
   if (shouldAutoplay()) {
     m_paused = false;
-    invalidateCachedTime();
     scheduleEvent(EventTypeNames::play);
     scheduleNotifyPlaying();
     m_autoplaying = false;
 
     updatePlayState();
   }
 
   // TODO(zqzhang): There's still flaky leak if onVisibilityChangedForAutoplay()
   // is never called.  The leak comes from either ElementVisibilityObserver or
   // IntersectionObserver. Should keep an eye on it.  See
@@ skipping 104 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect()
     const {
   IntRect result;
   if (LayoutObject* object = m_element->layoutObject())
     result = object->absoluteBoundingBoxRect();
   return result;
 }
 
 }  // namespace blink