VideoCaptureDeviceFactory: Change device enumeration to callback + QTKit enumerates in UI thread.

media/video/capture/mac/video_capture_device_factory_mac.mm

 // Copyright 2014 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 "media/video/capture/mac/video_capture_device_factory_mac.h"
 
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/task_runner_util.h"
 #import "media/video/capture/mac/avfoundation_glue.h"
 #include "media/video/capture/mac/video_capture_device_mac.h"
 #import "media/video/capture/mac/video_capture_device_avfoundation_mac.h"
 #import "media/video/capture/mac/video_capture_device_qtkit_mac.h"
 
 namespace media {
 
 // Some devices are not correctly supported in AVFoundation, f.i. Blackmagic,
 // see http://crbug.com/347371. The devices are identified by USB Vendor ID and
 // by a characteristic substring of the name, usually the vendor's name.
 const struct NameAndVid {
   const char* vid;
   const char* name;
 } kBlacklistedCameras[] = { { "a82c", "Blackmagic" } };
 
 // In device identifiers, the USB VID and PID are stored in 4 bytes each.
 const size_t kVidPidSize = 4;
 
-VideoCaptureDeviceFactoryMac::VideoCaptureDeviceFactoryMac() {
+static VideoCaptureDevice::Names EnumerateDevicesUsingQTKit(){
+  // DCHECK that ui_device_thread_ belongs to me.

[perkj_chrome, 2014/05/26 11:49:42]

remove this comment.

[mcasas, 2014/05/26 13:00:18]

Done.

+  VideoCaptureDevice::Names device_names;
+  NSMutableDictionary* capture_devices =
+      [[[NSMutableDictionary alloc] init] autorelease];
+  [VideoCaptureDeviceQTKit getDeviceNames:capture_devices];
+  for (NSString* key in capture_devices) {
+    VideoCaptureDevice::Name name(
+        [[capture_devices valueForKey:key] UTF8String],
+        [key UTF8String], VideoCaptureDevice::Name::QTKIT);
+    device_names.push_back(name);
+  }
+  return device_names;
+}
+
+static void RunDevicesEnumeratedCallback(
+    const base::Callback<void(media::VideoCaptureDevice::Names&)>& callback,
+    VideoCaptureDevice::Names device_names) {
+  callback.Run(device_names);
+}
+
+VideoCaptureDeviceFactoryMac::VideoCaptureDeviceFactoryMac(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
+    : ui_task_runner_(ui_task_runner) {
   thread_checker_.DetachFromThread();
 }
 
+VideoCaptureDeviceFactoryMac::~VideoCaptureDeviceFactoryMac() {}
+
 scoped_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryMac::Create(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
     const VideoCaptureDevice::Name& device_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(device_name.capture_api_type(),
             VideoCaptureDevice::Name::API_TYPE_UNKNOWN);
 
-  VideoCaptureDevice::Names device_names;
-  GetDeviceNames(&device_names);
-  VideoCaptureDevice::Names::iterator it = device_names.begin();
-  for (; it != device_names.end(); ++it) {
-    if (it->id() == device_name.id())
-      break;
-  }
-  if (it == device_names.end())
-    return scoped_ptr<VideoCaptureDevice>();
-
   scoped_ptr<VideoCaptureDeviceMac> capture_device(
       new VideoCaptureDeviceMac(device_name));
   if (!capture_device->Init(device_name.capture_api_type())) {
     LOG(ERROR) << "Could not initialize VideoCaptureDevice.";
     capture_device.reset();
   }
   return scoped_ptr<VideoCaptureDevice>(capture_device.Pass());
 }
 
 void VideoCaptureDeviceFactoryMac::GetDeviceNames(
-    VideoCaptureDevice::Names* const device_names) {
+    VideoCaptureDevice::Names* device_names) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Loop through all available devices and add to |device_names|.
   NSDictionary* capture_devices;
   if (AVFoundationGlue::IsAVFoundationSupported()) {
     bool is_any_device_blacklisted = false;
     DVLOG(1) << "Enumerating video capture devices using AVFoundation";
     capture_devices = [VideoCaptureDeviceAVFoundation deviceNames];
     std::string device_vid;
     // Enumerate all devices found by AVFoundation, translate the info for each
     // to class Name and add it to |device_names|.
@@ skipping 25 matching lines @@
             DVLOG(1) << "Enumerated blacklisted " << [device_name UTF8String];
             VideoCaptureDevice::Name name(
                 "QTKit " + std::string([device_name UTF8String]),
                 [key UTF8String], VideoCaptureDevice::Name::QTKIT);
             device_names->push_back(name);
           }
         }
       }
     }
   } else {
-    DVLOG(1) << "Enumerating video capture devices using QTKit";
-    capture_devices = [VideoCaptureDeviceQTKit deviceNames];
-    for (NSString* key in capture_devices) {
-      VideoCaptureDevice::Name name(
-          [[capture_devices valueForKey:key] UTF8String],
-          [key UTF8String], VideoCaptureDevice::Name::QTKIT);
-      device_names->push_back(name);
-    }
+    // We should not enumerate QTKit devices in Device Thread;
+    NOTREACHED();
   }
 }
 
+void VideoCaptureDeviceFactoryMac::EnumerateDeviceNames(
+    const base::Callback<void(media::VideoCaptureDevice::Names&)>& callback) {
+  if (AVFoundationGlue::IsAVFoundationSupported()) {
+    VideoCaptureDeviceFactory::EnumerateDeviceNames(callback);

[perkj_chrome, 2014/05/26 11:49:42]

This seems fragile. Remove GetDevicesNames and to the real implementation here
instead.

GetDeviceNames should now be made protected instead since its no longer intented
to be used from VideoCaptureManager right?

[mcasas, 2014/05/26 13:00:18]

Done.
Yes. Done.

+  } else {
+    DVLOG(1) << "Enumerating video capture devices using QTKit";
+    base::PostTaskAndReplyWithResult(ui_task_runner_, FROM_HERE,
+      base::Bind(&EnumerateDevicesUsingQTKit),
+      base::Bind(&RunDevicesEnumeratedCallback, callback));
+  }
+}
+
 void VideoCaptureDeviceFactoryMac::GetDeviceSupportedFormats(
     const VideoCaptureDevice::Name& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (device.capture_api_type() == VideoCaptureDevice::Name::AVFOUNDATION) {
     DVLOG(1) << "Enumerating video capture capabilities, AVFoundation";
     [VideoCaptureDeviceAVFoundation getDevice:device
                              supportedFormats:supported_formats];
   } else {
     NOTIMPLEMENTED();
   }
 }
 
 }  // namespace media