Rename RemovableDeviceNotifications=>StorageMonitor

chrome/browser/storage_monitor/storage_monitor_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/storage_monitor/removable_device_notifications_linux.h"
+#include "chrome/browser/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
@@ skipping 98 matching lines @@
 // If the requested information is unavailable, returns 0.
 uint64 GetDeviceStorageSize(const base::FilePath& device_path,
                             struct udev_device* device) {
   // sysfs provides the device size in units of 512-byte blocks.
   const std::string partition_size = udev_device_get_sysattr_value(
       device, kSizeSysAttr);
 
   // Keep track of device size, to see how often this information is
   // unavailable.
   UMA_HISTOGRAM_BOOLEAN(
       "RemovableDeviceNotificationsLinux.device_partition_size_available",

[tommycli, 2013/03/01 18:26:29]

This is still old name. I'll get it in a separate changelog.

[vandebo (ex-Chrome), 2013/03/01 19:47:39]

UMAs are special. A UMA is collecting data from users that have opted in.  So to
rename it means to partition the data. Sometimes that makes sense and sometimes
it doesn't.  I don't think it makes sense in this case.

       !partition_size.empty());
 
   uint64 total_size_in_bytes = 0;
   if (!base::StringToUint64(partition_size, &total_size_in_bytes))
     return 0;
   return (total_size_in_bytes <= kuint64max / 512) ?
       total_size_in_bytes * 512 : 0;
 }
 
 // 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);
   // Keep track of device uuid, to see how often we receive empty uuid values.
   UMA_HISTOGRAM_BOOLEAN(
       "RemovableDeviceNotificationsLinux.device_file_system_uuid_available",

[tommycli, 2013/03/01 18:26:29]

Samesies.

       !device_label.empty());
 
   const string16 name = GetFullProductName(
       GetUdevDevicePropertyValue(device, kVendor),
       GetUdevDevicePropertyValue(device, kModel));
 
   const string16 device_label_utf16 =
       (!device_label.empty() && IsStringUTF8(device_label)) ?
           UTF8ToUTF16(device_label) : string16();
   if (!name.empty() && !device_label_utf16.empty())
@@ skipping 60 matching lines @@
     *removable = (value && atoi(value) == 1);
   }
 
   if (partition_size_in_bytes)
     *partition_size_in_bytes = GetDeviceStorageSize(device_path, device);
   RecordGetDeviceInfoResult(true);
 }
 
 }  // namespace
 
-RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
+StorageMonitorLinux::StorageMonitorLinux(
     const base::FilePath& path)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(&GetDeviceInfo) {
 }
 
-RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
+StorageMonitorLinux::StorageMonitorLinux(
     const base::FilePath& path,
     GetDeviceInfoFunc get_device_info_func)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(get_device_info_func) {
 }
 
-RemovableDeviceNotificationsLinux::~RemovableDeviceNotificationsLinux() {
+StorageMonitorLinux::~StorageMonitorLinux() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
-void RemovableDeviceNotificationsLinux::Init() {
+void StorageMonitorLinux::Init() {
   DCHECK(!mtab_path_.empty());
 
   // Put |kKnownFileSystems| in std::set to get O(log N) access time.
   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));
+      base::Bind(&StorageMonitorLinux::InitOnFileThread, this));
 }
 
-bool RemovableDeviceNotificationsLinux::GetStorageInfoForPath(
+bool StorageMonitorLinux::GetStorageInfoForPath(
     const base::FilePath& path,
     StorageInfo* device_info) const {
   if (!path.IsAbsolute())
     return false;
 
   base::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;
 }
 
-uint64 RemovableDeviceNotificationsLinux::GetStorageSize(
+uint64 StorageMonitorLinux::GetStorageSize(
     const std::string& location) const {
   MountMap::const_iterator mount_info = mount_info_map_.find(
       base::FilePath(location));
   return (mount_info != mount_info_map_.end()) ?
       mount_info->second.partition_size_in_bytes : 0;
 }
 
-void RemovableDeviceNotificationsLinux::OnFilePathChanged(
+void StorageMonitorLinux::OnFilePathChanged(
     const base::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();
     return;
   }
 
   UpdateMtab();
 }
 
-RemovableDeviceNotificationsLinux::MountPointInfo::MountPointInfo()
+StorageMonitorLinux::MountPointInfo::MountPointInfo()
     : partition_size_in_bytes(0) {
 }
 
-void RemovableDeviceNotificationsLinux::InitOnFileThread() {
+void StorageMonitorLinux::InitOnFileThread() {
   DCHECK(!initialized_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   initialized_ = true;
 
   // The callback passed to Watch() has to be unretained. Otherwise
   // RemovableDeviceNotificationsLinux will live longer than expected, and
   // FilePathWatcher will get in trouble at shutdown time.
   bool ret = file_watcher_.Watch(
       mtab_path_, false,
-      base::Bind(&RemovableDeviceNotificationsLinux::OnFilePathChanged,
+      base::Bind(&StorageMonitorLinux::OnFilePathChanged,
                  base::Unretained(this)));
   if (!ret) {
     LOG(ERROR) << "Adding watch for " << mtab_path_.value() << " failed";
     return;
   }
 
   UpdateMtab();
 }
 
-void RemovableDeviceNotificationsLinux::UpdateMtab() {
+void StorageMonitorLinux::UpdateMtab() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   MountPointDeviceMap new_mtab;
   ReadMtab(mtab_path_, known_file_systems_, &new_mtab);
 
   // Check existing mtab entries for unaccounted mount points.
   // These mount points must have been removed in the new mtab.
   std::list<base::FilePath> mount_points_to_erase;
   std::list<base::FilePath> multiple_mounted_devices_needing_reattachment;
   for (MountMap::const_iterator old_iter = mount_info_map_.begin();
@@ skipping 61 matching lines @@
     MountMap::iterator old_iter = mount_info_map_.find(mount_point);
     if (old_iter == mount_info_map_.end() ||
         old_iter->second.mount_device != mount_device) {
       // New mount point found or an existing mount point found with a new
       // device.
       AddNewMount(mount_device, mount_point);
     }
   }
 }
 
-void RemovableDeviceNotificationsLinux::AddNewMount(
+void StorageMonitorLinux::AddNewMount(
     const base::FilePath& mount_device, const base::FilePath& mount_point) {
   MountPriorityMap::iterator priority =
       mount_priority_map_.find(mount_device);
   if (priority != mount_priority_map_.end()) {
     const base::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;
   }
@@ skipping 33 matching lines @@
   mount_priority_map_[mount_device][mount_point] = removable;
 
   if (removable) {
     receiver()->ProcessAttach(StorageInfo(
         device_id, GetDisplayNameForDevice(partition_size_in_bytes, name),
         mount_point.value()));
   }
 }
 
 }  // namespace chrome