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 {

[tommi (sloooow) - chröme, 2012/07/30 10:02:28]

MediaDeviceType and DeviceType sound very similar.  Can't we add these values to
the existing MediaDeviceType enumeration?

I realize that MediaDeviceType maps to the MediaDeviceInfo class, but we could
use that as well for audio/video devices.  The only member variable that doesn't
fit is perhaps the 'location' member.

I can see that class growing in the future to support pluggable devices in
general so I'd rather not start forking things now and have two types for
essentially the same thing.

+    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_