mac: Remove more media/base/mac glue unneeded now that we target 10.9

media/device_monitors/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/device_monitors/device_monitor_mac.h"
 
+#include <AVFoundation/AVFoundation.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"
-#import "media/base/mac/avfoundation_glue.h"
 
 namespace {
 
 // This class is used to keep track of system devices names and their types.
 class DeviceInfo {
  public:
   enum DeviceType { kAudio, kVideo, kMuxed, kUnknown, kInvalid };
 
   DeviceInfo(const std::string& unique_id, DeviceType type)
       : unique_id_(unique_id), type_(type) {}
@@ skipping 103 matching lines @@
 
 // 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
   // Callback for device changed, has to run on Device Thread.
   base::Closure onDeviceChangedCallback_;
 
   // Member to keep track of the devices we are already monitoring.
-  std::set<base::scoped_nsobject<CrAVCaptureDevice>> monitoredDevices_;
+  std::set<base::scoped_nsobject<AVCaptureDevice>> monitoredDevices_;
 
   // Pegged to the "main" thread -- usually content::BrowserThread::UI.
   base::ThreadChecker mainThreadChecker_;
 }
 
 - (id)initWithOnChangedCallback:(const base::Closure&)callback;
-- (void)startObserving:(base::scoped_nsobject<CrAVCaptureDevice>)device;
-- (void)stopObserving:(CrAVCaptureDevice*)device;
+- (void)startObserving:(base::scoped_nsobject<AVCaptureDevice>)device;
+- (void)stopObserving:(AVCaptureDevice*)device;
 - (void)clearOnDeviceChangedCallback;
 
 @end
 
 namespace {
 
 // This class owns and manages the lifetime of a CrAVFoundationDeviceObserver.
 // It is created and destroyed on AVFoundationMonitorImpl's main thread (usually
 // browser's UI thread), and it operates on this thread except for the expensive
 // device enumerations which are run on Device Thread.
@@ skipping 49 matching lines @@
   base::Closure on_device_changed_callback = base::Bind(
       &SuspendObserverDelegate::OnDeviceChanged, this, device_thread);
   suspend_observer_.reset([[CrAVFoundationDeviceObserver alloc]
       initWithOnChangedCallback:on_device_changed_callback]);
 
   // Enumerate the devices in Device thread and post the observers start to be
   // done on UI thread. The devices array is retained in |device_thread| and
   // released in DoStartObserver().
   base::PostTaskAndReplyWithResult(
       device_thread.get(), FROM_HERE, base::BindBlock(^{
-        return [[AVCaptureDeviceGlue devices] retain];
+        return [[AVCaptureDevice devices] retain];
       }),
       base::Bind(&SuspendObserverDelegate::DoStartObserver, this));
 }
 
 void SuspendObserverDelegate::OnDeviceChanged(
     const scoped_refptr<base::SingleThreadTaskRunner>& device_thread) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   // Enumerate the devices in Device thread and post the consolidation of the
   // new devices and the old ones to be done on main thread. The devices array
   // is retained in |device_thread| and released in DoOnDeviceChanged().
   PostTaskAndReplyWithResult(
       device_thread.get(), FROM_HERE, base::BindBlock(^{
-        return [[AVCaptureDeviceGlue devices] retain];
+        return [[AVCaptureDevice devices] retain];
       }),
       base::Bind(&SuspendObserverDelegate::DoOnDeviceChanged, this));
 }
 
 void SuspendObserverDelegate::ResetDeviceMonitor() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   avfoundation_monitor_impl_ = NULL;
   [suspend_observer_ clearOnDeviceChangedCallback];
 }
 
 SuspendObserverDelegate::~SuspendObserverDelegate() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 }
 
 void SuspendObserverDelegate::DoStartObserver(NSArray* devices) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::scoped_nsobject<NSArray> auto_release(devices);
-  for (CrAVCaptureDevice* device in devices) {
-    base::scoped_nsobject<CrAVCaptureDevice> device_ptr([device retain]);
+  for (AVCaptureDevice* device in devices) {
+    base::scoped_nsobject<AVCaptureDevice> device_ptr([device retain]);
     [suspend_observer_ startObserving:device_ptr];
   }
 }
 
 void SuspendObserverDelegate::DoOnDeviceChanged(NSArray* devices) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::scoped_nsobject<NSArray> auto_release(devices);
   std::vector<DeviceInfo> snapshot_devices;
-  for (CrAVCaptureDevice* device in devices) {
-    base::scoped_nsobject<CrAVCaptureDevice> device_ptr([device retain]);
+  for (AVCaptureDevice* device in devices) {
+    base::scoped_nsobject<AVCaptureDevice> device_ptr([device retain]);
     [suspend_observer_ startObserving:device_ptr];
 
     BOOL suspended = [device respondsToSelector:@selector(isSuspended)] &&
                      [device isSuspended];
     DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
-    if ([device hasMediaType:AVFoundationGlue::AVMediaTypeVideo()]) {
+    if ([device hasMediaType:AVMediaTypeVideo]) {
       if (suspended)
         continue;
       device_type = DeviceInfo::kVideo;
-    } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeMuxed()]) {
+    } else if ([device hasMediaType:AVMediaTypeMuxed]) {
       device_type = suspended ? DeviceInfo::kAudio : DeviceInfo::kMuxed;
-    } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeAudio()]) {
+    } else if ([device hasMediaType:AVMediaTypeAudio]) {
       device_type = DeviceInfo::kAudio;
     }
     snapshot_devices.push_back(
         DeviceInfo([[device uniqueID] UTF8String], device_type));
   }
   // Make sure no references are held to |devices| when
   // ConsolidateDevicesListAndNotify is called since the VideoCaptureManager
   // and AudioCaptureManagers also enumerates the available devices but on
   // another thread.
   auto_release.reset();
@@ skipping 34 matching lines @@
 
 AVFoundationMonitorImpl::AVFoundationMonitorImpl(
     media::DeviceMonitorMac* monitor,
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner)
     : DeviceMonitorMacImpl(monitor),
       device_task_runner_(device_task_runner),
       suspend_observer_delegate_(new SuspendObserverDelegate(this)) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   device_arrival_ =
-      [nc addObserverForName:AVFoundationGlue::
-                                 AVCaptureDeviceWasConnectedNotification()
+      [nc addObserverForName:AVCaptureDeviceWasConnectedNotification
                       object:nil
                        queue:nil
                   usingBlock:^(NSNotification* notification) {
                     OnDeviceChanged();
                   }];
   device_removal_ =
-      [nc addObserverForName:AVFoundationGlue::
-                                 AVCaptureDeviceWasDisconnectedNotification()
+      [nc addObserverForName:AVCaptureDeviceWasDisconnectedNotification
                       object:nil
                        queue:nil
                   usingBlock:^(NSNotification* notification) {
                     OnDeviceChanged();
                   }];
   suspend_observer_delegate_->StartObserver(device_task_runner_);
 }
 
 AVFoundationMonitorImpl::~AVFoundationMonitorImpl() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 16 matching lines @@
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   if ((self = [super init])) {
     DCHECK(!callback.is_null());
     onDeviceChangedCallback_ = callback;
   }
   return self;
 }
 
 - (void)dealloc {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
-  std::set<base::scoped_nsobject<CrAVCaptureDevice>>::iterator it =
+  std::set<base::scoped_nsobject<AVCaptureDevice>>::iterator it =
       monitoredDevices_.begin();
   while (it != monitoredDevices_.end())
     [self removeObservers:*(it++)];
   [super dealloc];
 }
 
-- (void)startObserving:(base::scoped_nsobject<CrAVCaptureDevice>)device {
+- (void)startObserving:(base::scoped_nsobject<AVCaptureDevice>)device {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   DCHECK(device != nil);
   // Skip this device if there are already observers connected to it.
   if (std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device) !=
       monitoredDevices_.end()) {
     return;
   }
   [device addObserver:self
            forKeyPath:@"suspended"
               options:0
               context:device.get()];
   [device addObserver:self
            forKeyPath:@"connected"
               options:0
               context:device.get()];
   monitoredDevices_.insert(device);
 }
 
-- (void)stopObserving:(CrAVCaptureDevice*)device {
+- (void)stopObserving:(AVCaptureDevice*)device {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   DCHECK(device != nil);
 
-  std::set<base::scoped_nsobject<CrAVCaptureDevice>>::iterator found =
+  std::set<base::scoped_nsobject<AVCaptureDevice>>::iterator found =
       std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device);
   DCHECK(found != monitoredDevices_.end());
   [self removeObservers:*found];
   monitoredDevices_.erase(found);
 }
 
 - (void)clearOnDeviceChangedCallback {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   onDeviceChangedCallback_.Reset();
 }
 
-- (void)removeObservers:(CrAVCaptureDevice*)device {
+- (void)removeObservers:(AVCaptureDevice*)device {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   // Check sanity of |device| via its -observationInfo. http://crbug.com/371271.
   if ([device observationInfo]) {
     [device removeObserver:self
                 forKeyPath:@"suspended"];
     [device removeObserver:self
                 forKeyPath:@"connected"];
   }
 }
 
 - (void)observeValueForKeyPath:(NSString*)keyPath
                       ofObject:(id)object
                         change:(NSDictionary*)change
                        context:(void*)context {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   if ([keyPath isEqual:@"suspended"])
     onDeviceChangedCallback_.Run();
   if ([keyPath isEqual:@"connected"])
-    [self stopObserving:static_cast<CrAVCaptureDevice*>(context)];
+    [self stopObserving:static_cast<AVCaptureDevice*>(context)];
 }
 
 @end  // @implementation CrAVFoundationDeviceObserver
 
 namespace media {
 
 DeviceMonitorMac::DeviceMonitorMac() {
   // 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.
-  AVFoundationGlue::InitializeAVFoundation();
-
     // 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));
 }
 
 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