Pass MSE media track info from ChunkDemuxer to blink::SourceBuffer

third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp

Index: third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp
diff --git a/third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp b/third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp
index 682550449bb7708ca8eb850f96f0aac07c50a1cd..2fa35646b2d85e978b8d00c90306c75a62c097f0 100644
--- a/third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp
+++ b/third_party/WebKit/Source/modules/mediasource/SourceBuffer.cpp
@@ -42,6 +42,11 @@
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/MediaError.h"
 #include "core/html/TimeRanges.h"
+#include "core/html/track/AudioTrack.h"
+#include "core/html/track/AudioTrackList.h"
+#include "core/html/track/TextTrack.h"
+#include "core/html/track/VideoTrack.h"
+#include "core/html/track/VideoTrackList.h"
 #include "core/streams/Stream.h"
 #include "modules/mediasource/MediaSource.h"
 #include "platform/Logging.h"
@@ -470,11 +475,13 @@ void SourceBuffer::removedFromMediaSource()
     m_asyncEventQueue = nullptr;
 }
 
-void SourceBuffer::initializationSegmentReceived()
+void SourceBuffer::initializationSegmentReceived(const WebVector<WebMediaPlayer::TrackId>& newTracks)
 {
-    WTF_LOG(Media, "SourceBuffer::initializationSegmentReceived %p", this);
+    WTF_LOG(Media, "SourceBuffer::initializationSegmentReceived %p tracks=%zu", this, newTracks.size());
     ASSERT(m_source);
+    ASSERT(m_source->mediaElement());
     ASSERT(m_updating);
+    ASSERT(newTracks.size() == m_pendingTracks.size());
 
     // https://dvcs.w3.org/hg/html-media/raw-file/tip/media-source/media-source.html#sourcebuffer-init-segment-received
     // FIXME: Make steps 1-7 synchronous with this call.
@@ -492,6 +499,61 @@ void SourceBuffer::initializationSegmentReceived()
         // 6. Set first initialization segment received flag to true.
         m_firstInitializationSegmentReceived = true;
     }
+
+    // TODO(servolk): Implement proper MSE init segment received algorithm.
+    if (!RuntimeEnabledFeatures::audioVideoTracksEnabled()) {
+        m_pendingTracks.clear();
+        return;
+    }
+
+    for (const auto& trackId : m_audioTrackIds) {
+        m_source->mediaElement()->audioTracks().remove(trackId);
+    }
+    for (const auto& trackId : m_videoTrackIds) {
+        m_source->mediaElement()->videoTracks().remove(trackId);
+    }
+    m_audioTrackIds.clear();
+    m_videoTrackIds.clear();
+
+    for (const auto& trackId : newTracks) {
+        for (const auto& track : m_pendingTracks) {

[wolenetz, 2016/03/23 19:34:13]

Good enough for now, but I suggest that a map might be a better structure. This
lookup is n^2 vs n with map. Alternatively, if we *don't* need the blink
TrackIDs in Chromium websourcebufferimpl, then why not just say "process all
pending, in the order they were added since last execution of init segment
received algorithm?"

[servolk, 2016/03/24 01:31:56]

I agree, but for now we support only 2 media tracks max (max 1 video and 1
audio), so I'm not too concerned about perf here. This is going to change when
we implement MSE spec-compliant 'init segment received' algorithm and make the
necessary changes to support multiple audio and/or video tracks. This is good
enough for now to ensure we don't break tests and existing functionality.

[wolenetz, 2016/03/24 01:54:07]

Acknowledged.

+            if (track->trackId() == trackId) {
+                if (track->type() == WebMediaPlayer::AudioTrack) {
+                    AudioTrack* audioTrack = static_cast<AudioTrack*>(track.get());
+                    WTF_LOG(Media, "Tracks (sb=%p): adding audioTrack %p trackId=%d id=%s label=%s lang=%s", this, audioTrack, audioTrack->trackId(), audioTrack->id().utf8().data(), audioTrack->label().utf8().data(), audioTrack->language().utf8().data());
+                    m_source->mediaElement()->audioTracks().add(audioTrack);
+                    m_audioTrackIds.append(trackId);
+                } else if (track->type() == WebMediaPlayer::VideoTrack) {
+                    VideoTrack* videoTrack = static_cast<VideoTrack*>(track.get());
+                    WTF_LOG(Media, "Tracks (sb=%p): adding videoTrack %p trackId=%d id=%s label=%s lang=%s", this, videoTrack, videoTrack->trackId(), videoTrack->id().utf8().data(), videoTrack->label().utf8().data(), videoTrack->language().utf8().data());
+                    m_source->mediaElement()->videoTracks().add(videoTrack);
+                    m_videoTrackIds.append(trackId);
+                }
+                break;
+            }
+        }
+    }
+    m_pendingTracks.clear();
+}
+
+WebMediaPlayer::TrackId SourceBuffer::createMediaTrack(WebMediaPlayer::TrackType type, WebString id, WebString kind, WebString label, WebString language)
+{
+    TrackBase* result = nullptr;
+    switch (type) {
+    case WebMediaPlayer::AudioTrack:
+        result = AudioTrack::create(id, kind, label, language, false);
+        break;
+    case WebMediaPlayer::TextTrack:
+        result = TextTrack::create(kind, label, language);
+        break;
+    case WebMediaPlayer::VideoTrack:
+        result = VideoTrack::create(id, kind, label, language, false);
+        break;
+    }
+
+    ASSERT(result);
+    m_pendingTracks.append(result);
+    return result->trackId();
 }
 
 bool SourceBuffer::hasPendingActivity() const
@@ -872,6 +934,9 @@ DEFINE_TRACE(SourceBuffer)
     visitor->trace(m_removeAsyncPartRunner);
     visitor->trace(m_appendStreamAsyncPartRunner);
     visitor->trace(m_stream);
+    visitor->trace(m_pendingTracks);
+    visitor->trace(m_audioTrackIds);
+    visitor->trace(m_videoTrackIds);
     RefCountedGarbageCollectedEventTargetWithInlineData<SourceBuffer>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }