[Media Gallery][Linux] Improve device media gallery names.

chrome/browser/system_monitor/removable_device_notifications_linux.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.
 
 // RemovableDeviceNotificationsLinux implementation.
 
 #include "chrome/browser/system_monitor/removable_device_notifications_linux.h"
 
 #include <libudev.h>
 #include <mntent.h>
 #include <stdio.h>
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_generic_obj.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/system_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
+#include "ui/base/text/bytes_formatting.h"
 
 namespace chrome {
 
-using base::SystemMonitor;
 using content::BrowserThread;
 
 namespace {
 
 static RemovableDeviceNotificationsLinux*
     g_removable_device_notifications_linux = NULL;
 
 // List of file systems we care about.
 const char* const kKnownFileSystems[] = {
   "ext2",
   "ext3",
   "ext4",
   "fat",
   "hfsplus",
   "iso9660",
   "msdos",
   "ntfs",
   "udf",
   "vfat",
 };
 
 // udev device property constants.
 const char kBlockSubsystemKey[] = "block";
-const char kDevName[] = "DEVNAME";
 const char kDiskDeviceTypeKey[] = "disk";
 const char kFsUUID[] = "ID_FS_UUID";
 const char kLabel[] = "ID_FS_LABEL";
 const char kModel[] = "ID_MODEL";
 const char kModelID[] = "ID_MODEL_ID";
+const char kPartitionSize[] = "UDISKS_PARTITION_SIZE";
 const char kRemovableSysAttr[] = "removable";
-const char kSerial[] = "ID_SERIAL";
 const char kSerialShort[] = "ID_SERIAL_SHORT";
+const char kSizeSysAttr[] = "size";
 const char kVendor[] = "ID_VENDOR";
 const char kVendorID[] = "ID_VENDOR_ID";
 
 // (mount point, mount device)
 // A mapping from mount point to mount device, as extracted from the mtab
 // file.
 typedef std::map<FilePath, FilePath> MountPointDeviceMap;
 
 // Reads mtab file entries into |mtab|.
 void ReadMtab(const FilePath& mtab_path,
@@ skipping 68 matching lines @@
     return std::string();
 
   return kVendorModelSerialPrefix + vendor + ":" + model + ":" + serial_short;
 }
 
 // Records GetDeviceInfo result, to see how often we fail to get device details.
 void RecordGetDeviceInfoResult(bool result) {
   UMA_HISTOGRAM_BOOLEAN("MediaDeviceNotification.UdevRequestSuccess", result);
 }
 
+// Returns the storage size information of the device specified by
+// |device_path|. If the requested information is unavailable, returns an
+// empty string.
+string16 GetSizeInfo(const FilePath& device_path, struct udev_device* device) {
+  // If the UDISKS_PARTITION_SIZE property is set, use it as the total size.

[Lei Zhang, 2012/11/09 04:51:22]

Can we reliably get the partition size from /sys? If so, I'd prefer that we do
not use UDISKS, because that relies on udisks being installed.

[kmadhusu, 2012/11/09 19:17:00]

I didn't find any documentation stating that we can rely on sysfs for device
information. udev_device_get_sysattr_value returns NULL if there is no sys
attribute value. If the udisks is not installed, GetUdevDevicePropertyValue is
going to fail.

+  // If the UDISKS_PARTITION_SIZE property is not set but sysfs provides a size
+  // value, which is the actual size in bytes divided by 512, use that as the
+  // total size instead.
+  uint sector_size = 1;
+  std::string partition_size = GetUdevDevicePropertyValue(device,
+                                                          kPartitionSize);
+  if (partition_size.empty()) {
+    sector_size = 512;
+    partition_size = udev_device_get_sysattr_value(device, kSizeSysAttr);
+    if (partition_size.empty())
+      return string16();
+  }
+  uint64 total_size_in_bytes = 0;
+  if (!base::StringToUint64(partition_size, &total_size_in_bytes))
+    return string16();
+  return ui::FormatBytes(total_size_in_bytes * sector_size);
+}
+
+// Constructs the device name from the device properties. If the device details
+// are unavailable, returns an empty string.
+string16 GetDeviceName(struct udev_device* device) {
+  std::string device_label = GetUdevDevicePropertyValue(device, kLabel);
+  if (!device_label.empty() && IsStringUTF8(device_label))
+    return UTF8ToUTF16(device_label);
+
+  device_label = GetUdevDevicePropertyValue(device, kFsUUID);
+  std::string vendor_name = GetUdevDevicePropertyValue(device, kVendor);
+  std::string model_name = GetUdevDevicePropertyValue(device, kModel);
+  if (!vendor_name.empty() && !model_name.empty())
+    device_label += " {" + vendor_name + ", " + model_name + "}";
+  else if (!vendor_name.empty())
+    device_label += " {" + vendor_name + "}";
+  else
+    device_label += " {" + model_name + "}";
+
+  return (!device_label.empty() && IsStringUTF8(device_label)) ?

[Lei Zhang, 2012/11/09 04:51:22]

|device_label| can't ever be empty.

[kmadhusu, 2012/11/09 19:17:00]

Assuming FS UUID is available for all devices, |device_label| will be never
empty. Realized that model_name can be empty. So added a check to validate the
model_name value.

+      UTF8ToUTF16(device_label) : string16();
+}
+
 // Get the device information using udev library.
-// On success, returns true and fill in |unique_id|, |name|, and |removable|.
+// On success, returns true and fill in |unique_id|, |name|, |removable| and
+// |storage_size|.
 void GetDeviceInfo(const FilePath& device_path, std::string* unique_id,
-                   string16* name, bool* removable) {
+                   string16* name, bool* removable, string16* storage_size) {
   DCHECK(!device_path.empty());
-
+  DCHECK(storage_size);
   ScopedUdevObject udev_obj(udev_new());
   if (!udev_obj.get()) {
     RecordGetDeviceInfoResult(false);
     return;
   }
 
   struct stat device_stat;
   if (stat(device_path.value().c_str(), &device_stat) < 0) {
     RecordGetDeviceInfoResult(false);
     return;
   }
 
   char device_type;
   if (S_ISCHR(device_stat.st_mode)) {
     device_type = 'c';
   } else if (S_ISBLK(device_stat.st_mode)) {
     device_type = 'b';
   } else {
     RecordGetDeviceInfoResult(false);
     return;  // Not a supported type.
   }
 
   ScopedUdevDeviceObject device(
       udev_device_new_from_devnum(udev_obj, device_type, device_stat.st_rdev));
   if (!device.get()) {
     RecordGetDeviceInfoResult(false);
     return;
   }
 
-  // Construct a device name using label or manufacturer (vendor and model)
-  // details.
-  if (name) {
-    std::string device_label = GetUdevDevicePropertyValue(device, kLabel);
-    if (device_label.empty())
-      device_label = GetUdevDevicePropertyValue(device, kSerial);
-    if (device_label.empty()) {
-      // Format: VendorInfo ModelInfo
-      // E.g.: KnCompany Model2010
-      device_label = GetUdevDevicePropertyValue(device, kVendor);
-      std::string model_name = GetUdevDevicePropertyValue(device, kModel);
-      if (device_label.empty())
-        device_label = model_name;
-      else if (!model_name.empty())
-        device_label += " " + model_name;
-    }
-    if (IsStringUTF8(device_label))
-      *name = UTF8ToUTF16(device_label);
-  }
+  if (name)
+    *name = GetDeviceName(device);
 
-  if (unique_id) {
+  if (unique_id)
     *unique_id = MakeDeviceUniqueId(device);
-  }
 
   if (removable) {
     const char* value = udev_device_get_sysattr_value(device,
                                                       kRemovableSysAttr);
     if (!value) {
       // |parent_device| is owned by |device| and does not need to be cleaned
       // up.
       struct udev_device* parent_device =
           udev_device_get_parent_with_subsystem_devtype(device,
                                                         kBlockSubsystemKey,
                                                         kDiskDeviceTypeKey);
       value = udev_device_get_sysattr_value(parent_device, kRemovableSysAttr);
     }
     *removable = (value && atoi(value) == 1);
   }
+  *storage_size = GetSizeInfo(device_path, device);
   RecordGetDeviceInfoResult(true);
 }
 
 }  // namespace
 
 RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
     const FilePath& path)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(&GetDeviceInfo) {
@@ skipping 31 matching lines @@
   for (size_t i = 0; i < arraysize(kKnownFileSystems); ++i)
     known_file_systems_.insert(kKnownFileSystems[i]);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&RemovableDeviceNotificationsLinux::InitOnFileThread, this));
 }
 
 bool RemovableDeviceNotificationsLinux::GetDeviceInfoForPath(
     const FilePath& path,
-    SystemMonitor::RemovableStorageInfo* device_info) const {
+    base::SystemMonitor::RemovableStorageInfo* device_info) const {
   if (!path.IsAbsolute())
     return false;
 
   FilePath current = path;
   while (!ContainsKey(mount_info_map_, current) && current != current.DirName())
     current = current.DirName();
 
   MountMap::const_iterator mount_info = mount_info_map_.find(current);
   if (mount_info == mount_info_map_.end())
     return false;
 
   if (device_info) {
     device_info->device_id = mount_info->second.device_id;
     device_info->name = mount_info->second.device_name;
     device_info->location = current.value();
   }
   return true;
 }
 
