Home | History | Annotate | Download | only in storage_monitor 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // StorageMonitorLinux unit tests.
      6 
      7 #include "components/storage_monitor/storage_monitor_linux.h"
      8 
      9 #include <mntent.h>
     10 #include <stdio.h>
     11 
     12 #include <string>
     13 
     14 #include "base/files/file_util.h"
     15 #include "base/files/scoped_temp_dir.h"
     16 #include "base/logging.h"
     17 #include "base/memory/scoped_ptr.h"
     18 #include "base/run_loop.h"
     19 #include "base/strings/utf_string_conversions.h"
     20 #include "components/storage_monitor/mock_removable_storage_observer.h"
     21 #include "components/storage_monitor/removable_device_constants.h"
     22 #include "components/storage_monitor/storage_info.h"
     23 #include "components/storage_monitor/storage_monitor.h"
     24 #include "components/storage_monitor/test_media_transfer_protocol_manager_linux.h"
     25 #include "components/storage_monitor/test_storage_monitor.h"
     26 #include "content/public/test/test_browser_thread_bundle.h"
     27 #include "testing/gtest/include/gtest/gtest.h"
     28 
     29 namespace storage_monitor {
     30 
     31 namespace {
     32 
     33 const char kValidFS[] = "vfat";
     34 const char kInvalidFS[] = "invalidfs";
     35 
     36 const char kInvalidPath[] = "invalid path does not exist";
     37 
     38 const char kDeviceDCIM1[] = "d1";
     39 const char kDeviceDCIM2[] = "d2";
     40 const char kDeviceDCIM3[] = "d3";
     41 const char kDeviceNoDCIM[] = "d4";
     42 const char kDeviceFixed[] = "d5";
     43 
     44 const char kInvalidDevice[] = "invalid_device";
     45 
     46 const char kMountPointA[] = "mnt_a";
     47 const char kMountPointB[] = "mnt_b";
     48 const char kMountPointC[] = "mnt_c";
     49 
     50 struct TestDeviceData {
     51   const char* device_path;
     52   const char* unique_id;
     53   StorageInfo::Type type;
     54   uint64 partition_size_in_bytes;
     55 };
     56 
     57 const TestDeviceData kTestDeviceData[] = {
     58   { kDeviceDCIM1, "UUID:FFF0-000F",
     59     StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, 88788 },
     60   { kDeviceDCIM2, "VendorModelSerial:ComName:Model2010:8989",
     61     StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
     62     8773 },
     63   { kDeviceDCIM3, "VendorModelSerial:::WEM319X792",
     64     StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM, 22837 },
     65   { kDeviceNoDCIM, "UUID:ABCD-1234",
     66     StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM, 512 },
     67   { kDeviceFixed, "UUID:743A-2349",
     68     StorageInfo::FIXED_MASS_STORAGE, 17282 },
     69 };
     70 
     71 scoped_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
     72                                       const base::FilePath& mount_point) {
     73   bool device_found = false;
     74   size_t i = 0;
     75   for (; i < arraysize(kTestDeviceData); i++) {
     76     if (device_path.value() == kTestDeviceData[i].device_path) {
     77       device_found = true;
     78       break;
     79     }
     80   }
     81 
     82   scoped_ptr<StorageInfo> storage_info;
     83   if (!device_found) {
     84     NOTREACHED();
     85     return storage_info.Pass();
     86   }
     87 
     88   StorageInfo::Type type = kTestDeviceData[i].type;
     89   storage_info.reset(new StorageInfo(
     90       StorageInfo::MakeDeviceId(type, kTestDeviceData[i].unique_id),
     91       mount_point.value(),
     92       base::ASCIIToUTF16("volume label"),
     93       base::ASCIIToUTF16("vendor name"),
     94       base::ASCIIToUTF16("model name"),
     95       kTestDeviceData[i].partition_size_in_bytes));
     96   return storage_info.Pass();
     97 }
     98 
     99 uint64 GetDevicePartitionSize(const std::string& device) {
    100   for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
    101     if (device == kTestDeviceData[i].device_path)
    102       return kTestDeviceData[i].partition_size_in_bytes;
    103   }
    104   return 0;
    105 }
    106 
    107 std::string GetDeviceId(const std::string& device) {
    108   for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
    109     if (device == kTestDeviceData[i].device_path) {
    110       return StorageInfo::MakeDeviceId(kTestDeviceData[i].type,
    111                                             kTestDeviceData[i].unique_id);
    112     }
    113   }
    114   if (device == kInvalidDevice) {
    115     return StorageInfo::MakeDeviceId(StorageInfo::FIXED_MASS_STORAGE,
    116                                           kInvalidDevice);
    117   }
    118   return std::string();
    119 }
    120 
    121 class TestStorageMonitorLinux : public StorageMonitorLinux {
    122  public:
    123   explicit TestStorageMonitorLinux(const base::FilePath& path)
    124       : StorageMonitorLinux(path) {
    125     SetMediaTransferProtocolManagerForTest(
    126         new TestMediaTransferProtocolManagerLinux());
    127     SetGetDeviceInfoCallbackForTest(base::Bind(&GetDeviceInfo));
    128   }
    129   virtual ~TestStorageMonitorLinux() {}
    130 
    131  private:
    132   virtual void UpdateMtab(
    133       const MtabWatcherLinux::MountPointDeviceMap& new_mtab) OVERRIDE {
    134     StorageMonitorLinux::UpdateMtab(new_mtab);
    135     base::MessageLoopProxy::current()->PostTask(
    136         FROM_HERE, base::MessageLoop::QuitClosure());
    137   }
    138 
    139   DISALLOW_COPY_AND_ASSIGN(TestStorageMonitorLinux);
    140 };
    141 
    142 class StorageMonitorLinuxTest : public testing::Test {
    143  public:
    144   struct MtabTestData {
    145     MtabTestData(const std::string& mount_device,
    146                  const std::string& mount_point,
    147                  const std::string& mount_type)
    148         : mount_device(mount_device),
    149           mount_point(mount_point),
    150           mount_type(mount_type) {
    151     }
    152 
    153     const std::string mount_device;
    154     const std::string mount_point;
    155     const std::string mount_type;
    156   };
    157 
    158   StorageMonitorLinuxTest()
    159       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
    160   virtual ~StorageMonitorLinuxTest() {}
    161 
    162  protected:
    163   virtual void SetUp() OVERRIDE {
    164     // Create and set up a temp dir with files for the test.
    165     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
    166     base::FilePath test_dir = scoped_temp_dir_.path().AppendASCII("test_etc");
    167     ASSERT_TRUE(base::CreateDirectory(test_dir));
    168     mtab_file_ = test_dir.AppendASCII("test_mtab");
    169     MtabTestData initial_test_data[] = {
    170       MtabTestData("dummydevice", "dummydir", kInvalidFS),
    171     };
    172     WriteToMtab(initial_test_data,
    173                 arraysize(initial_test_data),
    174                 true  /* overwrite */);
    175 
    176     monitor_.reset(new TestStorageMonitorLinux(mtab_file_));
    177 
    178     mock_storage_observer_.reset(new MockRemovableStorageObserver);
    179     monitor_->AddObserver(mock_storage_observer_.get());
    180 
    181     monitor_->Init();
    182     base::RunLoop().RunUntilIdle();
    183   }
    184 
    185   virtual void TearDown() OVERRIDE {
    186     base::RunLoop().RunUntilIdle();
    187     monitor_->RemoveObserver(mock_storage_observer_.get());
    188     base::RunLoop().RunUntilIdle();
    189 
    190     // Linux storage monitor must be destroyed on the UI thread, so do it here.
    191     monitor_.reset();
    192   }
    193 
    194   // Append mtab entries from the |data| array of size |data_size| to the mtab
    195   // file, and run the message loop.
    196   void AppendToMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
    197     WriteToMtab(data, data_size, false  /* do not overwrite */);
    198     base::RunLoop().Run();
    199   }
    200 
    201   // Overwrite the mtab file with mtab entries from the |data| array of size
    202   // |data_size|, and run the message loop.
    203   void OverwriteMtabAndRunLoop(const MtabTestData* data, size_t data_size) {
    204     WriteToMtab(data, data_size, true  /* overwrite */);
    205     base::RunLoop().Run();
    206   }
    207 
    208   // Simplied version of OverwriteMtabAndRunLoop() that just deletes all the
    209   // entries in the mtab file.
    210   void WriteEmptyMtabAndRunLoop() {
    211     OverwriteMtabAndRunLoop(NULL,  // No data.
    212                             0);    // No data length.
    213   }
    214 
    215   // Create a directory named |dir| relative to the test directory.
    216   // It has a DCIM directory, so StorageMonitorLinux recognizes it as a media
    217   // directory.
    218   base::FilePath CreateMountPointWithDCIMDir(const std::string& dir) {
    219     return CreateMountPoint(dir, true  /* create DCIM dir */);
    220   }
    221 
    222   // Create a directory named |dir| relative to the test directory.
    223   // It does not have a DCIM directory, so StorageMonitorLinux does not
    224   // recognize it as a media directory.
    225   base::FilePath CreateMountPointWithoutDCIMDir(const std::string& dir) {
    226     return CreateMountPoint(dir, false  /* do not create DCIM dir */);
    227   }
    228 
    229   void RemoveDCIMDirFromMountPoint(const std::string& dir) {
    230     base::FilePath dcim =
    231         scoped_temp_dir_.path().AppendASCII(dir).Append(kDCIMDirectoryName);
    232     base::DeleteFile(dcim, false);
    233   }
    234 
    235   MockRemovableStorageObserver& observer() {
    236     return *mock_storage_observer_;
    237   }
    238 
    239   StorageMonitor* notifier() {
    240     return monitor_.get();
    241   }
    242 
    243   uint64 GetStorageSize(const base::FilePath& path) {
    244     StorageInfo info;
    245     if (!notifier()->GetStorageInfoForPath(path, &info))
    246       return 0;
    247 
    248     return info.total_size_in_bytes();
    249   }
    250 
    251  private:
    252   // Create a directory named |dir| relative to the test directory.
    253   // Set |with_dcim_dir| to true if the created directory will have a "DCIM"
    254   // subdirectory.
    255   // Returns the full path to the created directory on success, or an empty
    256   // path on failure.
    257   base::FilePath CreateMountPoint(const std::string& dir, bool with_dcim_dir) {
    258     base::FilePath return_path(scoped_temp_dir_.path());
    259     return_path = return_path.AppendASCII(dir);
    260     base::FilePath path(return_path);
    261     if (with_dcim_dir)
    262       path = path.Append(kDCIMDirectoryName);
    263     if (!base::CreateDirectory(path))
    264       return base::FilePath();
    265     return return_path;
    266   }
    267 
    268   // Write the test mtab data to |mtab_file_|.
    269   // |data| is an array of mtab entries.
    270   // |data_size| is the array size of |data|.
    271   // |overwrite| specifies whether to overwrite |mtab_file_|.
    272   void WriteToMtab(const MtabTestData* data,
    273                    size_t data_size,
    274                    bool overwrite) {
    275     FILE* file = setmntent(mtab_file_.value().c_str(), overwrite ? "w" : "a");
    276     ASSERT_TRUE(file);
    277 
    278     // Due to the glibc *mntent() interface design, which is out of our
    279     // control, the mtnent struct has several char* fields, even though
    280     // addmntent() does not write to them in the calls below. To make the
    281     // compiler happy while avoiding making additional copies of strings,
    282     // we just const_cast() the strings' c_str()s.
    283     // Assuming addmntent() does not write to the char* fields, this is safe.
    284     // It is unlikely the platforms this test suite runs on will have an
    285     // addmntent() implementation that does change the char* fields. If that
    286     // was ever the case, the test suite will start crashing or failing.
    287     mntent entry;
    288     static const char kMountOpts[] = "rw";
    289     entry.mnt_opts = const_cast<char*>(kMountOpts);
    290     entry.mnt_freq = 0;
    291     entry.mnt_passno = 0;
    292     for (size_t i = 0; i < data_size; ++i) {
    293       entry.mnt_fsname = const_cast<char*>(data[i].mount_device.c_str());
    294       entry.mnt_dir = const_cast<char*>(data[i].mount_point.c_str());
    295       entry.mnt_type = const_cast<char*>(data[i].mount_type.c_str());
    296       ASSERT_EQ(0, addmntent(file, &entry));
    297     }
    298     ASSERT_EQ(1, endmntent(file));
    299   }
    300 
    301   content::TestBrowserThreadBundle thread_bundle_;
    302 
    303   scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
    304 
    305   // Temporary directory for created test data.
    306   base::ScopedTempDir scoped_temp_dir_;
    307   // Path to the test mtab file.
    308   base::FilePath mtab_file_;
    309 
    310   scoped_ptr<TestStorageMonitorLinux> monitor_;
    311 
    312   DISALLOW_COPY_AND_ASSIGN(StorageMonitorLinuxTest);
    313 };
    314 
    315 // Simple test case where we attach and detach a media device.
    316 TEST_F(StorageMonitorLinuxTest, BasicAttachDetach) {
    317   base::FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
    318   ASSERT_FALSE(test_path.empty());
    319   MtabTestData test_data[] = {
    320     MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
    321     MtabTestData(kDeviceFixed, kInvalidPath, kValidFS),
    322   };
    323   // Only |kDeviceDCIM2| should be attached, since |kDeviceFixed| has a bad
    324   // path.
    325   AppendToMtabAndRunLoop(test_data, arraysize(test_data));
    326 
    327   EXPECT_EQ(1, observer().attach_calls());
    328   EXPECT_EQ(0, observer().detach_calls());
    329   EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_attached().device_id());
    330   EXPECT_EQ(test_path.value(), observer().last_attached().location());
    331 
    332   // |kDeviceDCIM2| should be detached here.
    333   WriteEmptyMtabAndRunLoop();
    334   EXPECT_EQ(1, observer().attach_calls());
    335   EXPECT_EQ(1, observer().detach_calls());
    336   EXPECT_EQ(GetDeviceId(kDeviceDCIM2), observer().last_detached().device_id());
    337 }
    338 
    339 // Only removable devices are recognized.
    340 TEST_F(StorageMonitorLinuxTest, Removable) {
    341   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    342   ASSERT_FALSE(test_path_a.empty());
    343   MtabTestData test_data1[] = {
    344     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    345   };
    346   // |kDeviceDCIM1| should be attached as expected.
    347   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    348 
    349   EXPECT_EQ(1, observer().attach_calls());
    350   EXPECT_EQ(0, observer().detach_calls());
    351   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_attached().device_id());
    352   EXPECT_EQ(test_path_a.value(), observer().last_attached().location());
    353 
    354   // This should do nothing, since |kDeviceFixed| is not removable.
    355   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
    356   ASSERT_FALSE(test_path_b.empty());
    357   MtabTestData test_data2[] = {
    358     MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
    359   };
    360   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
    361   EXPECT_EQ(1, observer().attach_calls());
    362   EXPECT_EQ(0, observer().detach_calls());
    363 
    364   // |kDeviceDCIM1| should be detached as expected.
    365   WriteEmptyMtabAndRunLoop();
    366   EXPECT_EQ(1, observer().attach_calls());
    367   EXPECT_EQ(1, observer().detach_calls());
    368   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), observer().last_detached().device_id());
    369 
    370   // |kDeviceNoDCIM| should be attached as expected.
    371   MtabTestData test_data3[] = {
    372     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
    373   };
    374   AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
    375   EXPECT_EQ(2, observer().attach_calls());
    376   EXPECT_EQ(1, observer().detach_calls());
    377   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_attached().device_id());
    378   EXPECT_EQ(test_path_b.value(), observer().last_attached().location());
    379 
    380   // |kDeviceNoDCIM| should be detached as expected.
    381   WriteEmptyMtabAndRunLoop();
    382   EXPECT_EQ(2, observer().attach_calls());
    383   EXPECT_EQ(2, observer().detach_calls());
    384   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), observer().last_detached().device_id());
    385 }
    386 
    387 // More complicated test case with multiple devices on multiple mount points.
    388 TEST_F(StorageMonitorLinuxTest, SwapMountPoints) {
    389   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    390   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
    391   ASSERT_FALSE(test_path_a.empty());
    392   ASSERT_FALSE(test_path_b.empty());
    393 
    394   // Attach two devices.
    395   // (*'d mounts are those StorageMonitor knows about.)
    396   // kDeviceDCIM1 -> kMountPointA *
    397   // kDeviceDCIM2 -> kMountPointB *
    398   MtabTestData test_data1[] = {
    399     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    400     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
    401   };
    402   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    403   EXPECT_EQ(2, observer().attach_calls());
    404   EXPECT_EQ(0, observer().detach_calls());
    405 
    406   // Detach two devices from old mount points and attach the devices at new
    407   // mount points.
    408   // kDeviceDCIM1 -> kMountPointB *
    409   // kDeviceDCIM2 -> kMountPointA *
    410   MtabTestData test_data2[] = {
    411     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    412     MtabTestData(kDeviceDCIM2, test_path_a.value(), kValidFS),
    413   };
    414   OverwriteMtabAndRunLoop(test_data2, arraysize(test_data2));
    415   EXPECT_EQ(4, observer().attach_calls());
    416   EXPECT_EQ(2, observer().detach_calls());
    417 
    418   // Detach all devices.
    419   WriteEmptyMtabAndRunLoop();
    420   EXPECT_EQ(4, observer().attach_calls());
    421   EXPECT_EQ(4, observer().detach_calls());
    422 }
    423 
    424 // More complicated test case with multiple devices on multiple mount points.
    425 TEST_F(StorageMonitorLinuxTest, MultiDevicesMultiMountPoints) {
    426   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    427   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
    428   ASSERT_FALSE(test_path_a.empty());
    429   ASSERT_FALSE(test_path_b.empty());
    430 
    431   // Attach two devices.
    432   // (*'d mounts are those StorageMonitor knows about.)
    433   // kDeviceDCIM1 -> kMountPointA *
    434   // kDeviceDCIM2 -> kMountPointB *
    435   MtabTestData test_data1[] = {
    436     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    437     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
    438   };
    439   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    440   EXPECT_EQ(2, observer().attach_calls());
    441   EXPECT_EQ(0, observer().detach_calls());
    442 
    443   // Attach |kDeviceDCIM1| to |kMountPointB|.
    444   // |kDeviceDCIM2| is inaccessible, so it is detached. |kDeviceDCIM1| has been
    445   // attached at |kMountPointB|, but is still accessible from |kMountPointA|.
    446   // kDeviceDCIM1 -> kMountPointA *
    447   // kDeviceDCIM2 -> kMountPointB
    448   // kDeviceDCIM1 -> kMountPointB
    449   MtabTestData test_data2[] = {
    450     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    451   };
    452   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
    453   EXPECT_EQ(2, observer().attach_calls());
    454   EXPECT_EQ(1, observer().detach_calls());
    455 
    456   // Detach |kDeviceDCIM1| from |kMountPointA|, causing a detach and attach
    457   // event.
    458   // kDeviceDCIM2 -> kMountPointB
    459   // kDeviceDCIM1 -> kMountPointB *
    460   MtabTestData test_data3[] = {
    461     MtabTestData(kDeviceDCIM2, test_path_b.value(), kValidFS),
    462     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    463   };
    464   OverwriteMtabAndRunLoop(test_data3, arraysize(test_data3));
    465   EXPECT_EQ(3, observer().attach_calls());
    466   EXPECT_EQ(2, observer().detach_calls());
    467 
    468   // Attach |kDeviceDCIM1| to |kMountPointA|.
    469   // kDeviceDCIM2 -> kMountPointB
    470   // kDeviceDCIM1 -> kMountPointB *
    471   // kDeviceDCIM1 -> kMountPointA
    472   MtabTestData test_data4[] = {
    473     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    474   };
    475   AppendToMtabAndRunLoop(test_data4, arraysize(test_data4));
    476   EXPECT_EQ(3, observer().attach_calls());
    477   EXPECT_EQ(2, observer().detach_calls());
    478 
    479   // Detach |kDeviceDCIM1| from |kMountPointB|.
    480   // kDeviceDCIM1 -> kMountPointA *
    481   // kDeviceDCIM2 -> kMountPointB *
    482   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
    483   EXPECT_EQ(5, observer().attach_calls());
    484   EXPECT_EQ(3, observer().detach_calls());
    485 
    486   // Detach all devices.
    487   WriteEmptyMtabAndRunLoop();
    488   EXPECT_EQ(5, observer().attach_calls());
    489   EXPECT_EQ(5, observer().detach_calls());
    490 }
    491 
    492 TEST_F(StorageMonitorLinuxTest, MultipleMountPointsWithNonDCIMDevices) {
    493   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    494   base::FilePath test_path_b = CreateMountPointWithDCIMDir(kMountPointB);
    495   ASSERT_FALSE(test_path_a.empty());
    496   ASSERT_FALSE(test_path_b.empty());
    497 
    498   // Attach to one first.
    499   // (*'d mounts are those StorageMonitor knows about.)
    500   // kDeviceDCIM1 -> kMountPointA *
    501   MtabTestData test_data1[] = {
    502     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    503   };
    504   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    505   EXPECT_EQ(1, observer().attach_calls());
    506   EXPECT_EQ(0, observer().detach_calls());
    507 
    508   // Attach |kDeviceDCIM1| to |kMountPointB|.
    509   // kDeviceDCIM1 -> kMountPointA *
    510   // kDeviceDCIM1 -> kMountPointB
    511   MtabTestData test_data2[] = {
    512     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    513   };
    514   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
    515   EXPECT_EQ(1, observer().attach_calls());
    516   EXPECT_EQ(0, observer().detach_calls());
    517 
    518   // Attach |kDeviceFixed| (a non-removable device) to |kMountPointA|.
    519   // kDeviceDCIM1 -> kMountPointA
    520   // kDeviceDCIM1 -> kMountPointB *
    521   // kDeviceFixed -> kMountPointA
    522   MtabTestData test_data3[] = {
    523     MtabTestData(kDeviceFixed, test_path_a.value(), kValidFS),
    524   };
    525   RemoveDCIMDirFromMountPoint(kMountPointA);
    526   AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
    527   EXPECT_EQ(2, observer().attach_calls());
    528   EXPECT_EQ(1, observer().detach_calls());
    529 
    530   // Detach |kDeviceFixed|.
    531   // kDeviceDCIM1 -> kMountPointA
    532   // kDeviceDCIM1 -> kMountPointB *
    533   MtabTestData test_data4[] = {
    534     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    535     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    536   };
    537   CreateMountPointWithDCIMDir(kMountPointA);
    538   OverwriteMtabAndRunLoop(test_data4, arraysize(test_data4));
    539   EXPECT_EQ(2, observer().attach_calls());
    540   EXPECT_EQ(1, observer().detach_calls());
    541 
    542   // Attach |kDeviceNoDCIM| (a non-DCIM device) to |kMountPointB|.
    543   // kDeviceDCIM1  -> kMountPointA *
    544   // kDeviceDCIM1  -> kMountPointB
    545   // kDeviceNoDCIM -> kMountPointB *
    546   MtabTestData test_data5[] = {
    547     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
    548   };
    549   base::DeleteFile(test_path_b.Append(kDCIMDirectoryName), false);
    550   AppendToMtabAndRunLoop(test_data5, arraysize(test_data5));
    551   EXPECT_EQ(4, observer().attach_calls());
    552   EXPECT_EQ(2, observer().detach_calls());
    553 
    554   // Detach |kDeviceNoDCIM|.
    555   // kDeviceDCIM1 -> kMountPointA *
    556   // kDeviceDCIM1 -> kMountPointB
    557   MtabTestData test_data6[] = {
    558     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    559     MtabTestData(kDeviceDCIM1, test_path_b.value(), kValidFS),
    560   };
    561   CreateMountPointWithDCIMDir(kMountPointB);
    562   OverwriteMtabAndRunLoop(test_data6, arraysize(test_data6));
    563   EXPECT_EQ(4, observer().attach_calls());
    564   EXPECT_EQ(3, observer().detach_calls());
    565 
    566   // Detach |kDeviceDCIM1| from |kMountPointB|.
    567   // kDeviceDCIM1 -> kMountPointA *
    568   OverwriteMtabAndRunLoop(test_data1, arraysize(test_data1));
    569   EXPECT_EQ(4, observer().attach_calls());
    570   EXPECT_EQ(3, observer().detach_calls());
    571 
    572   // Detach all devices.
    573   WriteEmptyMtabAndRunLoop();
    574   EXPECT_EQ(4, observer().attach_calls());
    575   EXPECT_EQ(4, observer().detach_calls());
    576 }
    577 
    578 TEST_F(StorageMonitorLinuxTest, DeviceLookUp) {
    579   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    580   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
    581   base::FilePath test_path_c = CreateMountPointWithoutDCIMDir(kMountPointC);
    582   ASSERT_FALSE(test_path_a.empty());
    583   ASSERT_FALSE(test_path_b.empty());
    584   ASSERT_FALSE(test_path_c.empty());
    585 
    586   // Attach to one first.
    587   // (starred mounts are those StorageMonitor knows about.)
    588   // kDeviceDCIM1  -> kMountPointA *
    589   // kDeviceNoDCIM -> kMountPointB *
    590   // kDeviceFixed  -> kMountPointC
    591   MtabTestData test_data1[] = {
    592     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    593     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
    594     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
    595   };
    596   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    597   EXPECT_EQ(2, observer().attach_calls());
    598   EXPECT_EQ(0, observer().detach_calls());
    599 
    600   StorageInfo device_info;
    601   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_a, &device_info));
    602   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
    603   EXPECT_EQ(test_path_a.value(), device_info.location());
    604   EXPECT_EQ(88788ULL, device_info.total_size_in_bytes());
    605   EXPECT_EQ(base::ASCIIToUTF16("volume label"), device_info.storage_label());
    606   EXPECT_EQ(base::ASCIIToUTF16("vendor name"), device_info.vendor_name());
    607   EXPECT_EQ(base::ASCIIToUTF16("model name"), device_info.model_name());
    608 
    609   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
    610   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), device_info.device_id());
    611   EXPECT_EQ(test_path_b.value(), device_info.location());
    612 
    613   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
    614   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
    615   EXPECT_EQ(test_path_c.value(), device_info.location());
    616 
    617   // An invalid path.
    618   EXPECT_FALSE(notifier()->GetStorageInfoForPath(base::FilePath(kInvalidPath),
    619                                                  &device_info));
    620 
    621   // Test filling in of the mount point.
    622   EXPECT_TRUE(
    623       notifier()->GetStorageInfoForPath(test_path_a.Append("some/other/path"),
    624       &device_info));
    625   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
    626   EXPECT_EQ(test_path_a.value(), device_info.location());
    627 
    628   // One device attached at multiple points.
    629   // kDeviceDCIM1 -> kMountPointA *
    630   // kDeviceFixed -> kMountPointB
    631   // kDeviceFixed -> kMountPointC
    632   MtabTestData test_data2[] = {
    633     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    634     MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
    635     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
    636   };
    637   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
    638 
    639   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_a, &device_info));
    640   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id());
    641 
    642   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
    643   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
    644 
    645   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
    646   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id());
    647 
    648   EXPECT_EQ(2, observer().attach_calls());
    649   EXPECT_EQ(1, observer().detach_calls());
    650 }
    651 
    652 TEST_F(StorageMonitorLinuxTest, DevicePartitionSize) {
    653   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
    654   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
    655   ASSERT_FALSE(test_path_a.empty());
    656   ASSERT_FALSE(test_path_b.empty());
    657 
    658   MtabTestData test_data1[] = {
    659     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
    660     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
    661     MtabTestData(kDeviceFixed, kInvalidPath, kInvalidFS),
    662   };
    663   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
    664   EXPECT_EQ(2, observer().attach_calls());
    665   EXPECT_EQ(0, observer().detach_calls());
    666 
    667   EXPECT_EQ(GetDevicePartitionSize(kDeviceDCIM1),
    668             GetStorageSize(test_path_a));
    669   EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
    670             GetStorageSize(test_path_b));
    671   EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
    672             GetStorageSize(base::FilePath(kInvalidPath)));
    673 }
    674 
    675 }  // namespace
    676 
    677 }  // namespace storage_monitor
    678