Remove deprecated QTKit Video Capture Support

media/capture/device_monitor_mac.mm

 // 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 "media/capture/device_monitor_mac.h"
 
-#import <QTKit/QTKit.h>
-
 #include <set>
 
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
@@ skipping 18 matching lines @@
 
   const std::string& unique_id() const { return unique_id_; }
   DeviceType type() const { return type_; }
 
  private:
   std::string unique_id_;
   DeviceType type_;
   // Allow generated copy constructor and assignment.
 };
 
-// Base abstract class used by DeviceMonitorMac to interact with either a QTKit
-// or an AVFoundation implementation of events and notifications.
+// Base abstract class used by DeviceMonitorMac.
 class DeviceMonitorMacImpl {
  public:
   explicit DeviceMonitorMacImpl(media::DeviceMonitorMac* monitor)
       : monitor_(monitor),
         cached_devices_(),
         device_arrival_(nil),
         device_removal_(nil) {
     DCHECK(monitor);
     // Initialise the devices_cache_ with a not-valid entry. For the case in
     // which there is one single device in the system and we get notified when
@@ skipping 61 matching lines @@
   }
   // Update the cached devices with the current system snapshot.
   cached_devices_ = snapshot_devices;
 
   if (video_device_added || video_device_removed)
     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
   if (audio_device_added || audio_device_removed)
     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
 }
 
-class QTKitMonitorImpl : public DeviceMonitorMacImpl {
- public:
-  explicit QTKitMonitorImpl(media::DeviceMonitorMac* monitor);
-  ~QTKitMonitorImpl() override;
-
-  void OnDeviceChanged() override;
-
- private:
-  void CountDevices();
-  void OnAttributeChanged(NSNotification* notification);
-
-  id device_change_;
-};
-
-QTKitMonitorImpl::QTKitMonitorImpl(media::DeviceMonitorMac* monitor)
-    : DeviceMonitorMacImpl(monitor) {
-  NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
-  device_arrival_ =
-      [nc addObserverForName:QTCaptureDeviceWasConnectedNotification
-                      object:nil
-                       queue:nil
-                  usingBlock:^(NSNotification* notification) {
-                    OnDeviceChanged();
-                  }];
-  device_removal_ =
-      [nc addObserverForName:QTCaptureDeviceWasDisconnectedNotification
-                      object:nil
-                       queue:nil
-                  usingBlock:^(NSNotification* notification) {
-                    OnDeviceChanged();
-                  }];
-  device_change_ =
-      [nc addObserverForName:QTCaptureDeviceAttributeDidChangeNotification
-                      object:nil
-                       queue:nil
-                  usingBlock:^(NSNotification* notification) {
-                    OnAttributeChanged(notification);
-                  }];
-}
-
-QTKitMonitorImpl::~QTKitMonitorImpl() {
-  NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
-  [nc removeObserver:device_arrival_];
-  [nc removeObserver:device_removal_];
-  [nc removeObserver:device_change_];
-}
-
-void QTKitMonitorImpl::OnAttributeChanged(NSNotification* notification) {
-  if ([[[notification userInfo] objectForKey:QTCaptureDeviceChangedAttributeKey]
-          isEqualToString:QTCaptureDeviceSuspendedAttribute]) {
-    OnDeviceChanged();
-  }
-}
-
-void QTKitMonitorImpl::OnDeviceChanged() {
-  std::vector<DeviceInfo> snapshot_devices;
-
-  NSArray* devices = [QTCaptureDevice inputDevices];
-  for (QTCaptureDevice* device in devices) {
-    DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
-    // Act as if suspended video capture devices are not attached.  For
-    // example, a laptop's internal webcam is suspended when the lid is closed.
-    if ([device hasMediaType:QTMediaTypeVideo] &&
-        ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
-            boolValue]) {
-      device_type = DeviceInfo::kVideo;
-    } else if ([device hasMediaType:QTMediaTypeMuxed] &&
-               ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
-                   boolValue]) {
-      device_type = DeviceInfo::kMuxed;
-    } else if ([device hasMediaType:QTMediaTypeSound] &&
-               ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
-                   boolValue]) {
-      device_type = DeviceInfo::kAudio;
-    }
-    snapshot_devices.push_back(
-        DeviceInfo([[device uniqueID] UTF8String], device_type));
-  }
-  ConsolidateDevicesListAndNotify(snapshot_devices);
-}
-
 // Forward declaration for use by CrAVFoundationDeviceObserver.
 class SuspendObserverDelegate;
 
 }  // namespace
 
 // This class is a Key-Value Observer (KVO) shim. It is needed because C++
 // classes cannot observe Key-Values directly. Created, manipulated, and
 // destroyed on the UI Thread by SuspendObserverDelegate.
 @interface CrAVFoundationDeviceObserver : NSObject {
  @private
@@ skipping 296 matching lines @@
     onDeviceChangedCallback_.Run();
   if ([keyPath isEqual:@"connected"])
     [self stopObserving:static_cast<CrAVCaptureDevice*>(context)];
 }
 
 @end  // @implementation CrAVFoundationDeviceObserver
 
 namespace media {
 
 DeviceMonitorMac::DeviceMonitorMac() {
-  // Both QTKit and AVFoundation do not need to be fired up until the user
+  // AVFoundation do not need to be fired up until the user
   // exercises a GetUserMedia. Bringing up either library and enumerating the
   // devices in the system is an operation taking in the range of hundred of ms,
   // so it is triggered explicitly from MediaStreamManager::StartMonitoring().
 }
 
 DeviceMonitorMac::~DeviceMonitorMac() {}
 
 void DeviceMonitorMac::StartMonitoring(
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // We're on the UI thread so let's try to initialize AVFoundation and then
-  // see if it's supported.  IsAVFoundationSupported can't implicitly initialize
-  // the library since it can be called on different threads.
+  // We're on the UI thread so let's try to initialize AVFoundation.
   AVFoundationGlue::InitializeAVFoundation();
 
-  if (AVFoundationGlue::IsAVFoundationSupported()) {
     // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/458404
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
             "458404 DeviceMonitorMac::StartMonitoring::AVFoundation"));
     DVLOG(1) << "Monitoring via AVFoundation";
     device_monitor_impl_.reset(
         new AVFoundationMonitorImpl(this, device_task_runner));
-  } else {
-    // TODO(erikchen): Remove ScopedTracker below once http://crbug.com/458404
-    // is fixed.
-    tracked_objects::ScopedTracker tracking_profile(
-        FROM_HERE_WITH_EXPLICIT_FUNCTION(
-            "458404 DeviceMonitorMac::StartMonitoring::QTKit"));
-    DVLOG(1) << "Monitoring via QTKit";
-    device_monitor_impl_.reset(new QTKitMonitorImpl(this));
-  }
 }
 
 void DeviceMonitorMac::NotifyDeviceChanged(
     base::SystemMonitor::DeviceType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(xians): Remove the global variable for SystemMonitor.
   base::SystemMonitor::Get()->ProcessDevicesChanged(type);
 }
 
 }  // namespace media