Support alternate audio/video track ids in ChunkDemuxer tests

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 67 matching lines @@
 // The size of TrackEntry element in test file "webm_vp8_track_entry" starts at
 // index 1 and spans 8 bytes.
 const int kVideoTrackSizeOffset = 1;
 const int kVideoTrackSizeWidth = 8;
 const int kVideoTrackEntryHeaderSize =
     kVideoTrackSizeOffset + kVideoTrackSizeWidth;
 
 const int kVideoTrackNum = 1;
 const int kAudioTrackNum = 2;
 const int kTextTrackNum = 3;
-const int kAlternateTextTrackNum = 4;
+const int kAlternateVideoTrackNum = 4;
+const int kAlternateAudioTrackNum = 5;
+const int kAlternateTextTrackNum = 6;
 
 const int kAudioBlockDuration = 23;
 const int kVideoBlockDuration = 33;
 const int kTextBlockDuration = 100;
 const int kBlockSize = 10;
 
 const char kSourceId[] = "SourceId";
 const char kDefaultFirstClusterRange[] = "{ [0,46) }";
 const int kDefaultFirstClusterEndTimestamp = 66;
 const int kDefaultSecondClusterEndTimestamp = 132;
@@ skipping 159 matching lines @@
   // in kDefaultFirstCluster() so that these two clusters represent
   // a continuous region.
   scoped_ptr<Cluster> kDefaultSecondCluster() {
     return GenerateCluster(46, 66, 5);
   }
 
   ChunkDemuxerTest()
       : media_log_(new StrictMock<MockMediaLog>()),
         append_window_end_for_next_append_(kInfiniteDuration()) {
     init_segment_received_cb_ = base::Bind(
-        &ChunkDemuxerTest::InitSegmentReceivedWrapper, base::Unretained(this));
+        &ChunkDemuxerTest::InitSegmentReceived, base::Unretained(this));
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
         &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
     demuxer_.reset(new ChunkDemuxer(open_cb, encrypted_media_init_data_cb,
                                     media_log_, true));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
-                         bool is_audio_encrypted,
-                         bool is_video_encrypted,
-                         scoped_ptr<uint8_t[]>* buffer,
-                         int* size) {
-    CreateInitSegmentInternal(
-        stream_flags, is_audio_encrypted, is_video_encrypted, buffer, false,
-        size);
-  }
-
-  void CreateInitSegmentWithAlternateTextTrackNum(int stream_flags,
-                                                  bool is_audio_encrypted,
-                                                  bool is_video_encrypted,
-                                                  scoped_ptr<uint8_t[]>* buffer,
-                                                  int* size) {
-    DCHECK(stream_flags & HAS_TEXT);
-    CreateInitSegmentInternal(
-        stream_flags, is_audio_encrypted, is_video_encrypted, buffer, true,
-        size);
-  }
-
-  void CreateInitSegmentInternal(int stream_flags,
                                  bool is_audio_encrypted,
                                  bool is_video_encrypted,
                                  scoped_ptr<uint8_t[]>* buffer,
-                                 bool use_alternate_text_track_id,
                                  int* size) {
     bool has_audio = (stream_flags & HAS_AUDIO) != 0;
     bool has_video = (stream_flags & HAS_VIDEO) != 0;
     bool has_text = (stream_flags & HAS_TEXT) != 0;
     scoped_refptr<DecoderBuffer> ebml_header;
     scoped_refptr<DecoderBuffer> info;
     scoped_refptr<DecoderBuffer> audio_track_entry;
     scoped_refptr<DecoderBuffer> video_track_entry;
     scoped_refptr<DecoderBuffer> audio_content_encodings;
     scoped_refptr<DecoderBuffer> video_content_encodings;
     scoped_refptr<DecoderBuffer> text_track_entry;
 
     ebml_header = ReadTestDataFile("webm_ebml_element");
 
     info = ReadTestDataFile("webm_info_element");
 
     int tracks_element_size = 0;
 
     if (has_audio) {
       audio_track_entry = ReadTestDataFile("webm_vorbis_track_entry");
       tracks_element_size += audio_track_entry->data_size();
+      // Verify that we have TrackNum (0xD7) EBML element at expected offset.
+      DCHECK_EQ(audio_track_entry->data()[9], kWebMIdTrackNumber);
+      // Verify that the size of TrackNum element is 1. The actual value is 0x81
+      // due to how element sizes are encoded in EBML.
+      DCHECK_EQ(audio_track_entry->data()[10], 0x81);
+      // Ensure the track id in TrackNum EBML element matches kAudioTrackNum.
+      DCHECK_EQ(audio_track_entry->data()[11], kAudioTrackNum);
+      if (stream_flags & USE_ALTERNATE_AUDIO_TRACK_ID)
+        audio_track_entry->writable_data()[11] = kAlternateAudioTrackNum;
       if (is_audio_encrypted) {
         audio_content_encodings = ReadTestDataFile("webm_content_encodings");
         tracks_element_size += audio_content_encodings->data_size();
       }
     }
 
     if (has_video) {
       video_track_entry = ReadTestDataFile("webm_vp8_track_entry");
       tracks_element_size += video_track_entry->data_size();
+      // Verify that we have TrackNum (0xD7) EBML element at expected offset.
+      DCHECK_EQ(video_track_entry->data()[9], kWebMIdTrackNumber);
+      // Verify that the size of TrackNum element is 1. The actual value is 0x81
+      // due to how element sizes are encoded in EBML.
+      DCHECK_EQ(video_track_entry->data()[10], 0x81);
+      // Ensure the track id in TrackNum EBML element matches kVideoTrackNum.
+      DCHECK_EQ(video_track_entry->data()[11], kVideoTrackNum);
+      if (stream_flags & USE_ALTERNATE_VIDEO_TRACK_ID)
+        video_track_entry->writable_data()[11] = kAlternateVideoTrackNum;
       if (is_video_encrypted) {
         video_content_encodings = ReadTestDataFile("webm_content_encodings");
         tracks_element_size += video_content_encodings->data_size();
       }
     }
 
     if (has_text) {
       // TODO(matthewjheaney): create an abstraction to do
       // this (http://crbug/321454).
       // We need it to also handle the creation of multiple text tracks.
       //
       // This is the track entry for a text track,
       // TrackEntry [AE], size=30
-      //   TrackNum [D7], size=1, val=3 (or 4 if use_alternate_text_track_id)
+      //   TrackNum [D7], size=1, val=3 (or 4 if USE_ALTERNATE_TEXT_TRACK_ID)
       //   TrackUID [73] [C5], size=1, value=3 (must remain constant for same
       //     track, even if TrackNum changes)
       //   TrackType [83], size=1, val=0x11
       //   CodecId [86], size=18, val="D_WEBVTT/SUBTITLES"
       char str[] = "\xAE\x9E\xD7\x81\x03\x73\xC5\x81\x03"
                    "\x83\x81\x11\x86\x92"
                    "D_WEBVTT/SUBTITLES";
       DCHECK_EQ(str[4], kTextTrackNum);
-      if (use_alternate_text_track_id)
+      if (stream_flags & USE_ALTERNATE_TEXT_TRACK_ID)
         str[4] = kAlternateTextTrackNum;
 
       const int len = strlen(str);
       DCHECK_EQ(len, 32);
       const uint8_t* const buf = reinterpret_cast<const uint8_t*>(str);
       text_track_entry = DecoderBuffer::CopyFrom(buf, len);
       tracks_element_size += text_track_entry->data_size();
     }
 
     *size = ebml_header->data_size() + info->data_size() +
@@ skipping 73 matching lines @@
       type = "video/webm";
     }
 
     if (!has_audio && !has_video) {
       return AddId(kSourceId, HAS_AUDIO | HAS_VIDEO);
     }
 
     ChunkDemuxer::Status status = demuxer_->AddId(source_id, type, codecs);
     if (status == ChunkDemuxer::kOk)
       demuxer_->SetTracksWatcher(
-          source_id, base::Bind(&ChunkDemuxerTest::InitSegmentReceivedWrapper,
+          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::InitSegmentReceivedWrapper,
+          source_id, base::Bind(&ChunkDemuxerTest::InitSegmentReceived,
                                 base::Unretained(this)));
     return status;
   }
 #endif
 
   void AppendData(const uint8_t* data, size_t length) {
     AppendData(kSourceId, data, length);
   }
 
   void AppendCluster(const std::string& source_id,
                      scoped_ptr<Cluster> cluster) {
     AppendData(source_id, cluster->data(), cluster->size());
   }
 
   void AppendCluster(scoped_ptr<Cluster> cluster) {
     AppendCluster(kSourceId, std::move(cluster));
   }
 
   void AppendCluster(int timecode, int block_count) {
     AppendCluster(GenerateCluster(timecode, block_count));
   }
 
   void AppendSingleStreamCluster(const std::string& source_id, int track_number,
                                  int timecode, int block_count) {
     int block_duration = 0;
     switch (track_number) {
       case kVideoTrackNum:
+      case kAlternateVideoTrackNum:
         block_duration = kVideoBlockDuration;
         break;
       case kAudioTrackNum:
+      case kAlternateAudioTrackNum:
         block_duration = kAudioBlockDuration;
         break;
       case kTextTrackNum:  // Fall-through.
       case kAlternateTextTrackNum:
         block_duration = kTextBlockDuration;
         break;
     }
     ASSERT_NE(block_duration, 0);
     int end_timecode = timecode + block_count * block_duration;
     AppendCluster(source_id,
@@ skipping 71 matching lines @@
 
       if (track_number == kTextTrackNum ||
           track_number == kAlternateTextTrackNum) {
         block_info.duration = kTextBlockDuration;
         ASSERT_EQ(kWebMFlagKeyframe, block_info.flags)
             << "Text block with timestamp " << block_info.timestamp_in_ms
             << " was not marked as a key frame."
             << " All text blocks must be key frames";
       }
 
-      if (track_number == kAudioTrackNum)
+      if (track_number == kAudioTrackNum ||
+          track_number == kAlternateAudioTrackNum)
         ASSERT_TRUE(block_info.flags & kWebMFlagKeyframe);
 
       blocks->push_back(block_info);
     }
   }
 
   scoped_ptr<Cluster> GenerateCluster(const std::vector<BlockInfo>& blocks,
                                       bool unknown_size) {
     DCHECK_GT(blocks.size(), 0u);
     ClusterBuilder cb;
 
     std::vector<uint8_t> data(10);
     for (size_t i = 0; i < blocks.size(); ++i) {
       if (i == 0)
         cb.SetClusterTimecode(blocks[i].timestamp_in_ms);
 
       if (blocks[i].duration) {
-        if (blocks[i].track_number == kVideoTrackNum) {
+        if (blocks[i].track_number == kVideoTrackNum ||
+            blocks[i].track_number == kAlternateVideoTrackNum) {
           AddVideoBlockGroup(&cb,
                              blocks[i].track_number, blocks[i].timestamp_in_ms,
                              blocks[i].duration, blocks[i].flags);
         } else {
           cb.AddBlockGroup(blocks[i].track_number, blocks[i].timestamp_in_ms,
                            blocks[i].duration, blocks[i].flags,
                            &data[0], data.size());
         }
       } else {
         cb.AddSimpleBlock(blocks[i].track_number, blocks[i].timestamp_in_ms,
@@ skipping 169 matching lines @@
 
   PipelineStatusCB CreateInitDoneCB(PipelineStatus expected_status) {
     return base::Bind(&ChunkDemuxerTest::InitDoneCalled,
                       base::Unretained(this),
                       expected_status);
   }
 
   enum StreamFlags {
     HAS_AUDIO = 1 << 0,
     HAS_VIDEO = 1 << 1,
-    HAS_TEXT = 1 << 2
+    HAS_TEXT = 1 << 2,
+    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_AUDIO) {
       EXPECT_MEDIA_LOG(FoundStream("audio"));
       EXPECT_MEDIA_LOG(CodecName("audio", "vorbis"));
@@ skipping 30 matching lines @@
                                      arraysize(kEncryptedMediaInitData))))
           .Times(Exactly(need_key_count));
     }
 
     // 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, InitSegmentReceived(_));
+      EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     } else {
       // OnNewConfigs() requires at least one audio, video, or text track.
       EXPECT_MEDIA_LOG(StreamParsingFailed());
     }
 
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(expected_duration, expected_status), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
@@ skipping 21 matching lines @@
 
     if (has_text) {
       audio_flags |= HAS_TEXT;
       video_flags |= HAS_TEXT;
     }
 
     // Note: Unlike InitDemuxerWithEncryptionInfo, this method is currently
     // incompatible with InSequence tests. Refactoring of the duration
     // set expectation to not be added during CreateInitDoneCB() could fix this.
     ExpectInitMediaLogs(audio_flags);
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     AppendInitSegmentWithSourceId(audio_id, audio_flags);
 
     ExpectInitMediaLogs(video_flags);
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     AppendInitSegmentWithSourceId(video_id, video_flags);
     return true;
   }
 
   bool InitDemuxerAudioAndVideoSources(const std::string& audio_id,
                                        const std::string& video_id) {
     return InitDemuxerAudioAndVideoSourcesText(audio_id, video_id, false);
   }
 
   // Initializes the demuxer with data from 2 files with different
