Support multiple media tracks in MSE / ChunkDemuxer

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 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 "media/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 107 matching lines @@
   }
 }
 
 MATCHER_P(HasTimestamp, timestamp_in_ms, "") {
   return arg.get() && !arg->end_of_stream() &&
          arg->timestamp().InMilliseconds() == timestamp_in_ms;
 }
 
 MATCHER(IsEndOfStream, "") { return arg.get() && arg->end_of_stream(); }
 
-MATCHER_P(SegmentMissingFrames, frame_types_string, "") {
-  return CONTAINS_STRING(arg, "Media segment did not contain any " +
-                                  std::string(frame_types_string) +
-                                  " coded frames, mismatching initialization "
-                                  "segment. Therefore, MSE coded frame "
-                                  "processing may not interoperably detect "
-                                  "discontinuities in appended media.");
+MATCHER_P(SegmentMissingFrames, track_id, "") {
+  return CONTAINS_STRING(
+      arg, "Media segment did not contain any coded frames for track " +
+               std::string(track_id));
 }
 
 MATCHER(StreamParsingFailed, "") {
   return CONTAINS_STRING(arg, "Append: stream parsing failed.");
 }
 
 MATCHER_P(FoundStream, stream_type_string, "") {
   return CONTAINS_STRING(
              arg, "found_" + std::string(stream_type_string) + "_stream") &&
          CONTAINS_STRING(arg, "true");
 }
 
 MATCHER_P2(CodecName, stream_type_string, codec_string, "") {
   return CONTAINS_STRING(arg,
                          std::string(stream_type_string) + "_codec_name") &&
          CONTAINS_STRING(arg, std::string(codec_string));
 }
 
-MATCHER_P2(InitSegmentMismatchesMimeType,
-           track_type_string_with_article,
-           mime_missing_track_type_bool,
-           "") {
-  return CONTAINS_STRING(
-      arg, "Initialization segment " +
-               std::string(mime_missing_track_type_bool ? "has "
-                                                        : "does not have ") +
-               std::string(track_type_string_with_article) +
-               " track, but the mimetype " +
-               std::string(mime_missing_track_type_bool ? "does not specify "
-                                                        : "specifies ") +
-               std::string(track_type_string_with_article) + " codec.");
+MATCHER_P2(InitSegmentMismatchesMimeType, stream_type, codec_name, "") {
+  return CONTAINS_STRING(arg, std::string(stream_type) + " stream codec " +
+                                  std::string(codec_name) +
+                                  " doesn't match SourceBuffer codecs.");
+}
+
+MATCHER_P(InitSegmentMissesExpectedTrack, missing_codec, "") {
+  return CONTAINS_STRING(arg, "Initialization segment misses expected " +
+                                  std::string(missing_codec) + " track.");
 }
 
 MATCHER_P2(GeneratedSplice, duration_microseconds, time_microseconds, "") {
   return CONTAINS_STRING(arg, "Generated splice of overlap duration " +
                                   base::IntToString(duration_microseconds) +
                                   "us into new buffer at " +
                                   base::IntToString(time_microseconds) + "us.");
 }
 
 MATCHER_P2(SkippingSpliceAtOrBefore,
@@ skipping 205 matching lines @@
 
     memcpy(buf, info->data(), info->data_size());
     buf += info->data_size();
 
     memcpy(buf, kTracksHeader, kTracksHeaderSize);
     WriteInt64(buf + kTracksSizeOffset, tracks_element_size);
     buf += kTracksHeaderSize;
 
     // TODO(xhwang): Simplify this! Probably have test data files that contain
     // ContentEncodings directly instead of trying to create one at run-time.
-    if (has_audio) {
-      memcpy(buf, audio_track_entry->data(),
-             audio_track_entry->data_size());
-      if (is_audio_encrypted) {
-        memcpy(buf + audio_track_entry->data_size(),
-               audio_content_encodings->data(),
-               audio_content_encodings->data_size());
-        WriteInt64(buf + kAudioTrackSizeOffset,
-                   audio_track_entry->data_size() +
-                   audio_content_encodings->data_size() -
-                   kAudioTrackEntryHeaderSize);
-        buf += audio_content_encodings->data_size();
-      }
-      buf += audio_track_entry->data_size();
-    }
-
     if (has_video) {
       memcpy(buf, video_track_entry->data(),
              video_track_entry->data_size());
       if (is_video_encrypted) {
         memcpy(buf + video_track_entry->data_size(),
                video_content_encodings->data(),
                video_content_encodings->data_size());
         WriteInt64(buf + kVideoTrackSizeOffset,
                    video_track_entry->data_size() +
                    video_content_encodings->data_size() -
                    kVideoTrackEntryHeaderSize);
         buf += video_content_encodings->data_size();
       }
       buf += video_track_entry->data_size();
     }
 
+    if (has_audio) {
+      memcpy(buf, audio_track_entry->data(), audio_track_entry->data_size());
+      if (is_audio_encrypted) {
+        memcpy(buf + audio_track_entry->data_size(),
+               audio_content_encodings->data(),
+               audio_content_encodings->data_size());
+        WriteInt64(buf + kAudioTrackSizeOffset,
+                   audio_track_entry->data_size() +
+                       audio_content_encodings->data_size() -
+                       kAudioTrackEntryHeaderSize);
+        buf += audio_content_encodings->data_size();
+      }
+      buf += audio_track_entry->data_size();
+    }
+
     if (has_text) {
       memcpy(buf, text_track_entry->data(),
              text_track_entry->data_size());
       buf += text_track_entry->data_size();
     }
   }
 
   ChunkDemuxer::Status AddId() {
     return AddId(kSourceId, HAS_AUDIO | HAS_VIDEO);
   }
 
   ChunkDemuxer::Status AddId(const std::string& source_id, int stream_flags) {
     bool has_audio = (stream_flags & HAS_AUDIO) != 0;
     bool has_video = (stream_flags & HAS_VIDEO) != 0;
-    std::vector<std::string> codecs;
+    std::string codecs;
     std::string type;
 
     if (has_audio) {
-      codecs.push_back("vorbis");
+      codecs += "vorbis";
       type = "audio/webm";
     }
 
     if (has_video) {
-      codecs.push_back("vp8");
+      if (codecs == "")
+        codecs = "vp8";
+      else
+        codecs += ",vp8";
       type = "video/webm";
     }
 
     if (!has_audio && !has_video) {
       return AddId(kSourceId, HAS_AUDIO | HAS_VIDEO);
     }
 
-    ChunkDemuxer::Status status = demuxer_->AddId(source_id, type, codecs);
+    return AddId(source_id, type, codecs);
+  }
+
+  ChunkDemuxer::Status AddId(const std::string& source_id,
+                             const std::string& mime_type,
+                             const std::string& codecs) {
+    ChunkDemuxer::Status status = demuxer_->AddId(source_id, mime_type, codecs);
     if (status == ChunkDemuxer::kOk)
       demuxer_->SetTracksWatcher(
           source_id, base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                 base::Unretained(this)));
     return status;
   }
 
-#if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
-  ChunkDemuxer::Status AddIdForMp2tSource(const std::string& source_id) {
-    std::vector<std::string> codecs;
-    std::string type = "video/mp2t";
-    codecs.push_back("mp4a.40.2");
-    codecs.push_back("avc1.640028");
-    ChunkDemuxer::Status status = demuxer_->AddId(source_id, type, codecs);
-    if (status == ChunkDemuxer::kOk)
-      demuxer_->SetTracksWatcher(
-          source_id, base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
-                                base::Unretained(this)));
-    return status;
-  }
-#endif
-
   bool AppendData(const uint8_t* data, size_t length) {
     return AppendData(kSourceId, data, length);
   }
 
   bool AppendCluster(const std::string& source_id,
                      std::unique_ptr<Cluster> cluster) {
     return AppendData(source_id, cluster->data(), cluster->size());
   }
 
   bool AppendCluster(std::unique_ptr<Cluster> cluster) {
@@ skipping 324 matching lines @@
     USE_ALTERNATE_AUDIO_TRACK_ID = 1 << 3,
     USE_ALTERNATE_VIDEO_TRACK_ID = 1 << 4,
     USE_ALTERNATE_TEXT_TRACK_ID = 1 << 5,
   };
 
   bool InitDemuxer(int stream_flags) {
     return InitDemuxerWithEncryptionInfo(stream_flags, false, false);
   }
 
   void ExpectInitMediaLogs(int stream_flags) {
+    if (stream_flags & HAS_VIDEO) {
+      EXPECT_MEDIA_LOG(FoundStream("video"));
+      EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
+    }
     if (stream_flags & HAS_AUDIO) {
       EXPECT_MEDIA_LOG(FoundStream("audio"));
       EXPECT_MEDIA_LOG(CodecName("audio", "vorbis"));
     }
-
-    if (stream_flags & HAS_VIDEO) {
-      EXPECT_MEDIA_LOG(FoundStream("video"));
-      EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
-    }
   }
 
   bool InitDemuxerWithEncryptionInfo(
       int stream_flags, bool is_audio_encrypted, bool is_video_encrypted) {
     PipelineStatus expected_status =
         (stream_flags != 0) ? PIPELINE_OK : CHUNK_DEMUXER_ERROR_APPEND_FAILED;
 
     base::TimeDelta expected_duration = kNoTimestamp;
     if (expected_status == PIPELINE_OK)
       expected_duration = kDefaultDuration();
@@ skipping 17 matching lines @@
 
     // Adding expectations prior to CreateInitDoneCB() here because InSequence
     // tests require init segment received before duration set. Also, only
     // expect an init segment received callback if there is actually a track in
     // it.
     if (stream_flags != 0) {
       ExpectInitMediaLogs(stream_flags);
       EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     } else {
       // OnNewConfigs() requires at least one audio, video, or text track.
+      EXPECT_MEDIA_LOG(InitSegmentMissesExpectedTrack("vorbis"));
+      EXPECT_MEDIA_LOG(InitSegmentMissesExpectedTrack("vp8"));
       EXPECT_MEDIA_LOG(StreamParsingFailed());
     }
 
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(expected_duration, expected_status), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
 
     return AppendInitSegmentWithEncryptedInfo(
@@ skipping 1526 matching lines @@
       kSourceId, &tmp, 1, append_window_start_for_next_append_,
       append_window_end_for_next_append_, &timestamp_offset_map_[kSourceId]));
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithAudioOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp, CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
-  std::vector<std::string> codecs(1);
-  codecs[0] = "vorbis";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", codecs),
+  ASSERT_EQ(demuxer_->AddId(kSourceId, "audio/webm", "vorbis"),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Video track is unexpected per mimetype.
-  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("a video", true));
+  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("Video", "vp8"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   ASSERT_FALSE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, AVHeadersWithVideoOnlyType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp, CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
-  std::vector<std::string> codecs(1);
-  codecs[0] = "vp8";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
-            ChunkDemuxer::kOk);
+  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", "vp8"), ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Audio track is unexpected per mimetype.
-  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("an audio", true));
+  EXPECT_MEDIA_LOG(FoundStream("video"));
+  EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
+  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("Audio", "vorbis"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   ASSERT_FALSE(AppendInitSegment(HAS_AUDIO | HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, AudioOnlyHeaderWithAVType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp, CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
-  std::vector<std::string> codecs(2);
-  codecs[0] = "vorbis";
-  codecs[1] = "vp8";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
+  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", "vorbis,vp8"),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Video track is also expected per mimetype.
-  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("a video", false));
+  EXPECT_MEDIA_LOG(FoundStream("audio"));
+  EXPECT_MEDIA_LOG(CodecName("audio", "vorbis"));
+  EXPECT_MEDIA_LOG(InitSegmentMissesExpectedTrack("vp8"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   ASSERT_FALSE(AppendInitSegment(HAS_AUDIO));
 }
 
 TEST_F(ChunkDemuxerTest, VideoOnlyHeaderWithAVType) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kNoTimestamp, CHUNK_DEMUXER_ERROR_APPEND_FAILED),
       true);
 
-  std::vector<std::string> codecs(2);
-  codecs[0] = "vorbis";
-  codecs[1] = "vp8";
-  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", codecs),
+  ASSERT_EQ(demuxer_->AddId(kSourceId, "video/webm", "vorbis,vp8"),
             ChunkDemuxer::kOk);
   demuxer_->SetTracksWatcher(kSourceId,
                              base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                         base::Unretained(this)));
 
   // Audio track is also expected per mimetype.
