Unmute Tab Audio For Desktop Share

content/browser/media/capture/web_contents_audio_input_stream_unittest.cc

 // Copyright (c) 2013 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 "content/browser/media/capture/web_contents_audio_input_stream.h"
 
 #include <stdint.h>
 
 #include <list>
 
@@ skipping 15 matching lines @@
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
 using ::testing::SaveArg;
 using ::testing::WithArgs;
 
+using media::AudioBus;
 using media::AudioInputStream;
 using media::AudioOutputStream;
 using media::AudioParameters;
+using media::AudioPushSink;
 using media::SineWaveAudioSource;
 using media::VirtualAudioInputStream;
 using media::VirtualAudioOutputStream;
 
 namespace content {
 
 namespace {
 
 const int kRenderProcessId = 123;
 const int kRenderFrameId = 456;
@@ skipping 63 matching lines @@
     ON_CALL(*this, SetVolume(_))
         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::SetVolume));
     ON_CALL(*this, GetVolume())
         .WillByDefault(Invoke(&real_, &VirtualAudioInputStream::GetVolume));
     ON_CALL(*this, SetAutomaticGainControl(_))
         .WillByDefault(
             Invoke(&real_, &VirtualAudioInputStream::SetAutomaticGainControl));
     ON_CALL(*this, GetAutomaticGainControl())
         .WillByDefault(
             Invoke(&real_, &VirtualAudioInputStream::GetAutomaticGainControl));
-    ON_CALL(*this, AddOutputStream(NotNull(), _))
+    ON_CALL(*this, AddInputProvider(NotNull(), _))
         .WillByDefault(
-            Invoke(&real_, &VirtualAudioInputStream::AddOutputStream));
-    ON_CALL(*this, RemoveOutputStream(NotNull(), _))
+            Invoke(&real_, &VirtualAudioInputStream::AddInputProvider));
+    ON_CALL(*this, RemoveInputProvider(NotNull(), _))
         .WillByDefault(
-            Invoke(&real_, &VirtualAudioInputStream::RemoveOutputStream));
+            Invoke(&real_, &VirtualAudioInputStream::RemoveInputProvider));
   }
 
   ~MockVirtualAudioInputStream() {
     DCHECK(real_stream_is_closed_);
   }
 
   MOCK_METHOD0(Open, bool());
   MOCK_METHOD1(Start, void(AudioInputStream::AudioInputCallback*));
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD0(Close, void());
   MOCK_METHOD0(GetMaxVolume, double());
   MOCK_METHOD1(SetVolume, void(double));
   MOCK_METHOD0(GetVolume, double());
   MOCK_METHOD1(SetAutomaticGainControl, bool(bool));
   MOCK_METHOD0(GetAutomaticGainControl, bool());
-  MOCK_METHOD2(AddOutputStream, void(VirtualAudioOutputStream*,
-                                     const AudioParameters&));
-  MOCK_METHOD2(RemoveOutputStream, void(VirtualAudioOutputStream*,
-                                        const AudioParameters&));
+  MOCK_METHOD2(AddInputProvider,
+               void(media::AudioConverter::InputCallback*,
+                    const AudioParameters&));
+  MOCK_METHOD2(RemoveInputProvider,
+               void(media::AudioConverter::InputCallback*,
+                    const AudioParameters&));
 
  private:
   void OnRealStreamHasClosed(VirtualAudioInputStream* stream) {
     DCHECK_EQ(&real_, stream);
     DCHECK(!real_stream_is_closed_);
     real_stream_is_closed_ = true;
   }
 
   VirtualAudioInputStream real_;
   bool real_stream_is_closed_;
@@ skipping 11 matching lines @@
                     uint32_t hardware_delay_bytes,
                     double volume));
   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioInputCallback);
 };
 
 }  // namespace
 
