Refactor resource load and resource selection algorithms as per spec

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 453 matching lines @@
 
     removeElementFromDocumentMap(this, &oldDocument);
     addElementToDocumentMap(this, &document());
 
     // FIXME: This is a temporary fix to prevent this object from causing the
     // MediaPlayer to dereference LocalFrame and FrameLoader pointers from the
     // previous document. This restarts the load, as if the src attribute had been set.
     // A proper fix would provide a mechanism to allow this object to refresh
     // the MediaPlayer's LocalFrame and FrameLoader references on
     // document changes so that playback can be resumed properly.
-    clearMediaPlayer(LoadMediaResource);
-    scheduleDelayedAction(LoadMediaResource);
+    prepareForLoad();

[philipj_slow, 2015/12/18 15:12:24]

I think that this bit is made worse by this CL, expanding
scheduleDelayedAction() in order to avoid another call to prepareForLoad(), it
seems.

Could you try to instead remove prepareForLoad() from scheduleDelayedAction()?
I've often been surprised to rediscover that scheduleDelayedAction() actually
does something synchronously. Then presumably scheduleNextSourceChild() could
simply call scheduleDelayedAction() as well.

I don't know exactly how this will all end up, but without a clear idea that the
end result is going to be an improvement, I'm reluctant to make it temporarily
worse.

+    m_pendingActionFlags |= LoadMediaResource;
+    if (!m_loadTimer.isActive())
+        m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
 
     // Decrement the load event delay count on oldDocument now that m_webMediaPlayer has been destroyed
     // and there is no risk of dispatching a load event from within the destructor.
     oldDocument.decrementLoadEventDelayCount();
 
     ActiveDOMObject::didMoveToNewExecutionContext(&document());
     HTMLElement::didMoveToNewDocument(oldDocument);
 }
 
 bool HTMLMediaElement::supportsFocus() const
 {
     if (ownerDocument()->isMediaDocument())
         return false;
 
     // If no controls specified, we should still be able to focus the element if it has tabIndex.
     return shouldShowControls() || HTMLElement::supportsFocus();
 }
 
 bool HTMLMediaElement::isMouseFocusable() const
 {
     return false;
 }
 
 void HTMLMediaElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
     if (name == srcAttr) {
         // Trigger a reload, as long as the 'src' attribute is present.
         if (!value.isNull()) {
-            clearMediaPlayer(LoadMediaResource);
-            scheduleDelayedAction(LoadMediaResource);
+            prepareForLoad();
+            m_pendingActionFlags |= LoadMediaResource;
+            if (!m_loadTimer.isActive())
+                m_loadTimer.startOneShot(0, BLINK_FROM_HERE);
         }
     } else if (name == controlsAttr) {
         configureMediaControls();
     } else if (name == preloadAttr) {
         setPlayerPreload();
     } else {
         HTMLElement::parseAttribute(name, oldValue, value);
     }
 }
 
