When HLS redirects are encountered recreate WebMediaPlayer.

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 926 matching lines @@
     }
 }
 
 void HTMLMediaElement::loadSourceFromObject()
 {
     DCHECK(m_srcObject);
     m_loadState = LoadingFromSrcObject;
 
     // No type is available when the resource comes from the 'srcObject'
     // attribute.
-    ContentType contentType((String()));
-    loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), contentType);
+    loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), ContentType((String())));
 }
 
 void HTMLMediaElement::loadSourceFromAttribute()
 {
     m_loadState = LoadingFromSrcAttr;
     const AtomicString& srcValue = fastGetAttribute(srcAttr);
 
     // If the src attribute's value is the empty string ... jump down to the failed step below
     if (srcValue.isEmpty()) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         MEDIA_LOG << "selectMediaResource(" << (void*)this << "), empty 'src'";
         return;
     }
 
     KURL mediaURL = document().completeURL(srcValue);
     if (!isSafeToLoadURL(mediaURL, Complain)) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // No type is available when the url comes from the 'src' attribute so
     // MediaPlayer will have to pick a media engine based on the file extension.
-    ContentType contentType((String()));
-    loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
+    loadResource(WebMediaPlayerSource(WebURL(mediaURL)), ContentType((String())));
 }
 
 void HTMLMediaElement::loadNextSourceChild()
 {
     ContentType contentType((String()));
     KURL mediaURL = selectNextSourceChild(&contentType, Complain);
     if (!mediaURL.isValid()) {
         waitForSourceChange();
         return;
     }
 
     // Reset the MediaPlayer and MediaSource if any
     resetMediaPlayerAndMediaSource();
 
     m_loadState = LoadingFromSourceElement;
     loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
-void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, ContentType& contentType)
+void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source, const ContentType& contentType, const KURL& playerProvidedUrl)
 {
     DCHECK(isMainThread());
     KURL url;
     if (source.isURL()) {
-        url = source.getAsURL();
+        url = playerProvidedUrl.isNull() ? KURL(source.getAsURL()) : playerProvidedUrl;
         DCHECK(isSafeToLoadURL(url, Complain));
         MEDIA_LOG << "loadResource(" << (void*)this << ", " << urlForLoggingMedia(url) << ", " << contentType.raw() << ")";
     }
 
     LocalFrame* frame = document().frame();
     if (!frame) {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
         return;
     }
 
     // The resource fetch algorithm
     setNetworkState(NETWORK_LOADING);
 
     m_autoplayHelper->loadingStarted();
 
-    // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
-    // cache is an internal detail not exposed through the media element API.
-    m_currentSrc = url;
+    // Do not update the element visible source when using a player provided URL, this may reveal
+    // redirect origin information to the page.
+    if (playerProvidedUrl.isNull()) {
+        // Set m_currentSrc *before* changing to the cache url, the fact that we are loading from the app
+        // cache is an internal detail not exposed through the media element API.
+        m_currentSrc = url;
 
-    if (m_audioSourceNode)
-        m_audioSourceNode->onCurrentSrcChanged(m_currentSrc);
+        if (m_audioSourceNode)
+            m_audioSourceNode->onCurrentSrcChanged(m_currentSrc);
+    }
 
     MEDIA_LOG << "loadResource(" << (void*)this << ") - m_currentSrc -> " << urlForLoggingMedia(m_currentSrc);
 
     startProgressEventTimer();
 
     // Reset display mode to force a recalculation of what to show because we are resetting the player.
     setDisplayMode(Unknown);
 
     setPlayerPreload();
 
@@ skipping 28 matching lines @@
     if (attemptLoad && canLoadResource) {
         DCHECK(!webMediaPlayer());
 
         // Conditionally defer the load if effective preload is 'none'.
         // Skip this optional deferral for MediaStream sources or any blob URL,
         // including MediaSource blob URLs.
         if (!isStreamOrBlobUrl && effectivePreloadType() == WebMediaPlayer::PreloadNone) {
             MEDIA_LOG << "loadResource(" << (void*)this << ") : Delaying load because preload == 'none'";
             deferLoad();
         } else {
-            startPlayerLoad();
+            startPlayerLoad(playerProvidedUrl);

[foolip, 2016/06/23 11:22:36]

If preload=none, then I think you'll have taken the deferLoad() path above and
the playerProviderUrl will be lost.

I've looked through loadResource to see which steps we really want to run again
and not, and I think that it's actually very little.

An isSafeToLoadURL check should be done again I think, but currently isn't. Or
how does that currently work with redirects, is there something in WMPI that
check redirect URLs in a similar way?

I think that startProgressEventTimer shouldn't be necessary, at least I can't
see what would stop the timer in HTMLMediaElement::requestReload.

And for the rest, I think none of it is needed.

So, could you try to have requestReload call directly into startPlayerLoad with
the new URL, with just a isSafeToLoadURL check first?

[DaleCurtis, 2016/06/23 18:55:56]

This seems to work fine. Done.

         }
     } else {
         mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     }
 
     // If there is no poster to display, allow the media engine to render video frames as soon as
     // they are available.
     updateDisplayState();
 
     if (layoutObject())
         layoutObject()->updateFromElement();
 }
 
-void HTMLMediaElement::startPlayerLoad()
+void HTMLMediaElement::startPlayerLoad(const KURL& playerProvidedUrl)
 {
     DCHECK(!m_webMediaPlayer);
 
     WebMediaPlayerSource source;
     if (m_srcObject) {
         source = WebMediaPlayerSource(WebMediaStream(m_srcObject));
     } else {
         // Filter out user:pass as those two URL components aren't
         // considered for media resource fetches (including for the CORS
         // use-credentials mode.) That behavior aligns with Gecko, with IE
         // being more restrictive and not allowing fetches to such URLs.
         //
         // Spec reference: http://whatwg.org/c/#concept-media-load-resource
         //
         // FIXME: when the HTML spec switches to specifying resource
         // fetches in terms of Fetch (http://fetch.spec.whatwg.org), and
         // along with that potentially also specifying a setting for its
         // 'authentication flag' to control how user:pass embedded in a
         // media resource URL should be treated, then update the handling
         // here to match.
-        KURL requestURL = m_currentSrc;
+        KURL requestURL = playerProvidedUrl.isNull() ? KURL(m_currentSrc) : playerProvidedUrl;
         if (!requestURL.user().isEmpty())
             requestURL.setUser(String());
         if (!requestURL.pass().isEmpty())
             requestURL.setPass(String());
 
         KURL kurl(ParsedURLString, requestURL);
         source = WebMediaPlayerSource(WebURL(kurl));
     }
 
     LocalFrame* frame = document().frame();
@@ skipping 1880 matching lines @@
     if (remotePlaybackClient())
         remotePlaybackClient()->stateChanged(WebRemotePlaybackState::Disconnected);
 }
 
 void HTMLMediaElement::cancelledRemotePlaybackRequest()
 {
     if (remotePlaybackClient())
         remotePlaybackClient()->connectCancelled();
 }
 
+void HTMLMediaElement::requestReload(const WebURL& newUrl)
+{
+    DCHECK(webMediaPlayer());
+    DCHECK(!m_srcObject);
+    resetMediaPlayerAndMediaSource();
+    loadResource(WebMediaPlayerSource(newUrl), ContentType((String())));
+}
+
 // MediaPlayerPresentation methods
 void HTMLMediaElement::repaint()
 {
     if (m_webLayer)
         m_webLayer->invalidate();
 
     updateDisplayState();
     if (layoutObject())
         layoutObject()->setShouldDoFullPaintInvalidation();
 }
@@ skipping 1002 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink