Change base::SystemMonitor's media device functions to take a type and FilePath::StringType instead of a FilePath.

BUG=none
TEST=none

Review URL: https://chromiumcodereview.appspot.com/10780023

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@147758 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 122 insertions, 65 deletions

diff --git a/base/system_monitor/system_monitor.cc b/base/system_monitor/system_monitor.cc
index 5815b92..6db1db5 100644
--- a/base/system_monitor/system_monitor.cc
+++ b/base/system_monitor/system_monitor.cc
@@ -6,10 +6,11 @@
 
 #include <utility>
 
-#include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/stl_util.h"
 #include "base/time.h"
+#include "base/utf_string_conversions.h"
 
 namespace base {
 
@@ -86,14 +87,22 @@ void SystemMonitor::ProcessDevicesChanged() {
   NotifyDevicesChanged();
 }
 
-void SystemMonitor::ProcessMediaDeviceAttached(const DeviceIdType& id,
-                                               const std::string& name,
-                                               const FilePath& path) {
-  media_device_map_.insert(std::make_pair(id, MakeTuple(id, name, path)));
-  NotifyMediaDeviceAttached(id, name, path);
+void SystemMonitor::ProcessMediaDeviceAttached(
+    const std::string& id,
+    const string16& name,
+    MediaDeviceType type,
+    const FilePath::StringType& location) {
+  MediaDeviceInfo info(id, name, type, location);
+  if (ContainsKey(media_device_map_, id)) {
+    // This can happen if our unique id scheme fails. Ignore the incoming
+    // non-unique attachment.
+    return;
+  }
+  media_device_map_.insert(std::make_pair(id, info));
+  NotifyMediaDeviceAttached(id, name, type, location);
 }
 
-void SystemMonitor::ProcessMediaDeviceDetached(const DeviceIdType& id) {
+void SystemMonitor::ProcessMediaDeviceDetached(const std::string& id) {
   MediaDeviceMap::iterator it = media_device_map_.find(id);
   if (it != media_device_map_.end())
     media_device_map_.erase(it);
@@ -133,15 +142,18 @@ void SystemMonitor::NotifyDevicesChanged() {
     &DevicesChangedObserver::OnDevicesChanged);
 }
 
-void SystemMonitor::NotifyMediaDeviceAttached(const DeviceIdType& id,
-                                              const std::string& name,
-                                              const FilePath& path) {
-  DVLOG(1) << "MediaDeviceAttached with name " << name << " and id " << id;
+void SystemMonitor::NotifyMediaDeviceAttached(
+    const std::string& id,
+    const string16& name,
+    MediaDeviceType type,
+    const FilePath::StringType& location) {
+  DVLOG(1) << "MediaDeviceAttached with name " << UTF16ToUTF8(name)
+           << " and id " << id;
   devices_changed_observer_list_->Notify(
-    &DevicesChangedObserver::OnMediaDeviceAttached, id, name, path);
+    &DevicesChangedObserver::OnMediaDeviceAttached, id, name, type, location);
 }
 
-void SystemMonitor::NotifyMediaDeviceDetached(const DeviceIdType& id) {
+void SystemMonitor::NotifyMediaDeviceDetached(const std::string& id) {
   DVLOG(1) << "MediaDeviceDetached for id " << id;
   devices_changed_observer_list_->Notify(
     &DevicesChangedObserver::OnMediaDeviceDetached, id);
diff --git a/base/system_monitor/system_monitor.h b/base/system_monitor/system_monitor.h
index a6065d9..359feb6 100644
--- a/base/system_monitor/system_monitor.h
+++ b/base/system_monitor/system_monitor.h
@@ -5,12 +5,14 @@
 #ifndef BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 #define BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
-#include "base/tuple.h"
+#include "base/file_path.h"
+#include "base/string16.h"
 #include "build/build_config.h"
 
 // Windows HiRes timers drain the battery faster so we need to know the battery
@@ -35,8 +37,6 @@
 #include <objc/runtime.h>
 #endif  // OS_IOS
 
-class FilePath;
-
 namespace base {
 
 // Class for monitoring various system-related subsystems
@@ -51,9 +51,35 @@ class BASE_EXPORT SystemMonitor {
     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;
+  // 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,
+                    const FilePath::StringType& device_location)
+        : unique_id(id),
+          name(device_name),
+          type(device_type),
+          location(device_location) {
+    }
+
+    // Unique media device id - persists between device attachments.
+    std::string unique_id;
+
+    // Human readable media device name.
+    string16 name;
+
+    // Media device type.
+    MediaDeviceType type;
+
+    // Current attached media device location.
+    FilePath::StringType location;
+  };
 
   // Create SystemMonitor. Only one SystemMonitor instance per application
   // is allowed.
@@ -75,6 +101,9 @@ class BASE_EXPORT SystemMonitor {
 #endif  // OS_IOS
 #endif  // OS_MACOSX
 
+  // Returns information for attached media devices.
+  std::vector<MediaDeviceInfo> GetAttachedMediaDevices() const;
+
   //
   // Power-related APIs
   //
@@ -115,13 +144,12 @@ class BASE_EXPORT SystemMonitor {
 
     // When a media device is attached or detached, one of these two events
     // is triggered.
-    // TODO(vandebo) Pass an appropriate device identifier or way to interact
-    // with the devices instead of FilePath.
-    virtual void OnMediaDeviceAttached(const DeviceIdType& id,
-                                       const std::string& name,
-                                       const FilePath& path) {}
+    virtual void OnMediaDeviceAttached(const std::string& id,
+                                       const string16& name,
+                                       MediaDeviceType type,
+                                       const FilePath::StringType& location) {}
 
-    virtual void OnMediaDeviceDetached(const DeviceIdType& id) {}
+    virtual void OnMediaDeviceDetached(const std::string& id) {}
 
    protected:
     virtual ~DevicesChangedObserver() {}
@@ -151,17 +179,16 @@ class BASE_EXPORT SystemMonitor {
 
   // 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);
-
-  // Returns information for attached media devices.
-  std::vector<MediaDeviceInfo> GetAttachedMediaDevices() const;
+  void ProcessMediaDeviceAttached(const std::string& id,
+                                  const string16& name,
+                                  MediaDeviceType type,
+                                  const FilePath::StringType& location);
+  void ProcessMediaDeviceDetached(const std::string& id);
 
  private:
-  typedef std::map<base::SystemMonitor::DeviceIdType,
-                   MediaDeviceInfo> MediaDeviceMap;
+  // Mapping of unique device id to device info tuple.
+  typedef std::map<std::string, MediaDeviceInfo> MediaDeviceMap;
+
 #if defined(OS_MACOSX)
   void PlatformInit();
   void PlatformDestroy();
@@ -178,10 +205,11 @@ class BASE_EXPORT SystemMonitor {
 
   // Functions to trigger notifications.
   void NotifyDevicesChanged();
-  void NotifyMediaDeviceAttached(const DeviceIdType& id,
-                                 const std::string& name,
-                                 const FilePath& path);
-  void NotifyMediaDeviceDetached(const DeviceIdType& id);
+  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();
@@ -201,6 +229,7 @@ class BASE_EXPORT SystemMonitor {
   std::vector<id> notification_observers_;
 #endif
 
+  // Map of all the attached media devices.
   MediaDeviceMap media_device_map_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
diff --git a/base/system_monitor/system_monitor_unittest.cc b/base/system_monitor/system_monitor_unittest.cc
index cbde257..7c5f375 100644
--- a/base/system_monitor/system_monitor_unittest.cc
+++ b/base/system_monitor/system_monitor_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/file_path.h"
 #include "base/message_loop.h"
 #include "base/test/mock_devices_changed_observer.h"
+#include "base/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -108,6 +109,9 @@ TEST_F(SystemMonitorTest, PowerNotifications) {
 
 TEST_F(SystemMonitorTest, DeviceChangeNotifications) {
   const int kObservers = 5;
+  const string16 kDeviceName = ASCIIToUTF16("media device");
+  const std::string kDeviceId1 = "1";
+  const std::string kDeviceId2 = "2";
 
   testing::Sequence mock_sequencer[kObservers];
   MockDevicesChangedObserver observers[kObservers];
@@ -117,12 +121,15 @@ TEST_F(SystemMonitorTest, DeviceChangeNotifications) {
     EXPECT_CALL(observers[index], OnDevicesChanged())
         .Times(3)
         .InSequence(mock_sequencer[index]);
-    EXPECT_CALL(observers[index], OnMediaDeviceAttached(1, "media device",
-                                                        testing::_))
+    EXPECT_CALL(observers[index],
+                OnMediaDeviceAttached(kDeviceId1,
+                                      kDeviceName,
+                                      base::SystemMonitor::TYPE_PATH,
+                                      testing::_))
         .InSequence(mock_sequencer[index]);
-    EXPECT_CALL(observers[index], OnMediaDeviceDetached(1))
+    EXPECT_CALL(observers[index], OnMediaDeviceDetached(kDeviceId1))
         .InSequence(mock_sequencer[index]);
-    EXPECT_CALL(observers[index], OnMediaDeviceDetached(2))
+    EXPECT_CALL(observers[index], OnMediaDeviceDetached(kDeviceId2))
         .InSequence(mock_sequencer[index]);
   }
 
@@ -134,11 +141,14 @@ TEST_F(SystemMonitorTest, DeviceChangeNotifications) {
   message_loop_.RunAllPending();
 
   system_monitor_->ProcessMediaDeviceAttached(
-      1, "media device", FilePath(FILE_PATH_LITERAL("path")));
+      kDeviceId1,
+      kDeviceName,
+      base::SystemMonitor::TYPE_PATH,
+      FILE_PATH_LITERAL("path"));
   message_loop_.RunAllPending();
 
-  system_monitor_->ProcessMediaDeviceDetached(1);
-  system_monitor_->ProcessMediaDeviceDetached(2);
+  system_monitor_->ProcessMediaDeviceDetached(kDeviceId1);
+  system_monitor_->ProcessMediaDeviceDetached(kDeviceId2);
   message_loop_.RunAllPending();
 }
 
@@ -149,43 +159,49 @@ TEST_F(SystemMonitorTest, GetAttachedMediaDevicesEmpty) {
 }
 
 TEST_F(SystemMonitorTest, GetAttachedMediaDevicesAttachDetach) {
-  const SystemMonitor::DeviceIdType kDeviceId1 = 42;
-  const char kDeviceName1[] = "test";
+  const std::string kDeviceId1 = "42";
+  const string16 kDeviceName1 = ASCIIToUTF16("test");
   const FilePath kDevicePath1(FILE_PATH_LITERAL("/testfoo"));
   system_monitor_->ProcessMediaDeviceAttached(kDeviceId1,
-                                             kDeviceName1,
-                                             kDevicePath1);
+                                              kDeviceName1,
+                                              base::SystemMonitor::TYPE_PATH,
+                                              kDevicePath1.value());
   message_loop_.RunAllPending();
   std::vector<SystemMonitor::MediaDeviceInfo> devices =
       system_monitor_->GetAttachedMediaDevices();
   ASSERT_EQ(1U, devices.size());
-  EXPECT_EQ(kDeviceId1, devices[0].a);
-  EXPECT_EQ(kDeviceName1, devices[0].b);
-  EXPECT_EQ(kDevicePath1, devices[0].c);
+  EXPECT_EQ(kDeviceId1, devices[0].unique_id);
+  EXPECT_EQ(kDeviceName1, devices[0].name);
+  EXPECT_EQ(base::SystemMonitor::TYPE_PATH, devices[0].type);
+  EXPECT_EQ(kDevicePath1.value(), devices[0].location);
 
-  const SystemMonitor::DeviceIdType kDeviceId2 = 44;
-  const char kDeviceName2[] = "test2";
+  const std::string kDeviceId2 = "44";
+  const string16 kDeviceName2 = ASCIIToUTF16("test2");
   const FilePath kDevicePath2(FILE_PATH_LITERAL("/testbar"));
   system_monitor_->ProcessMediaDeviceAttached(kDeviceId2,
-                                             kDeviceName2,
-                                             kDevicePath2);
+                                              kDeviceName2,
+                                              base::SystemMonitor::TYPE_PATH,
+                                              kDevicePath2.value());
   message_loop_.RunAllPending();
   devices = system_monitor_->GetAttachedMediaDevices();
   ASSERT_EQ(2U, devices.size());
-  EXPECT_EQ(kDeviceId1, devices[0].a);
-  EXPECT_EQ(kDeviceName1, devices[0].b);
-  EXPECT_EQ(kDevicePath1, devices[0].c);
-  EXPECT_EQ(kDeviceId2, devices[1].a);
-  EXPECT_EQ(kDeviceName2, devices[1].b);
-  EXPECT_EQ(kDevicePath2, devices[1].c);
+  EXPECT_EQ(kDeviceId1, devices[0].unique_id);
+  EXPECT_EQ(kDeviceName1, devices[0].name);
+  EXPECT_EQ(base::SystemMonitor::TYPE_PATH, devices[0].type);
+  EXPECT_EQ(kDevicePath1.value(), devices[0].location);
+  EXPECT_EQ(kDeviceId2, devices[1].unique_id);
+  EXPECT_EQ(kDeviceName2, devices[1].name);
+  EXPECT_EQ(base::SystemMonitor::TYPE_PATH, devices[1].type);
+  EXPECT_EQ(kDevicePath2.value(), devices[1].location);
 
   system_monitor_->ProcessMediaDeviceDetached(kDeviceId1);
   message_loop_.RunAllPending();
   devices = system_monitor_->GetAttachedMediaDevices();
   ASSERT_EQ(1U, devices.size());
-  EXPECT_EQ(kDeviceId2, devices[0].a);
-  EXPECT_EQ(kDeviceName2, devices[0].b);
-  EXPECT_EQ(kDevicePath2, devices[0].c);
+  EXPECT_EQ(kDeviceId2, devices[0].unique_id);
+  EXPECT_EQ(kDeviceName2, devices[0].name);
+  EXPECT_EQ(base::SystemMonitor::TYPE_PATH, devices[0].type);
+  EXPECT_EQ(kDevicePath2.value(), devices[0].location);
 
   system_monitor_->ProcessMediaDeviceDetached(kDeviceId2);
   message_loop_.RunAllPending();