Allow muting/unmuting audio through media track API

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 <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 599 matching lines @@
       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);
     }
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
     chunk_demuxer_->SetTracksWatcher(
-        kSourceId, base::Bind(&MockMediaSource::InitSegmentReceivedWrapper,
+        kSourceId, base::Bind(&MockMediaSource::InitSegmentReceived,
                               base::Unretained(this)));
 
     AppendData(initial_append_size_);
   }
 
   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 {
     return last_timestamp_offset_;
   }
 
-  // A workaround for gtest mocks not allowing moving scoped_ptrs.
-  void InitSegmentReceivedWrapper(scoped_ptr<MediaTracks> tracks) {
-    InitSegmentReceived(tracks);
+  void InitSegmentReceived(scoped_ptr<MediaTracks> tracks) {
+    CHECK(tracks.get());
+    EXPECT_GT(tracks->tracks().size(), 0u);
+    CHECK(chunk_demuxer_);
+    // Generate track ids.
+    std::vector<unsigned> track_ids;
+    for (size_t track_id = 1; track_id <= tracks->tracks().size(); ++track_id) {
+      track_ids.push_back(track_id);
+    }
+
+    chunk_demuxer_->OnTrackIdsAssigned(*tracks.get(), track_ids);
+    InitSegmentReceivedMock(tracks);
   }
 
-  MOCK_METHOD1(InitSegmentReceived, void(scoped_ptr<MediaTracks>&));
+  MOCK_METHOD1(InitSegmentReceivedMock, void(scoped_ptr<MediaTracks>&));
 
  private:
   scoped_refptr<DecoderBuffer> file_data_;
   size_t current_position_;
   size_t initial_append_size_;
   std::string mimetype_;
   ChunkDemuxer* chunk_demuxer_;
   scoped_ptr<Demuxer> owned_chunk_demuxer_;
   Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
   base::TimeDelta last_timestamp_offset_;
@@ skipping 33 matching lines @@
  public:
   PipelineStatus StartPipelineWithMediaSource(MockMediaSource* source) {
     return StartPipelineWithMediaSource(source, kNormal);
   }
 
   PipelineStatus StartPipelineWithMediaSource(MockMediaSource* source,
                                               uint8_t test_type) {
     hashing_enabled_ = test_type & kHashed;
     clockless_playback_ = test_type & kClockless;
 
-    EXPECT_CALL(*source, InitSegmentReceived(_)).Times(AtLeast(1));
+    EXPECT_CALL(*source, InitSegmentReceivedMock(_)).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
 
     // Encrypted content not used, so this is never called.
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
@@ skipping 13 matching lines @@
                                     base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnWaitingForDecryptionKey,
                    base::Unretained(this)));
     message_loop_.Run();
     EXPECT_EQ(PIPELINE_OK, pipeline_status_);
     return pipeline_status_;
   }
 
   void StartPipelineWithEncryptedMedia(MockMediaSource* source,
                                        FakeEncryptedMedia* encrypted_media) {
-    EXPECT_CALL(*source, InitSegmentReceived(_)).Times(AtLeast(1));
+    EXPECT_CALL(*source, InitSegmentReceivedMock(_)).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
     EXPECT_CALL(*this, DecryptorAttached(true));
 
     // Encrypted content used but keys provided in advance, so this is
@@ skipping 1387 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());
 }
 
+TEST_F(PipelineIntegrationTest, AudioTrackMuteUnmute) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
+
+  // Start playback and play a little, to ensure demuxer streams are created.
+  Play();
+  ASSERT_TRUE(
+      WaitUntilCurrentTimeIsAfter(base::TimeDelta::FromMilliseconds(200)));
+  Pause();
+
+  const DemuxerStream* demux_stream = demuxer_->GetDemuxerStreamByTrackId(2);
+  EXPECT_NE(demux_stream, nullptr);
+  EXPECT_EQ(demux_stream->type(), DemuxerStream::AUDIO);
+
+  // TODO(servolk): Find a way to verify that audio is really muted/unmuted.
+  // This should mute the audio stream.
+  std::vector<const DemuxerStream*> enabledAudioStreams;
+  pipeline_->OnEnabledAudioStreamsChanged(enabledAudioStreams);
+
+  Play();
+  ASSERT_TRUE(
+      WaitUntilCurrentTimeIsAfter(base::TimeDelta::FromMilliseconds(500)));
+  Pause();
+
+  // This should unmute the audio stream.
+  enabledAudioStreams.push_back(demux_stream);
+  pipeline_->OnEnabledAudioStreamsChanged(enabledAudioStreams);
+
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
+TEST_F(PipelineIntegrationTest, VideoTrackSelectDeselect) {
+  ASSERT_EQ(PIPELINE_OK, Start("bear-320x240.webm"));
+
+  // Start playback and play a little, to ensure demuxer streams are created.
+  Play();
+  ASSERT_TRUE(
+      WaitUntilCurrentTimeIsAfter(base::TimeDelta::FromMilliseconds(200)));
+  Pause();
+
+  const DemuxerStream* demux_stream = demuxer_->GetDemuxerStreamByTrackId(1);
+  EXPECT_NE(demux_stream, nullptr);
+  EXPECT_EQ(demux_stream->type(), DemuxerStream::VIDEO);
+
+  // Deselect video stream.
+  pipeline_->OnSelectedVideoStreamChanged(nullptr);
+
+  Play();
+  ASSERT_TRUE(
+      WaitUntilCurrentTimeIsAfter(base::TimeDelta::FromMilliseconds(500)));
+  Pause();
+
+  // Select video stream.
+  pipeline_->OnSelectedVideoStreamChanged(demux_stream);
+
+  Play();
+  ASSERT_TRUE(WaitUntilOnEnded());
+}
+
 }  // namespace media