Added AVFoundation Glue and Device Monitoring for Mac.

content/browser/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 "content/browser/device_monitor_mac.h"
 
 #import <QTKit/QTKit.h>
 
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "media/video/capture/mac/avfoundation_glue.h"
 
-namespace content {
+namespace {
 
-class DeviceMonitorMac::QTMonitorImpl {
+// Interface used by DeviceMonitorMac to interact with either a QTKit or an
+// AVFoundation implementation of events and notifications.
+class MacMonitorInterface {
  public:
-  explicit QTMonitorImpl(DeviceMonitorMac* monitor);
-  virtual ~QTMonitorImpl() {}
+  virtual ~MacMonitorInterface() {};
 
-  void Start();
-  void Stop();
+  virtual void OnDeviceChanged() = 0;
+};
 
+class QTKitMonitorImpl : public MacMonitorInterface {
+ public:
+  QTKitMonitorImpl() {};
+  explicit QTKitMonitorImpl(content::DeviceMonitorMac* monitor);
+  virtual ~QTKitMonitorImpl();
+
+  virtual void OnDeviceChanged() OVERRIDE;
  private:
-  void OnDeviceChanged();
-
-  DeviceMonitorMac* monitor_;
+  content::DeviceMonitorMac* monitor_;
   int number_audio_devices_;
   int number_video_devices_;
   id device_arrival_;
   id device_removal_;
-
-  DISALLOW_COPY_AND_ASSIGN(QTMonitorImpl);
 };
 
-DeviceMonitorMac::QTMonitorImpl::QTMonitorImpl(DeviceMonitorMac* monitor)
+QTKitMonitorImpl::QTKitMonitorImpl(content::DeviceMonitorMac* monitor)
     : monitor_(monitor),
       number_audio_devices_(0),
       number_video_devices_(0),
       device_arrival_(nil),
       device_removal_(nil) {
   DCHECK(monitor);
-}
 
-void DeviceMonitorMac::QTMonitorImpl::Start() {
   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();}];
 }
 
-void DeviceMonitorMac::QTMonitorImpl::Stop() {
+QTKitMonitorImpl::~QTKitMonitorImpl() {
   if (!monitor_)
     return;
 
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   [nc removeObserver:device_arrival_];
   [nc removeObserver:device_removal_];
 }
 
-void DeviceMonitorMac::QTMonitorImpl::OnDeviceChanged() {
+void QTKitMonitorImpl::OnDeviceChanged() {
+  base::AutoLock lock(monitor_->lock_);

[Mark Mentovai, 2013/10/02 14:24:34]

How does this help?

The major problem here isn’t that multiple threads might enter OnDeviceChanged
simultaneously. (Maybe they may, maybe they won’t, it depends on QTKit and
AVFoundation internals.)

The major problem is that the state of the system can be different at the time
the notification is posted (when the system recognizes that a device has been
connected or disconnected) and the time you actually process the notification
(when your code in OnDeviceChanged runs).

Follow this example timeline:

0. 2 devices are present.
1. Unplug a device. 1 device is present now.
2. “Device disconnected” notification generated from (1).
3. Plug in a different device. 2 devices are present now.
4. “Device connected” notification generated from (3).
5. “Device disconnected” notification processed from (2). OnDeviceChanged runs,
and finds 2 devices are present. This looks like an unchanged state, so
NotifyDeviceChanged is not called.
6. “Device connected” notification processed from (4). OnDeviceChanged runs, and
finds 2 devices are present. This looks like an unchanged state, so
NotifyDeviceChanged is not called.

There are now 2 devices present, but they’re not the same 2 devices that were
present in step 0, because one device was removed and a new one was added.
NotifyDeviceChanged was never called.

Placing steps 5 and 6 under a lock does not help. The race is between step 3 and
step 5. You are assuming that step 5 will immediately follow step 2, but that’s
not necessarily the case.

[mcasas, 2013/10/02 16:16:00]

I  thought that when we register to the notifications, both are coming via an
unspecified queue, hence using [NSOperationQueue mainQueue], and events cannot
be delivered to the application (us) out of order. So you're saying that this
NSOperationQueue can deliver out of order? If this is the case then I should
create another queue with a simple policy and use it, how does this sound?

The lock prevented another case in which both events are delivered (in order)
very close to each other and there would be a race condition between them.

   NSArray* devices = [QTCaptureDevice inputDevices];
   int number_video_devices = 0;
   int number_audio_devices = 0;
   for (QTCaptureDevice* device in devices) {
     if ([device hasMediaType:QTMediaTypeVideo] ||
         [device hasMediaType:QTMediaTypeMuxed])
       ++number_video_devices;
 
     if ([device hasMediaType:QTMediaTypeSound] ||
         [device hasMediaType:QTMediaTypeMuxed])
       ++number_audio_devices;
   }
 
   if (number_video_devices_ != number_video_devices) {
     number_video_devices_ = number_video_devices;
     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
   }
 
   if (number_audio_devices_ != number_audio_devices) {
     number_audio_devices_ = number_audio_devices;
     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
   }
 }
 
-DeviceMonitorMac::DeviceMonitorMac() {
-  qt_monitor_.reset(new QTMonitorImpl(this));
-  qt_monitor_->Start();
+class AVFoundationMonitorImpl : public MacMonitorInterface {
+ public:
+  AVFoundationMonitorImpl() {};
+  explicit AVFoundationMonitorImpl(content::DeviceMonitorMac* monitor);
+  virtual ~AVFoundationMonitorImpl();
+
+  virtual void OnDeviceChanged() OVERRIDE;
+ private:
+  content::DeviceMonitorMac* monitor_;
+  int number_audio_devices_;
+  int number_video_devices_;
+  id device_arrival_;
+  id device_removal_;
+};
+
+AVFoundationMonitorImpl::AVFoundationMonitorImpl(
+    content::DeviceMonitorMac* monitor)
+    : monitor_(monitor),
+      number_audio_devices_(0),
+      number_video_devices_(0),
+      device_arrival_(nil),
+      device_removal_(nil) {
+  DCHECK(monitor);
+
+  NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
+  NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
+
+  device_arrival_ =
+      [nc addObserverForName:[AVFoundationGlue
+      avCaptureDeviceWasConnectedNotification]
+                      object:nil
+                       queue:mainQueue
+                  usingBlock:^(NSNotification* notification) {
+                      OnDeviceChanged();}];
+  DCHECK(device_arrival_);
+   device_removal_ =
+      [nc addObserverForName:[AVFoundationGlue
+      avCaptureDeviceWasDisconnectedNotification]
+                      object:nil
+                       queue:mainQueue
+                  usingBlock:^(NSNotification* notification) {
+                      OnDeviceChanged();}];
+  DCHECK(device_removal_);
 }
 
-DeviceMonitorMac::~DeviceMonitorMac() {
-  qt_monitor_->Stop();
+AVFoundationMonitorImpl::~AVFoundationMonitorImpl() {
+  if (!monitor_)
+    return;
+
+  NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
+  [nc removeObserver:device_arrival_];
+  [nc removeObserver:device_removal_];
 }
 
+void AVFoundationMonitorImpl::OnDeviceChanged() {
+  base::AutoLock lock(monitor_->lock_);
+  NSArray* devices = [AVCaptureDeviceGlue devices];
+  int number_video_devices = 0;
+  int number_audio_devices = 0;
+  for (CrAVCaptureDevice* device in devices) {
+    if ([AVCaptureDeviceGlue hasMediaType:[AVFoundationGlue avMediaTypeVideo]
+                         forCaptureDevice:device] ||
+      [AVCaptureDeviceGlue hasMediaType:[AVFoundationGlue avMediaTypeMuxed]
+                       forCaptureDevice:device]) {
+      ++number_video_devices;
+    }
+    if ([AVCaptureDeviceGlue hasMediaType:[AVFoundationGlue avMediaTypeAudio]
+                         forCaptureDevice:device] ||
+      [AVCaptureDeviceGlue hasMediaType:[AVFoundationGlue avMediaTypeMuxed]
+                       forCaptureDevice:device]) {
+      ++number_audio_devices;
+    }
+  }
+
+  if (number_video_devices_ != number_video_devices) {
+    DVLOG(1) << "Video device plugged " <<
+      ((number_video_devices_ > number_video_devices)? "out" : "in");
+    number_video_devices_ = number_video_devices;
+    monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
+  }
+
+  if (number_audio_devices_ != number_audio_devices) {
+    DVLOG(1) << "Audio device plugged " <<
+      ((number_audio_devices_ > number_audio_devices)? "out" : "in");
+    number_audio_devices_ = number_audio_devices;
+    monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
+  }
+}
+
+}  // namespace
+
+namespace content {
+
+DeviceMonitorMac::DeviceMonitorMac() {
+  if ([AVFoundationGlue isAVFoundationSupported]){
+    DVLOG(1) << "Monitoring via AVFoundation";
+    device_monitor_impl_.reset(new AVFoundationMonitorImpl(this));
+    // Force the device enumeration so we enumerate correctly devices already in
+    // the system and at the same time use the AVCaptureDeviceGlue so it in
+    // turn forces the AVCaptureDeviceGlue alloc-init.
+    device_monitor_impl_->OnDeviceChanged();
+  } else {
+    DVLOG(1) << "Monitoring via QTKit";
+    device_monitor_impl_.reset(new QTKitMonitorImpl(this));
+  }
+}
+
+DeviceMonitorMac::~DeviceMonitorMac() {}
+
 void DeviceMonitorMac::NotifyDeviceChanged(
     base::SystemMonitor::DeviceType type) {
   // TODO(xians): Remove the global variable for SystemMonitor.
   base::SystemMonitor::Get()->ProcessDevicesChanged(type);
 }
 
 }  // namespace content