-class WebContentsAudioInputStreamTest : public testing::Test {
+class WebContentsAudioInputStreamTest : public testing::TestWithParam<bool> {
  public:
   WebContentsAudioInputStreamTest()
       : thread_bundle_(new TestBrowserThreadBundle(
             TestBrowserThreadBundle::REAL_IO_THREAD)),
         audio_thread_("Audio thread"),
         mock_mirroring_manager_(new MockAudioMirroringManager()),
         mock_tracker_(new MockWebContentsTracker()),
         mock_vais_(NULL),
         wcais_(NULL),
         destination_(NULL),
         current_render_process_id_(kRenderProcessId),
         current_render_frame_id_(kRenderFrameId),
         on_data_event_(false, false) {
     audio_thread_.Start();
   }
 
   ~WebContentsAudioInputStreamTest() override {
     audio_thread_.Stop();
     thread_bundle_.reset();
 
     DCHECK(!mock_vais_);
     DCHECK(!wcais_);
     EXPECT_FALSE(destination_);
     DCHECK(streams_.empty());
     DCHECK(sources_.empty());
   }
 
+  // If this value is true, we are testing a WebContentsAudioInputStream
+  // instance, which requests duplicate audio.
+  // Otherwise, we are testing a WebContentsAudioInputStream instance, which
+  // requests diverting audio.
+  bool is_duplication() const { return GetParam(); }
+
   void Open() {
     mock_vais_ = new MockVirtualAudioInputStream(audio_thread_.task_runner());
     EXPECT_CALL(*mock_vais_, Open());
     EXPECT_CALL(*mock_vais_, Close());  // At Close() time.
 
     ASSERT_EQ(kRenderProcessId, current_render_process_id_);
     ASSERT_EQ(kRenderFrameId, current_render_frame_id_);
     EXPECT_CALL(*mock_tracker_.get(),
                 Start(kRenderProcessId, kRenderFrameId, _))
         .WillOnce(DoAll(
              SaveArg<2>(&change_callback_),
              WithArgs<0, 1>(Invoke(this,
                                    &WebContentsAudioInputStreamTest::
                                        SimulateChangeCallback))));
 
     EXPECT_CALL(*mock_tracker_.get(), Stop());  // At Close() time.
 
     wcais_ = new WebContentsAudioInputStream(
         current_render_process_id_, current_render_frame_id_,
-        mock_mirroring_manager_.get(),
-        mock_tracker_, mock_vais_);
+        mock_mirroring_manager_.get(), mock_tracker_, mock_vais_,
+        is_duplication());
     wcais_->Open();
   }
 
   void Start() {
     EXPECT_CALL(*mock_vais_, Start(&mock_input_callback_));
     EXPECT_CALL(*mock_vais_, Stop());  // At Stop() time.
 
     EXPECT_CALL(*mock_mirroring_manager_, StartMirroring(NotNull()))
         .WillOnce(SaveArg<0>(&destination_))
         .RetiresOnSaturation();
@@ skipping 33 matching lines @@
     // Note: WCAIS posts a task to invoke
     // MockAudioMirroringManager::StartMirroring() on the IO thread, which
     // causes our mock to set |destination_|.  Block until that has happened.
     base::WaitableEvent done(false, false);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(
             &base::WaitableEvent::Signal, base::Unretained(&done)));
     done.Wait();
     ASSERT_TRUE(destination_);
 
-    EXPECT_CALL(*mock_vais_, AddOutputStream(NotNull(), _))
+    EXPECT_CALL(*mock_vais_, AddInputProvider(NotNull(), _))
         .RetiresOnSaturation();
     // Later, when stream is closed:
-    EXPECT_CALL(*mock_vais_, RemoveOutputStream(NotNull(), _))
+    EXPECT_CALL(*mock_vais_, RemoveInputProvider(NotNull(), _))
         .RetiresOnSaturation();
 
     const AudioParameters& params = TestAudioParameters();
-    AudioOutputStream* const out = destination_->AddInput(params);
-    ASSERT_TRUE(out);
-    streams_.push_back(out);
-    EXPECT_TRUE(out->Open());
     SineWaveAudioSource* const source = new SineWaveAudioSource(
         params.channel_layout(), 200.0, params.sample_rate());
     sources_.push_back(source);
-    out->Start(source);
+    if (is_duplication()) {
+      media::AudioPushSink* out = destination_->AddPushInput(params);
+      ASSERT_TRUE(out);
+      sinks_.push_back(out);
+      std::unique_ptr<media::AudioBus> audio_data = AudioBus::Create(params);
+      base::TimeTicks now = base::TimeTicks::Now();
+      // 20 Audio buses are enough for all test cases.
+      const int kAudioBusesNumber = 20;
+      for (int i = 0; i < kAudioBusesNumber; i++) {
+        int frames = source->OnMoreData(audio_data.get(), 0, 0);
+        std::unique_ptr<media::AudioBus> copy = AudioBus::Create(params);
+        audio_data->CopyTo(copy.get());
+        out->OnData(std::move(copy), now);
+        now += base::TimeDelta::FromMillisecondsD(
+            frames * params.GetMicrosecondsPerFrame());
+      }
+    } else {
+      AudioOutputStream* const out = destination_->AddInput(params);
+      ASSERT_TRUE(out);
+      streams_.push_back(out);
+      EXPECT_TRUE(out->Open());
+      out->Start(source);
+    }
   }
 
   void RemoveOneInputInFIFOOrder() {
-    ASSERT_FALSE(streams_.empty());
-    AudioOutputStream* const out = streams_.front();
-    streams_.pop_front();
-    out->Stop();
-    out->Close();  // Self-deletes.
+    if (is_duplication()) {
+      ASSERT_FALSE(sinks_.empty());
+      AudioPushSink* const out = sinks_.front();
+      sinks_.pop_front();
+      out->Close();  // Self-deletes.
+    } else {
+      ASSERT_FALSE(streams_.empty());
+      AudioOutputStream* const out = streams_.front();
+      streams_.pop_front();
+      out->Stop();
+      out->Close();  // Self-deletes.
+    }
     ASSERT_TRUE(!sources_.empty());
     delete sources_.front();
     sources_.pop_front();
   }
 
   void ChangeMirroringTarget() {
     const int next_render_process_id =
         current_render_process_id_ == kRenderProcessId ?
             kAnotherRenderProcessId : kRenderProcessId;
     const int next_render_frame_id =
@@ skipping 70 matching lines @@
   // to simulate: 1) calls to AddInput(); and 2) diverting audio data.
   AudioMirroringManager::MirroringDestination* destination_;
 
   // Current target RenderFrame.  These get flipped in ChangedMirroringTarget().
   int current_render_process_id_;
   int current_render_frame_id_;
 
   // Streams provided by calls to WebContentsAudioInputStream::AddInput().  Each
   // is started with a simulated source of audio data.
   std::list<AudioOutputStream*> streams_;
+  std::list<media::AudioPushSink*> sinks_;
   std::list<SineWaveAudioSource*> sources_;  // 1:1 with elements in streams_.
 
   base::WaitableEvent on_data_event_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsAudioInputStreamTest);
 };
 
 #define RUN_ON_AUDIO_THREAD(method) \
   RunOnAudioThread(base::Bind(&WebContentsAudioInputStreamTest::method,  \
                               base::Unretained(this)))
 
