content/browser/device_monitor_mac.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/device_monitor_mac.h"
   6
   7 #import <QTKit/QTKit.h>
   8
   9 #include <set>
  10
  11 #include "base/bind_helpers.h"
  12 #include "base/logging.h"
  13 #include "base/mac/bind_objc_block.h"
  14 #include "base/mac/scoped_nsobject.h"
  15 #include "base/threading/thread_checker.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #import "media/base/mac/avfoundation_glue.h"
  18
  19 using content::BrowserThread;
  20
  21 namespace {
  22
  23 // This class is used to keep track of system devices names and their types.
  24 class DeviceInfo {
  25  public:
  26   enum DeviceType {
  27     kAudio,
  28     kVideo,
  29     kMuxed,
  30     kUnknown,
  31     kInvalid
  32   };
  33
  34   DeviceInfo(std::string unique_id, DeviceType type)
  35       : unique_id_(unique_id), type_(type) {}
  36
  37   // Operator== is needed here to use this class in a std::find. A given
  38   // |unique_id_| always has the same |type_| so for comparison purposes the
  39   // latter can be safely ignored.
  40   bool operator==(const DeviceInfo& device) const {
  41     return unique_id_ == device.unique_id_;
  42   }
  43
  44   const std::string& unique_id() const { return unique_id_; }
  45   DeviceType type() const { return type_; }
  46
  47  private:
  48   std::string unique_id_;
  49   DeviceType type_;
  50   // Allow generated copy constructor and assignment.
  51 };
  52
  53 // Base abstract class used by DeviceMonitorMac to interact with either a QTKit
  54 // or an AVFoundation implementation of events and notifications.
  55 class DeviceMonitorMacImpl {
  56  public:
  57   explicit DeviceMonitorMacImpl(content::DeviceMonitorMac* monitor)
  58       : monitor_(monitor),
  59         cached_devices_(),
  60         device_arrival_(nil),
  61         device_removal_(nil) {
  62     DCHECK(monitor);
  63     // Initialise the devices_cache_ with a not-valid entry. For the case in
  64     // which there is one single device in the system and we get notified when
  65     // it gets removed, this will prevent the system from thinking that no
  66     // devices were added nor removed and not notifying the |monitor_|.
  67     cached_devices_.push_back(DeviceInfo("invalid", DeviceInfo::kInvalid));
  68   }
  69   virtual ~DeviceMonitorMacImpl() {}
  70
  71   virtual void OnDeviceChanged() = 0;
  72
  73   // Method called by the default notification center when a device is removed
  74   // or added to the system. It will compare the |cached_devices_| with the
  75   // current situation, update it, and, if there's an update, signal to
  76   // |monitor_| with the appropriate device type.
  77   void ConsolidateDevicesListAndNotify(
  78       const std::vector<DeviceInfo>& snapshot_devices);
  79
  80  protected:
  81   content::DeviceMonitorMac* monitor_;
  82   std::vector<DeviceInfo> cached_devices_;
  83
  84   // Handles to NSNotificationCenter block observers.
  85   id device_arrival_;
  86   id device_removal_;
  87
  88  private:
  89   DISALLOW_COPY_AND_ASSIGN(DeviceMonitorMacImpl);
  90 };
  91
  92 void DeviceMonitorMacImpl::ConsolidateDevicesListAndNotify(
  93     const std::vector<DeviceInfo>& snapshot_devices) {
  94   bool video_device_added = false;
  95   bool audio_device_added = false;
  96   bool video_device_removed = false;
  97   bool audio_device_removed = false;
  98
  99   // Compare the current system devices snapshot with the ones cached to detect
 100   // additions, present in the former but not in the latter. If we find a device
 101   // in snapshot_devices entry also present in cached_devices, we remove it from
 102   // the latter vector.
 103   std::vector<DeviceInfo>::const_iterator it;
 104   for (it = snapshot_devices.begin(); it != snapshot_devices.end(); ++it) {
 105     std::vector<DeviceInfo>::iterator cached_devices_iterator =
 106         std::find(cached_devices_.begin(), cached_devices_.end(), *it);
 107     if (cached_devices_iterator == cached_devices_.end()) {
 108       video_device_added |= ((it->type() == DeviceInfo::kVideo) ||
 109                              (it->type() == DeviceInfo::kMuxed));
 110       audio_device_added |= ((it->type() == DeviceInfo::kAudio) ||
 111                              (it->type() == DeviceInfo::kMuxed));
 112       DVLOG(1) << "Device has been added, id: " << it->unique_id();
 113     } else {
 114       cached_devices_.erase(cached_devices_iterator);
 115     }
 116   }
 117   // All the remaining entries in cached_devices are removed devices.
 118   for (it = cached_devices_.begin(); it != cached_devices_.end(); ++it) {
 119     video_device_removed |= ((it->type() == DeviceInfo::kVideo) ||
 120                              (it->type() == DeviceInfo::kMuxed) ||
 121                              (it->type() == DeviceInfo::kInvalid));
 122     audio_device_removed |= ((it->type() == DeviceInfo::kAudio) ||
 123                              (it->type() == DeviceInfo::kMuxed) ||
 124                              (it->type() == DeviceInfo::kInvalid));
 125     DVLOG(1) << "Device has been removed, id: " << it->unique_id();
 126   }
 127   // Update the cached devices with the current system snapshot.
 128   cached_devices_ = snapshot_devices;
 129
 130   if (video_device_added || video_device_removed)
 131     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 132   if (audio_device_added || audio_device_removed)
 133     monitor_->NotifyDeviceChanged(base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE);
 134 }
 135
 136 class QTKitMonitorImpl : public DeviceMonitorMacImpl {
 137  public:
 138   explicit QTKitMonitorImpl(content::DeviceMonitorMac* monitor);
 139   ~QTKitMonitorImpl() override;
 140
 141   void OnDeviceChanged() override;
 142
 143  private:
 144   void CountDevices();
 145   void OnAttributeChanged(NSNotification* notification);
 146
 147   id device_change_;
 148 };
 149
 150 QTKitMonitorImpl::QTKitMonitorImpl(content::DeviceMonitorMac* monitor)
 151     : DeviceMonitorMacImpl(monitor) {
 152   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 153   device_arrival_ =
 154       [nc addObserverForName:QTCaptureDeviceWasConnectedNotification
 155                       object:nil
 156                        queue:nil
 157                   usingBlock:^(NSNotification* notification) {
 158                       OnDeviceChanged();}];
 159   device_removal_ =
 160       [nc addObserverForName:QTCaptureDeviceWasDisconnectedNotification
 161                       object:nil
 162                        queue:nil
 163                   usingBlock:^(NSNotification* notification) {
 164                       OnDeviceChanged();}];
 165   device_change_ =
 166       [nc addObserverForName:QTCaptureDeviceAttributeDidChangeNotification
 167                       object:nil
 168                        queue:nil
 169                   usingBlock:^(NSNotification* notification) {
 170                       OnAttributeChanged(notification);}];
 171 }
 172
 173 QTKitMonitorImpl::~QTKitMonitorImpl() {
 174   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 175   [nc removeObserver:device_arrival_];
 176   [nc removeObserver:device_removal_];
 177   [nc removeObserver:device_change_];
 178 }
 179
 180 void QTKitMonitorImpl::OnAttributeChanged(
 181     NSNotification* notification) {
 182   if ([[[notification userInfo]
 183          objectForKey:QTCaptureDeviceChangedAttributeKey]
 184       isEqualToString:QTCaptureDeviceSuspendedAttribute]) {
 185     OnDeviceChanged();
 186   }
 187 }
 188
 189 void QTKitMonitorImpl::OnDeviceChanged() {
 190   std::vector<DeviceInfo> snapshot_devices;
 191
 192   NSArray* devices = [QTCaptureDevice inputDevices];
 193   for (QTCaptureDevice* device in devices) {
 194     DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
 195     // Act as if suspended video capture devices are not attached.  For
 196     // example, a laptop's internal webcam is suspended when the lid is closed.
 197     if ([device hasMediaType:QTMediaTypeVideo] &&
 198         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 199         boolValue]) {
 200       device_type = DeviceInfo::kVideo;
 201     } else if ([device hasMediaType:QTMediaTypeMuxed] &&
 202         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 203         boolValue]) {
 204       device_type = DeviceInfo::kMuxed;
 205     } else if ([device hasMediaType:QTMediaTypeSound] &&
 206         ![[device attributeForKey:QTCaptureDeviceSuspendedAttribute]
 207         boolValue]) {
 208       device_type = DeviceInfo::kAudio;
 209     }
 210     snapshot_devices.push_back(
 211         DeviceInfo([[device uniqueID] UTF8String], device_type));
 212   }
 213   ConsolidateDevicesListAndNotify(snapshot_devices);
 214 }
 215
 216 // Forward declaration for use by CrAVFoundationDeviceObserver.
 217 class SuspendObserverDelegate;
 218
 219 }  // namespace
 220
 221 // This class is a Key-Value Observer (KVO) shim. It is needed because C++
 222 // classes cannot observe Key-Values directly. Created, manipulated, and
 223 // destroyed on the UI Thread by SuspendObserverDelegate.
 224 @interface CrAVFoundationDeviceObserver : NSObject {
 225  @private
 226   // Callback for device changed, has to run on Device Thread.
 227   base::Closure onDeviceChangedCallback_;
 228
 229   // Member to keep track of the devices we are already monitoring.
 230   std::set<base::scoped_nsobject<CrAVCaptureDevice> > monitoredDevices_;
 231 }
 232
 233 - (id)initWithOnChangedCallback:(const base::Closure&)callback;
 234 - (void)startObserving:(base::scoped_nsobject<CrAVCaptureDevice>)device;
 235 - (void)stopObserving:(CrAVCaptureDevice*)device;
 236 - (void)clearOnDeviceChangedCallback;
 237
 238 @end
 239
 240 namespace {
 241
 242 // This class owns and manages the lifetime of a CrAVFoundationDeviceObserver.
 243 // It is created and destroyed in UI thread by AVFoundationMonitorImpl, and it
 244 // operates on this thread except for the expensive device enumerations which
 245 // are run on Device Thread.
 246 class SuspendObserverDelegate :
 247     public base::RefCountedThreadSafe<SuspendObserverDelegate> {
 248  public:
 249   explicit SuspendObserverDelegate(DeviceMonitorMacImpl* monitor);
 250
 251   // Create |suspend_observer_| for all devices and register OnDeviceChanged()
 252   // as its change callback. Schedule bottom half in DoStartObserver().
 253   void StartObserver(
 254       const scoped_refptr<base::SingleThreadTaskRunner>& device_thread);
 255   // Enumerate devices in |device_thread| and run the bottom half in
 256   // DoOnDeviceChange(). |suspend_observer_| calls back here on suspend event,
 257   // and our parent AVFoundationMonitorImpl calls on connect/disconnect device.
 258   void OnDeviceChanged(
 259       const scoped_refptr<base::SingleThreadTaskRunner>& device_thread);
 260   // Remove the device monitor's weak reference. Remove ourselves as suspend
 261   // notification observer from |suspend_observer_|.
 262   void ResetDeviceMonitor();
 263
 264  private:
 265   friend class base::RefCountedThreadSafe<SuspendObserverDelegate>;
 266
 267   virtual ~SuspendObserverDelegate();
 268
 269   // Bottom half of StartObserver(), starts |suspend_observer_| for all devices.
 270   // Assumes that |devices| has been retained prior to being called, and
 271   // releases it internally.
 272   void DoStartObserver(NSArray* devices);
 273   // Bottom half of OnDeviceChanged(), starts |suspend_observer_| for current
 274   // devices and composes a snapshot of them to send it to
 275   // |avfoundation_monitor_impl_|. Assumes that |devices| has been retained
 276   // prior to being called, and releases it internally.
 277   void DoOnDeviceChanged(NSArray* devices);
 278
 279   base::scoped_nsobject<CrAVFoundationDeviceObserver> suspend_observer_;
 280   DeviceMonitorMacImpl* avfoundation_monitor_impl_;
 281 };
 282
 283 SuspendObserverDelegate::SuspendObserverDelegate(DeviceMonitorMacImpl* monitor)
 284     : avfoundation_monitor_impl_(monitor) {
 285   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 286 }
 287
 288 void SuspendObserverDelegate::StartObserver(
 289       const scoped_refptr<base::SingleThreadTaskRunner>& device_thread) {
 290   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 291
 292   base::Closure on_device_changed_callback =
 293       base::Bind(&SuspendObserverDelegate::OnDeviceChanged,
 294                  this, device_thread);
 295   suspend_observer_.reset([[CrAVFoundationDeviceObserver alloc]
 296       initWithOnChangedCallback:on_device_changed_callback]);
 297
 298   // Enumerate the devices in Device thread and post the observers start to be
 299   // done on UI thread. The devices array is retained in |device_thread| and
 300   // released in DoStartObserver().
 301   base::PostTaskAndReplyWithResult(
 302       device_thread.get(),
 303       FROM_HERE,
 304       base::BindBlock(^{ return [[AVCaptureDeviceGlue devices] retain]; }),
 305       base::Bind(&SuspendObserverDelegate::DoStartObserver, this));
 306 }
 307
 308 void SuspendObserverDelegate::OnDeviceChanged(
 309       const scoped_refptr<base::SingleThreadTaskRunner>& device_thread) {
 310   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 311   // Enumerate the devices in Device thread and post the consolidation of the
 312   // new devices and the old ones to be done on UI thread. The devices array
 313   // is retained in |device_thread| and released in DoOnDeviceChanged().
 314   PostTaskAndReplyWithResult(
 315       device_thread.get(),
 316       FROM_HERE,
 317       base::BindBlock(^{ return [[AVCaptureDeviceGlue devices] retain]; }),
 318       base::Bind(&SuspendObserverDelegate::DoOnDeviceChanged, this));
 319 }
 320
 321 void SuspendObserverDelegate::ResetDeviceMonitor() {
 322   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 323   avfoundation_monitor_impl_ = NULL;
 324   [suspend_observer_ clearOnDeviceChangedCallback];
 325 }
 326
 327 SuspendObserverDelegate::~SuspendObserverDelegate() {
 328   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 329 }
 330
 331 void SuspendObserverDelegate::DoStartObserver(NSArray* devices) {
 332   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 333   base::scoped_nsobject<NSArray> auto_release(devices);
 334   for (CrAVCaptureDevice* device in devices) {
 335     base::scoped_nsobject<CrAVCaptureDevice> device_ptr([device retain]);
 336     [suspend_observer_ startObserving:device_ptr];
 337   }
 338 }
 339
 340 void SuspendObserverDelegate::DoOnDeviceChanged(NSArray* devices) {
 341   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 342   base::scoped_nsobject<NSArray> auto_release(devices);
 343   std::vector<DeviceInfo> snapshot_devices;
 344   for (CrAVCaptureDevice* device in devices) {
 345     base::scoped_nsobject<CrAVCaptureDevice> device_ptr([device retain]);
 346     [suspend_observer_ startObserving:device_ptr];
 347
 348     BOOL suspended = [device respondsToSelector:@selector(isSuspended)] &&
 349         [device isSuspended];
 350     DeviceInfo::DeviceType device_type = DeviceInfo::kUnknown;
 351     if ([device hasMediaType:AVFoundationGlue::AVMediaTypeVideo()]) {
 352       if (suspended)
 353         continue;
 354       device_type = DeviceInfo::kVideo;
 355     } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeMuxed()]) {
 356       device_type = suspended ? DeviceInfo::kAudio : DeviceInfo::kMuxed;
 357     } else if ([device hasMediaType:AVFoundationGlue::AVMediaTypeAudio()]) {
 358       device_type = DeviceInfo::kAudio;
 359     }
 360     snapshot_devices.push_back(DeviceInfo([[device uniqueID] UTF8String],
 361                                           device_type));
 362   }
 363
 364   // |avfoundation_monitor_impl_| might have been NULLed asynchronously before
 365   // arriving at this line.
 366   if (avfoundation_monitor_impl_) {
 367     avfoundation_monitor_impl_->ConsolidateDevicesListAndNotify(
 368         snapshot_devices);
 369   }
 370 }
 371
 372 // AVFoundation implementation of the Mac Device Monitor, registers as a global
 373 // device connect/disconnect observer and plugs suspend/wake up device observers
 374 // per device. This class is created and lives in UI thread. Owns a
 375 // SuspendObserverDelegate that notifies when a device is suspended/resumed.
 376 class AVFoundationMonitorImpl : public DeviceMonitorMacImpl {
 377  public:
 378   AVFoundationMonitorImpl(
 379       content::DeviceMonitorMac* monitor,
 380       const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner);
 381   ~AVFoundationMonitorImpl() override;
 382
 383   void OnDeviceChanged() override;
 384
 385  private:
 386   // {Video,AudioInput}DeviceManager's "Device" thread task runner used for
 387   // posting tasks to |suspend_observer_delegate_|; valid after
 388   // MediaStreamManager calls StartMonitoring().
 389   const scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
 390
 391   scoped_refptr<SuspendObserverDelegate> suspend_observer_delegate_;
 392
 393   DISALLOW_COPY_AND_ASSIGN(AVFoundationMonitorImpl);
 394 };
 395
 396 AVFoundationMonitorImpl::AVFoundationMonitorImpl(
 397     content::DeviceMonitorMac* monitor,
 398     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner)
 399     : DeviceMonitorMacImpl(monitor),
 400       device_task_runner_(device_task_runner),
 401       suspend_observer_delegate_(new SuspendObserverDelegate(this)) {
 402   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 403   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 404   device_arrival_ =
 405       [nc addObserverForName:AVFoundationGlue::
 406           AVCaptureDeviceWasConnectedNotification()
 407                       object:nil
 408                        queue:nil
 409                   usingBlock:^(NSNotification* notification) {
 410                       OnDeviceChanged();}];
 411   device_removal_ =
 412       [nc addObserverForName:AVFoundationGlue::
 413           AVCaptureDeviceWasDisconnectedNotification()
 414                       object:nil
 415                        queue:nil
 416                   usingBlock:^(NSNotification* notification) {
 417                       OnDeviceChanged();}];
 418   suspend_observer_delegate_->StartObserver(device_task_runner_);
 419 }
 420
 421 AVFoundationMonitorImpl::~AVFoundationMonitorImpl() {
 422   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 423   suspend_observer_delegate_->ResetDeviceMonitor();
 424   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
 425   [nc removeObserver:device_arrival_];
 426   [nc removeObserver:device_removal_];
 427 }
 428
 429 void AVFoundationMonitorImpl::OnDeviceChanged() {
 430   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 431   suspend_observer_delegate_->OnDeviceChanged(device_task_runner_);
 432 }
 433
 434 }  // namespace
 435
 436 @implementation CrAVFoundationDeviceObserver
 437
 438 - (id)initWithOnChangedCallback:(const base::Closure&)callback {
 439   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 440   if ((self = [super init])) {
 441     DCHECK(!callback.is_null());
 442     onDeviceChangedCallback_ = callback;
 443   }
 444   return self;
 445 }
 446
 447 - (void)dealloc {
 448   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 449   std::set<base::scoped_nsobject<CrAVCaptureDevice> >::iterator it =
 450       monitoredDevices_.begin();
 451   while (it != monitoredDevices_.end())
 452     [self removeObservers:*(it++)];
 453   [super dealloc];
 454 }
 455
 456 - (void)startObserving:(base::scoped_nsobject<CrAVCaptureDevice>)device {
 457   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 458   DCHECK(device != nil);
 459   // Skip this device if there are already observers connected to it.
 460   if (std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device) !=
 461       monitoredDevices_.end()) {
 462     return;
 463   }
 464   [device addObserver:self
 465            forKeyPath:@"suspended"
 466               options:0
 467               context:device.get()];
 468   [device addObserver:self
 469            forKeyPath:@"connected"
 470               options:0
 471               context:device.get()];
 472   monitoredDevices_.insert(device);
 473 }
 474
 475 - (void)stopObserving:(CrAVCaptureDevice*)device {
 476   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 477   DCHECK(device != nil);
 478
 479   std::set<base::scoped_nsobject<CrAVCaptureDevice> >::iterator found =
 480       std::find(monitoredDevices_.begin(), monitoredDevices_.end(), device);
 481   DCHECK(found != monitoredDevices_.end());
 482   [self removeObservers:*found];
 483   monitoredDevices_.erase(found);
 484 }
 485
 486 - (void)clearOnDeviceChangedCallback {
 487   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 488   onDeviceChangedCallback_.Reset();
 489 }
 490
 491 - (void)removeObservers:(CrAVCaptureDevice*)device {
 492   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 493   // Check sanity of |device| via its -observationInfo. http://crbug.com/371271.
 494   if ([device observationInfo]) {
 495     [device removeObserver:self
 496                 forKeyPath:@"suspended"];
 497     [device removeObserver:self
 498                 forKeyPath:@"connected"];
 499   }
 500 }
 501
 502 - (void)observeValueForKeyPath:(NSString*)keyPath
 503                       ofObject:(id)object
 504                         change:(NSDictionary*)change
 505                        context:(void*)context {
 506   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 507   if ([keyPath isEqual:@"suspended"])
 508     onDeviceChangedCallback_.Run();
 509   if ([keyPath isEqual:@"connected"])
 510     [self stopObserving:static_cast<CrAVCaptureDevice*>(context)];
 511 }
 512
 513 @end  // @implementation CrAVFoundationDeviceObserver
 514
 515 namespace content {
 516
 517 DeviceMonitorMac::DeviceMonitorMac() {
 518   // Both QTKit and AVFoundation do not need to be fired up until the user
 519   // exercises a GetUserMedia. Bringing up either library and enumerating the
 520   // devices in the system is an operation taking in the range of hundred of ms,
 521   // so it is triggered explicitly from MediaStreamManager::StartMonitoring().
 522 }
 523
 524 DeviceMonitorMac::~DeviceMonitorMac() {}
 525
 526 void DeviceMonitorMac::StartMonitoring(
 527     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
 528   DCHECK(thread_checker_.CalledOnValidThread());
 529   if (AVFoundationGlue::IsAVFoundationSupported()) {
 530     DVLOG(1) << "Monitoring via AVFoundation";
 531     device_monitor_impl_.reset(new AVFoundationMonitorImpl(this,
 532                                                            device_task_runner));
 533   } else {
 534     DVLOG(1) << "Monitoring via QTKit";
 535     device_monitor_impl_.reset(new QTKitMonitorImpl(this));
 536   }
 537 }
 538
 539 void DeviceMonitorMac::NotifyDeviceChanged(
 540     base::SystemMonitor::DeviceType type) {
 541   DCHECK(thread_checker_.CalledOnValidThread());
 542   // TODO(xians): Remove the global variable for SystemMonitor.
 543   base::SystemMonitor::Get()->ProcessDevicesChanged(type);
 544 }
 545
 546 }  // namespace content