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.
+// StorageMonitorLinux 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 199 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(
-    const base::FilePath& path)
+StorageMonitorLinux::StorageMonitorLinux(const base::FilePath& path)
     : initialized_(false),
       mtab_path_(path),
       get_device_info_func_(&GetDeviceInfo) {
 }
 
-RemovableDeviceNotificationsLinux::RemovableDeviceNotificationsLinux(
-    const base::FilePath& path,
-    GetDeviceInfoFunc get_device_info_func)
+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(
-    const std::string& location) const {
+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(
-    const base::FilePath& path,
-    bool error) {
+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.
+  // StorageMonitorLinux 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(
-    const base::FilePath& mount_device, const base::FilePath& mount_point) {
+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 32 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