Use Traversal<HTMLSourceElement> to find the next source candidate

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 693 matching lines @@
     m_pendingActionFlags &= ~LoadMediaResource;
     m_sentEndEvent = false;
     m_sentStalledEvent = false;
     m_haveFiredLoadedData = false;
     m_completelyLoaded = false;
     m_havePreparedToPlay = false;
     m_displayMode = Unknown;
 
     // 1 - Abort any already-running instance of the resource selection algorithm for this element.
     m_loadState = WaitingForSource;
-    m_currentSourceNode = nullptr;
+    m_currentSourceElement = 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)
         scheduleEvent(EventTypeNames::abort);
 
@@ skipping 94 matching lines @@
     enum Mode { attribute, children };
 
     // 3 - If the media element has a src attribute, then let mode be attribute.
     Mode mode = attribute;
     if (!fastHasAttribute(srcAttr)) {
         // Otherwise, if the media element does not have a src attribute but has a source
         // element child, then let mode be children and let candidate be the first such
         // source element child in tree order.
         if (HTMLSourceElement* element = Traversal<HTMLSourceElement>::firstChild(*this)) {
             mode = children;
-            m_nextChildNodeToConsider = element;
-            m_currentSourceNode = nullptr;
+            m_nextSourceElement = element;
+            m_currentSourceElement = nullptr;
         } else {
             // Otherwise the media element has neither a src attribute nor a source element
             // child: set the networkState to NETWORK_EMPTY, and abort these steps; the
             // synchronous section ends.
             m_loadState = WaitingForSource;
             setShouldDelayLoadEvent(false);
             m_networkState = NETWORK_EMPTY;
 
             WTF_LOG(Media, "HTMLMediaElement::selectMediaResource, nothing to load");
             return;
@@ skipping 695 matching lines @@
     if (renderer())
         renderer()->updateFromElement();
 }
 
 void HTMLMediaElement::noneSupported()
 {
     WTF_LOG(Media, "HTMLMediaElement::noneSupported");
 
     stopPeriodicTimers();
     m_loadState = WaitingForSource;
-    m_currentSourceNode = nullptr;
+    m_currentSourceElement = nullptr;
 
     // 4.8.10.5
     // 6 - Reaching this step indicates that the media resource failed to load or that the given
     // URL could not be resolved. In one atomic operation, run the following steps:
 
     // 6.1 - Set the error attribute to a new MediaError object whose code attribute is set to
     // MEDIA_ERR_SRC_NOT_SUPPORTED.
     m_error = MediaError::create(MediaError::MEDIA_ERR_SRC_NOT_SUPPORTED);
 
     // 6.2 - Forget the media element's media-resource-specific text tracks.
@@ skipping 35 matching lines @@
     // 3 - Queue a task to fire a simple event named error at the media element.
     scheduleEvent(EventTypeNames::error);
 
     // 4 - Set the element's networkState attribute to the NETWORK_IDLE value.
     m_networkState = NETWORK_IDLE;
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
-    m_currentSourceNode = nullptr;
+    m_currentSourceElement = nullptr;
 }
 
 void HTMLMediaElement::cancelPendingEventsAndCallbacks()
 {
     WTF_LOG(Media, "HTMLMediaElement::cancelPendingEventsAndCallbacks");
     m_asyncEventQueue->cancelAllEvents();
 
     for (HTMLSourceElement* source = Traversal<HTMLSourceElement>::firstChild(*this); source; source = Traversal<HTMLSourceElement>::nextSibling(*source))
         source->cancelPendingErrorEvent();
 }
 
 void HTMLMediaElement::mediaPlayerNetworkStateChanged()
 {
     setNetworkState(m_player->networkState());
 }
 
 void HTMLMediaElement::mediaLoadingFailed(MediaPlayer::NetworkState error)
 {
     stopPeriodicTimers();
 
     // If we failed while trying to load a <source> element, the movie was never parsed, and there are more
     // <source> children, schedule the next one
     if (m_readyState < HAVE_METADATA && 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();
+        if (m_currentSourceElement)
+            m_currentSourceElement->scheduleErrorEvent();
         else
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState - 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()) {
             WTF_LOG(Media, "HTMLMediaElement::setNetworkState - scheduling next <source>");
@@ skipping 1182 matching lines @@
         configureTextTrackGroup(otherTracks);
 
     if (hasMediaControls())
         mediaControls()->closedCaptionTracksChanged();
 }
 
 bool HTMLMediaElement::havePotentialSourceChild()
 {
     // Stash the current <source> node and next nodes so we can restore them after checking
     // to see there is another potential.
-    RefPtrWillBeRawPtr<HTMLSourceElement> currentSourceNode = m_currentSourceNode;
-    RefPtrWillBeRawPtr<Node> nextNode = m_nextChildNodeToConsider;
+    RefPtrWillBeRawPtr<HTMLSourceElement> currentSourceElement = m_currentSourceElement;
+    RefPtrWillBeRawPtr<HTMLSourceElement> nextSourceElement = m_nextSourceElement;
 
     KURL nextURL = selectNextSourceChild(0, 0, DoNothing);
 
-    m_currentSourceNode = currentSourceNode;
-    m_nextChildNodeToConsider = nextNode;
+    m_currentSourceElement = currentSourceElement;
+    m_nextSourceElement = nextSourceElement;
 
     return nextURL.isValid();
 }
 
 KURL HTMLMediaElement::selectNextSourceChild(ContentType* contentType, String* keySystem, InvalidURLAction actionIfInvalid)
 {
 #if !LOG_DISABLED
     // Don't log if this was just called to find out if there are any valid <source> elements.
     bool shouldLog = actionIfInvalid != DoNothing;
     if (shouldLog)
         WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild");
 #endif
 
-    if (!m_nextChildNodeToConsider) {
+    if (!m_nextSourceElement) {
 #if !LOG_DISABLED
         if (shouldLog)
             WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild -> 0x0000, \"\"");
 #endif
         return KURL();
     }
 
     KURL mediaURL;
     Node* node;
     HTMLSourceElement* source = 0;
     String type;
     String system;
-    bool lookingForStartNode = m_nextChildNodeToConsider;
+    bool lookingForStartNode = m_nextSourceElement;
     bool canUseSourceElement = false;
 
     NodeVector potentialSourceNodes;
     getChildNodes(*this, potentialSourceNodes);
 
     for (unsigned i = 0; !canUseSourceElement && i < potentialSourceNodes.size(); ++i) {
         node = potentialSourceNodes[i].get();
-        if (lookingForStartNode && m_nextChildNodeToConsider != node)
+        if (lookingForStartNode && m_nextSourceElement != node)
             continue;
         lookingForStartNode = false;
 
         if (!isHTMLSourceElement(*node))
             continue;
         if (node->parentNode() != this)
             continue;
 
         source = toHTMLSourceElement(node);
 
@@ skipping 29 matching lines @@
 check_again:
         if (!canUseSourceElement && actionIfInvalid == Complain && source)
             source->scheduleErrorEvent();
     }
 
     if (canUseSourceElement) {
         if (contentType)
             *contentType = ContentType(type);
         if (keySystem)
             *keySystem = system;
-        m_currentSourceNode = source;
-        m_nextChildNodeToConsider = source->nextSibling();
+        m_currentSourceElement = source;
+        m_nextSourceElement = Traversal<HTMLSourceElement>::nextSibling(*source);
     } else {
-        m_currentSourceNode = nullptr;
-        m_nextChildNodeToConsider = nullptr;
+        m_currentSourceElement = nullptr;
+        m_nextSourceElement = nullptr;
     }
 
 #if !LOG_DISABLED
     if (shouldLog)
-        WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild -> %p, %s", m_currentSourceNode.get(), canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
+        WTF_LOG(Media, "HTMLMediaElement::selectNextSourceChild -> %p, %s", m_currentSourceElement.get(), canUseSourceElement ? urlForLoggingMedia(mediaURL).utf8().data() : "");
 #endif
     return canUseSourceElement ? mediaURL : KURL();
 }
 
 void HTMLMediaElement::sourceWasAdded(HTMLSourceElement* source)
 {
     WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded(%p)", source);
 
 #if !LOG_DISABLED
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
     WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded - 'src' is %s", urlForLoggingMedia(url).utf8().data());
 #endif
 
     // We should only consider a <source> element when there is not src attribute at all.
     if (fastHasAttribute(srcAttr))
         return;
 
     // 4.8.8 - If a source element is inserted as a child of a media element that has no src
     // attribute and whose networkState has the value NETWORK_EMPTY, the user agent must invoke
     // the media element's resource selection algorithm.
     if (networkState() == HTMLMediaElement::NETWORK_EMPTY) {
         scheduleDelayedAction(LoadMediaResource);
-        m_nextChildNodeToConsider = source;
+        m_nextSourceElement = source;
         return;
     }
 
-    if (m_currentSourceNode && source == m_currentSourceNode->nextSibling()) {
+    if (m_currentSourceElement && source == Traversal<HTMLSourceElement>::nextSibling(*m_currentSourceElement)) {
         WTF_LOG(Media, "HTMLMediaElement::sourceWasAdded - <source> inserted immediately after current source");
-        m_nextChildNodeToConsider = source;
+        m_nextSourceElement = source;
         return;
     }
 
-    if (m_nextChildNodeToConsider)
+    if (m_nextSourceElement)
         return;
 
     // 4.8.9.5, resource selection algorithm, source elements section:
     // 21. Wait until the node after pointer is a node other than the end of the list. (This step might wait forever.)
     // 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.
     m_networkState = NETWORK_LOADING;
 
     // 25. Jump back to the find next candidate step above.
-    m_nextChildNodeToConsider = source;
+    m_nextSourceElement = source;
     scheduleNextSourceChild();
 }
 
 void HTMLMediaElement::sourceWasRemoved(HTMLSourceElement* source)
 {
     WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved(%p)", source);
 
 #if !LOG_DISABLED
     KURL url = source->getNonEmptyURLAttribute(srcAttr);
     WTF_LOG(Media, "HTMLMediaElement::sourceWasRemoved - 'src' is %s", urlForLoggingMedia(url).utf8().data());
 #endif
 
-    if (source != m_currentSourceNode && source != m_nextChildNodeToConsider)
+    if (source != m_currentSourceElement && source != m_nextSourceElement)
         return;
 
-    if (source == m_nextChildNodeToConsider) {
-        if (m_currentSourceNode)
-            m_nextChildNodeToConsider = m_currentSourceNode->nextSibling();
-        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_nextChildNodeToConsider set to %p", m_nextChildNodeToConsider.get());
-    } else if (source == m_currentSourceNode) {
-        // Clear the current source node pointer, but don't change the movie as the spec says:
+    if (source == m_nextSourceElement) {
+        if (m_currentSourceElement)
+            m_nextSourceElement = Traversal<HTMLSourceElement>::nextSibling(*m_currentSourceElement);
+        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_nextSourceElement set to %p", m_nextSourceElement.get());
+    } else if (source == m_currentSourceElement) {
+        // Clear the current source element pointer, but don't change the movie as the spec says:
         // 4.8.8 - Dynamically modifying a source element and its attribute when the element is already
         // inserted in a video or audio element will have no effect.
-        m_currentSourceNode = nullptr;
-        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_currentSourceNode set to 0");
+        m_currentSourceElement = nullptr;
+        WTF_LOG(Media, "HTMLMediaElement::sourceRemoved - m_currentSourceElement set to 0");
     }
 }
 
 void HTMLMediaElement::mediaPlayerTimeChanged()
 {
     WTF_LOG(Media, "HTMLMediaElement::mediaPlayerTimeChanged");
 
     updateActiveTextTrackCues(currentTime());
 
     invalidateCachedTime();
@@ skipping 342 matching lines @@
         m_networkState = NETWORK_EMPTY;
         scheduleEvent(EventTypeNames::emptied);
     }
     else
         m_networkState = NETWORK_IDLE;
 
     // 5 - Set the element's delaying-the-load-event flag to false. This stops delaying the load event.
     setShouldDelayLoadEvent(false);
 
     // 6 - Abort the overall resource selection algorithm.
-    m_currentSourceNode = nullptr;
+    m_currentSourceElement = nullptr;
 
     // Reset m_readyState since m_player is gone.
     m_readyState = HAVE_NOTHING;
     updateMediaController();
     updateActiveTextTrackCues(0);
 }
 
 void HTMLMediaElement::clearMediaPlayerAndAudioSourceProviderClientWithoutLocking()
 {
 #if ENABLE(WEB_AUDIO)
@@ skipping 528 matching lines @@
         if (hasMediaControls())
             mediaControls()->mediaElementFocused();
     }
     HTMLElement::defaultEventHandler(event);
 }
 
 void HTMLMediaElement::trace(Visitor* visitor)
 {
     visitor->trace(m_asyncEventQueue);
     visitor->trace(m_error);
-    visitor->trace(m_currentSourceNode);
-    visitor->trace(m_nextChildNodeToConsider);
+    visitor->trace(m_currentSourceElement);
+    visitor->trace(m_nextSourceElement);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
     visitor->trace(m_mediaController);
 #if ENABLE(WEB_AUDIO)
     visitor->registerWeakMembers<HTMLMediaElement, &HTMLMediaElement::clearWeakMembers>(this);
 #endif
     WillBeHeapSupplementable<HTMLMediaElement>::trace(visitor);
     HTMLElement::trace(visitor);
@@ skipping 29 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 void HTMLMediaElement::clearWeakMembers(Visitor* visitor)
 {
     if (!visitor->isAlive(m_audioSourceNode) && audioSourceProvider())
         audioSourceProvider()->setClient(0);
 }
 #endif
 
 }