StorageMonitor: Make StorageInfo a real class.

chrome/browser/storage_monitor/volume_mount_watcher_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/volume_mount_watcher_win.h"
 
 #include <windows.h>
 
 #include <dbt.h>
 #include <fileapi.h>
@@ skipping 130 matching lines @@
                                         WriteInto(&guid, kMaxPathBufLen),
                                         kMaxPathBufLen)) {
     return false;
   }
 
   // If we're adding a floppy drive, return without querying any more
   // drive metadata -- it will cause the floppy drive to seek.
   // Note: treats FLOPPY as FIXED_MASS_STORAGE. This is intentional.
   DeviceType device_type = GetDeviceType(mount_point);
   if (device_type == FLOPPY) {
-    info->device_id = chrome::StorageInfo::MakeDeviceId(
-        chrome::StorageInfo::FIXED_MASS_STORAGE, UTF16ToUTF8(guid));
+    info->set_device_id(chrome::StorageInfo::MakeDeviceId(
+        chrome::StorageInfo::FIXED_MASS_STORAGE, UTF16ToUTF8(guid)));
     return true;
   }
 
-  chrome::StorageInfo::Type type =
-      chrome::StorageInfo::FIXED_MASS_STORAGE;
+  chrome::StorageInfo::Type type = chrome::StorageInfo::FIXED_MASS_STORAGE;
   if (device_type == REMOVABLE) {
     type = chrome::StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
     if (chrome::MediaStorageUtil::HasDcim(base::FilePath(mount_point)))
-       type = chrome::StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
+      type = chrome::StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
   }
 
   // NOTE: experimentally, this function returns false if there is no volume
   // name set.
   string16 volume_label;
   GetVolumeInformationW(device_path.value().c_str(),
                         WriteInto(&volume_label, kMaxPathBufLen),
                         kMaxPathBufLen, NULL, NULL, NULL, NULL, 0);
 
-  info->location = mount_point;
-  info->total_size_in_bytes = GetVolumeSize(mount_point);
-  info->device_id = chrome::StorageInfo::MakeDeviceId(
-      type, UTF16ToUTF8(guid));
+  uint64 total_size_in_bytes = GetVolumeSize(mount_point);
+  std::string device_id =
+      chrome::StorageInfo::MakeDeviceId(type, UTF16ToUTF8(guid));
 
   // TODO(gbillock): if volume_label.empty(), get the vendor/model information
   // for the volume.
-  info->vendor_name = string16();
-  info->model_name = string16();
-  info->storage_label = volume_label;
-
+  *info = chrome::StorageInfo(device_id, string16(), mount_point,
+                              volume_label, string16(), string16(),
+                              total_size_in_bytes);
   return true;
 }
 
 // Returns a vector of all the removable mass storage devices that are
 // connected.
 std::vector<base::FilePath> GetAttachedDevices() {
   std::vector<base::FilePath> result;
   string16 volume_name;
   HANDLE find_handle = FindFirstVolume(WriteInto(&volume_name, kMaxPathBufLen),
                                        kMaxPathBufLen);
@@ skipping 297 matching lines @@
 void VolumeMountWatcherWin::HandleDeviceAttachEventOnUIThread(
     const base::FilePath& device_path,
     const StorageInfo& info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   device_metadata_[device_path.value()] = info;
 
   DeviceCheckComplete(device_path);
 
   // Don't call removable storage observers for fixed volumes.
-  if (!StorageInfo::IsRemovableDevice(info.device_id))
+  if (!StorageInfo::IsRemovableDevice(info.device_id()))
     return;
 
   if (notifications_)
     notifications_->ProcessAttach(info);
 }
 
 void VolumeMountWatcherWin::HandleDeviceDetachEventOnUIThread(
     const string16& device_location) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MountPointDeviceMetadataMap::const_iterator device_info =
       device_metadata_.find(device_location);
   // If the device isn't type removable (like a CD), it won't be there.
   if (device_info == device_metadata_.end())
     return;
 
   if (notifications_)
-    notifications_->ProcessDetach(device_info->second.device_id);
+    notifications_->ProcessDetach(device_info->second.device_id());
   device_metadata_.erase(device_info);
 }
 
 void VolumeMountWatcherWin::EjectDevice(
     const std::string& device_id,
     base::Callback<void(StorageMonitor::EjectStatus)> callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::FilePath device =
       chrome::MediaStorageUtil::FindDevicePathById(device_id);
   if (device.empty()) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
   if (device_metadata_.erase(device.value()) == 0) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
   task_runner_->PostTask(FROM_HERE,
       base::Bind(&EjectDeviceInThreadPool, device, callback, task_runner_, 0));
 }
 
 }  // namespace chrome