StorageMonitor: Make StorageInfo a real class.

chrome/browser/storage_monitor/storage_monitor_mac.mm

 // 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_mac.h"
 
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
@@ skipping 29 matching lines @@
     return StorageInfo::FIXED_MASS_STORAGE;
   if (has_dcim)
     return StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
   return StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
 }
 
 StorageInfo BuildStorageInfo(
     CFDictionaryRef dict, std::string* bsd_name) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
-  StorageInfo info;
-
   CFStringRef device_bsd_name = base::mac::GetValueFromDictionary<CFStringRef>(
       dict, kDADiskDescriptionMediaBSDNameKey);
   if (device_bsd_name && bsd_name)
     *bsd_name = base::SysCFStringRefToUTF8(device_bsd_name);
 
   CFURLRef url = base::mac::GetValueFromDictionary<CFURLRef>(
       dict, kDADiskDescriptionVolumePathKey);
   NSURL* nsurl = base::mac::CFToNSCast(url);
-  info.location = base::mac::NSStringToFilePath([nsurl path]).value();
+  base::FilePath location = base::mac::NSStringToFilePath([nsurl path]);
   CFNumberRef size_number =
       base::mac::GetValueFromDictionary<CFNumberRef>(
           dict, kDADiskDescriptionMediaSizeKey);
-  if (size_number) {
-    CFNumberGetValue(size_number, kCFNumberLongLongType,
-                     &(info.total_size_in_bytes));
-  }
+  uint64 size_in_bytes = 0;
+  if (size_number)
+    CFNumberGetValue(size_number, kCFNumberLongLongType, &size_in_bytes);
 
