Mac AVFoundation: clean removal of device observers

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/mac/scoped_nsobject.h"
@@ skipping 186 matching lines @@
         ![[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 CrAVFoundationSuspendObserver.
+// Forward declaration for use by CrAVFoundationDeviceObserver.
 class AVFoundationMonitorImpl;
 
 }  // namespace
 
 // This class is a Key-Value Observer (KVO) shim.  It is needed because C++
 // classes cannot observe Key-Values directly.
-@interface CrAVFoundationSuspendObserver : NSObject {
+@interface CrAVFoundationDeviceObserver : NSObject {
  @private
   AVFoundationMonitorImpl* receiver_;
 }
 
 - (id)initWithChangeReceiver:(AVFoundationMonitorImpl*)receiver;
 - (void)startObserving:(CrAVCaptureDevice*)device;
 - (void)stopObserving:(CrAVCaptureDevice*)device;
 
 @end
 
 namespace {
 
 class AVFoundationMonitorImpl : public DeviceMonitorMacImpl {
  public:
   explicit AVFoundationMonitorImpl(content::DeviceMonitorMac* monitor);
   virtual ~AVFoundationMonitorImpl();
 
   virtual void OnDeviceChanged() OVERRIDE;
 
  private:
-  base::scoped_nsobject<CrAVFoundationSuspendObserver> suspend_observer_;
+  base::scoped_nsobject<CrAVFoundationDeviceObserver> suspend_observer_;
   DISALLOW_COPY_AND_ASSIGN(AVFoundationMonitorImpl);
 };
 
 AVFoundationMonitorImpl::AVFoundationMonitorImpl(
     content::DeviceMonitorMac* monitor)
     : DeviceMonitorMacImpl(monitor) {
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   device_arrival_ =
       [nc addObserverForName:AVFoundationGlue::
           AVCaptureDeviceWasConnectedNotification()
                       object:nil
                        queue:nil
                   usingBlock:^(NSNotification* notification) {
                       OnDeviceChanged();}];
   device_removal_ =
       [nc addObserverForName:AVFoundationGlue::
           AVCaptureDeviceWasDisconnectedNotification()
                       object:nil
                        queue:nil
                   usingBlock:^(NSNotification* notification) {
                       OnDeviceChanged();}];
   suspend_observer_.reset(
-      [[CrAVFoundationSuspendObserver alloc] initWithChangeReceiver:this]);
+      [[CrAVFoundationDeviceObserver alloc] initWithChangeReceiver:this]);
   for (CrAVCaptureDevice* device in [AVCaptureDeviceGlue devices])
     [suspend_observer_ startObserving:device];
 }
 
 AVFoundationMonitorImpl::~AVFoundationMonitorImpl() {
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   [nc removeObserver:device_arrival_];
   [nc removeObserver:device_removal_];
   for (CrAVCaptureDevice* device in [AVCaptureDeviceGlue devices])
     [suspend_observer_ stopObserving:device];
@@ skipping 16 matching lines @@
       device_type = DeviceInfo::kAudio;
     }
     snapshot_devices.push_back(DeviceInfo([[device uniqueID] UTF8String],
                                           device_type));
   }
   ConsolidateDevicesListAndNotify(snapshot_devices);
 }
 
 }  // namespace
 
-@implementation CrAVFoundationSuspendObserver
+@implementation CrAVFoundationDeviceObserver
 
 - (id)initWithChangeReceiver:(AVFoundationMonitorImpl*)receiver {
   if ((self = [super init])) {
     DCHECK(receiver != NULL);
     receiver_ = receiver;
   }
   return self;
 }
 
 - (void)startObserving:(CrAVCaptureDevice*)device {
   DCHECK(device != nil);
   [device addObserver:self
            forKeyPath:@"suspended"
               options:0
-              context:nil];
+              context:device];
+  [device addObserver:self
+           forKeyPath:@"connected"
+              options:0
+              context:device];
 }
 
 - (void)stopObserving:(CrAVCaptureDevice*)device {
   DCHECK(device != nil);
   [device removeObserver:self
               forKeyPath:@"suspended"];
+  [device removeObserver:self
+              forKeyPath:@"connected"];
 }
 
 - (void)observeValueForKeyPath:(NSString*)keyPath
                       ofObject:(id)object
                         change:(NSDictionary*)change
                        context:(void*)context {
   if ([keyPath isEqual:@"suspended"])
     receiver_->OnDeviceChanged();
+  if ([keyPath isEqual:@"connected"]) {

[Robert Sesek, 2014/03/06 17:08:20]

nit: you don't have braces around the other if, so why this one, or why not that
one?

[mcasas, 2014/03/06 17:21:58]

Done.
Apologies, forgot them after removing debug traces.

+    [self stopObserving:(CrAVCaptureDevice*)context];

[Robert Sesek, 2014/03/06 17:08:20]

static_cast

[mcasas, 2014/03/06 17:21:58]

Done.

+  }
 }
 
-@end  // @implementation CrAVFoundationSuspendObserver
+@end  // @implementation CrAVFoundationDeviceObserver
 
 namespace content {
 
 DeviceMonitorMac::DeviceMonitorMac() {
   if (AVFoundationGlue::IsAVFoundationSupported()) {
     DVLOG(1) << "Monitoring via AVFoundation";
     device_monitor_impl_.reset(new AVFoundationMonitorImpl(this));
     // For the AVFoundation to start sending connect/disconnect notifications,
     // the AVFoundation NSBundle has to be loaded and the devices enumerated.
     // This operation seems to take in the range of hundred of ms. so should be
     // moved to the point when is needed, and that is during
     // DeviceVideoCaptureMac +getDeviceNames.
   } 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