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 90 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 setSrcObjectURL(const AtomicString&);

[philipj_slow, 2016/03/21 11:13:13]

Rather than using an object URL, can you look into something like
Source/platform/MediaProvider which wraps the MediaStream (and later other
types), with the isMediaStream()/getAsMediaStream() pattern that generated union
types have?

This class (maybe it has to be public/platform/WebMediaProvider) would be used
by FrameLoaderClientImpl::createWebMediaPlayer or
RenderFrameImpl::createMediaPlayer to create a WebMediaPlayerMS instance for the
MediaStream object.

[Guido Urdaneta, 2016/03/21 16:34:53]

Source/platform and public/platform cannot access MediaStream due to dependency
restrictions. Fortunately, this dependency problem has already been solved for
MediaStreams with the MediaStreamDescriptor class in Source/platform.

The main difficulty I see of not using the URL is that all the code from
HTMLMediaElement to the creation of the WebMediaPlayer uses the URL, and it's in
the lowest layer where the MediaStreamDescriptor is obtained from the URL.

I think we would need alternative non-URL versions of at least
HTMLMediaElement::loadResource(), HTMLMediaElement::startPlayerLoad(),
FrameLoaderClientImpl::createWebMediaPlayer(), and
RenderFrameImpl::createMediaPlayer(). At first sight, it looks like a lot of
work. Of course, I'm not familiar with HTMLMediaElement code, so maybe there is
a way to do it without duplicating much code.

[philipj_slow, 2016/03/22 16:06:54]

Just judging by include rules, maybe public/web/WebMediaProvider.h +
Source/web/WebMediaProvider.cpp would work?

As for HTMLMediaElement processing, the nicest thing would be an entry point
that matches
https://html.spec.whatwg.org/multipage/embedded-content.html#concept-media-lo...
so that one can be confident that the implementation matches the spec. One idea
would be to let the WebMediaProvider represent both URLs and all kinds of
srcObjects and to use that throughout. Do you think that could work?

[Guido Urdaneta, 2016/03/24 14:38:44]

I went for the URL+srcObject approach. I called the class
public/platform/WebMediaElementSource. I did not use WebMediaProvider since the
spec uses that term for the non-URL case. I'm open to naming suggestions though
:)

I couldn't exactly match
https://html.spec.whatwg.org/multipage/embedded-content.html#concept-media-lo...
 because that logic seems to be split across HTMLMediaElement and the various
WebMediaPlayers. Intead, I left the current loading logic practically
unmodified. Just ignoring URL checks when it's an srcObject.

Please let me know what you think.

 
     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 227 matching lines @@
     // loading
     void invokeLoadAlgorithm();
     void invokeResourceSelectionAlgorithm();
     void loadInternal();
     void selectMediaResource();
     void loadResource(const KURL&, ContentType&);
     void startPlayerLoad();
     void setPlayerPreload();
     WebMediaPlayer::LoadType loadType() const;
     void scheduleNextSourceChild();
+    void loadSourceFromObject();
+    void loadSourceFromAttribute();
+    void loadSourceFromURL(const AtomicString&);
     void loadNextSourceChild();
     void clearMediaPlayer();
     void clearMediaPlayerAndAudioSourceProviderClientWithoutLocking();
     bool havePotentialSourceChild();
     void noneSupported();
     void mediaEngineError(MediaError*);
     void cancelPendingEventsAndCallbacks();
     void waitForSourceChange();
     void setIgnorePreloadNone();
 
@@ skipping 124 matching lines @@
     // 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;
     RefPtrWillBeMember<HTMLSourceElement> m_currentSourceNode;
     RefPtrWillBeMember<Node> m_nextChildNodeToConsider;
+    AtomicString m_srcObjectURL;
 
     // "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).
         WaitingForStopDelayingLoadEventTask,
         // The load is the deferred, and waiting for a triggering event.
         WaitingForTrigger,
@@ skipping 128 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