Refine StorageMonitor storage device getter

chrome/browser/storage_monitor/storage_monitor_win.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/storage_monitor/storage_monitor_win.h"
 
 #include <windows.h>
 #include <dbt.h>
 #include <fileapi.h>
 
@@ skipping 63 matching lines @@
   portable_device_watcher_->Init(window_);
 }
 
 bool StorageMonitorWin::GetStorageInfoForPath(const base::FilePath& path,
                                               StorageInfo* device_info) const {
   DCHECK(device_info);
 
   // TODO(gbillock): Move this logic up to StorageMonitor.
   // If we already know the StorageInfo for the path, just return it.
   // This will account for portable devices as well.
-  std::vector<StorageInfo> attached_devices = GetAttachedStorage();
+  std::vector<StorageInfo> attached_devices = GetAttachedRemovableStorages();
   size_t best_parent = attached_devices.size();
   size_t best_length = 0;
   for (size_t i = 0; i < attached_devices.size(); i++) {
     base::FilePath relative;
     if (base::FilePath(attached_devices[i].location()).AppendRelativePath(
             path, &relative)) {
       // Note: the relative path is longer for shorter shared path between
       // the path and the device mount point, so we want the shortest
       // relative path.
       if (relative.value().size() < best_length) {
@@ skipping 32 matching lines @@
     const std::string& storage_device_id,
     string16* device_location,
     string16* storage_object_id) const {
   StorageInfo::Type type;
   StorageInfo::CrackDeviceId(storage_device_id, &type, NULL);
   return ((type == StorageInfo::MTP_OR_PTP) &&
       portable_device_watcher_->GetMTPStorageInfoFromDeviceId(
           storage_device_id, device_location, storage_object_id));
 }
 
+std::vector<StorageInfo> StorageMonitorWin::GetAllAvailableStorages() const {
+  std::vector<StorageInfo> results;
+  if (volume_mount_watcher_.get())
+    results = volume_mount_watcher_->GetAllVolumeStorages();
+  return results;
+}
+
 // static
 LRESULT CALLBACK StorageMonitorWin::WndProcThunk(HWND hwnd, UINT message,
                                                  WPARAM wparam, LPARAM lparam) {
   StorageMonitorWin* msg_wnd = reinterpret_cast<StorageMonitorWin*>(
       GetWindowLongPtr(hwnd, GWLP_USERDATA));
   if (msg_wnd)
     return msg_wnd->WndProc(hwnd, message, wparam, lparam);
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
 
@@ skipping 17 matching lines @@
   // portable device as a media gallery.
   return volume_mount_watcher_->GetDeviceInfo(device_path, info);
 }
 
 void StorageMonitorWin::OnDeviceChange(UINT event_type, LPARAM data) {
   volume_mount_watcher_->OnWindowMessage(event_type, data);
   portable_device_watcher_->OnWindowMessage(event_type, data);
 }
 
 }  // namespace chrome