| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2015 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 | |
| 5 #include "content/browser/renderer_host/media/audio_output_device_enumerator.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <string> | |
| 9 | |
| 10 #include "base/bind.h" | |
| 11 #include "base/location.h" | |
| 12 #include "base/macros.h" | |
| 13 #include "base/memory/ref_counted.h" | |
| 14 #include "base/run_loop.h" | |
| 15 #include "base/strings/string_number_conversions.h" | |
| 16 #include "base/threading/thread_task_runner_handle.h" | |
| 17 #include "content/public/test/test_browser_thread_bundle.h" | |
| 18 #include "media/audio/audio_device_description.h" | |
| 19 #include "media/audio/fake_audio_log_factory.h" | |
| 20 #include "media/audio/fake_audio_manager.h" | |
| 21 #include "testing/gmock/include/gmock/gmock.h" | |
| 22 #include "testing/gtest/include/gtest/gtest.h" | |
| 23 | |
| 24 using testing::_; | |
| 25 | |
| 26 namespace content { | |
| 27 | |
| 28 namespace { | |
| 29 | |
| 30 class MockAudioManager : public media::FakeAudioManager { | |
| 31 public: | |
| 32 MockAudioManager(size_t num_devices) | |
| 33 : FakeAudioManager(base::ThreadTaskRunnerHandle::Get(), | |
| 34 base::ThreadTaskRunnerHandle::Get(), | |
| 35 &fake_audio_log_factory_), | |
| 36 num_devices_(num_devices) {} | |
| 37 MockAudioManager() : MockAudioManager(0) {} | |
| 38 ~MockAudioManager() override {} | |
| 39 | |
| 40 MOCK_METHOD1(MockGetAudioOutputDeviceNames, void(media::AudioDeviceNames*)); | |
| 41 | |
| 42 void GetAudioOutputDeviceNames( | |
| 43 media::AudioDeviceNames* device_names) override { | |
| 44 DCHECK(device_names->empty()); | |
| 45 MockGetAudioOutputDeviceNames(device_names); | |
| 46 if (num_devices_ > 0) { | |
| 47 device_names->push_back(media::AudioDeviceName::CreateDefault()); | |
| 48 for (size_t i = 0; i < num_devices_; i++) { | |
| 49 device_names->push_back( | |
| 50 media::AudioDeviceName("FakeDeviceName_" + base::IntToString(i), | |
| 51 "FakeDeviceId_" + base::IntToString(i))); | |
| 52 } | |
| 53 } | |
| 54 } | |
| 55 | |
| 56 private: | |
| 57 media::FakeAudioLogFactory fake_audio_log_factory_; | |
| 58 size_t num_devices_; | |
| 59 DISALLOW_COPY_AND_ASSIGN(MockAudioManager); | |
| 60 }; | |
| 61 | |
| 62 // Fake audio manager that exposes only the default device | |
| 63 class OnlyDefaultDeviceAudioManager : public MockAudioManager { | |
| 64 public: | |
| 65 OnlyDefaultDeviceAudioManager() {} | |
| 66 ~OnlyDefaultDeviceAudioManager() override {} | |
| 67 void GetAudioOutputDeviceNames( | |
| 68 media::AudioDeviceNames* device_names) override { | |
| 69 DCHECK(device_names->empty()); | |
| 70 MockGetAudioOutputDeviceNames(device_names); | |
| 71 device_names->push_front(media::AudioDeviceName::CreateDefault()); | |
| 72 } | |
| 73 | |
| 74 private: | |
| 75 DISALLOW_COPY_AND_ASSIGN(OnlyDefaultDeviceAudioManager); | |
| 76 }; | |
| 77 | |
| 78 } // namespace | |
| 79 | |
| 80 class AudioOutputDeviceEnumeratorTest : public ::testing::Test { | |
| 81 public: | |
| 82 AudioOutputDeviceEnumeratorTest() {} | |
| 83 ~AudioOutputDeviceEnumeratorTest() override {} | |
| 84 | |
| 85 MOCK_METHOD1(MockCallback, void(const AudioOutputDeviceEnumeration&)); | |
| 86 | |
| 87 // Performs n calls to MockCallback (one by QuitCallback) | |
| 88 // and n-1 calls to Enumerate | |
| 89 void EnumerateCallback(AudioOutputDeviceEnumerator* enumerator, | |
| 90 int n, | |
| 91 const AudioOutputDeviceEnumeration& result) { | |
| 92 MockCallback(result); | |
| 93 if (n > 1) { | |
| 94 enumerator->Enumerate( | |
| 95 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback, | |
| 96 base::Unretained(this), enumerator, n - 1)); | |
| 97 } else { | |
| 98 enumerator->Enumerate( | |
| 99 base::Bind(&AudioOutputDeviceEnumeratorTest::QuitCallback, | |
| 100 base::Unretained(this))); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 void EnumerateCountCallback(size_t num_entries_expected, | |
| 105 bool actual_devices_expected, | |
| 106 const AudioOutputDeviceEnumeration& result) { | |
| 107 EXPECT_EQ(actual_devices_expected, result.has_actual_devices); | |
| 108 EXPECT_EQ(num_entries_expected, result.devices.size()); | |
| 109 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, | |
| 110 run_loop_.QuitClosure()); | |
| 111 } | |
| 112 | |
| 113 void QuitCallback(const AudioOutputDeviceEnumeration& result) { | |
| 114 MockCallback(result); | |
| 115 base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, | |
| 116 run_loop_.QuitClosure()); | |
| 117 } | |
| 118 | |
| 119 protected: | |
| 120 TestBrowserThreadBundle thread_bundle_; | |
| 121 std::unique_ptr<MockAudioManager, media::AudioManagerDeleter> audio_manager_; | |
| 122 base::RunLoop run_loop_; | |
| 123 | |
| 124 private: | |
| 125 DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceEnumeratorTest); | |
| 126 }; | |
| 127 | |
| 128 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateWithCache) { | |
| 129 const int num_calls = 10; | |
| 130 audio_manager_.reset(new MockAudioManager()); | |
| 131 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(1); | |
| 132 EXPECT_CALL(*this, MockCallback(_)).Times(num_calls); | |
| 133 AudioOutputDeviceEnumerator enumerator( | |
| 134 audio_manager_.get(), | |
| 135 AudioOutputDeviceEnumerator::CACHE_POLICY_MANUAL_INVALIDATION); | |
| 136 enumerator.Enumerate( | |
| 137 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback, | |
| 138 base::Unretained(this), &enumerator, num_calls - 1)); | |
| 139 run_loop_.Run(); | |
| 140 } | |
| 141 | |
| 142 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateWithNoCache) { | |
| 143 const int num_calls = 10; | |
| 144 audio_manager_.reset(new MockAudioManager()); | |
| 145 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)) | |
| 146 .Times(num_calls); | |
| 147 EXPECT_CALL(*this, MockCallback(_)).Times(num_calls); | |
| 148 AudioOutputDeviceEnumerator enumerator( | |
| 149 audio_manager_.get(), | |
| 150 AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING); | |
| 151 enumerator.Enumerate( | |
| 152 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback, | |
| 153 base::Unretained(this), &enumerator, num_calls - 1)); | |
| 154 run_loop_.Run(); | |
| 155 } | |
| 156 | |
| 157 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateNoDevices) { | |
| 158 audio_manager_.reset(new MockAudioManager()); | |
| 159 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)); | |
| 160 AudioOutputDeviceEnumerator enumerator( | |
| 161 audio_manager_.get(), | |
| 162 AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING); | |
| 163 enumerator.Enumerate( | |
| 164 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback, | |
| 165 base::Unretained(this), 1, false)); | |
| 166 run_loop_.Run(); | |
| 167 } | |
| 168 | |
| 169 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateOnlyDefaultDevice) { | |
| 170 audio_manager_.reset(new OnlyDefaultDeviceAudioManager()); | |
| 171 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)); | |
| 172 AudioOutputDeviceEnumerator enumerator( | |
| 173 audio_manager_.get(), | |
| 174 AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING); | |
| 175 enumerator.Enumerate( | |
| 176 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback, | |
| 177 base::Unretained(this), 1, true)); | |
| 178 run_loop_.Run(); | |
| 179 } | |
| 180 | |
| 181 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateOneDevice) { | |
| 182 size_t num_devices = 1; | |
| 183 audio_manager_.reset(new MockAudioManager(num_devices)); | |
| 184 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)); | |
| 185 AudioOutputDeviceEnumerator enumerator( | |
| 186 audio_manager_.get(), | |
| 187 AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING); | |
| 188 enumerator.Enumerate( | |
| 189 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback, | |
| 190 base::Unretained(this), num_devices + 1, true)); | |
| 191 run_loop_.Run(); | |
| 192 } | |
| 193 | |
| 194 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateMultipleDevices) { | |
| 195 size_t num_devices = 5; | |
| 196 audio_manager_.reset(new MockAudioManager(num_devices)); | |
| 197 EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)); | |
| 198 AudioOutputDeviceEnumerator enumerator( | |
| 199 audio_manager_.get(), | |
| 200 AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING); | |
| 201 enumerator.Enumerate( | |
| 202 base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback, | |
| 203 base::Unretained(this), num_devices + 1, true)); | |
| 204 run_loop_.Run(); | |
| 205 } | |
| 206 | |
| 207 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2368213002:
Remove AudioOutputDeviceEnumerator. Replace usage with MediaDevicesManager. (Closed)
