Allow muting/unmuting audio through media track API

media/test/pipeline_integration_test.cc

Index: media/test/pipeline_integration_test.cc
diff --git a/media/test/pipeline_integration_test.cc b/media/test/pipeline_integration_test.cc
index ea8cd6e8c0c97eefdad2279f2c2917ed69362621..f4f4676f29f245b1dad9dcb5699208dcc7c04dc7 100644
--- a/media/test/pipeline_integration_test.cc
+++ b/media/test/pipeline_integration_test.cc
@@ -617,7 +617,7 @@ class MockMediaSource {
 
     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_);
@@ -634,12 +634,21 @@ class MockMediaSource {
     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_;
@@ -693,7 +702,7 @@ class PipelineIntegrationTest : public PipelineIntegrationTestHost {
     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_));
@@ -727,7 +736,7 @@ class PipelineIntegrationTest : public PipelineIntegrationTestHost {
 
   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_));
@@ -2135,4 +2144,63 @@ TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
             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.

[wolenetz, 2016/04/14 20:43:39]

Hmm. This could perhaps be done in a layout test that slaves the video element
to webaudio. For now (and since we're using the mute hack), please do manual
verification please at least on desktop.
For a little deeper automation that we could do now, consider using a
StrictMock<MediaLog> with associated expectations (and add some MEDIA_LOG(INFO)
to renderer_impl when the hack_muted state changes, and verify those logs are
emitted when expected in these tests.) WDYT? Using a StrictMock<MediaLog> all
over PipelineIntegrationTest is too much for this CL (and probably too much for
future maintenance), and is *not* what I'm asking :)

Once we're not using the mute hack, but indeed disabling decode, once any
asynchronously still-in-progress decode at time of pause finally completes, the
WMPI::decodedAudioBytes() stats should stop incrementing, so we could test
better there (and similarly for video).

[wolenetz, 2016/04/14 22:44:12]

For now, also you can check if the set of rendered audio samples changes
significantly by using the hashing mechanisms in this test.
e.g. "EXPECT_HASH_EQ("<something here>", GetAudioHash());". This macro doesn't
do anything on some pipelines (e.g. mojo), but on supported pipelines it does
detect changes.

[servolk, 2016/04/15 02:23:25]

Yeah, in the future we should be able to verify this using audio hash, but for
now this won't work, since audio hashing ignores volume (see NullAudioSink impl,
in particular ::SetVolume there, it does nothing). And making it use volume
might break other tests.
I've done manual verification of this both on MSE (YouTube) and FFmpeg code
paths.

[wolenetz, 2016/04/15 22:47:18]

Acknowledged.

+  // 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