@@ skipping 192 matching lines @@
 
     prepareForLoad();
     loadInternal();
     prepareToPlay();
 }
 
 void HTMLMediaElement::prepareForLoad()
 {
     WTF_LOG(Media, "HTMLMediaElement::prepareForLoad(%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_completelyLoaded = false;
-    m_havePreparedToPlay = false;
-    m_displayMode = Unknown;
+    NetworkState networkState = m_networkState;
+    resetMediaElement(LoadMediaResource);
 
     // 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
     // one of the task queues, then remove those tasks.
     cancelPendingEventsAndCallbacks();
 
     // 3 - If the media element's networkState is set to NETWORK_LOADING or NETWORK_IDLE, queue
     // a task to fire a simple event named abort at the media element.
-    if (m_networkState == NETWORK_LOADING || m_networkState == NETWORK_IDLE)
+    if (networkState == NETWORK_LOADING || networkState == NETWORK_IDLE)
         scheduleEvent(EventTypeNames::abort);
 
-    resetMediaPlayerAndMediaSource();
-
     // 4 - If the media element's networkState is not set to NETWORK_EMPTY, then run these substeps
-    if (m_networkState != NETWORK_EMPTY) {
+    if (networkState != NETWORK_EMPTY) {
         // 4.1 - Queue a task to fire a simple event named emptied at the media element.
         scheduleEvent(EventTypeNames::emptied);
 
         // 4.2 - If a fetching process is in progress for the media element, the user agent should stop it.
         setNetworkState(NETWORK_EMPTY);
 
         // 4.3 - Forget the media element's media-resource-specific tracks.
         forgetResourceSpecificTracks();
 
         // 4.4 - If readyState is not set to HAVE_NOTHING, then set it to that state.
@@ skipping 2221 matching lines @@
     audioSourceProvider().setClient(nullptr);
 #endif
     if (m_webMediaPlayer) {
 #if ENABLE(WEB_AUDIO)
         m_audioSourceProvider.wrap(nullptr);
 #endif
         m_webMediaPlayer.clear();
     }
 }
 
-void HTMLMediaElement::clearMediaPlayer(int flags)
+void HTMLMediaElement::resetMediaElement(int flags)
 {
     forgetResourceSpecificTracks();
 
     closeMediaSource();
 
     cancelDeferredLoad();
 
     {
         AudioSourceProviderClientLockScope scope(*this);
         clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     }
 
+#if ENABLE(WEB_AUDIO)
+    if (m_audioSourceNode)
+        audioSourceProvider().setClient(m_audioSourceNode);
+#endif
+
     stopPeriodicTimers();
     m_loadTimer.stop();
 
     m_pendingActionFlags &= ~flags;
     m_loadState = WaitingForSource;
 
     // We can't cast if we don't have a media player.
     m_remoteRoutesAvailable = false;
     m_playingRemotely = false;
+
+    // FIXME: Figure out appropriate place to reset LoadTextTrackResource if necessary and set m_pendingActionFlags to 0 here.
+    m_sentEndEvent = false;
+    m_sentStalledEvent = false;
+    m_haveFiredLoadedData = false;
+    m_completelyLoaded = false;
+    m_havePreparedToPlay = false;
+    m_displayMode = Unknown;
+
+    m_readyState = HAVE_NOTHING;
+    m_readyStateMaximum = HAVE_NOTHING;
+    setNetworkState(NETWORK_EMPTY);
+    setShouldDelayLoadEvent(false);
+    m_currentSourceNode = nullptr;
+    invalidateCachedTime();
+    cueTimeline().updateActiveCues(0);
+    m_playing = false;
+    m_paused = true;
+    m_seeking = false;
+
     if (mediaControls())
         mediaControls()->refreshCastButtonVisibilityWithoutUpdate();
 
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
 
 void HTMLMediaElement::stop()
 {
     WTF_LOG(Media, "HTMLMediaElement::stop(%p)", this);
 
     recordMetricsIfPausing();
 
     // Close the async event queue so that no events are enqueued.
     cancelPendingEventsAndCallbacks();
     m_asyncEventQueue->close();
 
-    // Stop the playback without generating events
-    clearMediaPlayer(-1);
-    m_readyState = HAVE_NOTHING;
-    m_readyStateMaximum = HAVE_NOTHING;
-    setNetworkState(NETWORK_EMPTY);
-    setShouldDelayLoadEvent(false);
-    m_currentSourceNode = nullptr;
-    invalidateCachedTime();
-    cueTimeline().updateActiveCues(0);
-    m_playing = false;
-    m_paused = true;
-    m_seeking = false;
+    // Clear everything in the Media Element
+    resetMediaElement(-1);
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 
-    stopPeriodicTimers();
-
     // Ensure that hasPendingActivity() is not preventing garbage collection, since otherwise this
     // media element will simply leak.
     ASSERT(!hasPendingActivity());
 }
 
 bool HTMLMediaElement::hasPendingActivity() const
 {
     // The delaying-the-load-event flag is set by resource selection algorithm when looking for a
     // resource to load, before networkState has reached to NETWORK_LOADING.
     if (m_shouldDelayLoadEvent)
@@ skipping 328 matching lines @@
 }
 
 void* HTMLMediaElement::preDispatchEventHandler(Event* event)
 {
     if (event && event->type() == EventTypeNames::webkitfullscreenchange)
         configureMediaControls();
 
     return nullptr;
 }
 
-// TODO(srirama.m): Refactor this and clearMediaPlayer to the extent possible.
+// TODO(srirama.m): Merge it to resetMediaElement if possible and remove it.
 void HTMLMediaElement::resetMediaPlayerAndMediaSource()
 {
     closeMediaSource();
 
     {
         AudioSourceProviderClientLockScope scope(*this);
         clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     }
 
     // We haven't yet found out if any remote routes are available.
@@ skipping 227 matching lines @@
     visitor->trace(m_client);
 }
 
 DEFINE_TRACE(HTMLMediaElement::AudioSourceProviderImpl)
 {
     visitor->trace(m_client);
 }
 #endif
 
 }