@@ skipping 15 matching lines @@
   // bear-640x360.webm :       [527-759)
   bool InitDemuxerWithConfigChangeData() {
     scoped_refptr<DecoderBuffer> bear1 = ReadTestDataFile("bear-320x240.webm");
     scoped_refptr<DecoderBuffer> bear2 = ReadTestDataFile("bear-640x360.webm");
 
     EXPECT_CALL(*this, DemuxerOpened());
 
     // Adding expectation prior to CreateInitDoneCB() here because InSequence
     // tests require init segment received before duration set.
     ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744),
                                  PIPELINE_OK), true);
 
     if (AddId(kSourceId, HAS_AUDIO | HAS_VIDEO) != ChunkDemuxer::kOk)
       return false;
 
     // Append the whole bear1 file.
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2)).Times(7);
     // Expect duration adjustment since actual duration differs slightly from
     // duration in the init segment.
     EXPECT_CALL(host_, SetDuration(base::TimeDelta::FromMilliseconds(2746)));
     AppendData(bear1->data(), bear1->data_size());
     // Last audio frame has timestamp 2721 and duration 24 (estimated from max
     // seen so far for audio track).
     // Last video frame has timestamp 2703 and duration 33 (from TrackEntry
     // DefaultDuration for video track).
     CheckExpectedRanges("{ [0,2736) }");
 
     // Append initialization segment for bear2.
     // Note: Offsets here and below are derived from
     // media/test/data/bear-640x360-manifest.js and
     // media/test/data/bear-320x240-manifest.js which were
     // generated from media/test/data/bear-640x360.webm and
     // media/test/data/bear-320x240.webm respectively.
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     AppendData(bear2->data(), 4340);
 
     // Append a media segment that goes from [0.527000, 1.014000).
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
     EXPECT_MEDIA_LOG(GeneratedSplice(20000, 527000));
     AppendData(bear2->data() + 55290, 18785);
     CheckExpectedRanges("{ [0,1027) [1201,2736) }");
 
     // Append initialization segment for bear1 & fill gap with [779-1197)
     // segment.
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     AppendData(bear1->data(), 4370);
     EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
     EXPECT_MEDIA_LOG(GeneratedSplice(26000, 779000));
     AppendData(bear1->data() + 72737, 28183);
     CheckExpectedRanges("{ [0,2736) }");
 
     MarkEndOfStream(PIPELINE_OK);
     return true;
   }
 