-TEST_F(WebContentsAudioInputStreamTest, OpenedButNeverStarted) {
+TEST_P(WebContentsAudioInputStreamTest, OpenedButNeverStarted) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringNothing) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringNothing) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   WaitForData();
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringOutputOutlivesSession) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringOutputOutlivesSession) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringOutputWithinSession) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringOutputWithinSession) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringNothingWithTargetChange) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringNothingWithTargetChange) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringOneStreamAfterTargetChange) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringOneStreamAfterTargetChange) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringOneStreamWithTargetChange) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringOneStreamWithTargetChange) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringLostTarget) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringLostTarget) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(LoseMirroringTarget);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
-TEST_F(WebContentsAudioInputStreamTest, MirroringMultipleStreamsAndTargets) {
+TEST_P(WebContentsAudioInputStreamTest, MirroringMultipleStreamsAndTargets) {
   RUN_ON_AUDIO_THREAD(Open);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   WaitForData();
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(AddAnotherInput);
   WaitForData();
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   WaitForData();
   RUN_ON_AUDIO_THREAD(ChangeMirroringTarget);
   RUN_ON_AUDIO_THREAD(RemoveOneInputInFIFOOrder);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
 }
 
+INSTANTIATE_TEST_CASE_P(, WebContentsAudioInputStreamTest, ::testing::Bool());
+
 }  // namespace content