Rename SystemMonitor's MediaDevice calls to RemovableStorage.

chrome/browser/media_gallery/media_storage_util.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.
 
 // chrome::MediaStorageUtil implementation.
 
 #include "chrome/browser/media_gallery/media_storage_util.h"
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/system_monitor/system_monitor.h"
 #include "content/public/browser/browser_thread.h"
 
 using base::SystemMonitor;
 using content::BrowserThread;
 
 namespace chrome {
 
 namespace {
 
-typedef std::vector<SystemMonitor::MediaDeviceInfo> MediaDevicesInfo;
+typedef std::vector<SystemMonitor::RemovableStorageInfo> RemovableStorageInfo;
 
 // Prefix constants for different device id spaces.
 const char kUsbMassStorageWithDCIMPrefix[] = "dcim:";
 const char kUsbMassStorageNoDCIMPrefix[] = "usb:";
 const char kOtherMassStoragePrefix[] = "path:";
 const char kUsbMtpPrefix[] = "mtp:";
 
 void EmptyPathIsFalseCallback(const MediaStorageUtil::BoolCallback& callback,
                               FilePath path) {
   callback.Run(!path.empty());
 }
 
 void ValidatePathOnFileThread(
     const FilePath& path, const MediaStorageUtil::FilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   FilePath result;
   if (file_util::PathExists(path))
     result = path;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, path));
 }
 
-FilePath::StringType FindMediaDeviceLocationById(const std::string& device_id) {
-  MediaDevicesInfo media_devices =
-      SystemMonitor::Get()->GetAttachedMediaDevices();
-  for (MediaDevicesInfo::const_iterator it = media_devices.begin();
+FilePath::StringType FindRemovableStorageLocationById(
+    const std::string& device_id) {
+  RemovableStorageInfo media_devices =
+      SystemMonitor::Get()->GetAttachedRemovableStorage();
+  for (RemovableStorageInfo::const_iterator it = media_devices.begin();
        it != media_devices.end();
        ++it) {
-    if (it->unique_id == device_id)
+    if (it->device_id == device_id)
       return it->location;
   }
   return FilePath::StringType();
 }
 
 // TODO(vandebo) use FilePath::AppendRelativePath instead
 // Make |path| a relative path, i.e. strip the drive letter and leading /.
 FilePath MakePathRelative(const FilePath& path) {
   if (!path.IsAbsolute())
     return path;
@@ skipping 80 matching lines @@
   std::string unique_id;
   if (!CrackDeviceId(device_id, &type, &unique_id)) {
     callback.Run(false);
     return;
   }
 
   switch (type) {
     case USB_MTP:  // Fall through
     case USB_MASS_STORAGE_WITH_DCIM:
       // We should be able to find media devices in SystemMonitor.
-      callback.Run(!FindMediaDeviceLocationById(device_id).empty());
+      callback.Run(!FindRemovableStorageLocationById(device_id).empty());
       break;
     case USB_MASS_STORAGE_NO_DCIM:
       FindUSBDeviceById(unique_id,
                         base::Bind(&EmptyPathIsFalseCallback, callback));
       break;
     case OTHER_MASS_STORAGE:
       // For this type, the unique_id is the path.
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&ValidatePathOnFileThread,
@@ skipping 38 matching lines @@
       FindUSBDeviceById(unique_id, callback);
       break;
     case OTHER_MASS_STORAGE:
       // For this type, the unique_id is the path.
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&ValidatePathOnFileThread,
                      FilePath::FromUTF8Unsafe(unique_id), callback));
       break;
     case USB_MASS_STORAGE_WITH_DCIM:
-      callback.Run(FilePath(FindMediaDeviceLocationById(device_id)));
+      callback.Run(FilePath(FindRemovableStorageLocationById(device_id)));
       break;
   }
   NOTREACHED();
   callback.Run(FilePath());
 }
 
 MediaStorageUtil::MediaStorageUtil() {}
 
 // static
 void MediaStorageUtil::FindUSBDeviceById(const std::string& unique_id,
                                          const FilePathCallback& callback) {
   // TODO(vandebo) This needs to be implemented per platform.
   // Type is USB_MASS_STORAGE_NO_DCIM, so it's a device possibly mounted
   // somewhere...
   NOTREACHED();
   callback.Run(FilePath());
 }
 
 }  // namespace chrome