@@ skipping 327 matching lines @@
                      int stream_flags) {
     EXPECT_CALL(*this, DemuxerOpened());
     demuxer_->Initialize(
         &host_, CreateInitDoneCB(duration, PIPELINE_OK), true);
 
     if (AddId(kSourceId, stream_flags) != ChunkDemuxer::kOk)
       return false;
 
     // Read a WebM file into memory and send the data to the demuxer.
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
-    EXPECT_CALL(*this, InitSegmentReceived(_));
+    EXPECT_CALL(*this, InitSegmentReceivedMock(_));
     AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
 
     // Verify that the timestamps on the first few packets match what we
     // expect.
     for (size_t i = 0;
          (timestamps[i].audio_time_ms != kSkip ||
           timestamps[i].video_time_ms != kSkip);
          i++) {
       bool audio_read_done = false;
       bool video_read_done = false;
@@ skipping 16 matching lines @@
     }
 
     return true;
   }
 
   MOCK_METHOD0(DemuxerOpened, void());
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
 
-  MOCK_METHOD1(InitSegmentReceived, void(scoped_ptr<MediaTracks>&));
+  MOCK_METHOD1(InitSegmentReceivedMock, void(scoped_ptr<MediaTracks>&));
 
   void Seek(base::TimeDelta seek_time) {
     demuxer_->StartWaitingForSeek(seek_time);
     demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunUntilIdle();
   }
 
   void MarkEndOfStream(PipelineStatus status) {
     demuxer_->MarkEndOfStream(status);
     message_loop_.RunUntilIdle();
@@ skipping 17 matching lines @@
   Demuxer::MediaTracksUpdatedCB init_segment_received_cb_;
 
   base::TimeDelta append_window_start_for_next_append_;
   base::TimeDelta append_window_end_for_next_append_;
 
   // Map of source id to timestamp offset to use for the next AppendData()
   // operation for that source id.
   std::map<std::string, base::TimeDelta> timestamp_offset_map_;
 
  public:
-  // A workaround for gtest mocks not allowing moving scoped_ptrs.
-  void InitSegmentReceivedWrapper(scoped_ptr<MediaTracks> tracks) {
-    InitSegmentReceived(tracks);
+  void InitSegmentReceived(scoped_ptr<MediaTracks> tracks) {
+    DCHECK(tracks.get());
+    DCHECK_GT(tracks->tracks().size(), 0u);
+
+    InitSegmentReceivedMock(tracks);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, Init) {
   InSequence s;
 
   // Test no streams, audio-only, video-only, and audio & video scenarios.
@@ skipping 144 matching lines @@
   ASSERT_TRUE(video_stream);
   ASSERT_TRUE(text_stream);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30),
                      MuxedStreamInfo(kTextTrackNum, "10K"));
   CheckExpectedRanges("{ [0,46) }");
 
   scoped_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
-  CreateInitSegmentWithAlternateTextTrackNum(HAS_TEXT | HAS_AUDIO | HAS_VIDEO,
-                                             false, false,
-                                             &info_tracks, &info_tracks_size);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  CreateInitSegment(
+      HAS_TEXT | HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_TEXT_TRACK_ID, false,
+      false, &info_tracks, &info_tracks_size);
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
       MuxedStreamInfo(kVideoTrackNum, "60K",
                       WebMClusterParser::kDefaultVideoBufferDurationInMs),
       MuxedStreamInfo(kAlternateTextTrackNum, "45K"));
 
   CheckExpectedRanges("{ [0,92) }");
   CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
   CheckExpectedBuffers(video_stream, "0K 30 60K");
   CheckExpectedBuffers(text_stream, "10K 45K");
 
   ShutdownDemuxer();
 }
 
