MediaCaptureFromElement: add captureStreamUntilEnded() and LayoutTest

third_party/WebKit/Source/modules/mediacapturefromelement/HTMLMediaElementCapture.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/mediacapturefromelement/HTMLMediaElementCapture.h"
 
 #include "core/dom/ExceptionCode.h"
+#include "core/events/EventListener.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/track/AudioTrackList.h"
 #include "core/html/track/VideoTrackList.h"
 #include "modules/encryptedmedia/HTMLMediaElementEncryptedMedia.h"
 #include "modules/encryptedmedia/MediaKeys.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/mediastream/MediaStreamRegistry.h"
 #include "platform/mediastream/MediaStreamCenter.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/WebMediaStreamTrack.h"
 
 namespace blink {
 
+namespace {
+
+// EventListener class to catch the HTMLMediaElement onEnded event and terminate
+// the MediaStream passed on construction.
+class HTMLMediaElementOnEndedEventListener : public EventListener {

[haraken, 2016/06/29 00:46:59]

It looks strange that you have to subclass the EventListener class.

Can we instead override EventTarget::dispatchEventInternal and call
m_stream->streamEnded()?

[foolip, 2016/06/29 10:31:04]

If this is all that this API does, do we really need it on the web platform?
Can't the web app itself simply listen for the event, call stop() on all
MediaStreamTracks and then stop using the MediaStream, letting it be GC'd?

+public:
+    static HTMLMediaElementOnEndedEventListener* create(MediaStream* stream)
+    {
+        return new HTMLMediaElementOnEndedEventListener(stream);
+    }
+
+    bool operator==(const EventListener& other) const override
+    {
+        return this == &other;
+    }
+
+    void handleEvent(ExecutionContext*, Event* event) override
+    {
+        DCHECK_EQ(EventTypeNames::ended, event->type());
+        if (m_stream)
+            m_stream->streamEnded();

[foolip, 2016/06/29 10:31:04]

I think that creating an ended event with scripts and dispatching it would reach
this code path?

It also looks like this doesn't cover the "After playback has ended, changes to
the media element — such as seeking, restarting playback or changing the source
media — do not result in changes to the captured MediaStream." bit in the spec,
because it's possible for streamEnded() to be called internally for a
MediaStream from captureStream() if all the tracks end, and then they'd look
identical? There's no extra state to say that one should get new tracks and the
other not, right?

+    }
+
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_stream);
+        EventListener::trace(visitor);
+    }
+
+private:
+    explicit HTMLMediaElementOnEndedEventListener(MediaStream* stream)
+        : EventListener(CPPEventListenerType)
+        , m_stream(stream)
+    {
+    }
+
+    WeakMember<MediaStream> m_stream;
+};
+
+} // anonymous namespace
+
 // static
 MediaStream* HTMLMediaElementCapture::captureStream(HTMLMediaElement& element, ExceptionState& exceptionState)
 {
     if (element.currentSrc().isNull()) {
         exceptionState.throwDOMException(NotSupportedError, "The media element must have a source.");
         return nullptr;
     }
 
     // Avoid capturing from EME-protected Media Elements.
     if (HTMLMediaElementEncryptedMedia::mediaKeys(element)) {
@@ skipping 11 matching lines @@
     webStream.initialize(WebVector<WebMediaStreamTrack>(), WebVector<WebMediaStreamTrack>());
     MediaStreamCenter::instance().didCreateMediaStream(webStream);
 
     if (element.hasVideo())
         Platform::current()->createHTMLVideoElementCapturer(&webStream, element.webMediaPlayer());
     if (element.hasAudio())
         Platform::current()->createHTMLAudioElementCapturer(&webStream, element.webMediaPlayer());
     return MediaStream::create(element.getExecutionContext(), webStream);
 }
 
+// static
+MediaStream* HTMLMediaElementCapture::captureStreamUntilEnded(HTMLMediaElement& element, ExceptionState& exceptionState)
+{
+    MediaStream* stream = captureStream(element, exceptionState);
+
+    element.addEventListener(EventTypeNames::ended, HTMLMediaElementOnEndedEventListener::create(stream), false);
+
+    return stream;
+}
+
+
 } // namespace blink