components/storage_monitor/storage_monitor_chromeos_unittest.cc

   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 #include "components/storage_monitor/storage_monitor_chromeos.h"
   6
   7 #include "base/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/logging.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "base/run_loop.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "chromeos/disks/mock_disk_mount_manager.h"
  14 #include "components/storage_monitor/mock_removable_storage_observer.h"
  15 #include "components/storage_monitor/removable_device_constants.h"
  16 #include "components/storage_monitor/storage_info.h"
  17 #include "components/storage_monitor/test_media_transfer_protocol_manager_linux.h"
  18 #include "components/storage_monitor/test_storage_monitor.h"
  19 #include "content/public/browser/browser_thread.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace storage_monitor {
  24
  25 namespace {
  26
  27 using content::BrowserThread;
  28 using chromeos::disks::DiskMountManager;
  29 using testing::_;
  30
  31 const char kDevice1[] = "/dev/d1";
  32 const char kDevice1Name[] = "d1";
  33 const char kDevice2[] = "/dev/disk/d2";
  34 const char kDevice2Name[] = "d2";
  35 const char kEmptyDeviceLabel[] = "";
  36 const char kMountPointA[] = "mnt_a";
  37 const char kMountPointB[] = "mnt_b";
  38 const char kSDCardDeviceName1[] = "8.6 MB Amy_SD";
  39 const char kSDCardDeviceName2[] = "8.6 MB SD Card";
  40 const char kSDCardMountPoint1[] = "media/removable/Amy_SD";
  41 const char kSDCardMountPoint2[] = "media/removable/SD Card";
  42 const char kProductName[] = "Z101";
  43 const char kUniqueId1[] = "FFFF-FFFF";
  44 const char kUniqueId2[] = "FFFF-FF0F";
  45 const char kVendorName[] = "CompanyA";
  46
  47 uint64 kDevice1SizeInBytes = 113048;
  48 uint64 kDevice2SizeInBytes = 212312;
  49 uint64 kSDCardSizeInBytes = 9000000;
  50
  51 std::string GetDCIMDeviceId(const std::string& unique_id) {
  52   return StorageInfo::MakeDeviceId(
  53       StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM,
  54       kFSUniqueIdPrefix + unique_id);
  55 }
  56
  57 // A test version of StorageMonitorCros that exposes protected methods to tests.
  58 class TestStorageMonitorCros : public StorageMonitorCros {
  59  public:
  60   TestStorageMonitorCros() {}
  61
  62   virtual ~TestStorageMonitorCros() {}
  63
  64   virtual void Init() OVERRIDE {
  65     SetMediaTransferProtocolManagerForTest(
  66         new TestMediaTransferProtocolManagerLinux());
  67     StorageMonitorCros::Init();
  68   }
  69
  70   virtual void OnMountEvent(DiskMountManager::MountEvent event,
  71       chromeos::MountError error_code,
  72       const DiskMountManager::MountPointInfo& mount_info) OVERRIDE {
  73     StorageMonitorCros::OnMountEvent(event, error_code, mount_info);
  74   }
  75
  76   virtual bool GetStorageInfoForPath(const base::FilePath& path,
  77                                      StorageInfo* device_info) const OVERRIDE {
  78     return StorageMonitorCros::GetStorageInfoForPath(path, device_info);
  79   }
  80   virtual void EjectDevice(
  81       const std::string& device_id,
  82       base::Callback<void(EjectStatus)> callback) OVERRIDE {
  83     StorageMonitorCros::EjectDevice(device_id, callback);
  84   }
  85
  86  private:
  87   DISALLOW_COPY_AND_ASSIGN(TestStorageMonitorCros);
  88 };
  89
  90 // Wrapper class to test StorageMonitorCros.
  91 class StorageMonitorCrosTest : public testing::Test {
  92  public:
  93   StorageMonitorCrosTest();
  94   virtual ~StorageMonitorCrosTest();
  95
  96   void EjectNotify(StorageMonitor::EjectStatus status);
  97
  98  protected:
  99   // testing::Test:
 100   virtual void SetUp() OVERRIDE;
 101   virtual void TearDown() OVERRIDE;
 102
 103   void MountDevice(chromeos::MountError error_code,
 104                    const DiskMountManager::MountPointInfo& mount_info,
 105                    const std::string& unique_id,
 106                    const std::string& device_label,
 107                    const std::string& vendor_name,
 108                    const std::string& product_name,
 109                    chromeos::DeviceType device_type,
 110                    uint64 device_size_in_bytes);
 111
 112   void UnmountDevice(chromeos::MountError error_code,
 113                      const DiskMountManager::MountPointInfo& mount_info);
 114
 115   uint64 GetDeviceStorageSize(const std::string& device_location);
 116
 117   // Create a directory named |dir| relative to the test directory.
 118   // Set |with_dcim_dir| to true if the created directory will have a "DCIM"
 119   // subdirectory.
 120   // Returns the full path to the created directory on success, or an empty
 121   // path on failure.
 122   base::FilePath CreateMountPoint(const std::string& dir, bool with_dcim_dir);
 123
 124   static void PostQuitToUIThread();
 125   static void WaitForFileThread();
 126
 127   MockRemovableStorageObserver& observer() {
 128     return *mock_storage_observer_;
 129   }
 130
 131   TestStorageMonitorCros* monitor_;
 132
 133   // Owned by DiskMountManager.
 134   chromeos::disks::MockDiskMountManager* disk_mount_manager_mock_;
 135
 136   StorageMonitor::EjectStatus status_;
 137
 138  private:
 139   content::TestBrowserThreadBundle thread_bundle_;
 140
 141   // Temporary directory for created test data.
 142   base::ScopedTempDir scoped_temp_dir_;
 143
 144   // Objects that talks with StorageMonitorCros.
 145   scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
 146
 147   DISALLOW_COPY_AND_ASSIGN(StorageMonitorCrosTest);
 148 };
 149
 150 StorageMonitorCrosTest::StorageMonitorCrosTest()
 151     : monitor_(NULL),
 152       disk_mount_manager_mock_(NULL),
 153       status_(StorageMonitor::EJECT_FAILURE),
 154       thread_bundle_(content::TestBrowserThreadBundle::REAL_FILE_THREAD) {
 155 }
 156
 157 StorageMonitorCrosTest::~StorageMonitorCrosTest() {
 158 }
 159
 160 void StorageMonitorCrosTest::SetUp() {
 161   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
 162   ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
 163   disk_mount_manager_mock_ = new chromeos::disks::MockDiskMountManager();
 164   DiskMountManager::InitializeForTesting(disk_mount_manager_mock_);
 165   disk_mount_manager_mock_->SetupDefaultReplies();
 166
 167   mock_storage_observer_.reset(new MockRemovableStorageObserver);
 168
 169   // Initialize the test subject.
 170   TestStorageMonitor::Destroy();
 171   monitor_ = new TestStorageMonitorCros();
 172   scoped_ptr<StorageMonitor> pass_monitor(monitor_);
 173   StorageMonitor::SetStorageMonitorForTesting(pass_monitor.Pass());
 174
 175   monitor_->Init();
 176   monitor_->AddObserver(mock_storage_observer_.get());
 177 }
 178
 179 void StorageMonitorCrosTest::TearDown() {
 180   monitor_->RemoveObserver(mock_storage_observer_.get());
 181   monitor_ = NULL;
 182
 183   disk_mount_manager_mock_ = NULL;
 184   DiskMountManager::Shutdown();
 185   WaitForFileThread();
 186 }
 187
 188 void StorageMonitorCrosTest::MountDevice(
 189     chromeos::MountError error_code,
 190     const DiskMountManager::MountPointInfo& mount_info,
 191     const std::string& unique_id,
 192     const std::string& device_label,
 193     const std::string& vendor_name,
 194     const std::string& product_name,
 195     chromeos::DeviceType device_type,
 196     uint64 device_size_in_bytes) {
 197   if (error_code == chromeos::MOUNT_ERROR_NONE) {
 198     disk_mount_manager_mock_->CreateDiskEntryForMountDevice(
 199         mount_info,
 200         unique_id,
 201         device_label,
 202         vendor_name,
 203         product_name,
 204         device_type,
 205         device_size_in_bytes,
 206         false /* is_parent */,
 207         true /* has_media */,
 208         false /* on_boot_device */,
 209         true /* on_removable_device */);
 210   }
 211   monitor_->OnMountEvent(DiskMountManager::MOUNTING, error_code, mount_info);
 212   WaitForFileThread();
 213 }
 214
 215 void StorageMonitorCrosTest::UnmountDevice(
 216     chromeos::MountError error_code,
 217     const DiskMountManager::MountPointInfo& mount_info) {
 218   monitor_->OnMountEvent(DiskMountManager::UNMOUNTING, error_code, mount_info);
 219   if (error_code == chromeos::MOUNT_ERROR_NONE)
 220     disk_mount_manager_mock_->RemoveDiskEntryForMountDevice(mount_info);
 221   WaitForFileThread();
 222 }
 223
 224 uint64 StorageMonitorCrosTest::GetDeviceStorageSize(
 225     const std::string& device_location) {
 226   StorageInfo info;
 227   if (!monitor_->GetStorageInfoForPath(base::FilePath(device_location), &info))
 228     return 0;
 229
 230   return info.total_size_in_bytes();
 231 }
 232
 233 base::FilePath StorageMonitorCrosTest::CreateMountPoint(
 234     const std::string& dir, bool with_dcim_dir) {
 235   base::FilePath return_path(scoped_temp_dir_.path());
 236   return_path = return_path.AppendASCII(dir);
 237   base::FilePath path(return_path);
 238   if (with_dcim_dir)
 239     path = path.Append(kDCIMDirectoryName);
 240   if (!base::CreateDirectory(path))
 241     return base::FilePath();
 242   return return_path;
 243 }
 244
 245 // static
 246 void StorageMonitorCrosTest::PostQuitToUIThread() {
 247   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 248                           base::MessageLoop::QuitClosure());
 249 }
 250
 251 // static
 252 void StorageMonitorCrosTest::WaitForFileThread() {
 253   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 254                           base::Bind(&PostQuitToUIThread));
 255   base::MessageLoop::current()->Run();
 256 }
 257
 258 void StorageMonitorCrosTest::EjectNotify(StorageMonitor::EjectStatus status) {
 259   status_ = status;
 260 }
 261
 262 // Simple test case where we attach and detach a media device.
 263 TEST_F(StorageMonitorCrosTest, BasicAttachDetach) {
 264   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
 265   ASSERT_FALSE(mount_path1.empty());
 266   DiskMountManager::MountPointInfo mount_info(
 267       kDevice1,
 268       mount_path1.value(),
 269       chromeos::MOUNT_TYPE_DEVICE,
 270       chromeos::disks::MOUNT_CONDITION_NONE);
 271   MountDevice(chromeos::MOUNT_ERROR_NONE,
 272               mount_info,
 273               kUniqueId1,
 274               kDevice1Name,
 275               kVendorName,
 276               kProductName,
 277               chromeos::DEVICE_TYPE_USB,
 278               kDevice1SizeInBytes);
 279   EXPECT_EQ(1, observer().attach_calls());
 280   EXPECT_EQ(0, observer().detach_calls());
 281   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 282             observer().last_attached().device_id());
 283   EXPECT_EQ(mount_path1.value(), observer().last_attached().location());
 284
 285   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info);
 286   EXPECT_EQ(1, observer().attach_calls());
 287   EXPECT_EQ(1, observer().detach_calls());
 288   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 289             observer().last_detached().device_id());
 290
 291   base::FilePath mount_path2 = CreateMountPoint(kMountPointB, true);
 292   ASSERT_FALSE(mount_path2.empty());
 293   DiskMountManager::MountPointInfo mount_info2(
 294       kDevice2,
 295       mount_path2.value(),
 296       chromeos::MOUNT_TYPE_DEVICE,
 297       chromeos::disks::MOUNT_CONDITION_NONE);
 298   MountDevice(chromeos::MOUNT_ERROR_NONE,
 299               mount_info2,
 300               kUniqueId2,
 301               kDevice2Name,
 302               kVendorName,
 303               kProductName,
 304               chromeos::DEVICE_TYPE_USB,
 305               kDevice2SizeInBytes);
 306   EXPECT_EQ(2, observer().attach_calls());
 307   EXPECT_EQ(1, observer().detach_calls());
 308   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 309             observer().last_attached().device_id());
 310   EXPECT_EQ(mount_path2.value(), observer().last_attached().location());
 311
 312   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info2);
 313   EXPECT_EQ(2, observer().attach_calls());
 314   EXPECT_EQ(2, observer().detach_calls());
 315   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 316             observer().last_detached().device_id());
 317 }
 318
 319 // Removable mass storage devices with no dcim folder are also recognized.
 320 TEST_F(StorageMonitorCrosTest, NoDCIM) {
 321   testing::Sequence mock_sequence;
 322   base::FilePath mount_path = CreateMountPoint(kMountPointA, false);
 323   const std::string kUniqueId = "FFFF-FFFF";
 324   ASSERT_FALSE(mount_path.empty());
 325   DiskMountManager::MountPointInfo mount_info(
 326       kDevice1,
 327       mount_path.value(),
 328       chromeos::MOUNT_TYPE_DEVICE,
 329       chromeos::disks::MOUNT_CONDITION_NONE);
 330   const std::string device_id = StorageInfo::MakeDeviceId(
 331       StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM,
 332       kFSUniqueIdPrefix + kUniqueId);
 333   MountDevice(chromeos::MOUNT_ERROR_NONE,
 334               mount_info,
 335               kUniqueId,
 336               kDevice1Name,
 337               kVendorName,
 338               kProductName,
 339               chromeos::DEVICE_TYPE_USB,
 340               kDevice1SizeInBytes);
 341   EXPECT_EQ(1, observer().attach_calls());
 342   EXPECT_EQ(0, observer().detach_calls());
 343   EXPECT_EQ(device_id, observer().last_attached().device_id());
 344   EXPECT_EQ(mount_path.value(), observer().last_attached().location());
 345 }
 346
 347 // Non device mounts and mount errors are ignored.
 348 TEST_F(StorageMonitorCrosTest, Ignore) {
 349   testing::Sequence mock_sequence;
 350   base::FilePath mount_path = CreateMountPoint(kMountPointA, true);
 351   const std::string kUniqueId = "FFFF-FFFF";
 352   ASSERT_FALSE(mount_path.empty());
 353
 354   // Mount error.
 355   DiskMountManager::MountPointInfo mount_info(
 356       kDevice1,
 357       mount_path.value(),
 358       chromeos::MOUNT_TYPE_DEVICE,
 359       chromeos::disks::MOUNT_CONDITION_NONE);
 360   MountDevice(chromeos::MOUNT_ERROR_UNKNOWN,
 361               mount_info,
 362               kUniqueId,
 363               kDevice1Name,
 364               kVendorName,
 365               kProductName,
 366               chromeos::DEVICE_TYPE_USB,
 367               kDevice1SizeInBytes);
 368   EXPECT_EQ(0, observer().attach_calls());
 369   EXPECT_EQ(0, observer().detach_calls());
 370
 371   // Not a device
 372   mount_info.mount_type = chromeos::MOUNT_TYPE_ARCHIVE;
 373   MountDevice(chromeos::MOUNT_ERROR_NONE,
 374               mount_info,
 375               kUniqueId,
 376               kDevice1Name,
 377               kVendorName,
 378               kProductName,
 379               chromeos::DEVICE_TYPE_USB,
 380               kDevice1SizeInBytes);
 381   EXPECT_EQ(0, observer().attach_calls());
 382   EXPECT_EQ(0, observer().detach_calls());
 383
 384   // Unsupported file system.
 385   mount_info.mount_type = chromeos::MOUNT_TYPE_DEVICE;
 386   mount_info.mount_condition =
 387       chromeos::disks::MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
 388   MountDevice(chromeos::MOUNT_ERROR_NONE,
 389               mount_info,
 390               kUniqueId,
 391               kDevice1Name,
 392               kVendorName,
 393               kProductName,
 394               chromeos::DEVICE_TYPE_USB,
 395               kDevice1SizeInBytes);
 396   EXPECT_EQ(0, observer().attach_calls());
 397   EXPECT_EQ(0, observer().detach_calls());
 398 }
 399
 400 TEST_F(StorageMonitorCrosTest, SDCardAttachDetach) {
 401   base::FilePath mount_path1 = CreateMountPoint(kSDCardMountPoint1, true);
 402   ASSERT_FALSE(mount_path1.empty());
 403   DiskMountManager::MountPointInfo mount_info1(
 404       kSDCardDeviceName1,
 405       mount_path1.value(),
 406       chromeos::MOUNT_TYPE_DEVICE,
 407       chromeos::disks::MOUNT_CONDITION_NONE);
 408   MountDevice(chromeos::MOUNT_ERROR_NONE,
 409               mount_info1,
 410               kUniqueId2,
 411               kSDCardDeviceName1,
 412               kVendorName,
 413               kProductName,
 414               chromeos::DEVICE_TYPE_SD,
 415               kSDCardSizeInBytes);
 416   EXPECT_EQ(1, observer().attach_calls());
 417   EXPECT_EQ(0, observer().detach_calls());
 418   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 419             observer().last_attached().device_id());
 420   EXPECT_EQ(mount_path1.value(), observer().last_attached().location());
 421
 422   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info1);
 423   EXPECT_EQ(1, observer().attach_calls());
 424   EXPECT_EQ(1, observer().detach_calls());
 425   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 426             observer().last_detached().device_id());
 427
 428   base::FilePath mount_path2 = CreateMountPoint(kSDCardMountPoint2, true);
 429   ASSERT_FALSE(mount_path2.empty());
 430   DiskMountManager::MountPointInfo mount_info2(
 431       kSDCardDeviceName2,
 432       mount_path2.value(),
 433       chromeos::MOUNT_TYPE_DEVICE,
 434       chromeos::disks::MOUNT_CONDITION_NONE);
 435   MountDevice(chromeos::MOUNT_ERROR_NONE,
 436               mount_info2,
 437               kUniqueId2,
 438               kSDCardDeviceName2,
 439               kVendorName,
 440               kProductName,
 441               chromeos::DEVICE_TYPE_SD,
 442               kSDCardSizeInBytes);
 443   EXPECT_EQ(2, observer().attach_calls());
 444   EXPECT_EQ(1, observer().detach_calls());
 445   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 446             observer().last_attached().device_id());
 447   EXPECT_EQ(mount_path2.value(), observer().last_attached().location());
 448
 449   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info2);
 450   EXPECT_EQ(2, observer().attach_calls());
 451   EXPECT_EQ(2, observer().detach_calls());
 452   EXPECT_EQ(GetDCIMDeviceId(kUniqueId2),
 453             observer().last_detached().device_id());
 454 }
 455
 456 TEST_F(StorageMonitorCrosTest, AttachDeviceWithEmptyLabel) {
 457   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
 458   ASSERT_FALSE(mount_path1.empty());
 459   DiskMountManager::MountPointInfo mount_info(
 460       kEmptyDeviceLabel,
 461       mount_path1.value(),
 462       chromeos::MOUNT_TYPE_DEVICE,
 463       chromeos::disks::MOUNT_CONDITION_NONE);
 464   MountDevice(chromeos::MOUNT_ERROR_NONE,
 465               mount_info,
 466               kUniqueId1,
 467               kEmptyDeviceLabel,
 468               kVendorName,
 469               kProductName,
 470               chromeos::DEVICE_TYPE_USB,
 471               kDevice1SizeInBytes);
 472   EXPECT_EQ(1, observer().attach_calls());
 473   EXPECT_EQ(0, observer().detach_calls());
 474   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 475             observer().last_attached().device_id());
 476   EXPECT_EQ(mount_path1.value(), observer().last_attached().location());
 477
 478   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info);
 479   EXPECT_EQ(1, observer().attach_calls());
 480   EXPECT_EQ(1, observer().detach_calls());
 481   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 482             observer().last_detached().device_id());
 483 }
 484
 485 TEST_F(StorageMonitorCrosTest, GetStorageSize) {
 486   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
 487   ASSERT_FALSE(mount_path1.empty());
 488   DiskMountManager::MountPointInfo mount_info(
 489       kEmptyDeviceLabel,
 490       mount_path1.value(),
 491       chromeos::MOUNT_TYPE_DEVICE,
 492       chromeos::disks::MOUNT_CONDITION_NONE);
 493   MountDevice(chromeos::MOUNT_ERROR_NONE,
 494               mount_info,
 495               kUniqueId1,
 496               kEmptyDeviceLabel,
 497               kVendorName,
 498               kProductName,
 499               chromeos::DEVICE_TYPE_USB,
 500               kDevice1SizeInBytes);
 501   EXPECT_EQ(1, observer().attach_calls());
 502   EXPECT_EQ(0, observer().detach_calls());
 503   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 504             observer().last_attached().device_id());
 505   EXPECT_EQ(mount_path1.value(), observer().last_attached().location());
 506
 507   EXPECT_EQ(kDevice1SizeInBytes, GetDeviceStorageSize(mount_path1.value()));
 508   UnmountDevice(chromeos::MOUNT_ERROR_NONE, mount_info);
 509   EXPECT_EQ(1, observer().attach_calls());
 510   EXPECT_EQ(1, observer().detach_calls());
 511   EXPECT_EQ(GetDCIMDeviceId(kUniqueId1),
 512             observer().last_detached().device_id());
 513 }
 514
 515 void UnmountFake(const std::string& location,
 516                  chromeos::UnmountOptions options,
 517                  const DiskMountManager::UnmountPathCallback& cb) {
 518   cb.Run(chromeos::MOUNT_ERROR_NONE);
 519 }
 520
 521 TEST_F(StorageMonitorCrosTest, EjectTest) {
 522   base::FilePath mount_path1 = CreateMountPoint(kMountPointA, true);
 523   ASSERT_FALSE(mount_path1.empty());
 524   DiskMountManager::MountPointInfo mount_info(
 525       kEmptyDeviceLabel,
 526       mount_path1.value(),
 527       chromeos::MOUNT_TYPE_DEVICE,
 528       chromeos::disks::MOUNT_CONDITION_NONE);
 529   MountDevice(chromeos::MOUNT_ERROR_NONE,
 530               mount_info,
 531               kUniqueId1,
 532               kEmptyDeviceLabel,
 533               kVendorName,
 534               kProductName,
 535               chromeos::DEVICE_TYPE_USB,
 536               kDevice1SizeInBytes);
 537   EXPECT_EQ(1, observer().attach_calls());
 538   EXPECT_EQ(0, observer().detach_calls());
 539
 540   ON_CALL(*disk_mount_manager_mock_, UnmountPath(_, _, _))
 541       .WillByDefault(testing::Invoke(&UnmountFake));
 542   EXPECT_CALL(*disk_mount_manager_mock_,
 543               UnmountPath(observer().last_attached().location(), _, _));
 544   monitor_->EjectDevice(observer().last_attached().device_id(),
 545                         base::Bind(&StorageMonitorCrosTest::EjectNotify,
 546                                    base::Unretained(this)));
 547   base::RunLoop().RunUntilIdle();
 548
 549   EXPECT_EQ(StorageMonitor::EJECT_OK, status_);
 550 }
 551
 552 }  // namespace
 553
 554 }  // namespace storage_monitor