Remove AudioOutputDeviceEnumerator. Replace usage with MediaDevicesManager.

content/browser/renderer_host/media/media_devices_manager_unittest.cc

 // Copyright 2016 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 "content/browser/renderer_host/media/media_devices_manager.h"
 
 #include <memory>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 149 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MediaDevicesManagerTest);
 };
 
 TEST_F(MediaDevicesManagerTest, EnumerateNoCacheAudioInput) {
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_))
       .Times(kNumCalls);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(0);
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(0);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, false, false}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateNoCacheVideoInput) {
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(0);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(kNumCalls);
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(0);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{false, true, false}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateNoCacheAudioOutput) {
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(0);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(0);
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_))
       .Times(kNumCalls);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{false, false, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateNoCacheAudio) {
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_))
       .Times(kNumCalls);
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_))
       .Times(kNumCalls);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, false, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateCacheAudio) {
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(1);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(0);
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(1);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_INPUT);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, false, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateCacheVideo) {
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(0);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(1);
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(0);
   EXPECT_CALL(*this, MockCallback(_)).Times(kNumCalls);
   EnableCache(MEDIA_DEVICE_TYPE_VIDEO_INPUT);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{false, true, false}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateCacheAudioWithDeviceChanges) {
   MediaDeviceEnumeration enumeration;
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(2);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(0);
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(2);
   EXPECT_CALL(*this, MockCallback(_))
       .Times(2 * kNumCalls)
       .WillRepeatedly(SaveArg<0>(&enumeration));
 
   size_t num_audio_input_devices = 5;
   size_t num_audio_output_devices = 3;
   audio_manager_->SetNumAudioInputDevices(num_audio_input_devices);
   audio_manager_->SetNumAudioOutputDevices(num_audio_output_devices);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_INPUT);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, false, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_audio_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size());
     EXPECT_EQ(num_audio_output_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size());
   }
 
   // Simulate device change
   num_audio_input_devices = 3;
   num_audio_output_devices = 4;
   audio_manager_->SetNumAudioInputDevices(num_audio_input_devices);
   audio_manager_->SetNumAudioOutputDevices(num_audio_output_devices);
   media_devices_manager_->OnDevicesChanged(base::SystemMonitor::DEVTYPE_AUDIO);
 
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, false, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_audio_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size());
     EXPECT_EQ(num_audio_output_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size());
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateCacheVideoWithDeviceChanges) {
   MediaDeviceEnumeration enumeration;
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(0);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(2);
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(0);
   EXPECT_CALL(*this, MockCallback(_))
       .Times(2 * kNumCalls)
       .WillRepeatedly(SaveArg<0>(&enumeration));
 
   // Simulate device change
   size_t num_video_input_devices = 5;
   video_capture_device_factory_->set_number_of_devices(num_video_input_devices);
   EnableCache(MEDIA_DEVICE_TYPE_VIDEO_INPUT);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{false, true, false}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_video_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size());
   }
 
   // Simulate device change
   num_video_input_devices = 9;
   video_capture_device_factory_->set_number_of_devices(num_video_input_devices);
   media_devices_manager_->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{false, true, false}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_video_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size());
   }
 }
 
 TEST_F(MediaDevicesManagerTest, EnumerateCacheAllWithDeviceChanges) {
   MediaDeviceEnumeration enumeration;
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(2);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(2);
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(2);
   EXPECT_CALL(*this, MockCallback(_))
       .Times(2 * kNumCalls)
       .WillRepeatedly(SaveArg<0>(&enumeration));
 
   size_t num_audio_input_devices = 5;
   size_t num_video_input_devices = 4;
   size_t num_audio_output_devices = 3;
   audio_manager_->SetNumAudioInputDevices(num_audio_input_devices);
   video_capture_device_factory_->set_number_of_devices(num_video_input_devices);
   audio_manager_->SetNumAudioOutputDevices(num_audio_output_devices);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_INPUT);
   EnableCache(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT);
   EnableCache(MEDIA_DEVICE_TYPE_VIDEO_INPUT);
+  MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_VIDEO_INPUT] = true;
+  devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT] = true;
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, true, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_audio_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size());
     EXPECT_EQ(num_video_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size());
     EXPECT_EQ(num_audio_output_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size());
   }
 
   // Simulate device changes
   num_audio_input_devices = 3;
   num_video_input_devices = 2;
   num_audio_output_devices = 4;
   audio_manager_->SetNumAudioInputDevices(num_audio_input_devices);
   video_capture_device_factory_->set_number_of_devices(num_video_input_devices);
   audio_manager_->SetNumAudioOutputDevices(num_audio_output_devices);
   media_devices_manager_->OnDevicesChanged(base::SystemMonitor::DEVTYPE_AUDIO);
   media_devices_manager_->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   for (int i = 0; i < kNumCalls; i++) {
     base::RunLoop run_loop;
     media_devices_manager_->EnumerateDevices(
-        {{true, true, true}},
+        devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
                    base::Unretained(this), &run_loop));
     run_loop.Run();
     EXPECT_EQ(num_audio_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT].size());
     EXPECT_EQ(num_video_input_devices,
               enumeration[MEDIA_DEVICE_TYPE_VIDEO_INPUT].size());
     EXPECT_EQ(num_audio_output_devices,
               enumeration[MEDIA_DEVICE_TYPE_AUDIO_OUTPUT].size());
   }
 }
 
 }  // namespace content