Allow HTMLMediaElement.currentTime to be set before the transition to HAVE_METADATA

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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 306 matching lines @@
     , m_defaultPlaybackRate(1.0f)
     , m_networkState(NETWORK_EMPTY)
     , m_readyState(HAVE_NOTHING)
     , m_readyStateMaximum(HAVE_NOTHING)
     , 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(std::numeric_limits<double>::max())
+    , m_defaultPlaybackStartPosition(0)
     , m_loadState(WaitingForSource)
     , m_deferredLoadState(NotDeferred)
     , m_deferredLoadTimer(this, &HTMLMediaElement::deferredLoadTimerFired)
     , m_webLayer(0)
     , m_preload(MediaPlayer::Auto)
     , m_displayMode(Unknown)
     , m_cachedTime(MediaPlayer::invalidTime())
     , m_cachedTimeWallClockUpdateTime(0)
     , m_minimumWallClockTimeToCacheMediaTime(0)
     , m_fragmentStartTime(MediaPlayer::invalidTime())
@@ skipping 1478 matching lines @@
         prepareMediaFragmentURI();
 
         selectInitialTracksIfNecessary();
 
         m_duration = duration();
         scheduleEvent(EventTypeNames::durationchange);
 
         if (isHTMLVideoElement())
             scheduleEvent(EventTypeNames::resize);
         scheduleEvent(EventTypeNames::loadedmetadata);
+
+        if (m_defaultPlaybackStartPosition > 0) {
+            seek(m_defaultPlaybackStartPosition);
+            m_defaultPlaybackStartPosition = 0;
+        }
+
         if (hasMediaControls())
             mediaControls()->reset();
         if (renderer())
             renderer()->updateFromElement();
     }
 
     bool shouldUpdateDisplayState = false;
 
     if (m_readyState >= HAVE_CURRENT_DATA && oldState < HAVE_CURRENT_DATA && !m_haveFiredLoadedData) {
         m_haveFiredLoadedData = true;
@@ skipping 80 matching lines @@
 {
     WTF_LOG(Media, "HTMLMediaElement::prepareToPlay(%p)", this);
     if (m_havePreparedToPlay)
         return;
     m_havePreparedToPlay = true;
 
     if (loadIsDeferred())
         startDeferredLoad();
 }
 
-void HTMLMediaElement::seek(double time, ExceptionState& exceptionState)
+void HTMLMediaElement::seek(double time)
 {
     WTF_LOG(Media, "HTMLMediaElement::seek(%f)", time);
 
     // 4.8.10.9 Seeking
 

[amogh.bihani, 2014/09/08 10:26:38]

While working on media fragments URI it came out that when media controller has
2 resources and the second resource has #t=2 then both resources seek till t=2
but if the first resource has #t=2, then when the media controller seeks till
t=2, second resource is still at HAVE_NOTHING, because of which it does not seek
till t=2. However,if we set here
if (HAVE_NOTHING) {
  m_defaultPlaybackStartPostition = time,
  return;
}
then the other resource would come to t=2 when it reaches loadedmetadata.

I could not find anything in the spec which would suggest what is the normal
behaviour.
What should be done here?

[philipj_slow, 2014/09/08 15:00:58]

It sounds like the problem is that setting MediaController.currentTime will
invoke HTMLMediaElement.seek(), but it's the HTMLMediaElement.currentTime setter
that saves the default playback start position in the HAVE_NOTHING case? And
moving that logic to seek() "fixes" the problem?

What I don't understand is how #t=2 on one element ends up seeking both elements
attached to a MediaController. applyMediaFragmentURI() just calls seek(), and
that doesn't do anything with the MediaController. Per spec I also don't see a
connection. Please help me out :)

[amogh.bihani, 2014/09/09 05:30:52]

Yes applyMediaFragmentURI seeks only the corresponding media but when we add
another media to the media group or MediaController then we call
addMediaElement() which internally calls bringElementUpToSpeed(). Now this calls
seek() for the new media attached. So if the first element has t=2, second will
also seek to that position (but the problem is that it is still in HAVE_NOTHING
state :/)

In step 13, it says that the media controller should seek to the media element's
initial playback position. So when second media has t=2, even the first moves to
that position.

Even in first scenario when we start the playback, the second media seeks to t=2
and then both start playing together, so I guess seeking it before hand would
look good and make both the scenarios uniform. Plus with this we won't be
fetching the resource which wont be played and save some data and power
(especially in hand held devices).

[philipj_slow, 2014/09/09 08:39:37]

I think the root problem is that, regardless of media fragments and the default
playback start position, attaching a media element with readyState HAVE_NOTHING
to a media controller will try to seek the media element but fail. If only later
calls play() it'll seek again, but if left paused it will stay in the
out-of-sync state.

If you want to file a spec bug about this, do so at http://whatwg.org/newbug and
post the bug number here.

Unless this CL exposes a problem that couldn't happen before, which doesn't seem
to be the case, I'm OK with leaving the problem unsolved.

-    // 1 - If the media element's readyState is HAVE_NOTHING, then raise an InvalidStateError exception.
-    if (m_readyState == HAVE_NOTHING) {
-        exceptionState.throwDOMException(InvalidStateError, "The element's readyState is HAVE_NOTHING.");
-        return;
-    }
-
     // If the media engine has been told to postpone loading data, let it go ahead now.
     if (m_preload < MediaPlayer::Auto && m_readyState < HAVE_FUTURE_DATA)
         prepareToPlay();
 
     // Get the current time before setting m_seeking, m_lastSeekTime is returned once it is set.
     refreshCachedTime();
     double now = currentTime();
 
     // 2 - 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
@@ skipping 25 matching lines @@
 
     // 7 - If the (possibly now changed) new playback position is not in one of the ranges given in the
     // seekable attribute, then let it be the position in one of the ranges given in the seekable attribute
     // that is the nearest to the new playback position. ... If there are no ranges given in the seekable
     // attribute then set the seeking IDL attribute to false and abort these steps.
     RefPtrWillBeRawPtr<TimeRanges> seekableRanges = seekable();
 
     // Short circuit seeking to the current time by just firing the events if no seek is required.
     // Don't skip calling the media engine if we are in poster mode because a seek should always
     // cancel poster display.
-    bool noSeekRequired = !seekableRanges->length() || (time == now && displayMode() != Poster);
+    bool noSeekRequired = !seekableRanges->length() || (time == now && !m_defaultPlaybackStartPosition && displayMode() != Poster);

[amogh.bihani, 2014/09/04 13:44:06]

Because of line 1944 we get time == now and hence seek never happens. In PS1, I
had mistakenly returned m_defaultPlaybackStartPosition in line 2082, hence it
was working :P.

Sorry it took nearly the whole day to debug this and briefly go through the
Fragment URI spec, hence I could not work much on handling fragment URI. I have
created a rought patch at https://codereview.chromium.org/539103002/.
This works fine but I have one doubt in it. Please help me there.

[philipj_slow, 2014/09/04 13:53:40]

Ah, right, this is a bit tricky now. The spec has split the concept of current
playback position and official playback position. The currentTime() exposed to
scripts is the official playback position, but using that internally is going to
cause little issues like this.

Maybe this isn't the place, but I would like to have
[ImplementedAs=officialPlaybackPosition] attribute double currentTime in the IDL
and only officialPlaybackPosition() and currentPlaybackPosition() internally so
that each call sites makes to make an explicit choice, hopefully matching the
spec.

[amogh.bihani, 2014/09/08 10:26:38]

Should I add a TODO here that this condition should be removed when official
playback position is implemented or first implement it and then land this on top
of that?

[philipj_slow, 2014/09/08 15:00:58]

If you want to work on official playback position that'd be nice, but it's
likely to be a bit complicated so I wouldn't block this CL on it. To fix this
problem, I would perhaps use "double now = m_cachedTime" above and add a comment
at that point saying that it's required to avoid getting the default playback
start position from currentTime().

[amogh.bihani, 2014/09/09 05:30:52]

Acknowledged.

 
     if (noSeekRequired) {
         if (time == now) {
             scheduleEvent(EventTypeNames::seeking);
             if (previousSeekStillPending)
                 return;
             // FIXME: There must be a stable state before timeupdate+seeked are dispatched and seeking
             // is reset to false. See http://crbug.com/266631
             scheduleTimeupdateEvent(false);
             scheduleEvent(EventTypeNames::seeked);
@@ skipping 74 matching lines @@
     m_cachedTime = MediaPlayer::invalidTime();
 }
 
 // playback state
 double HTMLMediaElement::currentTime() const
 {
 #if LOG_CACHED_TIME_WARNINGS
     static const double minCachedDeltaForWarning = 0.01;
 #endif
 
+    if (m_defaultPlaybackStartPosition)
+        return m_defaultPlaybackStartPosition;
+
     if (m_readyState == HAVE_NOTHING)
         return 0;
 
     if (m_seeking) {
         WTF_LOG(Media, "HTMLMediaElement::currentTime - seeking, returning %f", m_lastSeekTime);
         return m_lastSeekTime;
     }
 
     if (m_cachedTime != MediaPlayer::invalidTime() && m_paused) {
 #if LOG_CACHED_TIME_WARNINGS
         double delta = m_cachedTime - webMediaPlayer()->currentTime();
         if (delta > minCachedDeltaForWarning)
             WTF_LOG(Media, "HTMLMediaElement::currentTime - WARNING, cached time is %f seconds off of media time when paused", delta);
 #endif
         return m_cachedTime;
     }
 
     refreshCachedTime();
 
     return m_cachedTime;
 }
 
 void HTMLMediaElement::setCurrentTime(double time, ExceptionState& exceptionState)
 {
     if (m_mediaController) {
         exceptionState.throwDOMException(InvalidStateError, "The element is slaved to a MediaController.");
         return;
     }
-    seek(time, exceptionState);
+
+    // If the media element's readyState is HAVE_NOTHING, then set the default
+    // playback start position to that time.
+    if (m_readyState == HAVE_NOTHING) {
+        m_defaultPlaybackStartPosition = time;
+        return;
+    }
+
+    seek(time);
 }
 
 double HTMLMediaElement::duration() const
 {
     // FIXME: remove m_player check once we figure out how m_player is going
     // out of sync with readystate. m_player is cleared but readystate is not set
     // to HAVE_NOTHING
     if (!m_player || m_readyState < HAVE_METADATA)
         return std::numeric_limits<double>::quiet_NaN();
 
@@ skipping 118 matching lines @@
 
 void HTMLMediaElement::playInternal()
 {
     WTF_LOG(Media, "HTMLMediaElement::playInternal");
 
     // 4.8.10.9. Playing the media resource
     if (!m_player || m_networkState == NETWORK_EMPTY)
         scheduleDelayedAction(LoadMediaResource);
 
     if (endedPlayback())
-        seek(0, IGNORE_EXCEPTION);
+        seek(0);
 
     if (m_mediaController)
         m_mediaController->bringElementUpToSpeed(this);
 
     if (m_paused) {
         m_paused = false;
         invalidateCachedTime();
         scheduleEvent(EventTypeNames::play);
 
         if (m_readyState <= HAVE_CURRENT_DATA)
@@ skipping 841 matching lines @@
     double now = currentTime();
     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 && directionOfPlayback() == Forward) {
         // If the media element has a loop attribute specified and does not have a current media controller,
         if (loop() && !m_mediaController) {
             m_sentEndEvent = false;
             //  then seek to the earliest possible position of the media resource and abort these steps.
-            seek(0, IGNORE_EXCEPTION);
+            seek(0);
         } else {
             // If the media element does not have a current media controller, and the media element
             // has still ended playback, and the direction of playback is still forwards, and paused
             // is false,
             if (!m_mediaController && !m_paused) {
                 // changes paused to true and fires a simple event named pause at the media element.
                 m_paused = true;
                 scheduleEvent(EventTypeNames::pause);
             }
             // Queue a task to fire a simple event named ended at the media element.
@@ skipping 33 matching lines @@
     WTF_LOG(Media, "HTMLMediaElement::durationChanged : %f -> %f", m_duration, duration);
     m_duration = duration;
     scheduleEvent(EventTypeNames::durationchange);
 
     if (hasMediaControls())
         mediaControls()->reset();
     if (renderer())
         renderer()->updateFromElement();
 
     if (requestSeek)
-        seek(duration, IGNORE_EXCEPTION);
+        seek(duration);
 }
 
 void HTMLMediaElement::mediaPlayerPlaybackStateChanged()
 {
     WTF_LOG(Media, "HTMLMediaElement::mediaPlayerPlaybackStateChanged");
 
     if (!m_player || m_pausedInternal)
         return;
 
     if (webMediaPlayer()->paused())
@@ skipping 10 matching lines @@
     // user interaction or when it is technically required to play the video.
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
 
     enterFullscreen();
 }
 
 void HTMLMediaElement::mediaPlayerRequestSeek(double time)
 {
     // The player is the source of this seek request.
     if (m_mediaController) {
-        m_mediaController->setCurrentTime(time, IGNORE_EXCEPTION);
+        m_mediaController->setCurrentTime(time);
         return;
     }
-    setCurrentTime(time, IGNORE_EXCEPTION);
+    setCurrentTime(time, ASSERT_NO_EXCEPTION);
 }
 
 // MediaPlayerPresentation methods
 void HTMLMediaElement::mediaPlayerRepaint()
 {
     if (m_webLayer)
         m_webLayer->invalidate();
 
     updateDisplayState();
     if (renderer())
@@ skipping 677 matching lines @@
 
     if (m_fragmentStartTime != MediaPlayer::invalidTime() && m_readyState < HAVE_FUTURE_DATA)
         prepareToPlay();
 }
 
 void HTMLMediaElement::applyMediaFragmentURI()
 {
     if (m_fragmentStartTime != MediaPlayer::invalidTime()) {
         m_sentEndEvent = false;
         UseCounter::count(document(), UseCounter::HTMLMediaElementSeekToFragmentStart);
-        seek(m_fragmentStartTime, IGNORE_EXCEPTION);
+        seek(m_fragmentStartTime);
     }
 }
 
 WebMediaPlayer::CORSMode HTMLMediaElement::corsMode() const
 {
     const AtomicString& crossOriginMode = fastGetAttribute(crossoriginAttr);
     if (crossOriginMode.isNull())
         return WebMediaPlayer::CORSModeUnspecified;
     if (equalIgnoringCase(crossOriginMode, "use-credentials"))
         return WebMediaPlayer::CORSModeUseCredentials;
@@ skipping 86 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(0);
 }
 #endif
 
 }