Add SystemMonitor::GetMediaDevices()

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_
 #pragma once
 
+#include <map>
 #include <string>
+#include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
+#include "base/tuple.h"
 #include "build/build_config.h"
 
 // Windows HiRes timers drain the battery faster so we need to know the battery
 // status.  This isn't true for other platforms.
 #if defined(OS_WIN)
 #define ENABLE_BATTERY_MONITORING 1
 #else
 #undef ENABLE_BATTERY_MONITORING
 #endif  // !OS_WIN
 
@@ skipping 17 matching lines @@
 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.
   };
 
   typedef unsigned int DeviceIdType;
+  // (Media device id, Media device name, Media device path)
+  typedef Tuple3<DeviceIdType, std::string, FilePath> MediaDeviceInfo;
 
   // Create SystemMonitor. Only one SystemMonitor instance per application
   // is allowed.
   SystemMonitor();
   ~SystemMonitor();
 
   // Get the application-wide SystemMonitor (if not present, returns NULL).
   static SystemMonitor* Get();
 
 #if defined(OS_MACOSX)
@@ skipping 78 matching lines @@
   // Cross-platform handling of a power event.
   void ProcessPowerMessage(PowerEvent event_id);
 
   // Cross-platform handling of a device change event.
   void ProcessDevicesChanged();
   void ProcessMediaDeviceAttached(const DeviceIdType& id,
                                   const std::string& name,
                                   const FilePath& path);
   void ProcessMediaDeviceDetached(const DeviceIdType& id);
 
+  // Appends info for attached media devices to |results|.

[willchan no longer on Chromium, 2012/05/21 05:32:36]

Is there a reason you don't just return std::vector<MediaDeviceInfo>? Are we
worried about perf cost here? I'd prefer returning std::vector since it has a
clearer API. When you pass in an output param, it's unspecified how to treat any
existing data in that vector, so we have to rely on comments. Therefore, I'd
prefer not to use an output param unless it's necessary.

[Lei Zhang, 2012/05/21 19:42:06]

Done.

A lot of our code in our code base does it that way, e.g. SplitString(). Whereas
I have not seen as much code return a vector. I don't have a strong pref either
way.

[willchan no longer on Chromium, 2012/05/21 20:24:34]

You're right that our existing code generally uses output params. I don't agree
with that :) We've got a lot of suboptimal practices in our code base and I'm
trying to crack down on them.

Output params are better in some cases (such as wanting to reuse containers for
copy-avoidance reasons), but the interface is better defined with simply
returning the container if possible.

+  void GetAttachedMediaDevices(std::vector<MediaDeviceInfo>* results);
+
  private:
+  typedef std::map<base::SystemMonitor::DeviceIdType,
+                   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();
 
@@ skipping 14 matching lines @@
   scoped_refptr<ObserverListThreadSafe<PowerObserver> > power_observer_list_;
   scoped_refptr<ObserverListThreadSafe<DevicesChangedObserver> >
       devices_changed_observer_list_;
   bool battery_in_use_;
   bool suspended_;
 
 #if defined(ENABLE_BATTERY_MONITORING)
   base::OneShotTimer<SystemMonitor> delayed_battery_check_;
 #endif
 
+  MediaDeviceMap media_device_map_;
+
   DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
 };
 
 }  // namespace base
 
 #endif  // BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_