+TEST_F(ChunkDemuxerTest, AudioVideoTrackIdsChange) {
+  // Test with 1 audio and 1 video stream. Send a second init segment in which
+  // the audio and video track IDs change. Verify that appended buffers before
+  // and after the second init segment map to the same underlying track buffers.
+  CreateNewDemuxer();
+  ASSERT_TRUE(
+      InitDemuxerWithEncryptionInfo(HAS_AUDIO | HAS_VIDEO, false, false));
+  DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
+  DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  ASSERT_TRUE(audio_stream);
+  ASSERT_TRUE(video_stream);
+
+  AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
+                     MuxedStreamInfo(kVideoTrackNum, "0K 30", 30));
+  CheckExpectedRanges("{ [0,46) }");
+
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
+  AppendInitSegment(HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_AUDIO_TRACK_ID |
+                    USE_ALTERNATE_VIDEO_TRACK_ID);
+  AppendMuxedCluster(MuxedStreamInfo(kAlternateAudioTrackNum, "46K 69K", 63),
+                     MuxedStreamInfo(kAlternateVideoTrackNum, "60K", 23));
+  CheckExpectedRanges("{ [0,92) }");
+  CheckExpectedBuffers(audio_stream, "0K 23K 46K 69K");
+  CheckExpectedBuffers(video_stream, "0K 30 60K");
+
+  ShutdownDemuxer();
+}
+
 TEST_F(ChunkDemuxerTest, InitSegmentSetsNeedRandomAccessPointFlag) {
   // Tests that non-key-frames following an init segment are allowed
   // and dropped, as expected if the initialization segment received
   // algorithm correctly sets the needs random access point flag to true for all
   // track buffers. Note that the first initialization segment is insufficient
   // to fully test this since needs random access point flag initializes to
   // true.
   CreateNewDemuxer();
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
       .WillOnce(SaveArg<0>(&text_stream));
   ASSERT_TRUE(InitDemuxerWithEncryptionInfo(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO, false, false));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream && video_stream && text_stream);
 
   AppendMuxedCluster(
       MuxedStreamInfo(kAudioTrackNum, "23K",
                       WebMClusterParser::kDefaultAudioBufferDurationInMs),
       MuxedStreamInfo(kVideoTrackNum, "0 30K", 30),
       MuxedStreamInfo(kTextTrackNum, "25K 40K"));
   CheckExpectedRanges("{ [23,46) }");
 
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegment(HAS_TEXT | HAS_AUDIO | HAS_VIDEO);
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "46K 69K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "60 90K", 30),
                      MuxedStreamInfo(kTextTrackNum, "80K 90K"));
   CheckExpectedRanges("{ [23,92) }");
 
   CheckExpectedBuffers(audio_stream, "23K 46K 69K");
   CheckExpectedBuffers(video_stream, "30K 90K");
   CheckExpectedBuffers(text_stream, "25K 40K 80K 90K");
 }
 
 // Make sure that the demuxer reports an error if Shutdown()
 // is called before all the initialization segments are appended.
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppended) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", HAS_AUDIO), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video", HAS_VIDEO), ChunkDemuxer::kOk);
 
   ExpectInitMediaLogs(HAS_AUDIO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegmentWithSourceId("audio", HAS_AUDIO);
 
   ShutdownDemuxer();
 }
 
 TEST_F(ChunkDemuxerTest, Shutdown_BeforeAllInitSegmentsAppendedText) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(
           kDefaultDuration(), DEMUXER_ERROR_COULD_NOT_OPEN), true);
 
   EXPECT_EQ(AddId("audio", HAS_AUDIO), ChunkDemuxer::kOk);
   EXPECT_EQ(AddId("video_and_text", HAS_VIDEO), ChunkDemuxer::kOk);
 
   EXPECT_CALL(host_, AddTextStream(_, _))
       .Times(Exactly(1));
 
   ExpectInitMediaLogs(HAS_VIDEO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegmentWithSourceId("video_and_text", HAS_VIDEO | HAS_TEXT);
 
   ShutdownDemuxer();
 }
 
 // Verifies that all streams waiting for data receive an end of stream
 // buffer when Shutdown() is called.
 TEST_F(ChunkDemuxerTest, Shutdown_EndOfStreamWhileWaitingForData) {
   DemuxerStream* text_stream = NULL;
   EXPECT_CALL(host_, AddTextStream(_, _))
@@ skipping 499 matching lines @@
   memcpy(dst, info_tracks.get(), info_tracks_size);
   dst += info_tracks_size;
 
   memcpy(dst, cluster_a->data(), cluster_a->size());
   dst += cluster_a->size();
 
   memcpy(dst, cluster_b->data(), cluster_b->size());
   dst += cluster_b->size();
 
   ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendDataInPieces(buffer.get(), buffer_size);
 
   GenerateExpectedReads(0, 9);
 }
 
 TEST_F(ChunkDemuxerTest, WebMFile_AudioAndVideo) {
   struct BufferTimestamps buffer_timestamps[] = {
     {0, 0},
     {33, 3},
     {67, 6},
@@ skipping 170 matching lines @@
   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),
             ChunkDemuxer::kOk);
