add device type as an argument in OnDevicesChanged.

base/system_monitor/system_monitor.h

 // 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.
 
 #ifndef BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 #define BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 33 matching lines @@
 // TODO(mbelshe):  Add support beyond just power management.
 class BASE_EXPORT SystemMonitor {
  public:
   // Normalized list of power events.
   enum PowerEvent {
     POWER_STATE_EVENT,  // The Power status of the system has changed.
     SUSPEND_EVENT,      // The system is being suspended.
     RESUME_EVENT        // The system is being resumed.
   };
 
+  // Type of devices whose change need to be monitored, such as add/remove.
+  enum DeviceType {
+    DEVTYPE_AUDIO_CAPTURE,  // Audio capture device, e.g., microphone.
+    DEVTYPE_VIDEO_CAPTURE,  // Video capture device, e.g., webcam.
+    DEVTYPE_UNKNOWN,  // Other devices.
+  };
+
   // Type of location data to identify a currently attached media device.
   enum MediaDeviceType {
     TYPE_PATH,  // FilePath::StringType, e.g. a mount point.
     TYPE_MTP,   // (W)string to locate a MTP device, e.g. its usb bus/port.
   };
 
   struct MediaDeviceInfo {
     MediaDeviceInfo(const std::string& id,
                     const string16& device_name,
                     MediaDeviceType device_type,
@@ skipping 69 matching lines @@
     virtual void OnResume() {}
 
    protected:
     virtual ~PowerObserver() {}
   };
 
   class BASE_EXPORT DevicesChangedObserver {
    public:
     // Notification that the devices connected to the system have changed.
     // This is only implemented on Windows currently.
-    virtual void OnDevicesChanged() {}
+    virtual void OnDevicesChanged(DeviceType device_type) {}
 
     // When a media device is attached or detached, one of these two events
     // is triggered.
     virtual void OnMediaDeviceAttached(const std::string& id,
                                        const string16& name,
                                        MediaDeviceType type,
                                        const FilePath::StringType& location) {}
 
     virtual void OnMediaDeviceDetached(const std::string& id) {}
 
@@ skipping 17 matching lines @@
   // Windows-specific handling of a WM_POWERBROADCAST message.
   // Embedders of this API should hook their top-level window
   // message loop and forward WM_POWERBROADCAST through this call.
   void ProcessWmPowerBroadcastMessage(int event_id);
 #endif
 
   // Cross-platform handling of a power event.
   void ProcessPowerMessage(PowerEvent event_id);
 
   // Cross-platform handling of a device change event.
-  void ProcessDevicesChanged();
+  void ProcessDevicesChanged(DeviceType device_type);
   void ProcessMediaDeviceAttached(const std::string& id,
                                   const string16& name,
                                   MediaDeviceType type,
                                   const FilePath::StringType& location);
   void ProcessMediaDeviceDetached(const std::string& id);
 
  private:
   // Mapping of unique device id to device info tuple.
   typedef std::map<std::string, MediaDeviceInfo> MediaDeviceMap;
 
 #if defined(OS_MACOSX)
   void PlatformInit();
   void PlatformDestroy();
 #endif
 
   // Platform-specific method to check whether the system is currently
   // running on battery power.  Returns true if running on batteries,
   // false otherwise.
   bool IsBatteryPower();
 
   // Checks the battery status and notifies observers if the battery
   // status has changed.
   void BatteryCheck();
 
   // Functions to trigger notifications.
-  void NotifyDevicesChanged();
+  void NotifyDevicesChanged(DeviceType device_type);
   void NotifyMediaDeviceAttached(const std::string& id,
                                  const string16& name,
                                  MediaDeviceType type,
                                  const FilePath::StringType& data);
   void NotifyMediaDeviceDetached(const std::string& id);
   void NotifyPowerStateChange();
   void NotifySuspend();
   void NotifyResume();
 
   scoped_refptr<ObserverListThreadSafe<PowerObserver> > power_observer_list_;
@@ skipping 13 matching lines @@
 
   // Map of all the attached media devices.
   MediaDeviceMap media_device_map_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
 };
 
 }  // namespace base
 
 #endif  // BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_