Rename RemovableDeviceNotifications=>StorageMonitor

chrome/browser/storage_monitor/storage_monitor_linux_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.
 
-// RemovableDeviceNotificationsLinux unit tests.
+// StorageMonitorLinux unit tests.
 
-#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 <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 109 matching lines @@
 }
 
 string16 GetDeviceName(const std::string& device) {
   for (size_t i = 0; i < arraysize(kTestDeviceData); i++) {
     if (device == kTestDeviceData[i].device_path)
       return ASCIIToUTF16(kTestDeviceData[i].device_name);
   }
   return string16();
 }
 
-class RemovableDeviceNotificationsLinuxTestWrapper
-    : public RemovableDeviceNotificationsLinux {
+class TestStorageMonitorLinux : public StorageMonitorLinux {
  public:
-  RemovableDeviceNotificationsLinuxTestWrapper(const base::FilePath& path,
-                                               MessageLoop* message_loop)
-      : RemovableDeviceNotificationsLinux(path, &GetDeviceInfo),
+  TestStorageMonitorLinux(const base::FilePath& path, MessageLoop* message_loop)
+      : StorageMonitorLinux(path, &GetDeviceInfo),
         message_loop_(message_loop) {
   }
 
  private:
   // Avoids code deleting the object while there are references to it.
   // Aside from the base::RefCountedThreadSafe friend class, any attempts to
   // call this dtor will result in a compile-time error.
-  virtual ~RemovableDeviceNotificationsLinuxTestWrapper() {}
+  virtual ~TestStorageMonitorLinux() {}
 
   virtual void OnFilePathChanged(const base::FilePath& path,
                                  bool error) OVERRIDE {
-    RemovableDeviceNotificationsLinux::OnFilePathChanged(path, error);
+    StorageMonitorLinux::OnFilePathChanged(path, error);
     message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   MessageLoop* message_loop_;
 
-  DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationsLinuxTestWrapper);
+  DISALLOW_COPY_AND_ASSIGN(TestStorageMonitorLinux);
 };
 
-class RemovableDeviceNotificationLinuxTest : public testing::Test {
+class StorageMonitorLinuxTest : public testing::Test {
  public:
   struct MtabTestData {
     MtabTestData(const std::string& mount_device,
                  const std::string& mount_point,
                  const std::string& mount_type)
         : mount_device(mount_device),
           mount_point(mount_point),
           mount_type(mount_type) {
     }
 
     const std::string mount_device;
     const std::string mount_point;
     const std::string mount_type;
   };
 
-  RemovableDeviceNotificationLinuxTest()
+  StorageMonitorLinuxTest()
       : message_loop_(MessageLoop::TYPE_IO),
         file_thread_(content::BrowserThread::FILE, &message_loop_) {
   }
-  virtual ~RemovableDeviceNotificationLinuxTest() {}
+  virtual ~StorageMonitorLinuxTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     // Create and set up a temp dir with files for the test.
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     base::FilePath test_dir = scoped_temp_dir_.path().AppendASCII("test_etc");
     ASSERT_TRUE(file_util::CreateDirectory(test_dir));
     mtab_file_ = test_dir.AppendASCII("test_mtab");
     MtabTestData initial_test_data[] = {
       MtabTestData("dummydevice", "dummydir", kInvalidFS),
     };
     WriteToMtab(initial_test_data,
                 arraysize(initial_test_data),
                 true  /* overwrite */);
 
     // Initialize the test subject.
-    notifications_ = new RemovableDeviceNotificationsLinuxTestWrapper(
-        mtab_file_, &message_loop_);
+    monitor_ = new TestStorageMonitorLinux(mtab_file_, &message_loop_);
     mock_storage_observer_.reset(new MockRemovableStorageObserver);
-    notifications_->AddObserver(mock_storage_observer_.get());
+    monitor_->AddObserver(mock_storage_observer_.get());
 
-    notifications_->Init();
+    monitor_->Init();
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunUntilIdle();
-    notifications_->RemoveObserver(mock_storage_observer_.get());
-    notifications_ = NULL;
+    monitor_->RemoveObserver(mock_storage_observer_.get());
+    monitor_ = NULL;
   }
 
   // Append mtab entries from the |data| array of size |data_size| to the mtab
   // file, and run the message loop.
   void AppendToMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
     WriteToMtab(data, data_size, false  /* do not overwrite */);
     message_loop_.Run();
   }
 
   // Overwrite the mtab file with mtab entries from the |data| array of size
   // |data_size|, and run the message loop.
   void OverwriteMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
     WriteToMtab(data, data_size, true  /* overwrite */);
     message_loop_.Run();
   }
 
   // Simplied version of OverwriteMtabAndRunLoop() that just deletes all the
   // entries in the mtab file.
   void WriteEmptyMtabAndRunLoop() {
     OverwriteMtabAndRunLoop(NULL,  // No data.
                             0);    // No data length.
   }
 
   // Create a directory named |dir| relative to the test directory.
