Rename RemovableDeviceNotifications=>StorageMonitor

chrome/browser/storage_monitor/storage_monitor_chromeos_unittest.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 unit tests.
+// chromeos::StorageMonitorCros unit tests.
 
-#include "chrome/browser/storage_monitor/removable_device_notifications_chromeos.h"
+#include "chrome/browser/storage_monitor/storage_monitor_chromeos.h"
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/storage_monitor/media_storage_util.h"
 #include "chrome/browser/storage_monitor/mock_removable_storage_observer.h"
 #include "chrome/browser/storage_monitor/removable_device_constants.h"
@@ skipping 31 matching lines @@
 uint64 kDevice1SizeInBytes = 113048;
 uint64 kDevice2SizeInBytes = 212312;
 uint64 kSDCardSizeInBytes = 9000000;
 
 std::string GetDCIMDeviceId(const std::string& unique_id) {
   return chrome::MediaStorageUtil::MakeDeviceId(
       chrome::MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM,
       chrome::kFSUniqueIdPrefix + unique_id);
 }
 
-// Wrapper class to test RemovableDeviceNotificationsCros.
-class RemovableDeviceNotificationsCrosTest : public testing::Test {
+// Wrapper class to test StorageMonitorCros.
+class StorageMonitorCrosTest : public testing::Test {
  public:
-  RemovableDeviceNotificationsCrosTest();
-  virtual ~RemovableDeviceNotificationsCrosTest();
+  StorageMonitorCrosTest();
+  virtual ~StorageMonitorCrosTest();
 
  protected:
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void MountDevice(MountError error_code,
                    const DiskMountManager::MountPointInfo& mount_info,
                    const std::string& unique_id,
                    const std::string& device_label,
@@ skipping 23 matching lines @@
 
  private:
   // The message loops and threads to run tests on.
   MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   // Temporary directory for created test data.
   base::ScopedTempDir scoped_temp_dir_;
 
-  // Objects that talks with RemovableDeviceNotificationsCros.
+  // Objects that talks with StorageMonitorCros.
   scoped_ptr<chrome::MockRemovableStorageObserver> mock_storage_observer_;
   // Owned by DiskMountManager.
   disks::MockDiskMountManager* disk_mount_manager_mock_;
 
-  scoped_refptr<RemovableDeviceNotificationsCros> notifications_;
+  scoped_refptr<StorageMonitorCros> monitor_;
 
-  DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationsCrosTest);
+  DISALLOW_COPY_AND_ASSIGN(StorageMonitorCrosTest);
 };
 
-RemovableDeviceNotificationsCrosTest::RemovableDeviceNotificationsCrosTest()
+StorageMonitorCrosTest::StorageMonitorCrosTest()
     : ui_thread_(BrowserThread::UI, &ui_loop_),
       file_thread_(BrowserThread::FILE) {
 }
 
-RemovableDeviceNotificationsCrosTest::~RemovableDeviceNotificationsCrosTest() {
+StorageMonitorCrosTest::~StorageMonitorCrosTest() {
 }
 
-void RemovableDeviceNotificationsCrosTest::SetUp() {
+void StorageMonitorCrosTest::SetUp() {
   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
   file_thread_.Start();
   disk_mount_manager_mock_ = new disks::MockDiskMountManager();
   DiskMountManager::InitializeForTesting(disk_mount_manager_mock_);
   disk_mount_manager_mock_->SetupDefaultReplies();
 
   mock_storage_observer_.reset(new chrome::MockRemovableStorageObserver);
 
   // Initialize the test subject.
-  notifications_ = new RemovableDeviceNotificationsCros();
-  notifications_->AddObserver(mock_storage_observer_.get());
+  monitor_ = new StorageMonitorCros();
+  monitor_->AddObserver(mock_storage_observer_.get());
 }
 
-void RemovableDeviceNotificationsCrosTest::TearDown() {
-  notifications_->RemoveObserver(mock_storage_observer_.get());
-  notifications_ = NULL;
+void StorageMonitorCrosTest::TearDown() {
+  monitor_->RemoveObserver(mock_storage_observer_.get());
+  monitor_ = NULL;
 
   disk_mount_manager_mock_ = NULL;
   DiskMountManager::Shutdown();
   WaitForFileThread();
 }
 
-void RemovableDeviceNotificationsCrosTest::MountDevice(
+void StorageMonitorCrosTest::MountDevice(
     MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info,
     const std::string& unique_id,
     const std::string& device_label,
     const std::string& vendor_name,
     const std::string& product_name,
     DeviceType device_type,
     uint64 device_size_in_bytes) {
   if (error_code == MOUNT_ERROR_NONE) {
     disk_mount_manager_mock_->CreateDiskEntryForMountDevice(
         mount_info, unique_id, device_label, vendor_name, product_name,
         device_type, device_size_in_bytes);
   }
-  notifications_->OnMountEvent(disks::DiskMountManager::MOUNTING,
-                               error_code,
-                               mount_info);
+  monitor_->OnMountEvent(disks::DiskMountManager::MOUNTING, error_code,
+                         mount_info);
   WaitForFileThread();
 }
 
-void RemovableDeviceNotificationsCrosTest::UnmountDevice(
+void StorageMonitorCrosTest::UnmountDevice(
     MountError error_code,
     const DiskMountManager::MountPointInfo& mount_info) {
-  notifications_->OnMountEvent(disks::DiskMountManager::UNMOUNTING,
-                               error_code,
-                               mount_info);
+  monitor_->OnMountEvent(disks::DiskMountManager::UNMOUNTING, error_code,
+                         mount_info);
   if (error_code == MOUNT_ERROR_NONE)
     disk_mount_manager_mock_->RemoveDiskEntryForMountDevice(mount_info);
   WaitForFileThread();
 }
 
-uint64 RemovableDeviceNotificationsCrosTest::GetDeviceStorageSize(
+uint64 StorageMonitorCrosTest::GetDeviceStorageSize(
     const std::string& device_location) {
-  return notifications_->GetStorageSize(device_location);
+  return monitor_->GetStorageSize(device_location);
 }
 
-base::FilePath RemovableDeviceNotificationsCrosTest::CreateMountPoint(
+base::FilePath StorageMonitorCrosTest::CreateMountPoint(
     const std::string& dir, bool with_dcim_dir) {
   base::FilePath return_path(scoped_temp_dir_.path());
   return_path = return_path.AppendASCII(dir);
   base::FilePath path(return_path);
   if (with_dcim_dir)
     path = path.Append(chrome::kDCIMDirectoryName);
   if (!file_util::CreateDirectory(path))
     return base::FilePath();
   return return_path;
 }
 
 // static
-void RemovableDeviceNotificationsCrosTest::PostQuitToUIThread() {
+void StorageMonitorCrosTest::PostQuitToUIThread() {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           MessageLoop::QuitClosure());
 }
 
 // static
-void RemovableDeviceNotificationsCrosTest::WaitForFileThread() {
+void StorageMonitorCrosTest::WaitForFileThread() {
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                           base::Bind(&PostQuitToUIThread));
   MessageLoop::current()->Run();
 }
 
 // Simple test case where we attach and detach a media device.
-TEST_F(RemovableDeviceNotificationsCrosTest, BasicAttachDetach) {
+TEST_F(StorageMonitorCrosTest, BasicAttachDetach) {
   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
   ASSERT_FALSE(mount_path1.empty());
   DiskMountManager::MountPointInfo mount_info(kDevice1,
                                               mount_path1.value(),
                                               MOUNT_TYPE_DEVICE,
                                               disks::MOUNT_CONDITION_NONE);
   MountDevice(MOUNT_ERROR_NONE, mount_info, kUniqueId1, kDevice1Name,
               kVendorName, kProductName, DEVICE_TYPE_USB, kDevice1SizeInBytes);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
@@ skipping 22 matching lines @@
             observer().last_attached().name);
   EXPECT_EQ(mount_path2.value(), observer().last_attached().location);
 
   UnmountDevice(MOUNT_ERROR_NONE, mount_info2);
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(2, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2), observer().last_detached().device_id);
 }
 
 // Removable mass storage devices with no dcim folder are also recognized.
-TEST_F(RemovableDeviceNotificationsCrosTest, NoDCIM) {
+TEST_F(StorageMonitorCrosTest, NoDCIM) {
   testing::Sequence mock_sequence;
   base::FilePath mount_path = CreateMountPoint(kMountPointA, false);
   const std::string kUniqueId = "FFFF-FFFF";
   ASSERT_FALSE(mount_path.empty());
   DiskMountManager::MountPointInfo mount_info(kDevice1,
                                               mount_path.value(),
                                               MOUNT_TYPE_DEVICE,
                                               disks::MOUNT_CONDITION_NONE);
   const std::string device_id = chrome::MediaStorageUtil::MakeDeviceId(
       chrome::MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM,
       chrome::kFSUniqueIdPrefix + kUniqueId);
   MountDevice(MOUNT_ERROR_NONE, mount_info, kUniqueId, kDevice1Name,
               kVendorName, kProductName, DEVICE_TYPE_USB, kDevice1SizeInBytes);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
   EXPECT_EQ(device_id, observer().last_attached().device_id);
   EXPECT_EQ(ASCIIToUTF16(kDevice1NameWithSizeInfo),
             observer().last_attached().name);
   EXPECT_EQ(mount_path.value(), observer().last_attached().location);
 }
 
 // Non device mounts and mount errors are ignored.
-TEST_F(RemovableDeviceNotificationsCrosTest, Ignore) {
+TEST_F(StorageMonitorCrosTest, Ignore) {
   testing::Sequence mock_sequence;
   base::FilePath mount_path = CreateMountPoint(kMountPointA, true);
   const std::string kUniqueId = "FFFF-FFFF";
   ASSERT_FALSE(mount_path.empty());
 
   // Mount error.
   DiskMountManager::MountPointInfo mount_info(kDevice1,
                                               mount_path.value(),
                                               MOUNT_TYPE_DEVICE,
                                               disks::MOUNT_CONDITION_NONE);
@@ skipping 11 matching lines @@
 
   // Unsupported file system.
   mount_info.mount_type = MOUNT_TYPE_DEVICE;
   mount_info.mount_condition = disks::MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
   MountDevice(MOUNT_ERROR_NONE, mount_info, kUniqueId, kDevice1Name,
               kVendorName, kProductName, DEVICE_TYPE_USB, kDevice1SizeInBytes);
   EXPECT_EQ(0, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 }
 
-TEST_F(RemovableDeviceNotificationsCrosTest, SDCardAttachDetach) {
+TEST_F(StorageMonitorCrosTest, SDCardAttachDetach) {
   base::FilePath mount_path1 = CreateMountPoint(kSDCardMountPoint1, true);
   ASSERT_FALSE(mount_path1.empty());
   DiskMountManager::MountPointInfo mount_info1(kSDCardDeviceName1,
                                                mount_path1.value(),
                                                MOUNT_TYPE_DEVICE,
                                                disks::MOUNT_CONDITION_NONE);
   MountDevice(MOUNT_ERROR_NONE, mount_info1, kUniqueId2, kSDCardDeviceName1,
               kVendorName, kProductName, DEVICE_TYPE_SD, kSDCardSizeInBytes);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
@@ skipping 21 matching lines @@
   EXPECT_EQ(ASCIIToUTF16(kSDCardDeviceName2),
             observer().last_attached().name);
   EXPECT_EQ(mount_path2.value(), observer().last_attached().location);
 
   UnmountDevice(MOUNT_ERROR_NONE, mount_info2);
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(2, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2), observer().last_detached().device_id);
 }
 
-TEST_F(RemovableDeviceNotificationsCrosTest, AttachDeviceWithEmptyLabel) {
+TEST_F(StorageMonitorCrosTest, AttachDeviceWithEmptyLabel) {
   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
   ASSERT_FALSE(mount_path1.empty());
   DiskMountManager::MountPointInfo mount_info(kEmptyDeviceLabel,
                                               mount_path1.value(),
                                               MOUNT_TYPE_DEVICE,
                                               disks::MOUNT_CONDITION_NONE);
   MountDevice(MOUNT_ERROR_NONE, mount_info, kUniqueId1, kEmptyDeviceLabel,
               kVendorName, kProductName, DEVICE_TYPE_USB, kDevice1SizeInBytes);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1), observer().last_attached().device_id);
   EXPECT_EQ(ASCIIToUTF16(kDeviceNameWithManufacturerDetails),
             observer().last_attached().name);
   EXPECT_EQ(mount_path1.value(), observer().last_attached().location);
 
   UnmountDevice(MOUNT_ERROR_NONE, mount_info);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(1, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1), observer().last_detached().device_id);
 }
 
-TEST_F(RemovableDeviceNotificationsCrosTest, GetStorageSize) {
+TEST_F(StorageMonitorCrosTest, GetStorageSize) {
   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
   ASSERT_FALSE(mount_path1.empty());
   DiskMountManager::MountPointInfo mount_info(kEmptyDeviceLabel,
                                               mount_path1.value(),
                                               MOUNT_TYPE_DEVICE,
                                               disks::MOUNT_CONDITION_NONE);
   MountDevice(MOUNT_ERROR_NONE, mount_info, kUniqueId1, kEmptyDeviceLabel,
               kVendorName, kProductName, DEVICE_TYPE_USB, kDevice1SizeInBytes);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1), observer().last_attached().device_id);
   EXPECT_EQ(ASCIIToUTF16(kDeviceNameWithManufacturerDetails),
             observer().last_attached().name);
   EXPECT_EQ(mount_path1.value(), observer().last_attached().location);
 
   EXPECT_EQ(kDevice1SizeInBytes, GetDeviceStorageSize(mount_path1.value()));
   UnmountDevice(MOUNT_ERROR_NONE, mount_info);
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(1, observer().detach_calls());
   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1), observer().last_detached().device_id);
 }
 
 }  // namespace
 
 }  // namespace chromeos