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 17 matching lines @@
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.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/ElementTraversal.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/Microtask.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/html/HTMLMediaSource.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/HTMLTrackElement.h"
 #include "core/html/MediaError.h"
@@ skipping 255 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)
     , 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(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(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_userGestureRequiredForPlay(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_sentEndEvent(false)
     , m_closedCaptionsVisible(false)
     , m_ignorePreloadNone(false)
     , m_tracksAreReady(true)
     , m_processingPreferenceChange(false)
     , m_remoteRoutesAvailable(false)
     , m_playingRemotely(false)
     , m_isFinalizing(false)
     , m_initialPlayWithoutUserGesture(false)
     , m_autoplayMediaCounted(false)
     , m_inOverlayFullscreenVideo(false)
     , m_audioTracks(AudioTrackList::create(*this))
     , m_videoTracks(VideoTrackList::create(*this))
     , m_textTracks(nullptr)
     , m_playPromiseResolveTask(CancellableTaskFactory::create(this, &HTMLMediaElement::resolvePlayPromises))
     , m_playPromiseRejectTask(CancellableTaskFactory::create(this, &HTMLMediaElement::rejectPlayPromises))
+    , m_resourceSelectionAlgorithmContinuationTask(CancellableTaskFactory::create(this, &HTMLMediaElement::continueResourceSelectionAlgorithm))
     , m_audioSourceNode(nullptr)
     , m_autoplayHelper(*this)
 {
 #if ENABLE(OILPAN)
     ThreadState::current()->registerPreFinalizer(this);
 #endif
 
     WTF_LOG(Media, "HTMLMediaElement::HTMLMediaElement(%p)", this);
 
     if (document.settings() && document.settings()->mediaPlaybackRequiresUserGesture())
@@ skipping 17 matching lines @@
 
     setShouldDelayLoadEvent(false);
 
     if (m_textTracks)
         m_textTracks->clearOwner();
     m_audioTracks->shutdown();
     m_videoTracks->shutdown();
 
     closeMediaSource();
 
+    if (m_resourceSelectionAlgorithmContinuationTask->isPending())
+        m_resourceSelectionAlgorithmContinuationTask->cancel();
+
     removeElementFromDocumentMap(this, &document());
 
     // Destroying the player may cause a resource load to be canceled,
     // which could result in LocalDOMWindow::dispatchWindowLoadEvent() being
     // called via ResourceFetch::didLoadResource() then
     // FrameLoader::checkCompleted(). To prevent load event dispatching during
     // object destruction, we use Document::incrementLoadEventDelayCount().
     // See http://crbug.com/275223 for more details.
     document().incrementLoadEventDelayCount();
 
@@ skipping 182 matching lines @@
 void HTMLMediaElement::didRecalcStyle(StyleRecalcChange)
 {
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
 void HTMLMediaElement::scheduleTextTrackResourceLoad()
 {
     WTF_LOG(Media, "HTMLMediaElement::scheduleTextTrackResourceLoad(%p)", 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(PassRefPtrWillBeRawPtr<Event> event)
 {
 #if LOG_MEDIA_EVENTS
     WTF_LOG(Media, "HTMLMediaElement::scheduleEvent(%p) - scheduling '%s'", this, event->type().ascii().data());
 #endif
     m_asyncEventQueue->enqueueEvent(event);
 }
 
-void HTMLMediaElement::loadTimerFired(Timer<HTMLMediaElement>*)
+void HTMLMediaElement::textTrackLoadTimerFired(Timer<HTMLMediaElement>*)
 {
-    if (m_pendingActionFlags & LoadTextTrackResource)
-        honorUserPreferencesForAutomaticTextTrackSelection();
-
-    if (m_pendingActionFlags & LoadMediaResource) {
-        if (m_loadState == LoadingFromSourceElement)
-            loadNextSourceChild();
-        else
-            loadInternal();
-    }
-
-    m_pendingActionFlags = 0;
+    WTF_LOG(Media, "HTMLMediaElement::textTrackLoadTimerFired(%p)", this);
+    honorUserPreferencesForAutomaticTextTrackSelection();
 }
 
 MediaError* HTMLMediaElement::error() const
 {
     return m_error;
 }
 
 void HTMLMediaElement::setSrc(const AtomicString& url)
 {
     setAttribute(srcAttr, url);
@@ skipping 76 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()
 {
     WTF_LOG(Media, "HTMLMediaElement::invokeLoadAlgorithm(%p)", 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_sentEndEvent = false;
     m_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
     m_displayMode = Unknown;
 
     // 1 - Abort any already-running instance of the resource selection algorithm for this element.
     m_loadState = WaitingForSource;
     m_currentSourceNode = nullptr;
 
     // 2 - If there are any tasks from the media element's media element event task source in
@@ skipping 74 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();
+    enqueueMicrotaskForResourceSelectionAlgorithmContinuation();
+}
+
+void HTMLMediaElement::continueResourceSelectionAlgorithm()
+{
+    WTF_LOG(Media, "HTMLMediaElement::continueResourceSelectionAlgorithm(%p)", this);
+    loadInternal();
+}
+
+void HTMLMediaElement::enqueueMicrotaskForResourceSelectionAlgorithmContinuation()
+{
+    OwnPtr<WebTaskRunner::Task> task = adoptPtr(m_resourceSelectionAlgorithmContinuationTask->cancelAndCreate());
+    Microtask::enqueueMicrotask(task.release());
 }
 
 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 516 matching lines @@
         else
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - error event not sent, <source> was removed", this);
 
         // 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()) {
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - scheduling next <source>", this);
-            scheduleNextSourceChild();
+            Microtask::enqueueMicrotask(WTF::bind(&HTMLMediaElement::loadNextSourceChild, this));

[philipj_slow, 2016/04/06 12:06:52]

Per spec the "await a stable state" is before forgetResourceSpecificTracks(),
could you try to move it up to get the same effect? Note that you'll have to
make this microtask cancelable as well, and cancel it if the resource selection
algorithm is aborted.

[Srirama, 2016/04/11 08:07:59]

Done.

         } else {
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState(%p) - no more <source> elements, waiting", this);
             waitForSourceChange();
         }
 
         return;
     }
 
     if (error == WebMediaPlayer::NetworkStateNetworkError && m_readyState >= HAVE_METADATA)
         mediaEngineError(MediaError::create(MediaError::MEDIA_ERR_NETWORK));
@@ skipping 1379 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(NETWORK_LOADING);
 
     // 25. Jump back to the find next candidate step above.
     m_nextChildNodeToConsider = source;
-    scheduleNextSourceChild();
+    loadNextSourceChild();

[philipj_slow, 2016/04/06 12:06:52]

If there are many source children, will this recurse on the stack? Can you make
it crash by having 10000 of them?

[Srirama, 2016/04/11 08:07:59]

I wrote a test content like below.
*********************
audio = document.getElementById('a');
var audioFile = findMediaFile("audio", "content/test");
for (var i = 0; i < 10; i++) {
    source = document.createElement("source");
    source.setAttribute("src", "invalid.mp3");
    audio.appendChild(source);
}

source = document.createElement("source");
source.setAttribute("src", audioFile);
audio.appendChild(source);
***********************
loadNextSourceChild is never called from sourceWasAdded function (it bails out
early from one of the conditions), probably i will change the test case, but i
still feel that if it reaches to loadNextSourceChild step here it would have
finished previous source child processing.

[philipj_slow, 2016/04/19 14:52:44]

Can you change the test so that it appends 10000 plain source elements with no
attributes or anything, and then a source element that would actually load? When
you get to the source element with the src attribute, what does the stack look
like?

 }
 
 void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
 {
     WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p, %p)", this, source);
 
 #if !LOG_DISABLED
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
     WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p) - 'src' is %s", this, urlForLoggingMedia(url).utf8().data());
 #endif
@@ skipping 317 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 53 matching lines @@
 
     // When connected to a MediaSource, e.g. setting MediaSource.duration will cause a
     // durationchange event to be fired.
     if (m_mediaSource)
         return true;
 
     // Wait for any pending events to be fired.
     if (m_asyncEventQueue->hasPendingEvents())
         return true;
 
+    // Wait for any pending microtask to be fired.
+    if (m_resourceSelectionAlgorithmContinuationTask->isPending())

[philipj_slow, 2016/04/06 12:06:52]

Now that we're in an Oilpan only world I'm not entirely sure this is needed.
Will the pending task itself not have a strong reference to the HTMLMediaElement
object, or is it weak?

[Srirama, 2016/04/11 08:07:59]

I think it will be a strong pointer (ownptr), isn't it. I will remove it.

+        return true;
+
     return false;
 }
 
 bool HTMLMediaElement::isFullscreen() const
 {
     return Fullscreen::isActiveFullScreenElement(*this);
 }
 
 void HTMLMediaElement::enterFullscreen()
 {
@@ skipping 605 matching lines @@
 {
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 
 } // namespace blink