-  EXPECT_MEDIA_LOG(InitSegmentMismatchesMimeType("an audio", false));
+  EXPECT_MEDIA_LOG(FoundStream("video"));
+  EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
+  EXPECT_MEDIA_LOG(InitSegmentMissesExpectedTrack("vorbis"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   ASSERT_FALSE(AppendInitSegment(HAS_VIDEO));
 }
 
 TEST_F(ChunkDemuxerTest, MultipleHeaders) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(AppendCluster(kDefaultFirstCluster()));
 
   // Append another identical initialization segment.
@@ skipping 46 matching lines @@
 TEST_F(ChunkDemuxerTest, AddIdFailures) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   std::string audio_id = "audio1";
   std::string video_id = "video1";
 
   ASSERT_EQ(AddId(audio_id, HAS_AUDIO), ChunkDemuxer::kOk);
 
-  // Adding an id with audio/video should fail because we already added audio.
-  ASSERT_EQ(AddId(), ChunkDemuxer::kReachedIdLimit);
-
   ExpectInitMediaLogs(HAS_AUDIO);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   ASSERT_TRUE(AppendInitSegmentWithSourceId(audio_id, HAS_AUDIO));
 
   // Adding an id after append should fail.
   ASSERT_EQ(AddId(video_id, HAS_VIDEO), ChunkDemuxer::kReachedIdLimit);
 }
 
 // Test that Read() calls after a RemoveId() return "end of stream" buffers.
 TEST_F(ChunkDemuxerTest, RemoveId) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
   ASSERT_TRUE(InitDemuxerAudioAndVideoSources(audio_id, video_id));
 
   // Append audio and video data into separate source ids.
   ASSERT_TRUE(AppendCluster(
       audio_id,
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration)));
   ASSERT_TRUE(AppendCluster(video_id,
                             GenerateSingleStreamCluster(0, 132, kVideoTrackNum,
                                                         kVideoBlockDuration)));
 
   // Read() from audio should return normal buffers.
   GenerateAudioStreamExpectedReads(0, 4);
 