-  info.vendor_name = GetUTF16FromDictionary(
+  string16 vendor = GetUTF16FromDictionary(
       dict, kDADiskDescriptionDeviceVendorKey);
-  info.model_name = GetUTF16FromDictionary(
+  string16 model = GetUTF16FromDictionary(
       dict, kDADiskDescriptionDeviceModelKey);
-  info.storage_label = GetUTF16FromDictionary(
+  string16 label = GetUTF16FromDictionary(
       dict, kDADiskDescriptionVolumeNameKey);
 
   CFUUIDRef uuid = base::mac::GetValueFromDictionary<CFUUIDRef>(
       dict, kDADiskDescriptionVolumeUUIDKey);
   std::string unique_id;
   if (uuid) {
     base::mac::ScopedCFTypeRef<CFStringRef> uuid_string(
         CFUUIDCreateString(NULL, uuid));
     if (uuid_string.get())
       unique_id = base::SysCFStringRefToUTF8(uuid_string);
   }
   if (unique_id.empty()) {
     string16 revision = GetUTF16FromDictionary(
         dict, kDADiskDescriptionDeviceRevisionKey);
-    string16 unique_id2 = info.vendor_name;
-    unique_id2 = JoinName(unique_id2, info.model_name);
+    string16 unique_id2 = vendor;
+    unique_id2 = JoinName(unique_id2, model);
     unique_id2 = JoinName(unique_id2, revision);
     unique_id = UTF16ToUTF8(unique_id2);
   }
 
   CFBooleanRef is_removable_ref =
       base::mac::GetValueFromDictionary<CFBooleanRef>(
           dict, kDADiskDescriptionMediaRemovableKey);
   bool is_removable = is_removable_ref && CFBooleanGetValue(is_removable_ref);
   // Checking for DCIM only matters on removable devices.
-  bool has_dcim = is_removable &&
-                  MediaStorageUtil::HasDcim(base::FilePath(info.location));
+  bool has_dcim = is_removable && MediaStorageUtil::HasDcim(location);
   StorageInfo::Type device_type = GetDeviceType(is_removable, has_dcim);
+  std::string device_id;
   if (!unique_id.empty())
-    info.device_id = StorageInfo::MakeDeviceId(device_type,
-                                                    unique_id);
+    device_id = StorageInfo::MakeDeviceId(device_type, unique_id);
 
-  return info;
+  return StorageInfo(device_id, string16(), location.value(), label, vendor,
+                     model, size_in_bytes);
 }
 
 void GetDiskInfoAndUpdateOnFileThread(
     const base::WeakPtr<StorageMonitorMac>& monitor,
     base::mac::ScopedCFTypeRef<CFDictionaryRef> dict,
     StorageMonitorMac::UpdateType update_type) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
 
   std::string bsd_name;
   StorageInfo info = BuildStorageInfo(dict, &bsd_name);
@@ skipping 93 matching lines @@
     const std::string& bsd_name,
     const StorageInfo& info,
     UpdateType update_type) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   pending_disk_updates_--;
   bool initialization_complete = false;
   if (!IsInitialized() && pending_disk_updates_ == 0)
     initialization_complete = true;
 
-  if (info.device_id.empty() || bsd_name.empty()) {
+  if (info.device_id().empty() || bsd_name.empty()) {
     if (initialization_complete)
       MarkInitialized();
     return;
   }
 
   std::map<std::string, StorageInfo>::iterator it =
       disk_info_map_.find(bsd_name);
   if (it != disk_info_map_.end()) {
     // If an attached notification was previously posted then post a detached
     // notification now. This is used for devices that are being removed or
     // devices that have changed.
     if (ShouldPostNotificationForDisk(it->second)) {
-      receiver()->ProcessDetach(it->second.device_id);
+      receiver()->ProcessDetach(it->second.device_id());
     }
   }
 
   if (update_type == UPDATE_DEVICE_REMOVED) {
     if (it != disk_info_map_.end())
       disk_info_map_.erase(it);
   } else {
     disk_info_map_[bsd_name] = info;
-    MediaStorageUtil::RecordDeviceInfoHistogram(true, info.device_id,
-                                                info.storage_label);
+    MediaStorageUtil::RecordDeviceInfoHistogram(true, info.device_id(),
+                                                info.storage_label());
     if (ShouldPostNotificationForDisk(info))
       receiver()->ProcessAttach(info);
   }
 
   // We're not really honestly sure we're done, but this looks the best we
   // can do. Any misses should go out through notifications.
   if (initialization_complete)
     MarkInitialized();
 }
 
@@ skipping 17 matching lines @@
 
   return false;
 }
 
 void StorageMonitorMac::EjectDevice(
       const std::string& device_id,
       base::Callback<void(EjectStatus)> callback) {
   std::string bsd_name;
   for (std::map<std::string, StorageInfo>::iterator
       it = disk_info_map_.begin(); it != disk_info_map_.end(); ++it) {
-    if (it->second.device_id == device_id) {
+    if (it->second.device_id() == device_id) {
       bsd_name = it->first;
       disk_info_map_.erase(it);
       break;
     }
   }
 
   if (bsd_name.empty()) {
     callback.Run(EJECT_NO_SUCH_DEVICE);
     return;
   }
@@ skipping 54 matching lines @@
       FROM_HERE,
       base::Bind(GetDiskInfoAndUpdateOnFileThread,
                  AsWeakPtr(), dict, update_type));
 }
 
 
 bool StorageMonitorMac::ShouldPostNotificationForDisk(
     const StorageInfo& info) const {
   // Only post notifications about disks that have no empty fields and
   // are removable. Also exclude disk images (DMGs).
-  return !info.device_id.empty() &&
-         !info.location.empty() &&
-         info.model_name != ASCIIToUTF16(kDiskImageModelName) &&
-         StorageInfo::IsRemovableDevice(info.device_id) &&
-         StorageInfo::IsMassStorageDevice(info.device_id);
+  return !info.device_id().empty() &&
+         !info.location().empty() &&
+         info.model_name() != ASCIIToUTF16(kDiskImageModelName) &&
+         StorageInfo::IsRemovableDevice(info.device_id()) &&
+         StorageInfo::IsMassStorageDevice(info.device_id());
 }
 
 bool StorageMonitorMac::FindDiskWithMountPoint(
     const base::FilePath& mount_point,
     StorageInfo* info) const {
   for (std::map<std::string, StorageInfo>::const_iterator
       it = disk_info_map_.begin(); it != disk_info_map_.end(); ++it) {
-    if (it->second.location == mount_point.value()) {
+    if (it->second.location() == mount_point.value()) {
       *info = it->second;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace chrome