audio_input_device_unittest.cc 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154
  1. // Copyright (c) 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/audio/audio_input_device.h"
  5. #include <utility>
  6. #include "base/memory/ptr_util.h"
  7. #include "base/memory/read_only_shared_memory_region.h"
  8. #include "base/process/process_handle.h"
  9. #include "base/run_loop.h"
  10. #include "base/sync_socket.h"
  11. #include "base/task/single_thread_task_runner.h"
  12. #include "base/test/task_environment.h"
  13. #include "testing/gmock/include/gmock/gmock.h"
  14. #include "testing/gtest/include/gtest/gtest.h"
  15. using base::CancelableSyncSocket;
  16. using base::SyncSocket;
  17. using testing::_;
  18. using testing::DoAll;
  19. using testing::Invoke;
  20. using testing::InvokeWithoutArgs;
  21. namespace media {
  22. namespace {
  23. const size_t kMemorySegmentCount = 10u;
  24. class MockAudioInputIPC : public AudioInputIPC {
  25. public:
  26. MockAudioInputIPC() = default;
  27. ~MockAudioInputIPC() override = default;
  28. MOCK_METHOD4(CreateStream,
  29. void(AudioInputIPCDelegate* delegate,
  30. const AudioParameters& params,
  31. bool automatic_gain_control,
  32. uint32_t total_segments));
  33. MOCK_METHOD0(RecordStream, void());
  34. MOCK_METHOD1(SetVolume, void(double volume));
  35. MOCK_METHOD1(SetOutputDeviceForAec, void(const std::string&));
  36. MOCK_METHOD0(CloseStream, void());
  37. };
  38. class MockCaptureCallback : public AudioCapturerSource::CaptureCallback {
  39. public:
  40. MockCaptureCallback() = default;
  41. ~MockCaptureCallback() override = default;
  42. MOCK_METHOD0(OnCaptureStarted, void());
  43. MOCK_METHOD4(Capture,
  44. void(const AudioBus* audio_source,
  45. base::TimeTicks audio_capture_time,
  46. double volume,
  47. bool key_pressed));
  48. MOCK_METHOD2(OnCaptureError,
  49. void(AudioCapturerSource::ErrorCode code,
  50. const std::string& message));
  51. MOCK_METHOD1(OnCaptureMuted, void(bool is_muted));
  52. };
  53. } // namespace.
  54. class AudioInputDeviceTest
  55. : public ::testing::TestWithParam<AudioInputDevice::DeadStreamDetection> {};
  56. // Regular construction.
  57. TEST_P(AudioInputDeviceTest, Noop) {
  58. base::test::SingleThreadTaskEnvironment task_environment(
  59. base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
  60. MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
  61. scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
  62. base::WrapUnique(input_ipc), AudioInputDevice::Purpose::kUserInput,
  63. AudioInputDeviceTest::GetParam()));
  64. }
  65. ACTION_P(ReportStateChange, device) {
  66. static_cast<AudioInputIPCDelegate*>(device)->OnError(
  67. media::AudioCapturerSource::ErrorCode::kUnknown);
  68. }
  69. // Verify that we get an OnCaptureError() callback if CreateStream fails.
  70. TEST_P(AudioInputDeviceTest, FailToCreateStream) {
  71. AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
  72. CHANNEL_LAYOUT_STEREO, 48000, 480);
  73. MockCaptureCallback callback;
  74. MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
  75. scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
  76. base::WrapUnique(input_ipc), AudioInputDevice::Purpose::kUserInput,
  77. AudioInputDeviceTest::GetParam()));
  78. device->Initialize(params, &callback);
  79. EXPECT_CALL(*input_ipc, CreateStream(_, _, _, _))
  80. .WillOnce(ReportStateChange(device.get()));
  81. EXPECT_CALL(callback,
  82. OnCaptureError(AudioCapturerSource::ErrorCode::kUnknown, _));
  83. EXPECT_CALL(*input_ipc, CloseStream());
  84. device->Start();
  85. device->Stop();
  86. }
  87. TEST_P(AudioInputDeviceTest, CreateStream) {
  88. AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
  89. CHANNEL_LAYOUT_STEREO, 48000, 480);
  90. base::MappedReadOnlyRegion shared_memory;
  91. CancelableSyncSocket browser_socket;
  92. CancelableSyncSocket renderer_socket;
  93. const uint32_t memory_size =
  94. media::ComputeAudioInputBufferSize(params, kMemorySegmentCount);
  95. shared_memory = base::ReadOnlySharedMemoryRegion::Create(memory_size);
  96. ASSERT_TRUE(shared_memory.IsValid());
  97. memset(shared_memory.mapping.memory(), 0xff, memory_size);
  98. ASSERT_TRUE(
  99. CancelableSyncSocket::CreatePair(&browser_socket, &renderer_socket));
  100. base::ReadOnlySharedMemoryRegion duplicated_shared_memory_region =
  101. shared_memory.region.Duplicate();
  102. ASSERT_TRUE(duplicated_shared_memory_region.IsValid());
  103. base::test::TaskEnvironment ste;
  104. MockCaptureCallback callback;
  105. MockAudioInputIPC* input_ipc = new MockAudioInputIPC();
  106. scoped_refptr<AudioInputDevice> device(new AudioInputDevice(
  107. base::WrapUnique(input_ipc), AudioInputDevice::Purpose::kUserInput,
  108. AudioInputDeviceTest::GetParam()));
  109. device->Initialize(params, &callback);
  110. EXPECT_CALL(*input_ipc, CreateStream(_, _, _, _))
  111. .WillOnce(InvokeWithoutArgs([&]() {
  112. static_cast<AudioInputIPCDelegate*>(device.get())
  113. ->OnStreamCreated(std::move(duplicated_shared_memory_region),
  114. renderer_socket.Take(), false);
  115. }));
  116. EXPECT_CALL(*input_ipc, RecordStream());
  117. EXPECT_CALL(callback, OnCaptureStarted());
  118. device->Start();
  119. EXPECT_CALL(*input_ipc, CloseStream());
  120. device->Stop();
  121. }
  122. INSTANTIATE_TEST_SUITE_P(
  123. AudioInputDeviceGroup,
  124. AudioInputDeviceTest,
  125. ::testing::Values(AudioInputDevice::DeadStreamDetection::kDisabled,
  126. AudioInputDevice::DeadStreamDetection::kEnabled));
  127. } // namespace media.