Rename RemovableDeviceNotifications=>StorageMonitor

chrome/browser/storage_monitor/storage_monitor_chromeos.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.
 
-// chromeos::RemovableDeviceNotificationsCros implementation.
+// chromeos::StorageMonitorCros implementation.
 
-#include "chrome/browser/storage_monitor/removable_device_notifications_chromeos.h"
+#include "chrome/browser/storage_monitor/storage_monitor_chromeos.h"
 
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/storage_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/storage_monitor/media_storage_util.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
@@ skipping 61 matching lines @@
 
   if (storage_size_in_bytes)
     *storage_size_in_bytes = disk->total_size_in_bytes();
   return true;
 }
 
 }  // namespace
 
 using content::BrowserThread;
 
-RemovableDeviceNotificationsCros::RemovableDeviceNotificationsCros() {
+StorageMonitorCros::StorageMonitorCros() {
   DCHECK(disks::DiskMountManager::GetInstance());
   disks::DiskMountManager::GetInstance()->AddObserver(this);
   CheckExistingMountPointsOnUIThread();
 }
 
-RemovableDeviceNotificationsCros::~RemovableDeviceNotificationsCros() {
+StorageMonitorCros::~StorageMonitorCros() {
   disks::DiskMountManager* manager = disks::DiskMountManager::GetInstance();
   if (manager) {
     manager->RemoveObserver(this);
   }
 }
 
-void RemovableDeviceNotificationsCros::CheckExistingMountPointsOnUIThread() {
+void StorageMonitorCros::CheckExistingMountPointsOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const disks::DiskMountManager::MountPointMap& mount_point_map =
       disks::DiskMountManager::GetInstance()->mount_points();
   for (disks::DiskMountManager::MountPointMap::const_iterator it =
            mount_point_map.begin(); it != mount_point_map.end(); ++it) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        base::Bind(
-            &RemovableDeviceNotificationsCros::CheckMountedPathOnFileThread,
-            this, it->second));
+        base::Bind(&StorageMonitorCros::CheckMountedPathOnFileThread, this,
+                   it->second));
   }
 }
 
-void RemovableDeviceNotificationsCros::OnDiskEvent(
+void StorageMonitorCros::OnDiskEvent(
     disks::DiskMountManager::DiskEvent event,
     const disks::DiskMountManager::Disk* disk) {
 }
 
-void RemovableDeviceNotificationsCros::OnDeviceEvent(
+void StorageMonitorCros::OnDeviceEvent(
     disks::DiskMountManager::DeviceEvent event,
     const std::string& device_path) {
 }
 
-void RemovableDeviceNotificationsCros::OnMountEvent(
+void StorageMonitorCros::OnMountEvent(
     disks::DiskMountManager::MountEvent event,
     MountError error_code,
     const disks::DiskMountManager::MountPointInfo& mount_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ignore mount points that are not devices.
   if (mount_info.mount_type != MOUNT_TYPE_DEVICE)
     return;
   // Ignore errors.
   if (error_code != MOUNT_ERROR_NONE)
     return;
   if (mount_info.mount_condition != disks::MOUNT_CONDITION_NONE)
     return;
 
   switch (event) {
     case disks::DiskMountManager::MOUNTING: {
       if (ContainsKey(mount_map_, mount_info.mount_path)) {
         NOTREACHED();
         return;
       }
 
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
-          base::Bind(
-              &RemovableDeviceNotificationsCros::CheckMountedPathOnFileThread,
-              this, mount_info));
+          base::Bind(&StorageMonitorCros::CheckMountedPathOnFileThread, this,
+                     mount_info));
       break;
     }
     case disks::DiskMountManager::UNMOUNTING: {
       MountMap::iterator it = mount_map_.find(mount_info.mount_path);
       if (it == mount_map_.end())
         return;
       receiver()->ProcessDetach(it->second.storage_info.device_id);
       mount_map_.erase(it);
       break;
     }
   }
 }
 
-void RemovableDeviceNotificationsCros::OnFormatEvent(
+void StorageMonitorCros::OnFormatEvent(
     disks::DiskMountManager::FormatEvent event,
     FormatError error_code,
     const std::string& device_path) {
 }
 
-bool RemovableDeviceNotificationsCros::GetStorageInfoForPath(
-    const base::FilePath& path,
-    StorageInfo* device_info) const {
+bool StorageMonitorCros::GetStorageInfoForPath(const base::FilePath& path,
+                                               StorageInfo* device_info) const {
   if (!path.IsAbsolute())
     return false;
 
   base::FilePath current = path;
   while (!ContainsKey(mount_map_, current.value()) &&
          current != current.DirName()) {
     current = current.DirName();
   }
 
   MountMap::const_iterator info_it = mount_map_.find(current.value());
   if (info_it == mount_map_.end())
     return false;
 
   if (device_info)
     *device_info = info_it->second.storage_info;
   return true;
 }
 
-uint64 RemovableDeviceNotificationsCros::GetStorageSize(
+uint64 StorageMonitorCros::GetStorageSize(
     const std::string& device_location) const {
   MountMap::const_iterator info_it = mount_map_.find(device_location);
   return (info_it != mount_map_.end()) ?
       info_it->second.storage_size_in_bytes : 0;
 }
 
-void RemovableDeviceNotificationsCros::CheckMountedPathOnFileThread(
+void StorageMonitorCros::CheckMountedPathOnFileThread(
     const disks::DiskMountManager::MountPointInfo& mount_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   bool has_dcim = chrome::IsMediaDevice(mount_info.mount_path);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&RemovableDeviceNotificationsCros::AddMountedPathOnUIThread,
-                 this, mount_info, has_dcim));
+      base::Bind(&StorageMonitorCros::AddMountedPathOnUIThread, this,
+                 mount_info, has_dcim));
 }
 
-void RemovableDeviceNotificationsCros::AddMountedPathOnUIThread(
+void StorageMonitorCros::AddMountedPathOnUIThread(
     const disks::DiskMountManager::MountPointInfo& mount_info, bool has_dcim) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (ContainsKey(mount_map_, mount_info.mount_path)) {
     // CheckExistingMountPointsOnUIThread() added the mount point information
     // in the map before the device attached handler is called. Therefore, an
     // entry for the device already exists in the map.
     return;
   }
 
@@ skipping 23 matching lines @@
       storage_size_in_bytes
   };
   mount_map_.insert(std::make_pair(mount_info.mount_path, object_info));
   receiver()->ProcessAttach(StorageInfo(
       device_id,
       chrome::GetDisplayNameForDevice(storage_size_in_bytes, device_label),
       mount_info.mount_path));
 }
 
 }  // namespace chromeos