Mac VideoCapture: return empty GetModel() for non-USB non-built-in cameras.

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"
 
+#import <IOKit/audio/IOAudioTypes.h>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/strings/string_util.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 a characteristic
 // trailing substring of uniqueId and by (part of) the vendor's name.
 const struct NameAndVid {
   const char* unique_id_signature;
   const char* name;
 } kBlacklistedCameras[] = { { "-01FDA82C8A9C", "Blackmagic" } };
 
 static scoped_ptr<media::VideoCaptureDevice::Names>
 EnumerateDevicesUsingQTKit() {
   scoped_ptr<VideoCaptureDevice::Names> device_names(
         new VideoCaptureDevice::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],
+        [[[capture_devices valueForKey:key] deviceName] UTF8String],
         [key UTF8String], VideoCaptureDevice::Name::QTKIT);
     device_names->push_back(name);
   }
   return device_names.Pass();
 }
 
 static void RunDevicesEnumeratedCallback(
     const base::Callback<void(scoped_ptr<media::VideoCaptureDevice::Names>)>&
         callback,
     scoped_ptr<media::VideoCaptureDevice::Names> device_names) {
@@ skipping 50 matching lines @@
   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];
     // Enumerate all devices found by AVFoundation, translate the info for each
     // to class Name and add it to |device_names|.
     for (NSString* key in capture_devices) {
+      int transport_type = [[capture_devices valueForKey:key] transportType];
+      // Transport types are defined for Audio devices and reused for video.
+      VideoCaptureDevice::Name::TransportType device_transport_type =
+          (transport_type == kIOAudioDeviceTransportTypeBuiltIn ||
+              transport_type == kIOAudioDeviceTransportTypeUSB)
+          ? VideoCaptureDevice::Name::USB_OR_BUILT_IN
+          : VideoCaptureDevice::Name::OTHER_TRANSPORT;
       VideoCaptureDevice::Name name(
-          [[capture_devices valueForKey:key] UTF8String],
-          [key UTF8String], VideoCaptureDevice::Name::AVFOUNDATION);
+          [[[capture_devices valueForKey:key] deviceName] UTF8String],
+          [key UTF8String], VideoCaptureDevice::Name::AVFOUNDATION,
+          device_transport_type);
       device_names->push_back(name);
       for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
         is_any_device_blacklisted = EndsWith(name.id(),
             kBlacklistedCameras[i].unique_id_signature, false);
         if (is_any_device_blacklisted)
           break;
       }
     }
     // If there is any device blacklisted in the system, walk the QTKit device
     // list and add those devices with a blacklisted name to the |device_names|.
     // AVFoundation and QTKit device lists partially overlap, so add a "QTKit"
     // prefix to the latter ones to distinguish them from the AVFoundation ones.
     if (is_any_device_blacklisted) {
       capture_devices = [VideoCaptureDeviceQTKit deviceNames];
       for (NSString* key in capture_devices) {
-        NSString* device_name = [capture_devices valueForKey:key];
+        NSString* device_name = [[capture_devices valueForKey:key] deviceName];
         for (size_t i = 0; i < arraysize(kBlacklistedCameras); ++i) {
           if ([device_name rangeOfString:@(kBlacklistedCameras[i].name)
                                  options:NSCaseInsensitiveSearch].length != 0) {
             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);
           }
         }
@@ skipping 28 matching lines @@
   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