Correctly handle enumerations for AudioManagers that report only the default audio output device.

content/browser/renderer_host/media/audio_output_device_enumerator_unittest.cc

 // Copyright (c) 2015 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 <string>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/media/audio_output_device_enumerator.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/fake_audio_log_factory.h"
 #include "media/audio/fake_audio_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace content {
 
 namespace {
+
 class MockAudioManager : public media::FakeAudioManager {
  public:
-  MockAudioManager() : FakeAudioManager(&fake_audio_log_factory_) {}
+  MockAudioManager(size_t num_devices)
+      : FakeAudioManager(&fake_audio_log_factory_), num_devices_(num_devices) {}
+  MockAudioManager() : MockAudioManager(0) {}
   ~MockAudioManager() override {}
-  MOCK_METHOD1(GetAudioOutputDeviceNames, void(media::AudioDeviceNames*));
+
+  MOCK_METHOD1(MockGetAudioOutputDeviceNames, void(media::AudioDeviceNames*));
+
+  void GetAudioOutputDeviceNames(
+      media::AudioDeviceNames* device_names) override {
+    DCHECK(device_names->empty());
+    MockGetAudioOutputDeviceNames(device_names);
+    if (num_devices_ > 0) {
+      device_names->push_back(
+          media::AudioDeviceName(AudioManager::GetDefaultDeviceName(),
+                                 AudioManagerBase::kDefaultDeviceId));
+      for (size_t i = 0; i < num_devices_; i++) {
+        device_names->push_back(
+            media::AudioDeviceName("FakeDeviceName_" + base::IntToString(i),
+                                   "FakeDeviceId_" + base::IntToString(i)));
+      }
+    }
+  }
 
  private:
   media::FakeAudioLogFactory fake_audio_log_factory_;
+  size_t num_devices_;
   DISALLOW_COPY_AND_ASSIGN(MockAudioManager);
 };
+
+// Fake audio manager that exposes only the default device
+class OnlyDefaultDeviceAudioManager : public MockAudioManager {
+ public:
+  OnlyDefaultDeviceAudioManager() {}
+  ~OnlyDefaultDeviceAudioManager() override {}
+  void GetAudioOutputDeviceNames(
+      media::AudioDeviceNames* device_names) override {
+    DCHECK(device_names->empty());
+    MockGetAudioOutputDeviceNames(device_names);
+    device_names->push_front(
+        media::AudioDeviceName(AudioManager::GetDefaultDeviceName(),
+                               AudioManagerBase::kDefaultDeviceId));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OnlyDefaultDeviceAudioManager);
+};
+
 }  // namespace
 
 class AudioOutputDeviceEnumeratorTest : public ::testing::Test {
  public:
   AudioOutputDeviceEnumeratorTest()
-      : thread_bundle_(), task_runner_(base::ThreadTaskRunnerHandle::Get()) {
-    audio_manager_.reset(new MockAudioManager());
-  }
+      : thread_bundle_(), task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
 
   ~AudioOutputDeviceEnumeratorTest() override {}
 
   MOCK_METHOD1(MockCallback, void(const AudioOutputDeviceEnumeration&));
 
   // Performs n calls to MockCallback (one by QuitCallback)
   // and n-1 calls to Enumerate
   void EnumerateCallback(AudioOutputDeviceEnumerator* enumerator,
                          int n,
                          const AudioOutputDeviceEnumeration& result) {
     MockCallback(result);
     if (n > 1) {
       enumerator->Enumerate(
           base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback,
                      base::Unretained(this), enumerator, n - 1));
     } else {
       enumerator->Enumerate(
           base::Bind(&AudioOutputDeviceEnumeratorTest::QuitCallback,
                      base::Unretained(this)));
     }
   }
 
+  void EnumerateCountCallback(size_t num_entries_expected,
+                              bool actual_devices_expected,
+                              const AudioOutputDeviceEnumeration& result) {
+    EXPECT_EQ(actual_devices_expected, result.has_actual_devices);
+    EXPECT_EQ(num_entries_expected, result.devices.size());
+    task_runner_->PostTask(FROM_HERE, run_loop_.QuitClosure());
+  }
+
   void QuitCallback(const AudioOutputDeviceEnumeration& result) {
     MockCallback(result);
     task_runner_->PostTask(FROM_HERE, run_loop_.QuitClosure());
   }
 
  protected:
   scoped_ptr<MockAudioManager> audio_manager_;
   TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::RunLoop run_loop_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceEnumeratorTest);
 };
 
 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateWithCache) {
   const int num_calls = 10;
-  EXPECT_CALL(*audio_manager_, GetAudioOutputDeviceNames(_)).Times(1);
+  audio_manager_.reset(new MockAudioManager());
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(1);
   EXPECT_CALL(*this, MockCallback(_)).Times(num_calls);
   AudioOutputDeviceEnumerator enumerator(
       audio_manager_.get(),
       AudioOutputDeviceEnumerator::CACHE_POLICY_MANUAL_INVALIDATION);
   enumerator.Enumerate(
       base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback,
                  base::Unretained(this), &enumerator, num_calls - 1));
   run_loop_.Run();
 }
 
 TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateWithNoCache) {
   const int num_calls = 10;
-  EXPECT_CALL(*audio_manager_, GetAudioOutputDeviceNames(_)).Times(num_calls);
+  audio_manager_.reset(new MockAudioManager());
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_))
+      .Times(num_calls);
   EXPECT_CALL(*this, MockCallback(_)).Times(num_calls);
   AudioOutputDeviceEnumerator enumerator(
       audio_manager_.get(),
       AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING);
   enumerator.Enumerate(
       base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCallback,
                  base::Unretained(this), &enumerator, num_calls - 1));
   run_loop_.Run();
 }
 
+TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateNoDevices) {
+  audio_manager_.reset(new MockAudioManager());
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_));
+  AudioOutputDeviceEnumerator enumerator(
+      audio_manager_.get(),
+      AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING);
+  enumerator.Enumerate(
+      base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback,
+                 base::Unretained(this), 1, false));
+  run_loop_.Run();
+}
+
+TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateOnlyDefaultDevice) {
+  audio_manager_.reset(new OnlyDefaultDeviceAudioManager());
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_));
+  AudioOutputDeviceEnumerator enumerator(
+      audio_manager_.get(),
+      AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING);
+  enumerator.Enumerate(
+      base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback,
+                 base::Unretained(this), 1, true));
+  run_loop_.Run();
+}
+
+TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateOneDevice) {
+  size_t num_devices = 1;
+  audio_manager_.reset(new MockAudioManager(num_devices));
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_));
+  AudioOutputDeviceEnumerator enumerator(
+      audio_manager_.get(),
+      AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING);
+  enumerator.Enumerate(
+      base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback,
+                 base::Unretained(this), num_devices + 1, true));
+  run_loop_.Run();
+}
+
+TEST_F(AudioOutputDeviceEnumeratorTest, EnumerateMultipleDevices) {
+  size_t num_devices = 5;
+  audio_manager_.reset(new MockAudioManager(num_devices));
+  EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_));
+  AudioOutputDeviceEnumerator enumerator(
+      audio_manager_.get(),
+      AudioOutputDeviceEnumerator::CACHE_POLICY_NO_CACHING);
+  enumerator.Enumerate(
+      base::Bind(&AudioOutputDeviceEnumeratorTest::EnumerateCountCallback,
+                 base::Unretained(this), num_devices + 1, true));
+  run_loop_.Run();
+}
+
 }  // namespace content