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 StorageMonitorLinuxTestWrapper

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

A better name for this would probably be TestStorageMonitorLinux

+    : public StorageMonitorLinux {
  public:
-  RemovableDeviceNotificationsLinuxTestWrapper(const base::FilePath& path,
+  StorageMonitorLinuxTestWrapper(const base::FilePath& path,
                                                MessageLoop* message_loop)
-      : RemovableDeviceNotificationsLinux(path, &GetDeviceInfo),
+      : 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 ~StorageMonitorLinuxTestWrapper() {}
 
   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(StorageMonitorLinuxTestWrapper);
 };
 
 class RemovableDeviceNotificationLinuxTest : public testing::Test {

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

Missed this class.

  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) {
     }
 
@@ skipping 16 matching lines @@
     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(
+    notifications_ = new StorageMonitorLinuxTestWrapper(
         mtab_file_, &message_loop_);
     mock_storage_observer_.reset(new MockRemovableStorageObserver);
     notifications_->AddObserver(mock_storage_observer_.get());
 
     notifications_->Init();
     message_loop_.RunUntilIdle();
   }
 
   virtual void TearDown() OVERRIDE {
     message_loop_.RunUntilIdle();
@@ skipping 16 matching lines @@
   }
 
   // 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
+  // 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
+  // It does not have a DCIM directory, so StorageMonitorLinux
   // does not recognizes 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() {
+  StorageMonitorLinux* notifier() {
     return notifications_.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) {
@@ skipping 44 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<StorageMonitorLinuxTestWrapper> notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(RemovableDeviceNotificationLinuxTest);
 };
 
 // Simple test case where we attach and detach a media device.
 TEST_F(RemovableDeviceNotificationLinuxTest, BasicAttachDetach) {
   base::FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path.empty());
   MtabTestData test_data[] = {
     MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
@@ skipping 357 matching lines @@
             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