Do not use a persistent reference to store srcObject in HTMLMediaElement.

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 61 matching lines @@
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/Logging.h"
 #include "platform/MIMETypeFromURL.h"
 #include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioSourceProviderClient.h"
 #include "platform/graphics/GraphicsLayer.h"
+#include "platform/mediastream/MediaStreamDescriptor.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioSourceProvider.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebInbandTextTrack.h"
+#include "public/platform/WebMediaPlayerSource.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackClient.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackState.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/CString.h"
 #include <limits>
 
 #ifndef LOG_MEDIA_EVENTS
 // Default to not logging events because so many are generated they can overwhelm the rest of
@@ skipping 459 matching lines @@
     return new LayoutMedia(this);
 }
 
 Node::InsertionNotificationRequest HTMLMediaElement::insertedInto(ContainerNode* insertionPoint)
 {
     WTF_LOG(Media, "HTMLMediaElement::insertedInto(%p, %p)", this, insertionPoint);
 
     HTMLElement::insertedInto(insertionPoint);
     if (insertionPoint->inShadowIncludingDocument()) {
         UseCounter::count(document(), UseCounter::HTMLMediaElementInDocument);
-        if ((!getAttribute(srcAttr).isEmpty() || m_srcObject.isMediaProviderObject()) && m_networkState == NETWORK_EMPTY) {
+        if ((!getAttribute(srcAttr).isEmpty() || m_srcObject) && m_networkState == NETWORK_EMPTY) {
             m_ignorePreloadNone = false;
             invokeLoadAlgorithm();
         }
     }
 
     return InsertionShouldCallDidNotifySubtreeInsertions;
 }
 
 void HTMLMediaElement::didNotifySubtreeInsertionsToDocument()
 {
@@ skipping 74 matching lines @@
 MediaError* HTMLMediaElement::error() const
 {
     return m_error;
 }
 
 void HTMLMediaElement::setSrc(const AtomicString& url)
 {
     setAttribute(srcAttr, url);
 }
 
-void HTMLMediaElement::setSrcObject(const WebMediaPlayerSource& srcObject)
+void HTMLMediaElement::setSrcObject(MediaStreamDescriptor* srcObject)
 {
-    // srcObject can be a media-provider object or null.
-    ASSERT(!srcObject.isURL());
-
-    // The srcObject IDL attribute, on setting, must set the element's assigned
-    // media provider object to the new value, and then invoke the element's
-    // media element load algorithm.
     m_srcObject = srcObject;
     invokeLoadAlgorithm();
 }
 
 HTMLMediaElement::NetworkState HTMLMediaElement::getNetworkState() const
 {
     return m_networkState;
 }
 
 String HTMLMediaElement::canPlayType(const String& mimeType) const
@@ skipping 167 matching lines @@
 
 void HTMLMediaElement::selectMediaResource()
 {
     WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p)", this);
 
     enum Mode { Object, Attribute, Children, Nothing };
     Mode mode = Nothing;
 
     // 6 - If the media element has an assigned media provider object, then let
     //     mode be object.
-    if (m_srcObject.isMediaProviderObject()) {
+    if (m_srcObject) {
         mode = Object;
     } else if (fastHasAttribute(srcAttr)) {
         // Otherwise, if the media element has no assigned media provider object
         // but has a src attribute, then let mode be attribute.
         mode = Attribute;
     } else if (HTMLSourceElement* element = Traversal<HTMLSourceElement>::firstChild(*this)) {
         // Otherwise, if the media element does not have an assigned media
         // provider object and does not have a src attribute, but does have a
         // source element child, then let mode be children and let candidate be
         // the first such source element child in tree order.
@@ skipping 34 matching lines @@
         loadNextSourceChild();
         WTF_LOG(Media, "HTMLMediaElement::selectMediaResource(%p), using source element", this);
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 void HTMLMediaElement::loadSourceFromObject()
 {
-    ASSERT(m_srcObject.isMediaProviderObject());
+    ASSERT(m_srcObject);
     m_loadState = LoadingFromSrcObject;
 
     // No type is available when the resource comes from the 'srcObject'
     // attribute.
     ContentType contentType((String()));
-    loadResource(m_srcObject, contentType);
+    loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), contentType);
 }
 
 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);
@@ skipping 67 matching lines @@
     setPlayerPreload();
 
     if (fastHasAttribute(mutedAttr))
         m_muted = true;
     updateVolume();
 
     ASSERT(!m_mediaSource);
 
     bool attemptLoad = true;
 
-    bool isObjectOrBlobURL = source.isMediaProviderObject() || url.protocolIs(mediaSourceBlobProtocol);
-    if (isObjectOrBlobURL) {
+    if (source.isMediaStream() || url.protocolIs(mediaSourceBlobProtocol)) {
         bool isMediaStream = source.isMediaStream() || (source.isURL() && isMediaStreamURL(url.getString()));
         if (isMediaStream) {
             m_autoplayHelper->removeUserGestureRequirement(GesturelessPlaybackEnabledByStream);
         } else {
             m_mediaSource = HTMLMediaSource::lookup(url.getString());
 
             if (m_mediaSource) {
                 if (!m_mediaSource->attachToElement(this)) {
                     // Forget our reference to the MediaSource, so we leave it alone
                     // while processing remainder of load failure.
                     m_mediaSource = nullptr;
                     attemptLoad = false;
                 }
             }
         }
     }
 
-    bool canLoadResource = source.isMediaProviderObject() || canLoadURL(url, contentType);
+    bool canLoadResource = source.isMediaStream() || canLoadURL(url, contentType);
     if (attemptLoad && canLoadResource) {
         ASSERT(!webMediaPlayer());
 
         if (effectivePreloadType() == WebMediaPlayer::PreloadNone) {
             WTF_LOG(Media, "HTMLMediaElement::loadResource(%p) : Delaying load because preload == 'none'", this);
             deferLoad();
         } else {
             startPlayerLoad();
         }
     } 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()
 {
     ASSERT(!m_webMediaPlayer);
 
     WebMediaPlayerSource source;
-    if (m_srcObject.isMediaProviderObject()) {
-        source = m_srcObject;
+    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
@@ skipping 121 matching lines @@
     }
     ASSERT(m_deferredLoadState == WaitingForStopDelayingLoadEventTask);
     m_deferredLoadState = WaitingForTrigger;
 }
 
 WebMediaPlayer::LoadType HTMLMediaElement::loadType() const
 {
     if (m_mediaSource)
         return WebMediaPlayer::LoadTypeMediaSource;
 
-    if (m_srcObject.isMediaStream() || isMediaStreamURL(m_currentSrc.getString()))
+    if (m_srcObject || isMediaStreamURL(m_currentSrc.getString()))
         return WebMediaPlayer::LoadTypeMediaStream;
 
     return WebMediaPlayer::LoadTypeURL;
 }
 
 bool HTMLMediaElement::textTracksAreReady() const
 {
     // 4.8.10.12.1 Text track model
     // ...
     // The text tracks of a media element are ready if all the text tracks whose mode was not
@@ skipping 2409 matching lines @@
     visitor->trace(m_mediaSource);
     visitor->trace(m_audioTracks);
     visitor->trace(m_videoTracks);
     visitor->trace(m_cueTimeline);
     visitor->trace(m_textTracks);
     visitor->trace(m_textTracksWhenResourceSelectionBegan);
     visitor->trace(m_playResolvers);
     visitor->trace(m_audioSourceProvider);
     visitor->trace(m_autoplayHelperClient);
     visitor->trace(m_autoplayHelper);
+    visitor->trace(m_srcObject);
     visitor->template registerWeakMembers<HTMLMediaElement, &HTMLMediaElement::clearWeakMembers>(this);
     Supplementable<HTMLMediaElement>::trace(visitor);
     HTMLElement::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 void HTMLMediaElement::createPlaceholderTracksIfNecessary()
 {
     if (!RuntimeEnabledFeatures::audioVideoTracksEnabled())
         return;
@@ skipping 225 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect() const
 {
     IntRect result;
     if (LayoutObject* object = m_element->layoutObject())
         result = object->absoluteBoundingBoxRect();
     return result;
 }
 
 } // namespace blink