-  demuxer_->SetTracksWatcher(
-      kSourceId, base::Bind(&ChunkDemuxerTest::InitSegmentReceivedWrapper,
-                            base::Unretained(this)));
+  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(StreamParsingFailed());
   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);
-  demuxer_->SetTracksWatcher(
-      kSourceId, base::Bind(&ChunkDemuxerTest::InitSegmentReceivedWrapper,
-                            base::Unretained(this)));
+  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(StreamParsingFailed());
   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),
             ChunkDemuxer::kOk);
-  demuxer_->SetTracksWatcher(
-      kSourceId, base::Bind(&ChunkDemuxerTest::InitSegmentReceivedWrapper,
-                            base::Unretained(this)));
+  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(StreamParsingFailed());
   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),
             ChunkDemuxer::kOk);
-  demuxer_->SetTracksWatcher(
-      kSourceId, base::Bind(&ChunkDemuxerTest::InitSegmentReceivedWrapper,
-                            base::Unretained(this)));
+  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(StreamParsingFailed());
   AppendInitSegment(HAS_VIDEO);
 }
 
 TEST_F(ChunkDemuxerTest, MultipleHeaders) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   AppendCluster(kDefaultFirstCluster());
 
   // Append another identical initialization segment.
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegment(HAS_AUDIO | HAS_VIDEO);
 
   AppendCluster(kDefaultSecondCluster());
 
   GenerateExpectedReads(0, 9);
 }
 
 TEST_F(ChunkDemuxerTest, AddSeparateSourcesForAudioAndVideo) {
   std::string audio_id = "audio1";
   std::string video_id = "video1";
@@ skipping 35 matching lines @@
 
   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, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   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";
@@ skipping 223 matching lines @@
 }
 
 // Test ranges in an audio-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_AudioIdOnly) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(kSourceId, HAS_AUDIO), ChunkDemuxer::kOk);
   ExpectInitMediaLogs(HAS_AUDIO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegment(HAS_AUDIO);
 
   // Test a simple cluster.
   AppendCluster(
       GenerateSingleStreamCluster(0, 92, kAudioTrackNum, kAudioBlockDuration));
 
   CheckExpectedRanges("{ [0,92) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   AppendCluster(GenerateSingleStreamCluster(
       150, 219, kAudioTrackNum, kAudioBlockDuration));
 
   CheckExpectedRanges("{ [0,92) [150,219) }");
 }
 
 // Test ranges in a video-only stream.
 TEST_F(ChunkDemuxerTest, GetBufferedRanges_VideoIdOnly) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(kSourceId, HAS_VIDEO), ChunkDemuxer::kOk);
   ExpectInitMediaLogs(HAS_VIDEO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendInitSegment(HAS_VIDEO);
 
   // Test a simple cluster.
   AppendCluster(
       GenerateSingleStreamCluster(0, 132, kVideoTrackNum, kVideoBlockDuration));
 
   CheckExpectedRanges("{ [0,132) }");
 
   // Append a disjoint cluster to check for two separate ranges.
   AppendCluster(GenerateSingleStreamCluster(
@@ skipping 654 matching lines @@
   // 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:
   //        PTS: 370155 (0x0005a5eb)  [= 90 kHz-Timestamp: 0:00:04.1128]
   //        DTS: 367152 (0x00059a30)  [= 90 kHz-Timestamp: 0:00:04.0794]
   // Audio: last PES:
   //        PTS: 353788 (0x000565fc)  [= 90 kHz-Timestamp: 0:00:03.9309]
 
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-1280x720.ts");
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendData(kSourceId, buffer->data(), buffer->data_size());
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   // ResetParserState on the Mpeg2 TS parser triggers the emission of the last
   // video buffer which is pending in the stream parser.
   Ranges<base::TimeDelta> range_before_abort =
       demuxer_->GetBufferedRanges(kSourceId);
   demuxer_->ResetParserState(kSourceId,
@@ skipping 27 matching lines @@
   // 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:
   //        PTS: 370155 (0x0005a5eb)  [= 90 kHz-Timestamp: 0:00:04.1128]
   //        DTS: 367152 (0x00059a30)  [= 90 kHz-Timestamp: 0:00:04.0794]
   // Audio: last PES:
   //        PTS: 353788 (0x000565fc)  [= 90 kHz-Timestamp: 0:00:03.9309]
 
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("bear-1280x720.ts");
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   AppendData(kSourceId, buffer->data(), buffer->data_size());
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   // Seek to a time corresponding to buffers that will be emitted during the
   // abort.
   Seek(base::TimeDelta::FromMilliseconds(4110));
 
   // ResetParserState on the Mpeg2 TS parser triggers the emission of the last
@@ skipping 590 matching lines @@
   // Set the append window to [50,150).
   append_window_start_for_next_append_ = base::TimeDelta::FromMilliseconds(50);
   append_window_end_for_next_append_ = base::TimeDelta::FromMilliseconds(150);
 
   // Read a WebM file into memory and send the data to the demuxer.  The chunk
   // size has been chosen carefully to ensure the preroll buffer used by the
   // partial append window trim must come from a previous Append() call.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   AppendDataInPieces(buffer->data(), buffer->data_size(), 128);
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   CheckExpectedBuffers(stream, "50KP 50K 62K 86K 109K 122K 125K 128K");
 }
 
 TEST_F(ChunkDemuxerTest, AppendWindow_AudioConfigUpdateRemovesPreroll) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_,
       CreateInitDoneCB(base::TimeDelta::FromMilliseconds(2744), PIPELINE_OK),
       true);
   ASSERT_EQ(ChunkDemuxer::kOk, AddId(kSourceId, HAS_AUDIO));
 
   // Set the append window such that the first file is completely before the
   // append window.
   // Expect duration adjustment since actual duration differs slightly from
   // duration in the init segment.
   const base::TimeDelta duration_1 = base::TimeDelta::FromMilliseconds(2746);
   append_window_start_for_next_append_ = duration_1;
 
   // Read a WebM file into memory and append the data.
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-320x240-audio-only.webm");
   ExpectInitMediaLogs(HAS_AUDIO);
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   AppendDataInPieces(buffer->data(), buffer->data_size(), 512);
   CheckExpectedRanges("{ }");
 
   DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   AudioDecoderConfig config_1 = stream->audio_decoder_config();
 
   // Read a second WebM with a different config in and append the data.
   scoped_refptr<DecoderBuffer> buffer2 =
       ReadTestDataFile("bear-320x240-audio-only-48khz.webm");
-  EXPECT_CALL(*this, InitSegmentReceived(_));
+  EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(21));
   EXPECT_CALL(host_, SetDuration(_)).Times(AnyNumber());
   ASSERT_TRUE(SetTimestampOffset(kSourceId, duration_1));
   AppendDataInPieces(buffer2->data(), buffer2->data_size(), 512);
   CheckExpectedRanges("{ [2746,5519) }");
 
   Seek(duration_1);
   ExpectConfigChanged(DemuxerStream::AUDIO);
   ASSERT_FALSE(config_1.Matches(stream->audio_decoder_config()));
   CheckExpectedBuffers(stream, "2746K 2767K 2789K 2810K");
@@ skipping 490 matching lines @@
              cluster->size() - video_start);
 
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,91) }");
   CheckExpectedRanges("{ [30,90) }");
   CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
   CheckExpectedBuffers(video_stream, "71K 81");
 }
 
 }  // namespace media