Unmute Tab Audio For Desktop Share

media/audio/audio_output_controller_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/audio/audio_output_controller.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/test/test_message_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "media/audio/audio_device_description.h"
+#include "media/audio/audio_source_diverter.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::NotNull;
 using ::testing::Return;
 
 namespace media {
 
 static const int kSampleRate = AudioParameters::kAudioCDSampleRate;
 static const int kBitsPerSample = 16;
 static const ChannelLayout kChannelLayout = CHANNEL_LAYOUT_STEREO;
 static const int kSamplesPerPacket = kSampleRate / 100;
 static const double kTestVolume = 0.25;
+static const float kBufferNonZeroData = 1.0f;
 
 class MockAudioOutputControllerEventHandler
     : public AudioOutputController::EventHandler {
  public:
   MockAudioOutputControllerEventHandler() {}
 
   MOCK_METHOD0(OnCreated, void());
   MOCK_METHOD0(OnPlaying, void());
   MOCK_METHOD0(OnPaused, void());
   MOCK_METHOD0(OnError, void());
@@ skipping 26 matching lines @@
   MOCK_METHOD0(Close, void());
 
   // Set/get the callback passed to Start().
   AudioSourceCallback* callback() const { return callback_; }
   void SetCallback(AudioSourceCallback* asc) { callback_ = asc; }
 
  private:
   AudioSourceCallback* callback_;
 };
 
-static const float kBufferNonZeroData = 1.0f;
+class MockAudioPushSink : public AudioPushSink {
+ public:
+  MOCK_METHOD0(Close, void());
+  MOCK_METHOD1(OnDataCheck, void(float));
+
+  void OnData(const AudioBus& source, base::TimeTicks reference_time) override {
+    OnDataCheck(source.channel(0)[0]);
+  }
+};
+
 ACTION(PopulateBuffer) {
   arg0->Zero();
   // Note: To confirm the buffer will be populated in these tests, it's
   // sufficient that only the first float in channel 0 is set to the value.
   arg0->channel(0)[0] = kBufferNonZeroData;
 }
 
 class AudioOutputControllerTest : public testing::Test {
  public:
   AudioOutputControllerTest()
@@ skipping 74 matching lines @@
           .WillRepeatedly(
               Invoke(&mock_stream_, &MockAudioOutputStream::SetCallback));
       EXPECT_CALL(mock_stream_, Stop())
           .Times(num_times_to_be_started);
     }
 
     controller_->StartDiverting(&mock_stream_);
     base::RunLoop().RunUntilIdle();
   }
 
+  void Duplicate(MockAudioPushSink* sink) {
+    controller_->StartDuplicating(sink);
+    base::RunLoop().RunUntilIdle();
+  }
+
   void ReadDivertedAudioData() {
     std::unique_ptr<AudioBus> dest = AudioBus::Create(params_);
     ASSERT_TRUE(mock_stream_.callback());
     const int frames_read =
         mock_stream_.callback()->OnMoreData(dest.get(), 0, 0);
     EXPECT_LT(0, frames_read);
     EXPECT_EQ(kBufferNonZeroData, dest->channel(0)[0]);
   }
 
+  void ReadDuplicatedAudioData(std::vector<MockAudioPushSink*> sinks) {

[miu, 2016/05/06 22:29:50]

The argument type should be: const std::vector<...>&

[qiangchen, 2016/05/10 22:36:53]

Done.

+    for (size_t i = 0; i < sinks.size(); i++) {
+      EXPECT_CALL(*sinks[i], OnDataCheck(kBufferNonZeroData));
+    }
+
+    std::unique_ptr<AudioBus> dest = AudioBus::Create(params_);
+
+    // It is this OnMoreData() call that triggers |sink|'s OnData().
+    const int frames_read = controller_->OnMoreData(dest.get(), 0, 0);
+
+    EXPECT_LT(0, frames_read);
+    EXPECT_EQ(kBufferNonZeroData, dest->channel(0)[0]);
+  }
+
   void Revert(bool was_playing) {
     if (was_playing) {
       // Expect the handler to receive one OnPlaying() call as a result of the
       // stream switching back.
       EXPECT_CALL(mock_event_handler_, OnPlaying());
     }
 
     EXPECT_CALL(mock_stream_, Close());
 
     controller_->StopDiverting();
     base::RunLoop().RunUntilIdle();
   }
 
+  void StopDuplicate(MockAudioPushSink* sink) {

[miu, 2016/05/06 22:29:50]

naming nit: StopDuplicating

[qiangchen, 2016/05/10 22:36:53]

Done.

+    EXPECT_CALL(*sink, Close());
+    controller_->StopDuplicating(sink);
+    base::RunLoop().RunUntilIdle();
+  }
+
   void SwitchDevice(bool diverting) {
     if (!diverting) {
       // Expect the current stream to close and a new stream to start
       // playing if not diverting. When diverting, nothing happens
       // until diverting is stopped.
       EXPECT_CALL(mock_event_handler_, OnPlaying());
     }
 
     controller_->SwitchOutputDevice(
         AudioDeviceDescription::GetDefaultDeviceName(),
@@ skipping 117 matching lines @@
   Close();
 }
 
 TEST_F(AudioOutputControllerTest, DivertRevertClose) {
   Create(kSamplesPerPacket);
   DivertNeverPlaying();
   RevertWasNotPlaying();
   Close();
 }
 
+TEST_F(AudioOutputControllerTest, PlayDuplicateStopClose) {

[miu, 2016/05/06 22:29:50]

Nice tests here too!  :)

[qiangchen, 2016/05/10 22:36:53]

Acknowledged.

+  Create(kSamplesPerPacket);
+  MockAudioPushSink mock_sink;
+  Play();
+  Duplicate(&mock_sink);
+  ReadDuplicatedAudioData({&mock_sink});
+  StopDuplicate(&mock_sink);
+  Close();
+}
+
+TEST_F(AudioOutputControllerTest, TwoDuplicates) {
+  Create(kSamplesPerPacket);
+  MockAudioPushSink mock_sink_1;
+  MockAudioPushSink mock_sink_2;
+  Play();
+  Duplicate(&mock_sink_1);
+  Duplicate(&mock_sink_2);
+  ReadDuplicatedAudioData({&mock_sink_1, &mock_sink_2});
+  StopDuplicate(&mock_sink_1);
+  StopDuplicate(&mock_sink_2);
+  Close();
+}
+
+TEST_F(AudioOutputControllerTest, DuplicateDivertInteract) {
+  Create(kSamplesPerPacket);
+  MockAudioPushSink mock_sink;
+  Play();
+  Duplicate(&mock_sink);
+  DivertWhilePlaying();
+
+  // When diverted stream pulls data, it would trigger a push to sink.
+  EXPECT_CALL(mock_sink, OnDataCheck(kBufferNonZeroData));
+  ReadDivertedAudioData();
+
+  StopDuplicate(&mock_sink);
+  RevertWhilePlaying();
+  Close();
+}
+
+TEST_F(AudioOutputControllerTest, DuplicateSwitchDeviceInteract) {
+  Create(kSamplesPerPacket);
+  MockAudioPushSink mock_sink;
+  Play();
+  Duplicate(&mock_sink);
+  ReadDuplicatedAudioData({&mock_sink});
+
+  // Switching device would trigger a read, and in turn it would trigger a push
+  // to sink.
+  EXPECT_CALL(mock_sink, OnDataCheck(kBufferNonZeroData));
+  SwitchDevice(false);
+
+  StopDuplicate(&mock_sink);
+  Close();
+}
+
 }  // namespace media