+string16 RemovableDeviceNotificationsLinux::GetStorageSizeInfo(
+    const std::string& location) {
+  MountMap::const_iterator mount_info = mount_info_map_.find(
+      FilePath(location));
+  return (mount_info != mount_info_map_.end()) ?
+      mount_info->second.device_partition_size : string16();
+}
+
 void RemovableDeviceNotificationsLinux::OnFilePathChanged(const FilePath& path,
                                                           bool error) {
   if (path != mtab_path_) {
     // This cannot happen unless FilePathWatcher is buggy. Just ignore this
     // notification and do nothing.
     NOTREACHED();
     return;
   }
   if (error) {
     LOG(ERROR) << "Error watching " << mtab_path_.value();
@@ skipping 42 matching lines @@
     // |mount_point|.
     if (new_iter == new_mtab.end() || (new_iter->second != mount_device)) {
       MountPriorityMap::iterator priority =
           mount_priority_map_.find(mount_device);
       DCHECK(priority != mount_priority_map_.end());
       ReferencedMountPoint::const_iterator has_priority =
           priority->second.find(mount_point);
       if (MediaStorageUtil::IsRemovableDevice(old_iter->second.device_id)) {
         DCHECK(has_priority != priority->second.end());
         if (has_priority->second) {
-          SystemMonitor::Get()->ProcessRemovableStorageDetached(
+          base::SystemMonitor::Get()->ProcessRemovableStorageDetached(
               old_iter->second.device_id);
         }
         if (priority->second.size() > 1)
           multiple_mounted_devices_needing_reattachment.push_back(mount_device);
       }
       priority->second.erase(mount_point);
       if (priority->second.empty())
         mount_priority_map_.erase(mount_device);
       mount_points_to_erase.push_back(mount_point);
     }
@@ skipping 50 matching lines @@
     const FilePath& other_mount_point = priority->second.begin()->first;
     priority->second[mount_point] = false;
     mount_info_map_[mount_point] =
         mount_info_map_.find(other_mount_point)->second;
     return;
   }
 
   std::string unique_id;
   string16 name;
   bool removable;
-  get_device_info_func_(mount_device, &unique_id, &name, &removable);
+  string16 device_partition_size;
+  get_device_info_func_(mount_device, &unique_id, &name, &removable,
+                        &device_partition_size);
 
   // Keep track of device info details to see how often we get invalid values.
   MediaStorageUtil::RecordDeviceInfoHistogram(true, unique_id, name);
   if (unique_id.empty() || name.empty())
     return;
 
   bool has_dcim = IsMediaDevice(mount_point.value());
   MediaStorageUtil::Type type;
   if (removable) {
     if (has_dcim) {
       type = MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM;
     } else {
       type = MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
     }
   } else {
     type = MediaStorageUtil::FIXED_MASS_STORAGE;
   }
   std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
 
   MountPointInfo mount_point_info;
   mount_point_info.mount_device = mount_device;
   mount_point_info.device_id = device_id;
   mount_point_info.device_name = name;
+  mount_point_info.device_partition_size = device_partition_size;
 
   mount_info_map_[mount_point] = mount_point_info;
   mount_priority_map_[mount_device][mount_point] = removable;
 
   if (removable) {
-    SystemMonitor::Get()->ProcessRemovableStorageAttached(device_id, name,
-                                                          mount_point.value());
+    base::SystemMonitor::Get()->ProcessRemovableStorageAttached(
+        device_id, device_partition_size + ASCIIToUTF16(" ") + name,

[Lei Zhang, 2012/11/09 04:51:22]

How about adding a util function for this, so we can do this x-platform
consistently? Otherwise, if we decide to change the format, we have to do it in
several places.

[kmadhusu, 2012/11/09 19:17:00]

Done.

+        mount_point.value());
   }
 }
 
 }  // namespace chrome