Media element resource selection algorithm should "await a stable state"

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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 370 matching lines @@
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url)
 {
     return s_mediaStreamRegistry ? s_mediaStreamRegistry->contains(url) : false;
 }
 
 HTMLMediaElement::HTMLMediaElement(const QualifiedName& tagName, Document& document)
     : HTMLElement(tagName, document)
     , ActiveScriptWrappable(this)
     , ActiveDOMObject(&document)
-    , m_loadTimer(this, &HTMLMediaElement::loadTimerFired)
+    , m_textTrackLoadTimer(this, &HTMLMediaElement::textTrackLoadTimerFired)
     , m_progressEventTimer(this, &HTMLMediaElement::progressEventTimerFired)
     , m_playbackProgressTimer(this, &HTMLMediaElement::playbackProgressTimerFired)
     , m_audioTracksTimer(this, &HTMLMediaElement::audioTracksTimerFired)
     , m_playedTimeRanges()
     , m_asyncEventQueue(GenericEventQueue::create(this))
     , 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_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_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)
     , m_sentStalledEvent(false)
     , m_ignorePreloadNone(false)
     , m_textTracksVisible(false)
     , m_shouldPerformAutomaticTrackSelection(true)
     , m_tracksAreReady(true)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
     , m_inOverlayFullscreenVideo(false)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
     , m_playPromiseResolveTask(CancellableTaskFactory::create(this, &HTMLMediaElement::resolveScheduledPlayPromises))
     , m_playPromiseRejectTask(CancellableTaskFactory::create(this, &HTMLMediaElement::rejectScheduledPlayPromises))