+  // Audio stream will become inaccessible after |audio_id| is removed, so save
+  // it here to read from it after RemoveId.
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+
   // Remove the audio id.
   demuxer_->RemoveId(audio_id);
 
   // Read() from audio should return "end of stream" buffers.
   bool audio_read_done = false;
-  ReadAudio(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
+  audio_stream->Read(base::Bind(&OnReadDone_EOSExpected, &audio_read_done));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(audio_read_done);
 
   // Read() from video should still return normal buffers.
   GenerateVideoStreamExpectedReads(0, 4);
 }
 
 // Test that removing an ID immediately after adding it does not interfere with
 // quota for new IDs in the future.
 TEST_F(ChunkDemuxerTest, RemoveAndAddId) {
@@ skipping 545 matching lines @@
 
 #if defined(USE_PROPRIETARY_CODECS)
 #if defined(OS_ANDROID)
   if (HasPlatformDecoderSupport())
     expected = ChunkDemuxer::kOk;
 #else
   expected = ChunkDemuxer::kOk;
 #endif
 #endif
 
-  std::vector<std::string> codecs;
-  codecs.push_back("avc1.4D4041");
-
-  EXPECT_EQ(demuxer_->AddId("source_id", "video/mp4", codecs), expected);
+  EXPECT_EQ(demuxer_->AddId("source_id", "video/mp4", "avc1.4D4041"), expected);
 }
 
 // Test codec ID's that are not compliant with RFC6381, but have been
 // seen in the wild.
 TEST_F(ChunkDemuxerTest, CodecIDsThatAreNotRFC6381Compliant) {
   ChunkDemuxer::Status expected = ChunkDemuxer::kNotSupported;
 
 #if defined(USE_PROPRIETARY_CODECS)
   expected = ChunkDemuxer::kOk;
 #endif
   const char* codec_ids[] = {
     // GPAC places leading zeros on the audio object type.
     "mp4a.40.02",
     "mp4a.40.05"
   };
 
   for (size_t i = 0; i < arraysize(codec_ids); ++i) {
-    std::vector<std::string> codecs;
-    codecs.push_back(codec_ids[i]);
-
     ChunkDemuxer::Status result =
-        demuxer_->AddId("source_id", "audio/mp4", codecs);
+        demuxer_->AddId("source_id", "audio/mp4", codec_ids[i]);
 
     EXPECT_EQ(result, expected)
         << "Fail to add codec_id '" << codec_ids[i] << "'";
 
     if (result == ChunkDemuxer::kOk)
       demuxer_->RemoveId("source_id");
   }
 }
 
 TEST_F(ChunkDemuxerTest, EndOfStreamStillSetAfterSeek) {
@@ skipping 281 matching lines @@
                              append_window_end_for_next_append_,
                              &timestamp_offset_map_[kSourceId]);
 
   // After ResetParserState(), parsing should no longer be in the middle of a
   // media segment.
   ASSERT_FALSE(demuxer_->IsParsingMediaSegment(kSourceId));
 }
 
 #if defined(USE_PROPRIETARY_CODECS)
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
+namespace {
+const char* kMp2tMimeType = "video/mp2t";
+const char* kMp2tCodecs = "mp4a.40.2,avc1.640028";
+}
+
 TEST_F(ChunkDemuxerTest, EmitBuffersDuringAbort) {
   EXPECT_CALL(*this, DemuxerOpened());
   EXPECT_MEDIA_LOG(FoundStream("audio"));
   EXPECT_MEDIA_LOG(CodecName("audio", "aac"));
   EXPECT_MEDIA_LOG(FoundStream("video"));
   EXPECT_MEDIA_LOG(CodecName("video", "h264"));
   demuxer_->Initialize(&host_, CreateInitDoneCB(kInfiniteDuration, PIPELINE_OK),
                        true);
-  EXPECT_EQ(ChunkDemuxer::kOk, AddIdForMp2tSource(kSourceId));
+  EXPECT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, kMp2tMimeType, kMp2tCodecs));
 
   // For info:
   // DTS/PTS derived using dvbsnoop -s ts -if bear-1280x720.ts -tssubdecode
   // Video: first PES:
   //        PTS: 126912 (0x0001efc0)  [= 90 kHz-Timestamp: 0:00:01.4101]
   //        DTS: 123909 (0x0001e405)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Audio: first PES:
   //        PTS: 126000 (0x0001ec30)  [= 90 kHz-Timestamp: 0:00:01.4000]
   //        DTS: 123910 (0x0001e406)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Video: last PES:
