input_stream_unittest.cc 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537
  1. // Copyright 2018 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 "services/audio/input_stream.h"
  5. #include <memory>
  6. #include <string>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/callback_helpers.h"
  10. #include "base/memory/read_only_shared_memory_region.h"
  11. #include "base/test/task_environment.h"
  12. #include "media/audio/audio_io.h"
  13. #include "media/audio/mock_audio_manager.h"
  14. #include "media/audio/test_audio_thread.h"
  15. #include "mojo/public/cpp/bindings/pending_receiver.h"
  16. #include "mojo/public/cpp/bindings/pending_remote.h"
  17. #include "mojo/public/cpp/bindings/receiver.h"
  18. #include "mojo/public/cpp/bindings/remote.h"
  19. #include "mojo/public/cpp/system/functions.h"
  20. #include "services/audio/stream_factory.h"
  21. #include "services/audio/test/mock_log.h"
  22. #include "testing/gmock/include/gmock/gmock.h"
  23. #include "testing/gtest/include/gtest/gtest.h"
  24. using testing::_;
  25. using testing::NiceMock;
  26. using testing::NotNull;
  27. using testing::Return;
  28. using testing::StrictMock;
  29. namespace audio {
  30. namespace {
  31. const uint32_t kDefaultSharedMemoryCount = 10;
  32. const bool kDoEnableAGC = true;
  33. const bool kDoNotEnableAGC = false;
  34. const bool kValidStream = true;
  35. const bool kInvalidStream = false;
  36. const bool kMuted = true;
  37. const bool kNotMuted = false;
  38. const char* kDefaultDeviceId = "default";
  39. class MockStreamClient : public media::mojom::AudioInputStreamClient {
  40. public:
  41. MockStreamClient() = default;
  42. MockStreamClient(const MockStreamClient&) = delete;
  43. MockStreamClient& operator=(const MockStreamClient&) = delete;
  44. mojo::PendingRemote<media::mojom::AudioInputStreamClient> MakeRemote() {
  45. DCHECK(!receiver_.is_bound());
  46. mojo::PendingRemote<media::mojom::AudioInputStreamClient> remote;
  47. receiver_.Bind(remote.InitWithNewPipeAndPassReceiver());
  48. receiver_.set_disconnect_handler(base::BindOnce(
  49. &MockStreamClient::BindingConnectionError, base::Unretained(this)));
  50. return remote;
  51. }
  52. void CloseBinding() { receiver_.reset(); }
  53. MOCK_METHOD1(OnError, void(media::mojom::InputStreamErrorCode));
  54. MOCK_METHOD1(OnMutedStateChanged, void(bool));
  55. MOCK_METHOD0(BindingConnectionError, void());
  56. private:
  57. mojo::Receiver<media::mojom::AudioInputStreamClient> receiver_{this};
  58. };
  59. class MockStreamObserver : public media::mojom::AudioInputStreamObserver {
  60. public:
  61. MockStreamObserver() = default;
  62. MockStreamObserver(const MockStreamObserver&) = delete;
  63. MockStreamObserver& operator=(const MockStreamObserver&) = delete;
  64. mojo::PendingRemote<media::mojom::AudioInputStreamObserver> MakeRemote() {
  65. DCHECK(!receiver_.is_bound());
  66. mojo::PendingRemote<media::mojom::AudioInputStreamObserver> remote;
  67. receiver_.Bind(remote.InitWithNewPipeAndPassReceiver());
  68. receiver_.set_disconnect_handler(base::BindOnce(
  69. &MockStreamObserver::BindingConnectionError, base::Unretained(this)));
  70. return remote;
  71. }
  72. void CloseBinding() { receiver_.reset(); }
  73. MOCK_METHOD0(DidStartRecording, void());
  74. MOCK_METHOD0(BindingConnectionError, void());
  75. private:
  76. mojo::Receiver<media::mojom::AudioInputStreamObserver> receiver_{this};
  77. };
  78. class MockStream : public media::AudioInputStream {
  79. public:
  80. MockStream() {}
  81. MockStream(const MockStream&) = delete;
  82. MockStream& operator=(const MockStream&) = delete;
  83. double GetMaxVolume() override { return 1; }
  84. MOCK_METHOD0(Open, media::AudioInputStream::OpenOutcome());
  85. MOCK_METHOD1(Start, void(AudioInputCallback*));
  86. MOCK_METHOD0(Stop, void());
  87. MOCK_METHOD0(Close, void());
  88. MOCK_METHOD1(SetVolume, void(double));
  89. MOCK_METHOD0(GetVolume, double());
  90. MOCK_METHOD1(SetAutomaticGainControl, bool(bool));
  91. MOCK_METHOD0(GetAutomaticGainControl, bool());
  92. MOCK_METHOD0(IsMuted, bool());
  93. MOCK_METHOD1(SetOutputDeviceForAec, void(const std::string&));
  94. };
  95. } // namespace
  96. class AudioServiceInputStreamTest : public testing::Test {
  97. public:
  98. AudioServiceInputStreamTest()
  99. : audio_manager_(std::make_unique<media::TestAudioThread>(false)),
  100. stream_factory_(&audio_manager_, /*aecdump_recording_manager=*/nullptr),
  101. stream_factory_receiver_(
  102. &stream_factory_,
  103. remote_stream_factory_.BindNewPipeAndPassReceiver()) {}
  104. AudioServiceInputStreamTest(const AudioServiceInputStreamTest&) = delete;
  105. AudioServiceInputStreamTest& operator=(const AudioServiceInputStreamTest&) =
  106. delete;
  107. ~AudioServiceInputStreamTest() override { audio_manager_.Shutdown(); }
  108. void SetUp() override {
  109. mojo::SetDefaultProcessErrorHandler(
  110. base::BindRepeating(&AudioServiceInputStreamTest::BadMessageCallback,
  111. base::Unretained(this)));
  112. }
  113. void TearDown() override {
  114. mojo::SetDefaultProcessErrorHandler(base::NullCallback());
  115. }
  116. mojo::PendingRemote<media::mojom::AudioInputStream> CreateStream(
  117. bool enable_agc) {
  118. mojo::PendingRemote<media::mojom::AudioInputStream> remote_stream;
  119. remote_stream_factory_->CreateInputStream(
  120. remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
  121. observer_.MakeRemote(), log_.MakeRemote(), kDefaultDeviceId,
  122. media::AudioParameters::UnavailableDeviceParams(),
  123. kDefaultSharedMemoryCount, enable_agc,
  124. base::ReadOnlySharedMemoryRegion(), nullptr,
  125. base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
  126. base::Unretained(this)));
  127. return remote_stream;
  128. }
  129. mojo::PendingRemote<media::mojom::AudioInputStream>
  130. CreateStreamWithNullptrLog() {
  131. mojo::PendingRemote<media::mojom::AudioInputStream> remote_stream;
  132. remote_stream_factory_->CreateInputStream(
  133. remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
  134. observer_.MakeRemote(), mojo::NullRemote(), kDefaultDeviceId,
  135. media::AudioParameters::UnavailableDeviceParams(),
  136. kDefaultSharedMemoryCount, false, base::ReadOnlySharedMemoryRegion(),
  137. nullptr,
  138. base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
  139. base::Unretained(this)));
  140. return remote_stream;
  141. }
  142. mojo::PendingRemote<media::mojom::AudioInputStream>
  143. CreateStreamWithNullptrObserver() {
  144. mojo::PendingRemote<media::mojom::AudioInputStream> remote_stream;
  145. remote_stream_factory_->CreateInputStream(
  146. remote_stream.InitWithNewPipeAndPassReceiver(), client_.MakeRemote(),
  147. mojo::NullRemote(), log_.MakeRemote(), kDefaultDeviceId,
  148. media::AudioParameters::UnavailableDeviceParams(),
  149. kDefaultSharedMemoryCount, false, base::ReadOnlySharedMemoryRegion(),
  150. nullptr,
  151. base::BindOnce(&AudioServiceInputStreamTest::OnCreated,
  152. base::Unretained(this)));
  153. return remote_stream;
  154. }
  155. media::MockAudioManager& audio_manager() { return audio_manager_; }
  156. MockStreamClient& client() { return client_; }
  157. MockStreamObserver& observer() { return observer_; }
  158. MockLog& log() { return log_; }
  159. void OnCreated(media::mojom::ReadOnlyAudioDataPipePtr ptr,
  160. bool initially_muted,
  161. const absl::optional<base::UnguessableToken>& stream_id) {
  162. EXPECT_EQ(stream_id.has_value(), !!ptr);
  163. CreatedCallback(!!ptr, initially_muted);
  164. }
  165. MOCK_METHOD2(CreatedCallback, void(bool /*valid*/, bool /*initially_muted*/));
  166. MOCK_METHOD1(BadMessageCallback, void(const std::string&));
  167. private:
  168. base::test::TaskEnvironment scoped_task_env_;
  169. media::MockAudioManager audio_manager_;
  170. StreamFactory stream_factory_;
  171. mojo::Remote<media::mojom::AudioStreamFactory> remote_stream_factory_;
  172. mojo::Receiver<media::mojom::AudioStreamFactory> stream_factory_receiver_;
  173. StrictMock<MockStreamClient> client_;
  174. StrictMock<MockStreamObserver> observer_;
  175. NiceMock<MockLog> log_;
  176. };
  177. TEST_F(AudioServiceInputStreamTest, ConstructDestruct) {
  178. NiceMock<MockStream> mock_stream;
  179. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  180. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  181. const std::string& device_id) { return stream; },
  182. &mock_stream));
  183. EXPECT_CALL(mock_stream, Open())
  184. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  185. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  186. EXPECT_CALL(log(), OnCreated(_, _));
  187. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  188. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  189. CreateStream(kDoNotEnableAGC));
  190. base::RunLoop().RunUntilIdle();
  191. EXPECT_CALL(mock_stream, Close());
  192. EXPECT_CALL(log(), OnClosed());
  193. EXPECT_CALL(client(), BindingConnectionError());
  194. EXPECT_CALL(observer(), BindingConnectionError());
  195. remote_stream.reset();
  196. base::RunLoop().RunUntilIdle();
  197. }
  198. TEST_F(AudioServiceInputStreamTest, ConstructDestructNullptrLog) {
  199. NiceMock<MockStream> mock_stream;
  200. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  201. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  202. const std::string& device_id) { return stream; },
  203. &mock_stream));
  204. EXPECT_CALL(mock_stream, Open())
  205. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  206. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  207. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  208. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  209. CreateStreamWithNullptrLog());
  210. base::RunLoop().RunUntilIdle();
  211. EXPECT_CALL(mock_stream, Close());
  212. EXPECT_CALL(client(), BindingConnectionError());
  213. EXPECT_CALL(observer(), BindingConnectionError());
  214. remote_stream.reset();
  215. base::RunLoop().RunUntilIdle();
  216. }
  217. TEST_F(AudioServiceInputStreamTest, ConstructDestructNullptrObserver) {
  218. NiceMock<MockStream> mock_stream;
  219. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  220. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  221. const std::string& device_id) { return stream; },
  222. &mock_stream));
  223. EXPECT_CALL(mock_stream, Open())
  224. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  225. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  226. EXPECT_CALL(log(), OnCreated(_, _));
  227. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  228. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  229. CreateStreamWithNullptrObserver());
  230. base::RunLoop().RunUntilIdle();
  231. EXPECT_CALL(mock_stream, Close());
  232. EXPECT_CALL(log(), OnClosed());
  233. EXPECT_CALL(client(), BindingConnectionError());
  234. remote_stream.reset();
  235. base::RunLoop().RunUntilIdle();
  236. }
  237. TEST_F(AudioServiceInputStreamTest,
  238. ConstructStreamAndCloseClientBinding_DestructsStream) {
  239. NiceMock<MockStream> mock_stream;
  240. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  241. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  242. const std::string& device_id) { return stream; },
  243. &mock_stream));
  244. EXPECT_CALL(mock_stream, Open())
  245. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  246. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  247. EXPECT_CALL(log(), OnCreated(_, _));
  248. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  249. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  250. CreateStream(kDoNotEnableAGC));
  251. base::RunLoop().RunUntilIdle();
  252. EXPECT_CALL(mock_stream, Close());
  253. EXPECT_CALL(log(), OnClosed());
  254. EXPECT_CALL(observer(), BindingConnectionError());
  255. client().CloseBinding();
  256. base::RunLoop().RunUntilIdle();
  257. }
  258. TEST_F(AudioServiceInputStreamTest,
  259. ConstructStreamAndCloseObserverBinding_DestructsStream) {
  260. NiceMock<MockStream> mock_stream;
  261. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  262. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  263. const std::string& device_id) { return stream; },
  264. &mock_stream));
  265. EXPECT_CALL(mock_stream, Open())
  266. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  267. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  268. EXPECT_CALL(log(), OnCreated(_, _));
  269. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  270. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  271. CreateStream(kDoNotEnableAGC));
  272. base::RunLoop().RunUntilIdle();
  273. EXPECT_CALL(mock_stream, Close());
  274. EXPECT_CALL(log(), OnClosed());
  275. EXPECT_CALL(client(), BindingConnectionError());
  276. observer().CloseBinding();
  277. base::RunLoop().RunUntilIdle();
  278. }
  279. TEST_F(AudioServiceInputStreamTest,
  280. ConstructStreamAndResetStreamPtr_DestructsStream) {
  281. NiceMock<MockStream> mock_stream;
  282. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  283. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  284. const std::string& device_id) { return stream; },
  285. &mock_stream));
  286. EXPECT_CALL(mock_stream, Open())
  287. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  288. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  289. EXPECT_CALL(log(), OnCreated(_, _));
  290. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  291. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  292. CreateStream(kDoNotEnableAGC));
  293. base::RunLoop().RunUntilIdle();
  294. EXPECT_CALL(mock_stream, Close());
  295. EXPECT_CALL(log(), OnClosed());
  296. EXPECT_CALL(client(), BindingConnectionError());
  297. EXPECT_CALL(observer(), BindingConnectionError());
  298. remote_stream.reset();
  299. base::RunLoop().RunUntilIdle();
  300. }
  301. TEST_F(AudioServiceInputStreamTest, Record) {
  302. NiceMock<MockStream> mock_stream;
  303. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  304. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  305. const std::string& device_id) { return stream; },
  306. &mock_stream));
  307. EXPECT_CALL(mock_stream, Open())
  308. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  309. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  310. EXPECT_CALL(log(), OnCreated(_, _));
  311. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  312. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  313. CreateStream(kDoNotEnableAGC));
  314. base::RunLoop().RunUntilIdle();
  315. EXPECT_CALL(mock_stream, Start(NotNull()));
  316. EXPECT_CALL(log(), OnStarted());
  317. EXPECT_CALL(observer(), DidStartRecording());
  318. remote_stream->Record();
  319. base::RunLoop().RunUntilIdle();
  320. EXPECT_CALL(mock_stream, Stop());
  321. EXPECT_CALL(mock_stream, Close());
  322. EXPECT_CALL(log(), OnClosed());
  323. EXPECT_CALL(client(), BindingConnectionError());
  324. EXPECT_CALL(observer(), BindingConnectionError());
  325. remote_stream.reset();
  326. base::RunLoop().RunUntilIdle();
  327. }
  328. TEST_F(AudioServiceInputStreamTest, SetVolume) {
  329. NiceMock<MockStream> mock_stream;
  330. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  331. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  332. const std::string& device_id) { return stream; },
  333. &mock_stream));
  334. EXPECT_CALL(mock_stream, Open())
  335. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  336. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  337. EXPECT_CALL(log(), OnCreated(_, _));
  338. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  339. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  340. CreateStream(kDoNotEnableAGC));
  341. base::RunLoop().RunUntilIdle();
  342. const double new_volume = 0.618;
  343. EXPECT_CALL(mock_stream, SetVolume(new_volume));
  344. EXPECT_CALL(log(), OnSetVolume(new_volume));
  345. remote_stream->SetVolume(new_volume);
  346. base::RunLoop().RunUntilIdle();
  347. EXPECT_CALL(mock_stream, Close());
  348. EXPECT_CALL(log(), OnClosed());
  349. EXPECT_CALL(client(), BindingConnectionError());
  350. EXPECT_CALL(observer(), BindingConnectionError());
  351. remote_stream.reset();
  352. base::RunLoop().RunUntilIdle();
  353. }
  354. TEST_F(AudioServiceInputStreamTest, SetNegativeVolume_BadMessage) {
  355. NiceMock<MockStream> mock_stream;
  356. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  357. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  358. const std::string& device_id) { return stream; },
  359. &mock_stream));
  360. EXPECT_CALL(mock_stream, Open())
  361. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  362. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  363. EXPECT_CALL(log(), OnCreated(_, _));
  364. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  365. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  366. CreateStream(kDoNotEnableAGC));
  367. base::RunLoop().RunUntilIdle();
  368. EXPECT_CALL(*this, BadMessageCallback(_));
  369. EXPECT_CALL(mock_stream, Close());
  370. EXPECT_CALL(log(), OnClosed());
  371. EXPECT_CALL(client(), BindingConnectionError());
  372. EXPECT_CALL(observer(), BindingConnectionError());
  373. remote_stream->SetVolume(-0.618);
  374. base::RunLoop().RunUntilIdle();
  375. }
  376. TEST_F(AudioServiceInputStreamTest, SetVolumeGreaterThanOne_BadMessage) {
  377. NiceMock<MockStream> mock_stream;
  378. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  379. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  380. const std::string& device_id) { return stream; },
  381. &mock_stream));
  382. EXPECT_CALL(mock_stream, Open())
  383. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  384. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  385. EXPECT_CALL(log(), OnCreated(_, _));
  386. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  387. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  388. CreateStream(kDoNotEnableAGC));
  389. base::RunLoop().RunUntilIdle();
  390. EXPECT_CALL(*this, BadMessageCallback(_));
  391. EXPECT_CALL(mock_stream, Close());
  392. EXPECT_CALL(log(), OnClosed());
  393. EXPECT_CALL(client(), BindingConnectionError());
  394. EXPECT_CALL(observer(), BindingConnectionError());
  395. remote_stream->SetVolume(1.618);
  396. base::RunLoop().RunUntilIdle();
  397. }
  398. TEST_F(AudioServiceInputStreamTest, CreateStreamWithAGCEnable_PropagateAGC) {
  399. NiceMock<MockStream> mock_stream;
  400. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  401. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  402. const std::string& device_id) { return stream; },
  403. &mock_stream));
  404. EXPECT_CALL(mock_stream, Open())
  405. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  406. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kNotMuted));
  407. EXPECT_CALL(mock_stream, SetAutomaticGainControl(kDoEnableAGC));
  408. EXPECT_CALL(log(), OnCreated(_, _));
  409. EXPECT_CALL(*this, CreatedCallback(kValidStream, kNotMuted));
  410. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  411. CreateStream(kDoEnableAGC));
  412. base::RunLoop().RunUntilIdle();
  413. EXPECT_CALL(log(), OnClosed());
  414. EXPECT_CALL(mock_stream, Close());
  415. EXPECT_CALL(client(), BindingConnectionError());
  416. EXPECT_CALL(observer(), BindingConnectionError());
  417. remote_stream.reset();
  418. base::RunLoop().RunUntilIdle();
  419. }
  420. TEST_F(AudioServiceInputStreamTest,
  421. CreateInitiallyMutedStream_PropagateInitiallyMuted) {
  422. NiceMock<MockStream> mock_stream;
  423. audio_manager().SetMakeInputStreamCB(base::BindRepeating(
  424. [](media::AudioInputStream* stream, const media::AudioParameters& params,
  425. const std::string& device_id) { return stream; },
  426. &mock_stream));
  427. EXPECT_CALL(mock_stream, Open())
  428. .WillOnce(Return(MockStream::OpenOutcome::kSuccess));
  429. EXPECT_CALL(mock_stream, IsMuted()).WillOnce(Return(kMuted));
  430. EXPECT_CALL(log(), OnCreated(_, _));
  431. EXPECT_CALL(*this, CreatedCallback(kValidStream, kMuted));
  432. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  433. CreateStream(kDoEnableAGC));
  434. base::RunLoop().RunUntilIdle();
  435. EXPECT_CALL(log(), OnClosed());
  436. EXPECT_CALL(mock_stream, Close());
  437. EXPECT_CALL(client(), BindingConnectionError());
  438. EXPECT_CALL(observer(), BindingConnectionError());
  439. remote_stream.reset();
  440. base::RunLoop().RunUntilIdle();
  441. }
  442. TEST_F(AudioServiceInputStreamTest,
  443. ConstructWithStreamCreationFailure_SignalsError) {
  444. // By default, MockAudioManager fails to create a stream.
  445. mojo::Remote<media::mojom::AudioInputStream> remote_stream(
  446. CreateStream(kDoNotEnableAGC));
  447. EXPECT_CALL(*this, CreatedCallback(kInvalidStream, kNotMuted));
  448. EXPECT_CALL(log(), OnError());
  449. EXPECT_CALL(client(), OnError(media::mojom::InputStreamErrorCode::kUnknown));
  450. EXPECT_CALL(client(), BindingConnectionError());
  451. EXPECT_CALL(observer(), BindingConnectionError());
  452. base::RunLoop().RunUntilIdle();
  453. }
  454. } // namespace audio