[Chrome OS]Implement MediaStorageUtil::GetDeviceInfoForPath function to support media gallery permi…

chrome/browser/system_monitor/media_transfer_protocol_device_observer_chromeos.cc

 // 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.
 
 #include "chrome/browser/system_monitor/media_transfer_protocol_device_observer_chromeos.h"
 
+#include "base/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
-#include "base/system_monitor/system_monitor.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/mtp/media_transfer_protocol_manager.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
 #include "chromeos/dbus/mtp_storage_info.pb.h"
 
 namespace chromeos {
 namespace mtp {
 
 using chrome::MediaStorageUtil;
 
 namespace {
 
+static MediaTransferProtocolDeviceObserverCros* g_mtp_device_observer = NULL;
+
 // Device root path constant.
 const char kRootPath[] = "/";
 
+// Constructs and returns the location of the device using the |storage_name|.
+std::string GetDeviceLocationFromStorageName(const std::string& storage_name) {
+  // Construct a dummy device path using the storage name. This is only used
+  // for registering device media file system.
+  // E.g.: /usb:2,2:12345
+  DCHECK(!storage_name.empty());
+  return kRootPath + storage_name;
+}
+
 // Returns the storage identifier of the device from the given |storage_name|.
 // E.g. If the |storage_name| is "usb:2,2:65537", the storage identifier is
 // "65537".
 std::string GetStorageIdFromStorageName(const std::string& storage_name) {
   std::vector<std::string> name_parts;
   base::SplitString(storage_name, ':', &name_parts);
   return name_parts.size() == 3 ? name_parts[2] : std::string();
 }
 
 // Returns a unique device id from the given |storage_info|.
@@ skipping 52 matching lines @@
 
   if (!storage_info)
     return;
 
   if (id)
     *id = GetDeviceIdFromStorageInfo(*storage_info);
 
   if (label)
     *label = GetDeviceLabelFromStorageInfo(*storage_info);
 
-  // Construct a dummy device path using the storage name. This is only used
-  // for registering device media file system.
-  // E.g.: /usb:2,2:12345
+
   if (location)
-    *location = kRootPath + storage_name;
+    *location = GetDeviceLocationFromStorageName(storage_name);
 }
 
 }  // namespace
 
 MediaTransferProtocolDeviceObserverCros::
 MediaTransferProtocolDeviceObserverCros()
     : get_storage_info_func_(&GetStorageInfo) {
+  DCHECK(!g_mtp_device_observer);
+  g_mtp_device_observer = this;
+
   MediaTransferProtocolManager* mtp_manager =
       MediaTransferProtocolManager::GetInstance();
   if (mtp_manager)
     mtp_manager->AddObserver(this);
   EnumerateStorages();
 }
 
 // This constructor is only used by unit tests.
 MediaTransferProtocolDeviceObserverCros::
     MediaTransferProtocolDeviceObserverCros(
         GetStorageInfoFunc get_storage_info_func)
     : get_storage_info_func_(get_storage_info_func) {
   // In unit tests, we don't have a media transfer protocol manager.
   DCHECK(!MediaTransferProtocolManager::GetInstance());
+
+  // In unit tests, we don't call
+  // MediaTransferProtocolDeviceObserverCros::GetInstance(). so it is safe to
+  // keep this NULL;
+  DCHECK(!g_mtp_device_observer);

[Lei Zhang, 2012/09/16 00:17:05]

this is weird, why not just set |g_mtp_device_observer| so the test ctor's
behavior is consistent with the real one?

[kmadhusu, 2012/09/16 22:35:42]

Done.

 }
 
 MediaTransferProtocolDeviceObserverCros::
 ~MediaTransferProtocolDeviceObserverCros() {
+  if (g_mtp_device_observer) {
+    DCHECK_EQ(this, g_mtp_device_observer);
+    g_mtp_device_observer = NULL;
+  }
+
   MediaTransferProtocolManager* mtp_manager =
       MediaTransferProtocolManager::GetInstance();
   if (mtp_manager)
     mtp_manager->RemoveObserver(this);
 }
 
+// static
+MediaTransferProtocolDeviceObserverCros*
+MediaTransferProtocolDeviceObserverCros::GetInstance() {
+  DCHECK(g_mtp_device_observer != NULL);
+  return g_mtp_device_observer;
+}
+
+MediaTransferProtocolDeviceObserverCros::StorageInfo::StorageInfo() {
+}
+
+bool MediaTransferProtocolDeviceObserverCros::GetStorageInfoForPath(
+    const FilePath& path,
+    base::SystemMonitor::RemovableStorageInfo* storage_info) const {
+  if (!path.IsAbsolute())
+    return false;
+
+  FilePath current = path;
+  while (!ContainsKey(storage_map_, current.value()) &&

[vandebo (ex-Chrome), 2012/09/16 00:31:44]

Why do this?  Isn't the path for a mtp device a fixed format?

[kmadhusu, 2012/09/16 22:35:42]

Fixed. The first component of the path is always the device location.

+         current != current.DirName()) {
+    current = current.DirName();
+  }
+
+  StorageLocationToInfoMap::const_iterator info_it =
+      storage_map_.find(current.value());
+  if (info_it == storage_map_.end())
+    return false;
+
+  if (storage_info) {
+    storage_info->device_id = info_it->second.id;
+    storage_info->name = info_it->second.name;
+    storage_info->location = info_it->second.location;
+  }
+  return true;
+}
+
 // MediaTransferProtocolManager::Observer override.
 void MediaTransferProtocolDeviceObserverCros::StorageChanged(
     bool is_attached,
     const std::string& storage_name) {
   DCHECK(!storage_name.empty());
 
   base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
   DCHECK(system_monitor);
 
   // New storage is attached.
   if (is_attached) {
     std::string device_id;
     string16 device_name;
     std::string location;
     get_storage_info_func_(storage_name, &device_id, &device_name, &location);
 
     // Keep track of device id and device name to see how often we receive
     // empty values.
     UMA_HISTOGRAM_BOOLEAN("MediaDeviceNotification.MTPDeviceUUIDAvailable",
                           !device_id.empty());
     UMA_HISTOGRAM_BOOLEAN("MediaDeviceNotification.MTPDeviceNameAvailable",
                           !device_name.empty());
 
     if (device_id.empty() || device_name.empty())
       return;
 
-    DCHECK(!ContainsKey(storage_map_, storage_name));
-    storage_map_[storage_name] = device_id;
+    DCHECK(!ContainsKey(storage_map_, location));
+
+    StorageInfo storage_info;
+    storage_info.id = device_id;
+    storage_info.location = location;
+    storage_info.name = device_name;
+    storage_map_[location] = storage_info;
     system_monitor->ProcessRemovableStorageAttached(device_id, device_name,
                                                     location);
   } else {
     // Existing storage is detached.
-    StorageNameToIdMap::iterator it = storage_map_.find(storage_name);
+    std::string location;
+    StorageLocationToInfoMap::iterator it =
+        storage_map_.find(GetDeviceLocationFromStorageName(storage_name));
     if (it == storage_map_.end())
       return;
-    system_monitor->ProcessRemovableStorageDetached(it->second);
+    system_monitor->ProcessRemovableStorageDetached(it->second.id);
     storage_map_.erase(it);
   }
 }
 
 void MediaTransferProtocolDeviceObserverCros::EnumerateStorages() {
   typedef std::vector<std::string> StorageList;
   MediaTransferProtocolManager* mtp_manager =
       MediaTransferProtocolManager::GetInstance();
   DCHECK(mtp_manager);
   StorageList storages = mtp_manager->GetStorages();
   for (StorageList::const_iterator storage_iter = storages.begin();
        storage_iter != storages.end(); ++storage_iter) {
     StorageChanged(true, *storage_iter);
   }
 }
 
 }  // namespace mtp
 }  // namespace chromeos