Make FakeVideoCaptureDeviceFactory configurable to arbitrary fake device configurations

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 331 matching lines @@
   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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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(
         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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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(
         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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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(
         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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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(
         devices_to_enumerate,
         base::Bind(&MediaDevicesManagerTest::EnumerateCallback,
@@ skipping 11 matching lines @@
 TEST_F(MediaDevicesManagerTest, SubscribeDeviceChanges) {
   EXPECT_CALL(*audio_manager_, MockGetAudioOutputDeviceNames(_)).Times(3);
   EXPECT_CALL(*video_capture_device_factory_, MockGetDeviceDescriptors())
       .Times(3);
   EXPECT_CALL(*audio_manager_, MockGetAudioInputDeviceNames(_)).Times(3);
 
   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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      num_video_input_devices);
   audio_manager_->SetNumAudioOutputDevices(num_audio_output_devices);
 
   // Run an enumeration to make sure |media_devices_manager_| has the new
   // configuration.
   EXPECT_CALL(*this, MockCallback(_));
   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;
   base::RunLoop run_loop;
@@ skipping 51 matching lines @@
   EXPECT_CALL(subscriber_all,
               OnDevicesChanged(MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, _))
       .Times(2)
       .WillRepeatedly(SaveArg<1>(&notification_all_audio_output));
 
   // 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);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(num_audio_input_devices, notification_audio_input.size());
   EXPECT_EQ(num_video_input_devices, notification_video_input.size());
   EXPECT_EQ(num_audio_output_devices, notification_audio_output.size());
   EXPECT_EQ(num_audio_input_devices, notification_all_audio_input.size());
   EXPECT_EQ(num_video_input_devices, notification_all_video_input.size());
   EXPECT_EQ(num_audio_output_devices, notification_all_audio_output.size());
 
   media_devices_manager_->UnsubscribeDeviceChangeNotifications(
       MEDIA_DEVICE_TYPE_AUDIO_INPUT, &subscriber_audio_input);
   media_devices_manager_->UnsubscribeDeviceChangeNotifications(
       MEDIA_DEVICE_TYPE_VIDEO_INPUT, &subscriber_video_input);
   media_devices_manager_->UnsubscribeDeviceChangeNotifications(
       MEDIA_DEVICE_TYPE_AUDIO_OUTPUT, &subscriber_audio_output);
 
   // Simulate further device changes. Only the objects still subscribed to the
   // device-change events will receive notifications.
   num_audio_input_devices = 2;
   num_video_input_devices = 1;
   num_audio_output_devices = 3;
   audio_manager_->SetNumAudioInputDevices(num_audio_input_devices);
-  video_capture_device_factory_->set_number_of_devices(num_video_input_devices);
+  video_capture_device_factory_->SetToDefaultDevicesConfig(
+      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);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(num_audio_input_devices, notification_all_audio_input.size());
   EXPECT_EQ(num_video_input_devices, notification_all_video_input.size());
   EXPECT_EQ(num_audio_output_devices, notification_all_audio_output.size());
 }
 
 }  // namespace content