Remove VideoCaptureDeviceFactory::EnumerateDeviceDescriptors()

content/browser/renderer_host/media/video_capture_manager.cc

 // Copyright (c) 2012 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/video_capture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 209 matching lines @@
 }
 
 void VideoCaptureManager::EnumerateDevices(
     const EnumerationCallback& client_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureManager::EnumerateDevices";
 
   // Bind a callback to ConsolidateDevicesInfoOnDeviceThread() with an argument
   // for another callback to OnDevicesInfoEnumerated() to be run in the current
   // loop, i.e. IO loop. Pass a timer for UMA histogram collection.
-  base::Callback<void(std::unique_ptr<VideoCaptureDeviceDescriptors>)>
-      devices_enumerated_callback = base::Bind(
-          &VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread, this,
-          media::BindToCurrentLoop(base::Bind(
-              &VideoCaptureManager::OnDevicesInfoEnumerated, this,
-              base::Owned(new base::ElapsedTimer()), client_callback)),
-          devices_info_cache_);
-  // OK to use base::Unretained() since we own the VCDFactory and |this| is
-  // bound in |devices_enumerated_callback|.
   device_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&media::VideoCaptureDeviceFactory::EnumerateDeviceDescriptors,
-                 base::Unretained(video_capture_device_factory_.get()),
-                 devices_enumerated_callback));
+      base::Bind(&VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread,

[chfremer, 2017/04/07 16:34:21]

As a heads up, I am sorry about the extra work this means, but there is a CL
still in flight and about to land that will conflict with this, see
https://codereview.chromium.org/2805533002/. There, the call to
EnumerateDeviceDescriptors has moved to a new class VideoCaptureSystem.
The changes you made here will probably have to be applied there instead.

[Chandan, 2017/04/10 09:18:24]

Done.

+                 this,
+                 media::BindToCurrentLoop(base::Bind(
+                     &VideoCaptureManager::OnDevicesInfoEnumerated, this,
+                     base::Owned(new base::ElapsedTimer()), client_callback)),
+                 devices_info_cache_));
 }
 
 const media::VideoCaptureDeviceDescriptor*
 VideoCaptureManager::LookupDeviceDescriptor(const std::string& id) {
   const DeviceInfo* info = GetDeviceInfoById(id);
   return info ? (&info->descriptor) : nullptr;
 }
 
 int VideoCaptureManager::Open(const MediaStreamDevice& device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 509 matching lines @@
   for (const auto& it : devices_info_cache_) {
     devices.emplace_back(it.descriptor);
     descriptors_and_formats.emplace_back(it.descriptor, it.supported_formats);
     MediaInternals::GetInstance()->UpdateVideoCaptureDeviceCapabilities(
         descriptors_and_formats);
   }
 
   client_callback.Run(devices);
 }
 
 void VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread(

[chfremer, 2017/04/07 16:34:21]

Now that this method includes the logic for pulling new device descriptors from
the factory, we may want to rename it. Maybe "UpdateDeviceInfosOnDeviceThread"?

[Chandan, 2017/04/10 09:18:24]

This method no longer exists in this class.

     base::Callback<void(const VideoCaptureManager::DeviceInfos&)>
         on_devices_enumerated_callback,
-    const VideoCaptureManager::DeviceInfos& old_device_info_cache,
-    std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors_snapshot) {
+    const VideoCaptureManager::DeviceInfos& old_device_info_cache) {
   DCHECK(device_task_runner_->BelongsToCurrentThread());
+  media::VideoCaptureDeviceDescriptors descriptors;
+  video_capture_device_factory_->GetDeviceDescriptors(&descriptors);
   // Construct |new_devices_info_cache| with the cached devices that are still
   // present in the system, and remove their names from |names_snapshot|, so we
   // keep there the truly new devices.
   VideoCaptureManager::DeviceInfos new_devices_info_cache;
   for (const auto& device_info : old_device_info_cache) {
-    for (VideoCaptureDeviceDescriptors::iterator it =
-             descriptors_snapshot->begin();
-         it != descriptors_snapshot->end(); ++it) {
+    for (VideoCaptureDeviceDescriptors::iterator it = descriptors.begin();
+         it != descriptors.end(); ++it) {
       if (device_info.descriptor.device_id == it->device_id) {
         new_devices_info_cache.push_back(device_info);
-        descriptors_snapshot->erase(it);
+        descriptors.erase(it);
         break;
       }
     }
   }
 
   // Get the device info for the new devices in |names_snapshot|.
-  for (const auto& it : *descriptors_snapshot) {
+  for (const auto& it : descriptors) {
     DeviceInfo device_info(it);
     video_capture_device_factory_->GetSupportedFormats(
         it, &device_info.supported_formats);
     ConsolidateCaptureFormats(&device_info.supported_formats);
     new_devices_info_cache.push_back(device_info);
   }
 
   on_devices_enumerated_callback.Run(new_devices_info_cache);
 }
 
@@ skipping 161 matching lines @@
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, controller.get(),
                        controller->parameters());
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content