Add srcObject attribute of type MediaStream to HTMLMediaElement.

third_party/WebKit/Source/core/html/HTMLMediaElement.h

 /*
  * 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 21 matching lines @@
 #include "core/dom/ActiveDOMObject.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/events/GenericEventQueue.h"
 #include "core/html/AutoplayExperimentHelper.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/track/TextTrack.h"
 #include "platform/Supplementable.h"
 #include "platform/audio/AudioSourceProvider.h"
 #include "public/platform/WebAudioSourceProviderClient.h"
 #include "public/platform/WebMediaPlayerClient.h"
+#include "public/platform/WebMediaPlayerSource.h"
 #include "public/platform/WebMimeRegistry.h"
 
 #if !ENABLE(OILPAN)
 #include "wtf/WeakPtr.h"
 #endif
 
 namespace blink {
 
 class AudioSourceProviderClient;
 class AudioTrackList;
@@ skipping 55 matching lines @@
 
     bool hasRemoteRoutes() const { return m_remoteRoutesAvailable; }
     bool isPlayingRemotely() const { return m_playingRemotely; }
 
     // error state
     MediaError* error() const;
 
     // network state
     void setSrc(const AtomicString&);
     const KURL& currentSrc() const { return m_currentSrc; }
+    void setSrcObject(const WebMediaPlayerSource&);
+    const WebMediaPlayerSource& getSrcObject() const { return m_srcObject; }
 
     enum NetworkState { NETWORK_EMPTY, NETWORK_IDLE, NETWORK_LOADING, NETWORK_NO_SOURCE };
     NetworkState getNetworkState() const;
 
     String preload() const;
     void setPreload(const AtomicString&);
     WebMediaPlayer::Preload preloadType() const;
     String effectivePreload() const;
     WebMediaPlayer::Preload effectivePreloadType() const;
 
@@ skipping 232 matching lines @@
     void checkIfSeekNeeded();
     void addPlayedRange(double start, double end);
 
     void scheduleEvent(const AtomicString& eventName); // FIXME: Rename to scheduleNamedEvent for clarity.
 
     // loading
     void invokeLoadAlgorithm();
     void invokeResourceSelectionAlgorithm();
     void loadInternal();
     void selectMediaResource();
-    void loadResource(const KURL&, ContentType&);
+    void loadResource(const WebMediaPlayerSource&, ContentType&);
     void startPlayerLoad();
     void setPlayerPreload();
     WebMediaPlayer::LoadType loadType() const;
     void scheduleNextSourceChild();
+    void loadSourceFromObject();
+    void loadSourceFromAttribute();
     void loadNextSourceChild();
     void clearMediaPlayer();
     void clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     bool havePotentialSourceChild();
     void noneSupported();
     void mediaEngineError(MediaError*);
     void cancelPendingEventsAndCallbacks();
     void waitForSourceChange();
     void setIgnorePreloadNone();
 
@@ skipping 96 matching lines @@
     UnthrottledTimer<HTMLMediaElement> m_audioTracksTimer;
     Member<TimeRanges> m_playedTimeRanges;
     Member<GenericEventQueue> m_asyncEventQueue;
 
     double m_playbackRate;
     double m_defaultPlaybackRate;
     NetworkState m_networkState;
     ReadyState m_readyState;
     ReadyState m_readyStateMaximum;
     KURL m_currentSrc;
+    WebMediaPlayerSource m_srcObject;

[sof, 2016/04/12 18:40:22]

This value object contains a WebMediaStream, which in turn contains a
WebPrivatePtr<MediaStreamDescriptor> (a persistent) -- have this been verified
not to hold on to too much? i.e., that there isn't a cycle back to
HTMLMediaElement somehow via that WebPrivatePtr<>.

[Guido Urdaneta, 2016/04/12 21:38:55]

I don't think there are any cycles, but I will replace the persistent reference
in an upcoming CL to avoid future problems.

 
     Member<MediaError> m_error;
 
     double m_volume;
     double m_lastSeekTime;
 
     double m_previousProgressTime;
 
     // Cached duration to suppress duplicate events if duration unchanged.
     double m_duration;
 
     // The last time a timeupdate event was sent (wall clock).
     double m_lastTimeUpdateEventWallTime;
 
     // The last time a timeupdate event was sent in movie time.
     double m_lastTimeUpdateEventMovieTime;
 
     // The default playback start position.
     double m_defaultPlaybackStartPosition;
 
     // Loading state.
-    enum LoadState { WaitingForSource, LoadingFromSrcAttr, LoadingFromSourceElement };
+    enum LoadState { WaitingForSource, LoadingFromSrcObject, LoadingFromSrcAttr, LoadingFromSourceElement };
     LoadState m_loadState;
     Member<HTMLSourceElement> m_currentSourceNode;
     Member<Node> m_nextChildNodeToConsider;
 
     // "Deferred loading" state (for preload=none).
     enum DeferredLoadState {
         // The load is not deferred.
         NotDeferred,
         // The load is deferred, and waiting for the task to set the
         // delaying-the-load-event flag (to false).
@@ skipping 138 matching lines @@
 inline bool isHTMLMediaElement(const HTMLElement& element)
 {
     return isHTMLAudioElement(element) || isHTMLVideoElement(element);
 }
 
 DEFINE_HTMLELEMENT_TYPE_CASTS_WITH_FUNCTION(HTMLMediaElement);
 
 } // namespace blink
 
 #endif // HTMLMediaElement_h