@@ skipping 27 matching lines @@
 }
 
 TEST_F(ChunkDemuxerTest, SeekCompleteDuringAbort) {
   EXPECT_CALL(*this, DemuxerOpened());
   EXPECT_MEDIA_LOG(FoundStream("audio"));
   EXPECT_MEDIA_LOG(CodecName("audio", "aac"));
   EXPECT_MEDIA_LOG(FoundStream("video"));
   EXPECT_MEDIA_LOG(CodecName("video", "h264"));
   demuxer_->Initialize(&host_, CreateInitDoneCB(kInfiniteDuration, PIPELINE_OK),
                        true);
-  EXPECT_EQ(ChunkDemuxer::kOk, AddIdForMp2tSource(kSourceId));
+  EXPECT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, kMp2tMimeType, kMp2tCodecs));
 
   // For info:
   // DTS/PTS derived using dvbsnoop -s ts -if bear-1280x720.ts -tssubdecode
   // Video: first PES:
   //        PTS: 126912 (0x0001efc0)  [= 90 kHz-Timestamp: 0:00:01.4101]
   //        DTS: 123909 (0x0001e405)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Audio: first PES:
   //        PTS: 126000 (0x0001ec30)  [= 90 kHz-Timestamp: 0:00:01.4000]
   //        DTS: 123910 (0x0001e406)  [= 90 kHz-Timestamp: 0:00:01.3767]
   // Video: last PES:
@@ skipping 266 matching lines @@
   Seek(seek_time);
 
   // Append data to satisfy the seek.
   ASSERT_TRUE(AppendCluster(seek_time.InMilliseconds(), 10));
 }
 
 TEST_F(ChunkDemuxerTest, SetMemoryLimitType) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Set different memory limits for audio and video.
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
-  demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 5 * kBlockSize + 1);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, 5 * kBlockSize + 1);
 
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(1000);
 
   // Append data at the start that can be garbage collected:
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum,
                       "0K 23K 46K 69K 92K 115K 138K 161K 184K 207K", 23),
       MuxedStreamInfo(kVideoTrackNum, "0K 33K 66K 99K 132K", 33));
 
   // We should be right at buffer limit, should pass
@@ skipping 16 matching lines @@
   // We should delete first append, and be exactly at buffer limit
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 0));
 
   // Verify that the old data, and nothing more, has been garbage collected.
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [1000,1230) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [1000,1165) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekForward) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
   CheckExpectedRanges("{ [1000,1230) }");
 
   // GC should be able to evict frames in the currently buffered range, since
   // those frames are earlier than the seek target position.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2000);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   CheckExpectedRanges("{ [1115,1230) [2000,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_SingleRange_SeekBack) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 10);
   CheckExpectedRanges("{ [1000,1230) }");
 
   // GC should be able to evict frames in the currently buffered range, since
   // seek target position has no data and so we should allow some frames to be
   // evicted to make space for the upcoming append at seek target position.
   base::TimeDelta seek_time = base::TimeDelta();
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 5);
   CheckExpectedRanges("{ [0,115) [1115,1230) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekForward) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict frames in the currently buffered ranges, since
   // those frames are earlier than the seek target position.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(3000);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 3000, 5);
   CheckExpectedRanges("{ [2069,2115) [3000,3115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween1) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict all frames from the first buffered range, since
   // those frames are earlier than the seek target position. But there's only 5
   // blocks worth of data in the first range and seek target position has no
   // data, so GC proceeds with trying to delete some frames from the back of
   // buffered ranges, that doesn't yield anything, since that's the most
   // recently appended data, so then GC starts removing data from the front of
   // the remaining buffered range (2000ms) to ensure we free up enough space for
   // the upcoming append and allow seek to proceed.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(1500);
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1500, 5);
   CheckExpectedRanges("{ [1500,1615) [2069,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekInbetween2) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
 
   // Append some data at position 2000ms first, then at 1000ms, so that the last
   // appended data position is in the first buffered range (that matters to the
   // GC algorithm since it tries to preserve more recently appended data).
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // Now try performing garbage collection without announcing seek first, i.e.
   // without calling Seek(), the GC algorithm should try to preserve data in the
   // first range, since that is most recently appended data.
   base::TimeDelta seek_time = base::TimeDelta::FromMilliseconds(2030);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 5 * kBlockSize));
 
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1500, 5);
   CheckExpectedRanges("{ [1000,1115) [1500,1615) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek_MultipleRanges_SeekBack) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
   // Append some data at position 1000ms then at 2000ms
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 1000, 5);
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 2000, 5);
   CheckExpectedRanges("{ [1000,1115) [2000,2115) }");
 
   // GC should be able to evict frames in the currently buffered ranges, since
   // those frames are earlier than the seek target position.
   base::TimeDelta seek_time = base::TimeDelta();
   Seek(seek_time);
   EXPECT_TRUE(demuxer_->EvictCodedFrames(kSourceId, seek_time, 8 * kBlockSize));
 
   // Append data to complete seek operation
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 5);
   CheckExpectedRanges("{ [0,115) [2069,2115) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCDuringSeek) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   base::TimeDelta seek_time1 = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta seek_time2 = base::TimeDelta::FromMilliseconds(500);
 
   // Initiate a seek to |seek_time1|.
   Seek(seek_time1);
 
   // Append data to satisfy the first seek request.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum,
                             seek_time1.InMilliseconds(), 5);
