src/chrome/browser/chromeos/file_manager/volume_manager_unittest.cc

   1 // Copyright 2013 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 "chrome/browser/chromeos/file_manager/volume_manager.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
  13 #include "chrome/browser/chromeos/file_manager/volume_manager_observer.h"
  14 #include "chrome/common/pref_names.h"
  15 #include "chrome/test/base/testing_profile.h"
  16 #include "chromeos/dbus/fake_power_manager_client.h"
  17 #include "chromeos/disks/disk_mount_manager.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace file_manager {
  22 namespace {
  23
  24 class LoggingObserver : public VolumeManagerObserver {
  25  public:
  26   struct Event {
  27     enum EventType {
  28       DISK_ADDED,
  29       DISK_REMOVED,
  30       DEVICE_ADDED,
  31       DEVICE_REMOVED,
  32       VOLUME_MOUNTED,
  33       VOLUME_UNMOUNTED,
  34       FORMAT_STARTED,
  35       FORMAT_COMPLETED,
  36     } type;
  37
  38     // Available on DEVICE_ADDED, DEVICE_REMOVED, VOLUME_MOUNTED,
  39     // VOLUME_UNMOUNTED, FORMAT_STARTED and FORMAT_COMPLETED.
  40     std::string device_path;
  41
  42     // Available on DISK_ADDED.
  43     bool mounting;
  44
  45     // Available on VOLUME_MOUNTED and VOLUME_UNMOUNTED.
  46     chromeos::MountError mount_error;
  47
  48     // Available on VOLUME_MOUNTED.
  49     bool is_remounting;
  50
  51     // Available on FORMAT_STARTED and FORMAT_COMPLETED.
  52     bool success;
  53   };
  54
  55   LoggingObserver() {}
  56   virtual ~LoggingObserver() {}
  57
  58   const std::vector<Event>& events() const { return events_; }
  59
  60   // VolumeManagerObserver overrides.
  61   virtual void OnDiskAdded(const chromeos::disks::DiskMountManager::Disk& disk,
  62                            bool mounting) OVERRIDE {
  63     Event event;
  64     event.type = Event::DISK_ADDED;
  65     event.device_path = disk.device_path();  // Keep only device_path.
  66     event.mounting = mounting;
  67     events_.push_back(event);
  68   }
  69
  70   virtual void OnDiskRemoved(
  71       const chromeos::disks::DiskMountManager::Disk& disk) OVERRIDE {
  72     Event event;
  73     event.type = Event::DISK_REMOVED;
  74     event.device_path = disk.device_path();  // Keep only device_path.
  75     events_.push_back(event);
  76   }
  77
  78   virtual void OnDeviceAdded(const std::string& device_path) OVERRIDE {
  79     Event event;
  80     event.type = Event::DEVICE_ADDED;
  81     event.device_path = device_path;
  82     events_.push_back(event);
  83   }
  84
  85   virtual void OnDeviceRemoved(const std::string& device_path) OVERRIDE {
  86     Event event;
  87     event.type = Event::DEVICE_REMOVED;
  88     event.device_path = device_path;
  89     events_.push_back(event);
  90   }
  91
  92   virtual void OnVolumeMounted(chromeos::MountError error_code,
  93                                const VolumeInfo& volume_info,
  94                                bool is_remounting) OVERRIDE {
  95     Event event;
  96     event.type = Event::VOLUME_MOUNTED;
  97     event.device_path = volume_info.source_path.AsUTF8Unsafe();
  98     event.mount_error = error_code;
  99     event.is_remounting = is_remounting;
 100     events_.push_back(event);
 101   }
 102
 103   virtual void OnVolumeUnmounted(chromeos::MountError error_code,
 104                                  const VolumeInfo& volume_info) OVERRIDE {
 105     Event event;
 106     event.type = Event::VOLUME_UNMOUNTED;
 107     event.device_path = volume_info.source_path.AsUTF8Unsafe();
 108     event.mount_error = error_code;
 109     events_.push_back(event);
 110   }
 111
 112   virtual void OnFormatStarted(
 113       const std::string& device_path, bool success) OVERRIDE {
 114     Event event;
 115     event.type = Event::FORMAT_STARTED;
 116     event.device_path = device_path;
 117     event.success = success;
 118     events_.push_back(event);
 119   }
 120
 121   virtual void OnFormatCompleted(
 122       const std::string& device_path, bool success) OVERRIDE {
 123     Event event;
 124     event.type = Event::FORMAT_COMPLETED;
 125     event.device_path = device_path;
 126     event.success = success;
 127     events_.push_back(event);
 128   }
 129
 130  private:
 131   std::vector<Event> events_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(LoggingObserver);
 134 };
 135
 136 }  // namespace
 137
 138 class VolumeManagerTest : public testing::Test {
 139  protected:
 140   VolumeManagerTest() {
 141   }
 142   virtual ~VolumeManagerTest() {
 143   }
 144
 145   virtual void SetUp() OVERRIDE {
 146     power_manager_client_.reset(new chromeos::FakePowerManagerClient);
 147     disk_mount_manager_.reset(new FakeDiskMountManager);
 148     profile_.reset(new TestingProfile);
 149     volume_manager_.reset(new VolumeManager(profile_.get(),
 150                                             NULL,  // DriveIntegrationService
 151                                             power_manager_client_.get(),
 152                                             disk_mount_manager_.get()));
 153   }
 154
 155   content::TestBrowserThreadBundle thread_bundle_;
 156   scoped_ptr<chromeos::FakePowerManagerClient> power_manager_client_;
 157   scoped_ptr<FakeDiskMountManager> disk_mount_manager_;
 158   scoped_ptr<TestingProfile> profile_;
 159   scoped_ptr<VolumeManager> volume_manager_;
 160 };
 161
 162 TEST_F(VolumeManagerTest, OnFileSystemMounted) {
 163   LoggingObserver observer;
 164   volume_manager_->AddObserver(&observer);
 165
 166   volume_manager_->OnFileSystemMounted();
 167
 168   ASSERT_EQ(1U, observer.events().size());
 169   const LoggingObserver::Event& event = observer.events()[0];
 170   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 171   EXPECT_EQ(drive::util::GetDriveMountPointPath().AsUTF8Unsafe(),
 172             event.device_path);
 173   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 174   EXPECT_FALSE(event.is_remounting);
 175
 176   volume_manager_->RemoveObserver(&observer);
 177 }
 178
 179 TEST_F(VolumeManagerTest, OnFileSystemBeingUnmounted) {
 180   LoggingObserver observer;
 181   volume_manager_->AddObserver(&observer);
 182
 183   volume_manager_->OnFileSystemBeingUnmounted();
 184
 185   ASSERT_EQ(1U, observer.events().size());
 186   const LoggingObserver::Event& event = observer.events()[0];
 187   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 188   EXPECT_EQ(drive::util::GetDriveMountPointPath().AsUTF8Unsafe(),
 189             event.device_path);
 190   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 191
 192   volume_manager_->RemoveObserver(&observer);
 193 }
 194
 195 TEST_F(VolumeManagerTest, OnDiskEvent_Hidden) {
 196   LoggingObserver observer;
 197   volume_manager_->AddObserver(&observer);
 198
 199   const bool kIsHidden = true;
 200   const chromeos::disks::DiskMountManager::Disk kDisk(
 201       "device1", "", "", "", "", "", "", "", "", "", "", "",
 202       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, kIsHidden);
 203
 204   volume_manager_->OnDiskEvent(
 205       chromeos::disks::DiskMountManager::DISK_ADDED, &kDisk);
 206   EXPECT_EQ(0U, observer.events().size());
 207
 208   volume_manager_->OnDiskEvent(
 209       chromeos::disks::DiskMountManager::DISK_REMOVED, &kDisk);
 210   EXPECT_EQ(0U, observer.events().size());
 211
 212   volume_manager_->OnDiskEvent(
 213       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 214   EXPECT_EQ(0U, observer.events().size());
 215
 216   volume_manager_->RemoveObserver(&observer);
 217 }
 218
 219 TEST_F(VolumeManagerTest, OnDiskEvent_Added) {
 220   // Enable external storage.
 221   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 222
 223   LoggingObserver observer;
 224   volume_manager_->AddObserver(&observer);
 225
 226   const chromeos::disks::DiskMountManager::Disk kEmptyDevicePathDisk(
 227       "",  // empty device path.
 228       "", "", "", "", "", "", "", "", "", "", "",
 229       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 230   volume_manager_->OnDiskEvent(
 231       chromeos::disks::DiskMountManager::DISK_ADDED, &kEmptyDevicePathDisk);
 232   EXPECT_EQ(0U, observer.events().size());
 233
 234   const bool kHasMedia = true;
 235   const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 236       "device1", "", "", "", "", "", "", "", "", "", "", "",
 237       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, kHasMedia, false, false);
 238   volume_manager_->OnDiskEvent(
 239       chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 240   ASSERT_EQ(1U, observer.events().size());
 241   const LoggingObserver::Event& event = observer.events()[0];
 242   EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 243   EXPECT_EQ("device1", event.device_path);
 244   EXPECT_TRUE(event.mounting);
 245
 246   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 247   const FakeDiskMountManager::MountRequest& mount_request =
 248       disk_mount_manager_->mount_requests()[0];
 249   EXPECT_EQ("device1", mount_request.source_path);
 250   EXPECT_EQ("", mount_request.source_format);
 251   EXPECT_EQ("", mount_request.mount_label);
 252   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 253
 254   volume_manager_->RemoveObserver(&observer);
 255 }
 256
 257 TEST_F(VolumeManagerTest, OnDiskEvent_AddedNonMounting) {
 258   // Enable external storage.
 259   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 260
 261   // Device which is already mounted.
 262   {
 263     LoggingObserver observer;
 264     volume_manager_->AddObserver(&observer);
 265
 266     const bool kHasMedia = true;
 267     const chromeos::disks::DiskMountManager::Disk kMountedMediaDisk(
 268         "device1", "mounted", "", "", "", "", "", "", "", "", "", "",
 269         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 270         kHasMedia, false, false);
 271     volume_manager_->OnDiskEvent(
 272         chromeos::disks::DiskMountManager::DISK_ADDED, &kMountedMediaDisk);
 273     ASSERT_EQ(1U, observer.events().size());
 274     const LoggingObserver::Event& event = observer.events()[0];
 275     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 276     EXPECT_EQ("device1", event.device_path);
 277     EXPECT_FALSE(event.mounting);
 278
 279     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 280
 281     volume_manager_->RemoveObserver(&observer);
 282   }
 283
 284   // Device without media.
 285   {
 286     LoggingObserver observer;
 287     volume_manager_->AddObserver(&observer);
 288
 289     const bool kWithoutMedia = false;
 290     const chromeos::disks::DiskMountManager::Disk kNoMediaDisk(
 291         "device1", "", "", "", "", "", "", "", "", "", "", "",
 292         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 293         kWithoutMedia, false, false);
 294     volume_manager_->OnDiskEvent(
 295         chromeos::disks::DiskMountManager::DISK_ADDED, &kNoMediaDisk);
 296     ASSERT_EQ(1U, observer.events().size());
 297     const LoggingObserver::Event& event = observer.events()[0];
 298     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 299     EXPECT_EQ("device1", event.device_path);
 300     EXPECT_FALSE(event.mounting);
 301
 302     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 303
 304     volume_manager_->RemoveObserver(&observer);
 305   }
 306
 307   // External storage is disabled.
 308   {
 309     profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 310
 311     LoggingObserver observer;
 312     volume_manager_->AddObserver(&observer);
 313
 314     const bool kHasMedia = true;
 315     const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 316         "device1", "", "", "", "", "", "", "", "", "", "", "",
 317         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 318         kHasMedia, false, false);
 319     volume_manager_->OnDiskEvent(
 320         chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 321     ASSERT_EQ(1U, observer.events().size());
 322     const LoggingObserver::Event& event = observer.events()[0];
 323     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 324     EXPECT_EQ("device1", event.device_path);
 325     EXPECT_FALSE(event.mounting);
 326
 327     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 328
 329     volume_manager_->RemoveObserver(&observer);
 330   }
 331 }
 332
 333 TEST_F(VolumeManagerTest, OnDiskEvent_Removed) {
 334   LoggingObserver observer;
 335   volume_manager_->AddObserver(&observer);
 336
 337   const chromeos::disks::DiskMountManager::Disk kMountedDisk(
 338       "device1", "mount_path", "", "", "", "", "", "", "", "", "", "",
 339       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 340   volume_manager_->OnDiskEvent(
 341       chromeos::disks::DiskMountManager::DISK_REMOVED, &kMountedDisk);
 342
 343   ASSERT_EQ(1U, observer.events().size());
 344   const LoggingObserver::Event& event = observer.events()[0];
 345   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 346   EXPECT_EQ("device1", event.device_path);
 347
 348   ASSERT_EQ(1U, disk_mount_manager_->unmount_requests().size());
 349   const FakeDiskMountManager::UnmountRequest& unmount_request =
 350       disk_mount_manager_->unmount_requests()[0];
 351   EXPECT_EQ("mount_path", unmount_request.mount_path);
 352   EXPECT_EQ(chromeos::UNMOUNT_OPTIONS_LAZY, unmount_request.options);
 353
 354   volume_manager_->RemoveObserver(&observer);
 355 }
 356
 357 TEST_F(VolumeManagerTest, OnDiskEvent_RemovedNotMounted) {
 358   LoggingObserver observer;
 359   volume_manager_->AddObserver(&observer);
 360
 361   const chromeos::disks::DiskMountManager::Disk kNotMountedDisk(
 362       "device1", "", "", "", "", "", "", "", "", "", "", "",
 363       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 364   volume_manager_->OnDiskEvent(
 365       chromeos::disks::DiskMountManager::DISK_REMOVED, &kNotMountedDisk);
 366
 367   ASSERT_EQ(1U, observer.events().size());
 368   const LoggingObserver::Event& event = observer.events()[0];
 369   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 370   EXPECT_EQ("device1", event.device_path);
 371
 372   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 373
 374   volume_manager_->RemoveObserver(&observer);
 375 }
 376
 377 TEST_F(VolumeManagerTest, OnDiskEvent_Changed) {
 378   // Changed event is just ignored.
 379   LoggingObserver observer;
 380   volume_manager_->AddObserver(&observer);
 381
 382   const chromeos::disks::DiskMountManager::Disk kDisk(
 383       "device1", "", "", "", "", "", "", "", "", "", "", "",
 384       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 385   volume_manager_->OnDiskEvent(
 386       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 387
 388   EXPECT_EQ(0U, observer.events().size());
 389   EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
 390   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 391
 392   volume_manager_->RemoveObserver(&observer);
 393 }
 394
 395 TEST_F(VolumeManagerTest, OnDeviceEvent_Added) {
 396   LoggingObserver observer;
 397   volume_manager_->AddObserver(&observer);
 398
 399   volume_manager_->OnDeviceEvent(
 400       chromeos::disks::DiskMountManager::DEVICE_ADDED, "device1");
 401
 402   ASSERT_EQ(1U, observer.events().size());
 403   const LoggingObserver::Event& event = observer.events()[0];
 404   EXPECT_EQ(LoggingObserver::Event::DEVICE_ADDED, event.type);
 405   EXPECT_EQ("device1", event.device_path);
 406
 407   volume_manager_->RemoveObserver(&observer);
 408 }
 409
 410 TEST_F(VolumeManagerTest, OnDeviceEvent_Removed) {
 411   LoggingObserver observer;
 412   volume_manager_->AddObserver(&observer);
 413
 414   volume_manager_->OnDeviceEvent(
 415       chromeos::disks::DiskMountManager::DEVICE_REMOVED, "device1");
 416
 417   ASSERT_EQ(1U, observer.events().size());
 418   const LoggingObserver::Event& event = observer.events()[0];
 419   EXPECT_EQ(LoggingObserver::Event::DEVICE_REMOVED, event.type);
 420   EXPECT_EQ("device1", event.device_path);
 421
 422   volume_manager_->RemoveObserver(&observer);
 423 }
 424
 425 TEST_F(VolumeManagerTest, OnDeviceEvent_Scanned) {
 426   LoggingObserver observer;
 427   volume_manager_->AddObserver(&observer);
 428
 429   volume_manager_->OnDeviceEvent(
 430       chromeos::disks::DiskMountManager::DEVICE_SCANNED, "device1");
 431
 432   // SCANNED event is just ignored.
 433   EXPECT_EQ(0U, observer.events().size());
 434
 435   volume_manager_->RemoveObserver(&observer);
 436 }
 437
 438 TEST_F(VolumeManagerTest, OnMountEvent_Mounting) {
 439   LoggingObserver observer;
 440   volume_manager_->AddObserver(&observer);
 441
 442   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 443       "device1",
 444       "mount1",
 445       chromeos::MOUNT_TYPE_DEVICE,
 446       chromeos::disks::MOUNT_CONDITION_NONE);
 447
 448   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
 449                                 chromeos::MOUNT_ERROR_NONE,
 450                                 kMountPoint);
 451
 452   ASSERT_EQ(1U, observer.events().size());
 453   const LoggingObserver::Event& event = observer.events()[0];
 454   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 455   EXPECT_EQ("device1", event.device_path);
 456   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 457   EXPECT_FALSE(event.is_remounting);
 458
 459   volume_manager_->RemoveObserver(&observer);
 460 }
 461
 462 TEST_F(VolumeManagerTest, OnMountEvent_Remounting) {
 463   scoped_ptr<chromeos::disks::DiskMountManager::Disk> disk(
 464       new chromeos::disks::DiskMountManager::Disk(
 465           "device1", "", "", "", "", "", "", "", "", "", "uuid1", "",
 466           chromeos::DEVICE_TYPE_UNKNOWN, 0,
 467           false, false, false, false, false));
 468   disk_mount_manager_->AddDiskForTest(disk.release());
 469   disk_mount_manager_->MountPath(
 470       "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 471
 472   // Emulate system suspend and then resume.
 473   {
 474     power_manager_client_->SendSuspendImminent();
 475     power_manager::SuspendState state;
 476     state.set_type(power_manager::SuspendState_Type_SUSPEND_TO_MEMORY);
 477     state.set_wall_time(0);
 478     power_manager_client_->SendSuspendStateChanged(state);
 479     state.set_type(power_manager::SuspendState_Type_RESUME);
 480     power_manager_client_->SendSuspendStateChanged(state);
 481
 482     // After resume, the device is unmounted and then mounted.
 483     disk_mount_manager_->UnmountPath(
 484         "device1", chromeos::UNMOUNT_OPTIONS_NONE,
 485         chromeos::disks::DiskMountManager::UnmountPathCallback());
 486     disk_mount_manager_->MountPath(
 487         "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 488   }
 489
 490   LoggingObserver observer;
 491   volume_manager_->AddObserver(&observer);
 492
 493   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 494       "device1",
 495       "mount1",
 496       chromeos::MOUNT_TYPE_DEVICE,
 497       chromeos::disks::MOUNT_CONDITION_NONE);
 498
 499   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
 500                                 chromeos::MOUNT_ERROR_NONE,
 501                                 kMountPoint);
 502
 503   ASSERT_EQ(1U, observer.events().size());
 504   const LoggingObserver::Event& event = observer.events()[0];
 505   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 506   EXPECT_EQ("device1", event.device_path);
 507   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 508   EXPECT_TRUE(event.is_remounting);
 509
 510   volume_manager_->RemoveObserver(&observer);
 511 }
 512
 513 TEST_F(VolumeManagerTest, OnMountEvent_Unmounting) {
 514   LoggingObserver observer;
 515   volume_manager_->AddObserver(&observer);
 516
 517   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 518       "device1",
 519       "mount1",
 520       chromeos::MOUNT_TYPE_DEVICE,
 521       chromeos::disks::MOUNT_CONDITION_NONE);
 522
 523   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
 524                                 chromeos::MOUNT_ERROR_NONE,
 525                                 kMountPoint);
 526
 527   ASSERT_EQ(1U, observer.events().size());
 528   const LoggingObserver::Event& event = observer.events()[0];
 529   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 530   EXPECT_EQ("device1", event.device_path);
 531   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 532
 533   volume_manager_->RemoveObserver(&observer);
 534 }
 535
 536 TEST_F(VolumeManagerTest, OnFormatEvent_Started) {
 537   LoggingObserver observer;
 538   volume_manager_->AddObserver(&observer);
 539
 540   volume_manager_->OnFormatEvent(
 541       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 542       chromeos::FORMAT_ERROR_NONE,
 543       "device1");
 544
 545   ASSERT_EQ(1U, observer.events().size());
 546   const LoggingObserver::Event& event = observer.events()[0];
 547   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 548   EXPECT_EQ("device1", event.device_path);
 549   EXPECT_TRUE(event.success);
 550
 551   volume_manager_->RemoveObserver(&observer);
 552 }
 553
 554 TEST_F(VolumeManagerTest, OnFormatEvent_StartFailed) {
 555   LoggingObserver observer;
 556   volume_manager_->AddObserver(&observer);
 557
 558   volume_manager_->OnFormatEvent(
 559       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 560       chromeos::FORMAT_ERROR_UNKNOWN,
 561       "device1");
 562
 563   ASSERT_EQ(1U, observer.events().size());
 564   const LoggingObserver::Event& event = observer.events()[0];
 565   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 566   EXPECT_EQ("device1", event.device_path);
 567   EXPECT_FALSE(event.success);
 568
 569   volume_manager_->RemoveObserver(&observer);
 570 }
 571
 572 TEST_F(VolumeManagerTest, OnFormatEvent_Completed) {
 573   LoggingObserver observer;
 574   volume_manager_->AddObserver(&observer);
 575
 576   volume_manager_->OnFormatEvent(
 577       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 578       chromeos::FORMAT_ERROR_NONE,
 579       "device1");
 580
 581   ASSERT_EQ(1U, observer.events().size());
 582   const LoggingObserver::Event& event = observer.events()[0];
 583   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 584   EXPECT_EQ("device1", event.device_path);
 585   EXPECT_TRUE(event.success);
 586
 587   // When "format" is successfully done, VolumeManager requests to mount it.
 588   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 589   const FakeDiskMountManager::MountRequest& mount_request =
 590       disk_mount_manager_->mount_requests()[0];
 591   EXPECT_EQ("device1", mount_request.source_path);
 592   EXPECT_EQ("", mount_request.source_format);
 593   EXPECT_EQ("", mount_request.mount_label);
 594   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 595
 596   volume_manager_->RemoveObserver(&observer);
 597 }
 598
 599 TEST_F(VolumeManagerTest, OnFormatEvent_CompletedFailed) {
 600   LoggingObserver observer;
 601   volume_manager_->AddObserver(&observer);
 602
 603   volume_manager_->OnFormatEvent(
 604       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 605       chromeos::FORMAT_ERROR_UNKNOWN,
 606       "device1");
 607
 608   ASSERT_EQ(1U, observer.events().size());
 609   const LoggingObserver::Event& event = observer.events()[0];
 610   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 611   EXPECT_EQ("device1", event.device_path);
 612   EXPECT_FALSE(event.success);
 613
 614   EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
 615
 616   volume_manager_->RemoveObserver(&observer);
 617 }
 618
 619 TEST_F(VolumeManagerTest, OnExternalStorageDisabledChanged) {
 620   // Here create two mount points.
 621   disk_mount_manager_->MountPath(
 622       "mount1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 623   disk_mount_manager_->MountPath(
 624       "mount2", "", "", chromeos::MOUNT_TYPE_DEVICE);
 625
 626   // Initially, there are two mount points.
 627   ASSERT_EQ(2U, disk_mount_manager_->mount_points().size());
 628   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 629
 630   // Emulate to set kExternalStorageDisabled to false.
 631   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 632   volume_manager_->OnExternalStorageDisabledChanged();
 633
 634   // Expect no effects.
 635   EXPECT_EQ(2U, disk_mount_manager_->mount_points().size());
 636   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 637
 638   // Emulate to set kExternalStorageDisabled to true.
 639   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 640   volume_manager_->OnExternalStorageDisabledChanged();
 641
 642   // The all mount points should be unmounted.
 643   EXPECT_EQ(0U, disk_mount_manager_->mount_points().size());
 644
 645   EXPECT_EQ(2U, disk_mount_manager_->unmount_requests().size());
 646   const FakeDiskMountManager::UnmountRequest& unmount_request1 =
 647       disk_mount_manager_->unmount_requests()[0];
 648   EXPECT_EQ("mount1", unmount_request1.mount_path);
 649
 650   const FakeDiskMountManager::UnmountRequest& unmount_request2 =
 651       disk_mount_manager_->unmount_requests()[1];
 652   EXPECT_EQ("mount2", unmount_request2.mount_path);
 653 }
 654
 655 }  // namespace file_manager