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_lastTimeUpdateEventMovieTime(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(std::numeric_limits<double>::quiet_NaN()),
+      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
+      // movie time at the moment we ran out of data to play.

[mlamouri (slow - plz ping), 2016/10/26 15:32:54]

movie time?

[chcunningham, 2016/10/26 19:29:41]

we call it movie time in scheduleTimeupdateEvent... I think I just started
spreading that. I've now changed both to mediaTime :).

+      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 61 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());

[mlamouri (slow - plz ping), 2016/10/26 15:32:54]

"let it be that position instead" could win the title of most confusing spec
wording I've read in a while :).

[chcunningham, 2016/10/26 19:29:41]

Lol, agree

 
   // 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());

[mlamouri (slow - plz ping), 2016/10/26 15:32:54]

You did this somewhere above too. Can we deal with this in a cleaner fashion?
Sounds a bit odd to have random places where the official playback position is
reset.

[chcunningham, 2016/10/26 19:29:41]

I'm not in love with it, but I'm not sure how to improve. The need to have
official position update post-seek is at odds with our blocking of automatic
updates under conditions of (paused || waiting). As is, I think this is still an
improvement over all of the undocumented invalidateCachedTime() calls - there
are only two cases where I setOfficialPlaybackPosition() that aren't mandated by
the spec, and I've documented them both :). Open to suggestions though. 

+
   // 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.
+  if (m_readyState == kHaveNothing)
+    return std::numeric_limits<double>::quiet_NaN();
+
+  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.
+    // REVIEWER: Not sure what the spec expects really. If I don't do this here,

[mlamouri (slow - plz ping), 2016/10/26 15:32:54]

+foolip@, are you familiar with the spirit of the spec for this?

[foolip, 2016/10/26 19:43:30]

Per spec, it's OK for the duration to change any number of times during
playback. If duration was way too short or way too long, then that's clearly the
only way to actually play to the end and stop there sensibly. I'm inclined to
suggest always updating duration once known if it's off by more than one audio
sample or one video frame, but this is probably not the best CL for it.

+    // I at least need to update MediaControlsPainter::paintMediaSliderInternal
+    // to not skip ranges when rangeEnd < currentTime.
+    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 movieTime = currentPlaybackPosition();
   double now = WTF::currentTime();
-  double movieTime = currentTime();
 
   bool haveNotRecentlyFiredTimeupdate =
       (now - m_lastTimeUpdateEventWallTime) >= maxTimeupdateEventFrequency;
   bool movieTimeHasProgressed = movieTime != m_lastTimeUpdateEventMovieTime;
 
   // 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)) {
@@ skipping 524 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 37 matching lines @@
   m_remoteRoutesAvailable = false;
   m_playingRemotely = false;
   if (mediaControls())
     mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
   if (layoutObject())
     layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::contextDestroyed() {
-  BLINK_MEDIA_LOG << "contextDestroyed(" << (void*)this << ")";

[mlamouri (slow - plz ping), 2016/10/26 15:32:54]

Why did you remove this LOG?

[chcunningham, 2016/10/26 19:29:41]

Mistake. Fixed.

 
   // Close the async event queue so that no events are enqueued.
   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 = std::numeric_limits<double>::quiet_NaN();
+  m_officialPlaybackPositionNeedsUpdate = true;
   cueTimeline().updateActiveCues(0);
   m_playing = false;
   m_paused = true;
   m_seeking = false;
 
   if (layoutObject())
     layoutObject()->updateFromElement();
 
   stopPeriodicTimers();
 
@@ skipping 631 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