[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 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) {
+  // sysfs provides the device size value, which is the actual size in bytes
+  // divided by 512.
+  const std::string partition_size = udev_device_get_sysattr_value(
+      device, kSizeSysAttr);
+  uint64 total_size_in_bytes = 0;
+  if (partition_size.empty() ||
+      !base::StringToUint64(partition_size, &total_size_in_bytes))
+    return string16();
+  return ui::FormatBytes(total_size_in_bytes * 512);
+}
+
+// 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);

[Lei Zhang, 2012/11/12 08:01:39]

What are the chances that a partition will not have a UUID?

[Lei Zhang, 2012/11/12 08:01:39]

Also, why do we put the UUID in the display name on Linux, but not on CrOS?

[kmadhusu, 2012/11/12 19:56:19]

On Linux, When the user opens a device in a file dialog, they can easily map the
UUID to the device. On CrOS, there is no easy way of mapping the UUID with the
actual device (user has to open the terminal and navigate to the mount path to
map the UUID value).

[kmadhusu, 2012/11/12 19:56:19]

Chances are very less. Added a UMA to track this.

+  std::string manufacturer_name = GetDeviceManufacturerName(
+      GetUdevDevicePropertyValue(device, kVendor),
+      GetUdevDevicePropertyValue(device, kModel));
+  if (!manufacturer_name.empty())
+    device_label += " " + manufacturer_name;
+  return IsStringUTF8(device_label) ? 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);

[Lei Zhang, 2012/11/12 08:01:39]

It's weird to make |storage_size| required, but the other output parameters are
optional.

[kmadhusu, 2012/11/12 19:56:19]

Made |storage_size| as a optional param just to be consistent with other output
params.

   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::GetStorageSize(
+    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, GetDisplayNameForDevice(device_partition_size, name),
+        mount_point.value());
   }
 }
 
 }  // namespace chrome