Support multiple media tracks in MSE / ChunkDemuxer

media/test/pipeline_integration_test.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
@@ skipping 543 matching lines @@
                               const uint8_t* pData,
                               int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
     ASSERT_TRUE(
         chunk_demuxer_->AppendData(kSourceId, pData, size, append_window_start,
                                    append_window_end, &timestamp_offset));
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void SetMemoryLimits(size_t limit_bytes) {
-    chunk_demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, limit_bytes);
-    chunk_demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, limit_bytes);
+    chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::AUDIO, limit_bytes);
+    chunk_demuxer_->SetMemoryLimitsForTest(DemuxerStream::VIDEO, limit_bytes);
   }
 
   void EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize) {
     chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime, newDataSize);
   }
 
   void RemoveRange(base::TimeDelta start, base::TimeDelta end) {
     chunk_demuxer_->Remove(kSourceId, start, end);
   }
 
@@ skipping 28 matching lines @@
 
     AppendData(initial_append_size_);
   }
 
   ChunkDemuxer::Status AddId() {
     // This code assumes that |mimetype_| is one of the following forms.
     // 1. audio/mpeg
     // 2. video/webm;codec="vorbis,vp8".
     size_t semicolon = mimetype_.find(";");
     std::string type = mimetype_;
-    std::vector<std::string> codecs;
+    std::string codecs_param = "";
     if (semicolon != std::string::npos) {
       type = mimetype_.substr(0, semicolon);
       size_t codecs_param_start = mimetype_.find("codecs=\"", semicolon);
 
       CHECK_NE(codecs_param_start, std::string::npos);
 
       codecs_param_start += 8;  // Skip over the codecs=".
 
       size_t codecs_param_end = mimetype_.find("\"", codecs_param_start);
 
       CHECK_NE(codecs_param_end, std::string::npos);
 
-      std::string codecs_param = mimetype_.substr(
-          codecs_param_start, codecs_param_end - codecs_param_start);
-      codecs = base::SplitString(codecs_param, ",", base::KEEP_WHITESPACE,
-                                 base::SPLIT_WANT_NONEMPTY);
+      codecs_param = mimetype_.substr(codecs_param_start,
+                                      codecs_param_end - codecs_param_start);
     }
 
-    return chunk_demuxer_->AddId(kSourceId, type, codecs);
+    return chunk_demuxer_->AddId(kSourceId, type, codecs_param);
   }
 
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
     DCHECK(!init_data.empty());
     CHECK(!encrypted_media_init_data_cb_.is_null());
     encrypted_media_init_data_cb_.Run(init_data_type, init_data);
   }
 
   base::TimeDelta last_timestamp_offset() const {
@@ skipping 1733 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media