Implement mapping blink track id to demuxer streams

media/base/media_tracks.cc

Index: media/base/media_tracks.cc
diff --git a/media/base/media_tracks.cc b/media/base/media_tracks.cc
index 367bd01b3878b4a341be6c23966c4b25e76e7e9a..621d052d1e718cddf5064f1ca18697a4f12c2c01 100644
--- a/media/base/media_tracks.cc
+++ b/media/base/media_tracks.cc
@@ -15,30 +15,66 @@ MediaTracks::MediaTracks() {}
 
 MediaTracks::~MediaTracks() {}
 
-void MediaTracks::AddAudioTrack(const AudioDecoderConfig& config,
-                                const std::string& id,
-                                const std::string& kind,
-                                const std::string& label,
-                                const std::string& language) {
+const MediaTrack* MediaTracks::AddAudioTrack(const AudioDecoderConfig& config,
+                                             const std::string& id,

[chcunningham, 2016/06/02 21:24:45]

What are the plans for this "id"? Its a little confusing to call this ID while a
trackID also exists. IIUC, these strings are always things like "audio", "text",
"video"... but I'm guessing that may change if we later enable multi-track? The
core of my question is - can we name these something else, here and in the
various places they're created/passed?

[servolk, 2016/06/02 23:53:11]

How about byteStreamTrackId?
Also, these are typically just numbers for now, so it's "1", "2", "3" instead of
"audio", "video". I've already prepared a separate CL to change the type from
string to StreamParser::TrackId (see
https://codereview.chromium.org/1861963008/). I'll do the renaming there as well
to keep this CL easier to review.

[chcunningham, 2016/06/03 20:42:49]

byteStreamTrackId sounds good

+                                             const std::string& kind,
+                                             const std::string& label,
+                                             const std::string& language) {
   DCHECK(config.IsValidConfig());
   CHECK(audio_configs_.find(id) == audio_configs_.end());
   std::unique_ptr<MediaTrack> track = base::WrapUnique(
       new MediaTrack(MediaTrack::Audio, id, kind, label, language));
   tracks_.push_back(std::move(track));
   audio_configs_[id] = config;
+  return tracks_.back().get();
 }
 
-void MediaTracks::AddVideoTrack(const VideoDecoderConfig& config,
-                                const std::string& id,
-                                const std::string& kind,
-                                const std::string& label,
-                                const std::string& language) {
+const MediaTrack* MediaTracks::AddVideoTrack(const VideoDecoderConfig& config,
+                                             const std::string& id,
+                                             const std::string& kind,
+                                             const std::string& label,
+                                             const std::string& language) {
   DCHECK(config.IsValidConfig());
   CHECK(video_configs_.find(id) == video_configs_.end());
   std::unique_ptr<MediaTrack> track = base::WrapUnique(
       new MediaTrack(MediaTrack::Video, id, kind, label, language));
   tracks_.push_back(std::move(track));
   video_configs_[id] = config;
+  return tracks_.back().get();
+}
+
+void MediaTracks::SetDemuxerStreamForMediaTrack(const MediaTrack* track,
+                                                const DemuxerStream* stream) {
+  DCHECK(track_to_demux_stream_map_.find(track) ==

[chcunningham, 2016/06/02 21:24:45]

How are you deciding when to DCHECK vs CHECK? Both of the new methods here mix
DCHECK and CHECK

[servolk, 2016/06/02 23:53:11]

In this case dcheck are for things that might indicate issues but might be
costly and unnecessary in release builds, whereas checks are used to protect us
from e.g. invalid memory accesses.

[chcunningham, 2016/06/03 20:42:49]

Acknowledged.

+         track_to_demux_stream_map_.end());
+
+  bool track_found = false;
+  for (const auto& t : tracks_) {
+    if (t.get() == track) {
+      track_found = true;
+      break;
+    }
+  }
+  CHECK(track_found);
+
+  track_to_demux_stream_map_[track] = stream;
+}
+
+MediaTracks::TrackIdToDemuxStreamMap MediaTracks::OnTrackIdsAssigned(
+    const std::vector<unsigned>& track_ids) const {
+  TrackIdToDemuxStreamMap result;
+  CHECK_EQ(tracks().size(), track_ids.size());
+  CHECK_EQ(track_to_demux_stream_map_.size(), tracks().size());
+  for (size_t i = 0; i < track_ids.size(); ++i) {
+    const MediaTrack* track = tracks()[i].get();
+    DCHECK(track);
+    const auto& it = track_to_demux_stream_map_.find(track);
+    CHECK(it != track_to_demux_stream_map_.end());
+    DVLOG(3) << "OnTrackIdsAssigned track_id=" << track_ids[i]
+             << " DemuxerStream=" << it->second;
+    result[track_ids[i]] = it->second;
+  }
+  return result;
 }
 
 const AudioDecoderConfig& MediaTracks::getAudioConfig(