@@ skipping 24 matching lines @@
   // around |seek_time2|, because that's the current playback position,
   // and the newly appended range, since this is the most recent append.
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 700, 5);
   EXPECT_FALSE(demuxer_->EvictCodedFrames(kSourceId, seek_time2, 0));
   CheckExpectedRanges("{ [500,615) [700,815) }");
 }
 
 TEST_F(ChunkDemuxerTest, GCKeepPlayhead) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
 
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 5 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 5 * kBlockSize);
 
   // Append data at the start that can be garbage collected:
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
   CheckExpectedRanges("{ [0,230) }");
 
   // We expect garbage collection to fail, as we don't want to spontaneously
   // create gaps in source buffer stream. Gaps could break playback for many
   // clients, who don't bother to check ranges after append.
   EXPECT_FALSE(demuxer_->EvictCodedFrames(
       kSourceId, base::TimeDelta::FromMilliseconds(0), 0));
@@ skipping 378 matching lines @@
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   ASSERT_TRUE(AppendCluster(GenerateCluster(0, 0, 4)));
   ASSERT_TRUE(AppendData(kCuesHeader, sizeof(kCuesHeader)));
   ASSERT_TRUE(AppendCluster(GenerateCluster(46, 66, 5)));
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, EvictCodedFramesTest) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, 10 * kBlockSize);
-  demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, 15 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, 10 * kBlockSize);
+  demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, 15 * kBlockSize);
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   const char* kAudioStreamInfo = "0K 40K 80K 120K 160K 200K 240K 280K";
   const char* kVideoStreamInfo = "0K 10 20K 30 40K 50 60K 70 80K 90 100K "
       "110 120K 130 140K";
   // Append 8 blocks (80 bytes) of data to audio stream and 15 blocks (150
   // bytes) to video stream.
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, kAudioStreamInfo, 40),
                      MuxedStreamInfo(kVideoTrackNum, kVideoStreamInfo, 10));
@@ skipping 28 matching lines @@
   // byte block to stay under 100 bytes memory limit after append
   // 80 - 10 + 28 = 98).
   // For video stream 150 + 52 = 202. Video limit is 150 bytes. We need to
   // remove at least 6 blocks to stay under limit.
   CheckExpectedBuffers(audio_stream, "40K 80K 120K 160K 200K 240K 280K");
   CheckExpectedBuffers(video_stream, "60K 70 80K 90 100K 110 120K 130 140K");
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioOnly) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO));
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("2"));
   ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_VideoOnly) {
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
   ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioFrame_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("2"));
   AppendSingleStreamCluster(kSourceId, kVideoTrackNum, 0, 10);
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingVideoFrame_AudioVideo) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
   AppendSingleStreamCluster(kSourceId, kAudioTrackNum, 0, 10);
 }
 
 TEST_F(ChunkDemuxerTest, SegmentMissingAudioVideoFrames) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("audio or video"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("2"));
   ASSERT_TRUE(AppendCluster(GenerateEmptyCluster(0)));
 }
 
 TEST_F(ChunkDemuxerTest, RelaxedKeyframe_FirstSegmentMissingKeyframe) {
   // Append V:[n n n][n n K]
   // Expect V:           [K]
   ASSERT_TRUE(InitDemuxer(HAS_VIDEO));
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(10)).Times(2);
@@ skipping 113 matching lines @@
   //        V:       [n n n][n K n]
   // Expect:
   //        A:       [K K K][K K K]
   //        V [................K n] (As would occur if there really were a
   //        jagged cluster start and not badly muxed clusters as used to
   //        simulate a jagged start in this test.)
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
-  EXPECT_MEDIA_LOG(SegmentMissingFrames("video"));
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("1"));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 10K 20D10K"),
                      MuxedStreamInfo(kVideoTrackNum, ""));
   demuxer_->Remove(kSourceId, base::TimeDelta(),
                    base::TimeDelta::FromMilliseconds(30));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "30K 40K 50D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "30 40 50", 10));
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "60K 70K 80D10K"),
                      MuxedStreamInfo(kVideoTrackNum, "60 70K 80", 10));
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,90) }");
@@ skipping 94 matching lines @@
 TEST_F(ChunkDemuxerTest, StreamStatusNotifications) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   EXPECT_NE(nullptr, audio_stream);
   CheckStreamStatusNotifications(audio_stream);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   EXPECT_NE(nullptr, video_stream);
   CheckStreamStatusNotifications(video_stream);
 }
 
+TEST_F(ChunkDemuxerTest, MultipleIds) {
+  CreateNewDemuxer();
+  EXPECT_CALL(*this, DemuxerOpened());
+  EXPECT_CALL(host_, SetDuration(_)).Times(2);
+  demuxer_->Initialize(&host_, CreateInitDoneCB(kNoTimestamp, PIPELINE_OK),
+                       true);
+
+  const char* kId1 = "id1";
+  const char* kId2 = "id2";
+  EXPECT_EQ(AddId(kId1, "video/webm", "opus,vp9"), ChunkDemuxer::kOk);
+  EXPECT_EQ(AddId(kId2, "video/webm", "opus,vp9"), ChunkDemuxer::kOk);
+  scoped_refptr<DecoderBuffer> data1 = ReadTestDataFile("green-a300hz.webm");
+  scoped_refptr<DecoderBuffer> data2 = ReadTestDataFile("red-a500hz.webm");
+
+  EXPECT_MEDIA_LOG(FoundStream("audio")).Times(2);
+  EXPECT_MEDIA_LOG(FoundStream("video")).Times(2);
+  EXPECT_MEDIA_LOG(CodecName("audio", "opus")).Times(2);
+  EXPECT_MEDIA_LOG(CodecName("video", "vp9")).Times(2);
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_)).Times(2);
+  EXPECT_MEDIA_LOG(SegmentMissingFrames("1")).Times(AnyNumber());
+
+  EXPECT_TRUE(AppendData(kId1, data1->data(), data1->data_size()));
+  EXPECT_TRUE(AppendData(kId2, data2->data(), data2->data_size()));
+  CheckExpectedRanges(kId1, "{ [0,12007) }");
+  CheckExpectedRanges(kId2, "{ [0,10007) }");
+}
+
+TEST_F(ChunkDemuxerTest, CompleteInitAfterIdRemoved) {
+  CreateNewDemuxer();
+  EXPECT_CALL(*this, DemuxerOpened());
+  demuxer_->Initialize(&host_,
+                       CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
+
+  // Add two ids, then remove one of the ids and verify that adding init segment
+  // only for the remaining id still triggers the InitDoneCB.
+  const char* kId1 = "id1";
+  const char* kId2 = "id2";
+  EXPECT_EQ(AddId(kId1, "video/webm", "vp8"), ChunkDemuxer::kOk);
+  EXPECT_EQ(AddId(kId2, "video/webm", "vp9"), ChunkDemuxer::kOk);
+  demuxer_->RemoveId(kId2);
+
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
+  EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(30));
+  EXPECT_MEDIA_LOG(FoundStream("video"));
+  EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
+
+  ASSERT_TRUE(AppendInitSegmentWithSourceId(kId1, HAS_VIDEO));
+  AppendSingleStreamCluster(kId1, kVideoTrackNum, "0K 30 60 90");
+}
+
+TEST_F(ChunkDemuxerTest, RemovingIdMustRemoveStreams) {
+  CreateNewDemuxer();
+  EXPECT_CALL(*this, DemuxerOpened());
+  demuxer_->Initialize(&host_,
+                       CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
+
+  const char* kId1 = "id1";
+  EXPECT_EQ(AddId(kId1, "video/webm", "vorbis,vp8"), ChunkDemuxer::kOk);
+
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
+  EXPECT_MEDIA_LOG(FoundStream("video"));
+  EXPECT_MEDIA_LOG(CodecName("video", "vp8"));
+  EXPECT_MEDIA_LOG(FoundStream("audio"));
+  EXPECT_MEDIA_LOG(CodecName("audio", "vorbis"));
+
+  // Append init segment to ensure demuxer streams get created.
+  ASSERT_TRUE(AppendInitSegmentWithSourceId(kId1, HAS_AUDIO | HAS_VIDEO));
+  EXPECT_NE(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO));
+  EXPECT_NE(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+
+  // Removing the id should remove also the DemuxerStreams.
+  demuxer_->RemoveId(kId1);
+  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::AUDIO));
+  EXPECT_EQ(nullptr, demuxer_->GetStream(DemuxerStream::VIDEO));
+}
+
+// TODO(servolk): Add a unit test with multiple audio/video tracks using the
+// same codec type in a single SourceBuffer/MediaSourceState, when WebM parser
+// supports multiple tracks. crbug.com/646900
+
 }  // namespace media