+    , m_resourceSelectionAlgorithmContinuationTask(CancellableTaskFactory::create(this, &HTMLMediaElement::continueResourceSelectionAlgorithm))
+    , m_loadNextSourceChildAfterErrorTask(CancellableTaskFactory::create(this, &HTMLMediaElement::loadNextSourceChildAfterError))
     , m_audioSourceNode(nullptr)
     , m_autoplayHelperClient(AutoplayHelperClientImpl::create(this))
     , m_autoplayHelper(AutoplayExperimentHelper::create(m_autoplayHelperClient.get()))
     , m_autoplayUmaHelper(AutoplayUmaHelper::create(this))
     , m_remotePlaybackClient(nullptr)
     , m_autoplayVisibilityObserver(nullptr)
 {
     ThreadState::current()->registerPreFinalizer(this);
 
     BLINK_MEDIA_LOG << "HTMLMediaElement(" << (void*)this << ")";
@@ skipping 179 matching lines @@
 void HTMLMediaElement::didRecalcStyle(StyleRecalcChange)
 {
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::scheduleTextTrackResourceLoad()
 {
     BLINK_MEDIA_LOG << "scheduleTextTrackResourceLoad(" << (void*)this << ")";
 
-    m_pendingActionFlags |= LoadTextTrackResource;
-
-    if (!m_loadTimer.isActive())
-        m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
-}
-
-void HTMLMediaElement::scheduleNextSourceChild()
-{
-    // Schedule the timer to try the next <source> element WITHOUT resetting state ala invokeLoadAlgorithm.
-    m_pendingActionFlags |= LoadMediaResource;
-    m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
+    if (!m_textTrackLoadTimer.isActive())
+        m_textTrackLoadTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::scheduleEvent(const AtomicString& eventName)
 {
     scheduleEvent(Event::createCancelable(eventName));
 }
 
 void HTMLMediaElement::scheduleEvent(Event* event)
 {
 #if LOG_MEDIA_EVENTS
     BLINK_MEDIA_LOG << "scheduleEvent(" << (void*)this << ")" << " - scheduling '" << event->type() << "'";
 #endif
     m_asyncEventQueue->enqueueEvent(event);
 }
 
-void HTMLMediaElement::loadTimerFired(TimerBase*)
+void HTMLMediaElement::textTrackLoadTimerFired(TimerBase*)
 {
-    if (m_pendingActionFlags & LoadTextTrackResource)
-        honorUserPreferencesForAutomaticTextTrackSelection();
-
-    if (m_pendingActionFlags & LoadMediaResource) {
-        if (m_loadState == LoadingFromSourceElement)
-            loadNextSourceChild();
-        else
-            loadInternal();
-    }
-
-    m_pendingActionFlags = 0;
+    BLINK_MEDIA_LOG << "HTMLMediaElement::textTrackLoadTimerFired(" << (void*)this << ")";
+    honorUserPreferencesForAutomaticTextTrackSelection();
 }
 
 MediaError* HTMLMediaElement::error() const
 {
     return m_error;
 }
 
 void HTMLMediaElement::setSrc(const AtomicString& url)
 {
     setAttribute(srcAttr, url);
@@ skipping 47 matching lines @@
 // TODO(srirama.m): Currently m_ignorePreloadNone is reset before calling
 // invokeLoadAlgorithm() in all places except load(). Move it inside here
 // once microtask is implemented for "Await a stable state" step
 // in resource selection algorithm.
 void HTMLMediaElement::invokeLoadAlgorithm()
 {
     BLINK_MEDIA_LOG << "invokeLoadAlgorithm(" << (void*)this << ")";
 
     // Perform the cleanup required for the resource load algorithm to run.
     stopPeriodicTimers();
-    m_loadTimer.stop();
     cancelDeferredLoad();
-    // FIXME: Figure out appropriate place to reset LoadTextTrackResource if necessary and set m_pendingActionFlags to 0 here.
-    m_pendingActionFlags &= ~LoadMediaResource;
     m_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
     m_displayMode = Unknown;
 
     // 1 - Abort any already-running instance of the resource selection algorithm for this element.
+    m_resourceSelectionAlgorithmContinuationTask->cancel();
+    m_loadNextSourceChildAfterErrorTask->cancel();
     m_loadState = WaitingForSource;
     m_currentSourceNode = nullptr;
 
     // 2 - Let pending tasks be a list of tasks from the media element's media
     // element task source in one of the task queues.
     //
     // 3 - For each task in the pending tasks that would run resolve pending
     // play promises or project pending play prmoises algorithms, immediately
     // resolve or reject those promises in the order the corresponding tasks
     // were queued.
@@ skipping 100 matching lines @@
     // so they are closer to the relevant spec steps.
     m_lastSeekTime = 0;
     m_duration = std::numeric_limits<double>::quiet_NaN();
 
     // 3 - Set the media element's delaying-the-load-event flag to true (this delays the load event)
     setShouldDelayLoadEvent(true);
     if (mediaControls())
         mediaControls()->reset();
 
     // 4 - Await a stable state, allowing the task that invoked this algorithm to continue
-    // TODO(srirama.m): Remove scheduleNextSourceChild() and post a microtask instead.
-    // See http://crbug.com/593289 for more details.
-    scheduleNextSourceChild();
+    Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, m_resourceSelectionAlgorithmContinuationTask->cancelAndCreate());

[foolip, 2016/09/02 10:31:00]

Just to be clear, this and the below use of
Platform::current()->currentThread()->getWebTaskRunner()->postTask are both
places where I think we should either switch to the correct microtask timing,
and that using task timing in the interim creates the risk of getting stuck with
that timing for a long time instead.

+}
+
+void HTMLMediaElement::continueResourceSelectionAlgorithm()
+{
+    BLINK_MEDIA_LOG << "HTMLMediaElement::continueResourceSelectionAlgorithm(" << (void*)this << ")";
+    loadInternal();
 }
 
 void HTMLMediaElement::loadInternal()
 {
     // HTMLMediaElement::textTracksAreReady will need "... the text tracks whose mode was not in the
     // disabled state when the element's resource selection algorithm last started".
     m_textTracksWhenResourceSelectionBegan.clear();
     if (m_textTracks) {
         for (unsigned i = 0; i < m_textTracks->length(); ++i) {
             TextTrack* track = m_textTracks->anonymousIndexedGetter(i);
@@ skipping 109 matching lines @@
         return;
     }
 
     // Reset the MediaPlayer and MediaSource if any
     resetMediaPlayerAndMediaSource();
 
     m_loadState = LoadingFromSourceElement;
     loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
+void HTMLMediaElement::loadNextSourceChildAfterError()
+{
+    // 9.Otherwise.11 - Forget the media element's media-resource-specific tracks.
+    forgetResourceSpecificTracks();
+    loadNextSourceChild();
+}
+
 void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, const ContentType& contentType)
 {
     DCHECK(isMainThread());
     KURL url;
     if (source.isURL()) {
         url = source.getAsURL();
         DCHECK(isSafeToLoadURL(url, Complain));
         BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
     }
 
@@ skipping 418 matching lines @@
     if (m_readyState < kHaveMetadata && m_loadState == LoadingFromSourceElement) {
 
         // resource selection algorithm
         // Step 9.Otherwise.9 - Failed with elements: Queue a task, using the DOM manipulation task source, to fire a simple event named error at the candidate element.
         if (m_currentSourceNode)
             m_currentSourceNode->scheduleErrorEvent();
         else
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - error event not sent, <source> was removed";
 
         // 9.Otherwise.10 - Asynchronously await a stable state. The synchronous section consists of all the remaining steps of this algorithm until the algorithm says the synchronous section has ended.
-
-        // 9.Otherwise.11 - Forget the media element's media-resource-specific tracks.
-        forgetResourceSpecificTracks();
-
         if (havePotentialSourceChild()) {
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - scheduling next <source>";
-            scheduleNextSourceChild();
+            Platform::current()->currentThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, m_loadNextSourceChildAfterErrorTask->cancelAndCreate());
         } else {
             BLINK_MEDIA_LOG << "setNetworkState(" << (void*)this << ") - no more <source> elements, waiting";
             waitForSourceChange();
         }
 
         return;
     }
 
     if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= kHaveMetadata)
         mediaEngineError(MediaError::create(MediaError::kMediaErrNetwork));
@@ skipping 1388 matching lines @@
     // 22. Asynchronously await a stable state...
     // 23. Set the element's delaying-the-load-event flag back to true (this delays the load event again, in case
     // it hasn't been fired yet).
     setShouldDelayLoadEvent(true);
 
     // 24. Set the networkState back to NETWORK_LOADING.
     setNetworkState(kNetworkLoading);
 
     // 25. Jump back to the find next candidate step above.
     m_nextChildNodeToConsider = source;
-    scheduleNextSourceChild();
+    loadNextSourceChild();
 }
 
 void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
 {
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ", " << source << ")";
 
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
     BLINK_MEDIA_LOG << "sourceWasRemoved(" << (void*)this << ") - 'src' is " << urlForLoggingMedia(url);
 
     if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
@@ skipping 327 matching lines @@
     closeMediaSource();
 
     cancelDeferredLoad();
 
     {
         AudioSourceProviderClientLockScope scope(*this);
         clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     }
 
     stopPeriodicTimers();
-    m_loadTimer.stop();
+    m_textTrackLoadTimer.stop();
 
-    m_pendingActionFlags = 0;
     m_loadState = WaitingForSource;
 
     // We can't cast if we don't have a media player.
     m_remoteRoutesAvailable = false;
     m_playingRemotely = false;
     if (mediaControls())
         mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
@@ skipping 803 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink