Allow muting/unmuting audio through media track API

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 64 matching lines @@
 const int kAudioTrackEntryHeaderSize =
     kAudioTrackSizeOffset + kAudioTrackSizeWidth;
 
 // 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;
 
+// Track numbers AKA bytestream track ids. Bytestream track ids might change
+// within a single playback session if there is only one track of a given type.
 const int kVideoTrackNum = 1;
 const int kAudioTrackNum = 2;
 const int kTextTrackNum = 3;
 const int kAlternateVideoTrackNum = 4;
 const int kAlternateAudioTrackNum = 5;
 const int kAlternateTextTrackNum = 6;
 
+// These value represent externally assigned track ids (for example track ids
+// assigned by blink). Not to be confused with bytestream track ids above. The
+// main difference is that these track ids must stay the same for the duration
+// of the playback session, whereas track numbers / bytestream track ids might
+// change in subsequent init segments.
+const int kVideoTrackId = 10;
+const int kAudioTrackId = 11;
+
 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 1285 matching lines @@
 
   // 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:
   void InitSegmentReceived(scoped_ptr<MediaTracks> tracks) {
     DCHECK(tracks.get());
     DCHECK_GT(tracks->tracks().size(), 0u);
 
+    std::vector<unsigned> track_ids;
+    for (const auto& track : tracks->tracks()) {
+      if (track->type() == MediaTrack::Audio) {
+        track_ids.push_back(kAudioTrackId);
+      } else if (track->type() == MediaTrack::Video) {
+        track_ids.push_back(kVideoTrackId);
+      } else {
+        NOTREACHED();
+      }
+    }
+    demuxer_->OnTrackIdsAssigned(*tracks.get(), track_ids);
+
     InitSegmentReceivedMock(tracks);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
 TEST_F(ChunkDemuxerTest, Init) {
   InSequence s;
 
@@ skipping 179 matching lines @@
   // 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);
+  ASSERT_EQ(audio_stream, demuxer_->GetDemuxerStreamByTrackId(kAudioTrackId));
+  ASSERT_EQ(video_stream, demuxer_->GetDemuxerStreamByTrackId(kVideoTrackId));
 
   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");
+  ASSERT_EQ(audio_stream, demuxer_->GetDemuxerStreamByTrackId(kAudioTrackId));
+  ASSERT_EQ(video_stream, demuxer_->GetDemuxerStreamByTrackId(kVideoTrackId));
 
   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
@@ skipping 3050 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