-  // It has a DCIM directory, so RemovableDeviceNotificationsLinux recognizes it
-  // as a media directory.
+  // It has a DCIM directory, so StorageMonitorLinux recognizes it as a media
+  // directory.
   base::FilePath CreateMountPointWithDCIMDir(const std::string& dir) {
     return CreateMountPoint(dir, true  /* create DCIM dir */);
   }
 
   // Create a directory named |dir| relative to the test directory.
-  // It does not have a DCIM directory, so RemovableDeviceNotificationsLinux
-  // does not recognizes it as a media directory.
+  // It does not have a DCIM directory, so StorageMonitorLinux does not
+  // recognize it as a media directory.
   base::FilePath CreateMountPointWithoutDCIMDir(const std::string& dir) {
     return CreateMountPoint(dir, false  /* do not create DCIM dir */);
   }
 
   void RemoveDCIMDirFromMountPoint(const std::string& dir) {
     base::FilePath dcim =
         scoped_temp_dir_.path().AppendASCII(dir).Append(kDCIMDirectoryName);
     file_util::Delete(dcim, false);
   }
 
   MockRemovableStorageObserver& observer() {
     return *mock_storage_observer_;
   }
 
-  RemovableDeviceNotificationsLinux* notifier() {
-    return notifications_.get();
+  StorageMonitorLinux* notifier() {
+    return monitor_.get();
   }
 
  private:
   // Create a directory named |dir| relative to the test directory.
   // Set |with_dcim_dir| to true if the created directory will have a "DCIM"
   // subdirectory.
   // Returns the full path to the created directory on success, or an empty
   // path on failure.
   base::FilePath CreateMountPoint(const std::string& dir, bool with_dcim_dir) {
     base::FilePath return_path(scoped_temp_dir_.path());
@@ skipping 43 matching lines @@
   MessageLoop message_loop_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
 
   // Temporary directory for created test data.
   base::ScopedTempDir scoped_temp_dir_;
   // Path to the test mtab file.
   base::FilePath mtab_file_;
 
-  scoped_refptr<RemovableDeviceNotificationsLinuxTestWrapper> notifications_;
+  scoped_refptr<TestStorageMonitorLinux> monitor_;
 
-  DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationLinuxTest);
+  DISALLOW_COPY_AND_ASSIGN(StorageMonitorLinuxTest);
 };
 
 // Simple test case where we attach and detach a media device.
-TEST_F(RemovableDeviceNotificationLinuxTest, BasicAttachDetach) {
+TEST_F(StorageMonitorLinuxTest, BasicAttachDetach) {
   base::FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path.empty());
   MtabTestData test_data[] = {
     MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
     MtabTestData(kDeviceFixed, kInvalidPath, kValidFS),
   };
   // Only |kDeviceDCIM2| should be attached, since |kDeviceFixed| has a bad
   // path.
   AppendToMtabAndRunLoop(test_data, arraysize(test_data));
 
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
   EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_attached().device_id);
   EXPECT_EQ(GetDeviceNameWithSizeDetails(kDeviceDCIM2),
             observer().last_attached().name);
   EXPECT_EQ(test_path.value(),
             observer().last_attached().location);
 
   // |kDeviceDCIM2| should be detached here.
   WriteEmptyMtabAndRunLoop();
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(1, observer().detach_calls());
   EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_detached().device_id);
 }
 
 // Only removable devices are recognized.
-TEST_F(RemovableDeviceNotificationLinuxTest, Removable) {
+TEST_F(StorageMonitorLinuxTest, Removable) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path_a.empty());
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
   // |kDeviceDCIM1| should be attached as expected.
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
 
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
@@ skipping 33 matching lines @@
             observer().last_attached().location);
 
   // |kDeviceNoDCIM| should be detached as expected.
   WriteEmptyMtabAndRunLoop();
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(2, observer().detach_calls());
   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_detached().device_id);
 }
 
 // More complicated test case with multiple devices on multiple mount points.
-TEST_F(RemovableDeviceNotificationLinuxTest, SwapMountPoints) {
+TEST_F(StorageMonitorLinuxTest, SwapMountPoints) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
   // Attach two devices.
-  // (*'d mounts are those RemovableStorageNotifications knows about.)
+  // (*'d mounts are those StorageMonitor knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 
   // Detach two devices from old mount points and attach the devices at new
   // mount points.
   // kDeviceDCIM1 -> kMountPointB *
   // kDeviceDCIM2 -> kMountPointA *
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_a.value(), kValidFS),
   };
   OverwriteMtabAndRunLoop(test_data2, arraysize(test_data2));
   EXPECT_EQ(4, observer().attach_calls());
   EXPECT_EQ(2, observer().detach_calls());
 
   // Detach all devices.
   WriteEmptyMtabAndRunLoop();
   EXPECT_EQ(4, observer().attach_calls());
   EXPECT_EQ(4, observer().detach_calls());
 }
 
 // More complicated test case with multiple devices on multiple mount points.
-TEST_F(RemovableDeviceNotificationLinuxTest, MultiDevicesMultiMountPoints) {
+TEST_F(StorageMonitorLinuxTest, MultiDevicesMultiMountPoints) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
   // Attach two devices.
-  // (*'d mounts are those RemovableStorageNotifications knows about.)
+  // (*'d mounts are those StorageMonitor knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   // kDeviceDCIM2 -> kMountPointB *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 
@@ skipping 39 matching lines @@
   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(5, observer().attach_calls());
   EXPECT_EQ(3, observer().detach_calls());
 
   // Detach all devices.
   WriteEmptyMtabAndRunLoop();
   EXPECT_EQ(5, observer().attach_calls());
   EXPECT_EQ(5, observer().detach_calls());
 }
 
-TEST_F(RemovableDeviceNotificationLinuxTest,
-       MultipleMountPointsWithNonDCIMDevices) {
+TEST_F(StorageMonitorLinuxTest, MultipleMountPointsWithNonDCIMDevices) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
   // Attach to one first.
-  // (*'d mounts are those RemovableStorageNotifications knows about.)
+  // (*'d mounts are those StorageMonitor knows about.)
   // kDeviceDCIM1 -> kMountPointA *
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(1, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 
   // Attach |kDeviceDCIM1| to |kMountPointB|.
   // kDeviceDCIM1 -> kMountPointA *
@@ skipping 58 matching lines @@
   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(4, observer().attach_calls());
   EXPECT_EQ(3, observer().detach_calls());
 
   // Detach all devices.
   WriteEmptyMtabAndRunLoop();
   EXPECT_EQ(4, observer().attach_calls());
   EXPECT_EQ(4, observer().detach_calls());
 }
 
-TEST_F(RemovableDeviceNotificationLinuxTest, DeviceLookUp) {
+TEST_F(StorageMonitorLinuxTest, DeviceLookUp) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   base::FilePath test_path_c = CreateMountPointWithoutDCIMDir(kMountPointC);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
   ASSERT_FALSE(test_path_c.empty());
 
   // Attach to one first.
-  // (*'d mounts are those RemovableStorageNotifications knows about.)
+  // (*'d mounts are those StorageMonitor knows about.)
   // kDeviceDCIM1  -> kMountPointA *
   // kDeviceNoDCIM -> kMountPointB *
   // kDeviceFixed  -> kMountPointC
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(2, observer().attach_calls());
@@ skipping 44 matching lines @@
   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
 
   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
 
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(1, observer().detach_calls());
 }
 
-TEST_F(RemovableDeviceNotificationLinuxTest, DevicePartitionSize) {
+TEST_F(StorageMonitorLinuxTest, DevicePartitionSize) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
 
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, kInvalidPath, kInvalidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 
   EXPECT_EQ(GetDevicePartitionSize(kDeviceDCIM1),
             notifier()->GetStorageSize(test_path_a.value()));
   EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
             notifier()->GetStorageSize(test_path_b.value()));
   EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
             notifier()->GetStorageSize(kInvalidPath));
 }
 
 }  // namespace
 
 }  // namespace chrome