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, OnDriveFileSystemMountAndUnmount) {
 163   LoggingObserver observer;
 164   volume_manager_->AddObserver(&observer);
 165
 166   volume_manager_->OnFileSystemMounted();
 167
 168   ASSERT_EQ(1U, observer.events().size());
 169   LoggingObserver::Event event = observer.events()[0];
 170   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 171   EXPECT_EQ(drive::util::GetDriveMountPointPath(profile_.get()).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_->OnFileSystemBeingUnmounted();
 177
 178   ASSERT_EQ(2U, observer.events().size());
 179   event = observer.events()[1];
 180   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 181   EXPECT_EQ(drive::util::GetDriveMountPointPath(profile_.get()).AsUTF8Unsafe(),
 182             event.device_path);
 183   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 184
 185   volume_manager_->RemoveObserver(&observer);
 186 }
 187
 188 TEST_F(VolumeManagerTest, OnDriveFileSystemUnmountWithoutMount) {
 189   LoggingObserver observer;
 190   volume_manager_->AddObserver(&observer);
 191   volume_manager_->OnFileSystemBeingUnmounted();
 192
 193   // Unmount event for non-mounted volume is not reported.
 194   ASSERT_EQ(0U, observer.events().size());
 195   volume_manager_->RemoveObserver(&observer);
 196 }
 197
 198 TEST_F(VolumeManagerTest, OnDiskEvent_Hidden) {
 199   LoggingObserver observer;
 200   volume_manager_->AddObserver(&observer);
 201
 202   const bool kIsHidden = true;
 203   const chromeos::disks::DiskMountManager::Disk kDisk(
 204       "device1", "", "", "", "", "", "", "", "", "", "", "",
 205       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, kIsHidden);
 206
 207   volume_manager_->OnDiskEvent(
 208       chromeos::disks::DiskMountManager::DISK_ADDED, &kDisk);
 209   EXPECT_EQ(0U, observer.events().size());
 210
 211   volume_manager_->OnDiskEvent(
 212       chromeos::disks::DiskMountManager::DISK_REMOVED, &kDisk);
 213   EXPECT_EQ(0U, observer.events().size());
 214
 215   volume_manager_->OnDiskEvent(
 216       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 217   EXPECT_EQ(0U, observer.events().size());
 218
 219   volume_manager_->RemoveObserver(&observer);
 220 }
 221
 222 TEST_F(VolumeManagerTest, OnDiskEvent_Added) {
 223   // Enable external storage.
 224   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 225
 226   LoggingObserver observer;
 227   volume_manager_->AddObserver(&observer);
 228
 229   const chromeos::disks::DiskMountManager::Disk kEmptyDevicePathDisk(
 230       "",  // empty device path.
 231       "", "", "", "", "", "", "", "", "", "", "",
 232       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 233   volume_manager_->OnDiskEvent(
 234       chromeos::disks::DiskMountManager::DISK_ADDED, &kEmptyDevicePathDisk);
 235   EXPECT_EQ(0U, observer.events().size());
 236
 237   const bool kHasMedia = true;
 238   const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 239       "device1", "", "", "", "", "", "", "", "", "", "", "",
 240       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, kHasMedia, false, false);
 241   volume_manager_->OnDiskEvent(
 242       chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 243   ASSERT_EQ(1U, observer.events().size());
 244   const LoggingObserver::Event& event = observer.events()[0];
 245   EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 246   EXPECT_EQ("device1", event.device_path);
 247   EXPECT_TRUE(event.mounting);
 248
 249   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 250   const FakeDiskMountManager::MountRequest& mount_request =
 251       disk_mount_manager_->mount_requests()[0];
 252   EXPECT_EQ("device1", mount_request.source_path);
 253   EXPECT_EQ("", mount_request.source_format);
 254   EXPECT_EQ("", mount_request.mount_label);
 255   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 256
 257   volume_manager_->RemoveObserver(&observer);
 258 }
 259
 260 TEST_F(VolumeManagerTest, OnDiskEvent_AddedNonMounting) {
 261   // Enable external storage.
 262   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 263
 264   // Device which is already mounted.
 265   {
 266     LoggingObserver observer;
 267     volume_manager_->AddObserver(&observer);
 268
 269     const bool kHasMedia = true;
 270     const chromeos::disks::DiskMountManager::Disk kMountedMediaDisk(
 271         "device1", "mounted", "", "", "", "", "", "", "", "", "", "",
 272         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 273         kHasMedia, false, false);
 274     volume_manager_->OnDiskEvent(
 275         chromeos::disks::DiskMountManager::DISK_ADDED, &kMountedMediaDisk);
 276     ASSERT_EQ(1U, observer.events().size());
 277     const LoggingObserver::Event& event = observer.events()[0];
 278     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 279     EXPECT_EQ("device1", event.device_path);
 280     EXPECT_FALSE(event.mounting);
 281
 282     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 283
 284     volume_manager_->RemoveObserver(&observer);
 285   }
 286
 287   // Device without media.
 288   {
 289     LoggingObserver observer;
 290     volume_manager_->AddObserver(&observer);
 291
 292     const bool kWithoutMedia = false;
 293     const chromeos::disks::DiskMountManager::Disk kNoMediaDisk(
 294         "device1", "", "", "", "", "", "", "", "", "", "", "",
 295         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 296         kWithoutMedia, false, false);
 297     volume_manager_->OnDiskEvent(
 298         chromeos::disks::DiskMountManager::DISK_ADDED, &kNoMediaDisk);
 299     ASSERT_EQ(1U, observer.events().size());
 300     const LoggingObserver::Event& event = observer.events()[0];
 301     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 302     EXPECT_EQ("device1", event.device_path);
 303     EXPECT_FALSE(event.mounting);
 304
 305     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 306
 307     volume_manager_->RemoveObserver(&observer);
 308   }
 309
 310   // External storage is disabled.
 311   {
 312     profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 313
 314     LoggingObserver observer;
 315     volume_manager_->AddObserver(&observer);
 316
 317     const bool kHasMedia = true;
 318     const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 319         "device1", "", "", "", "", "", "", "", "", "", "", "",
 320         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 321         kHasMedia, false, false);
 322     volume_manager_->OnDiskEvent(
 323         chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 324     ASSERT_EQ(1U, observer.events().size());
 325     const LoggingObserver::Event& event = observer.events()[0];
 326     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 327     EXPECT_EQ("device1", event.device_path);
 328     EXPECT_FALSE(event.mounting);
 329
 330     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 331
 332     volume_manager_->RemoveObserver(&observer);
 333   }
 334 }
 335
 336 TEST_F(VolumeManagerTest, OnDiskEvent_Removed) {
 337   LoggingObserver observer;
 338   volume_manager_->AddObserver(&observer);
 339
 340   const chromeos::disks::DiskMountManager::Disk kMountedDisk(
 341       "device1", "mount_path", "", "", "", "", "", "", "", "", "", "",
 342       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 343   volume_manager_->OnDiskEvent(
 344       chromeos::disks::DiskMountManager::DISK_REMOVED, &kMountedDisk);
 345
 346   ASSERT_EQ(1U, observer.events().size());
 347   const LoggingObserver::Event& event = observer.events()[0];
 348   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 349   EXPECT_EQ("device1", event.device_path);
 350
 351   ASSERT_EQ(1U, disk_mount_manager_->unmount_requests().size());
 352   const FakeDiskMountManager::UnmountRequest& unmount_request =
 353       disk_mount_manager_->unmount_requests()[0];
 354   EXPECT_EQ("mount_path", unmount_request.mount_path);
 355   EXPECT_EQ(chromeos::UNMOUNT_OPTIONS_LAZY, unmount_request.options);
 356
 357   volume_manager_->RemoveObserver(&observer);
 358 }
 359
 360 TEST_F(VolumeManagerTest, OnDiskEvent_RemovedNotMounted) {
 361   LoggingObserver observer;
 362   volume_manager_->AddObserver(&observer);
 363
 364   const chromeos::disks::DiskMountManager::Disk kNotMountedDisk(
 365       "device1", "", "", "", "", "", "", "", "", "", "", "",
 366       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 367   volume_manager_->OnDiskEvent(
 368       chromeos::disks::DiskMountManager::DISK_REMOVED, &kNotMountedDisk);
 369
 370   ASSERT_EQ(1U, observer.events().size());
 371   const LoggingObserver::Event& event = observer.events()[0];
 372   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 373   EXPECT_EQ("device1", event.device_path);
 374
 375   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 376
 377   volume_manager_->RemoveObserver(&observer);
 378 }
 379
 380 TEST_F(VolumeManagerTest, OnDiskEvent_Changed) {
 381   // Changed event is just ignored.
 382   LoggingObserver observer;
 383   volume_manager_->AddObserver(&observer);
 384
 385   const chromeos::disks::DiskMountManager::Disk kDisk(
 386       "device1", "", "", "", "", "", "", "", "", "", "", "",
 387       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false);
 388   volume_manager_->OnDiskEvent(
 389       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 390
 391   EXPECT_EQ(0U, observer.events().size());
 392   EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
 393   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 394
 395   volume_manager_->RemoveObserver(&observer);
 396 }
 397
 398 TEST_F(VolumeManagerTest, OnDeviceEvent_Added) {
 399   LoggingObserver observer;
 400   volume_manager_->AddObserver(&observer);
 401
 402   volume_manager_->OnDeviceEvent(
 403       chromeos::disks::DiskMountManager::DEVICE_ADDED, "device1");
 404
 405   ASSERT_EQ(1U, observer.events().size());
 406   const LoggingObserver::Event& event = observer.events()[0];
 407   EXPECT_EQ(LoggingObserver::Event::DEVICE_ADDED, event.type);
 408   EXPECT_EQ("device1", event.device_path);
 409
 410   volume_manager_->RemoveObserver(&observer);
 411 }
 412
 413 TEST_F(VolumeManagerTest, OnDeviceEvent_Removed) {
 414   LoggingObserver observer;
 415   volume_manager_->AddObserver(&observer);
 416
 417   volume_manager_->OnDeviceEvent(
 418       chromeos::disks::DiskMountManager::DEVICE_REMOVED, "device1");
 419
 420   ASSERT_EQ(1U, observer.events().size());
 421   const LoggingObserver::Event& event = observer.events()[0];
 422   EXPECT_EQ(LoggingObserver::Event::DEVICE_REMOVED, event.type);
 423   EXPECT_EQ("device1", event.device_path);
 424
 425   volume_manager_->RemoveObserver(&observer);
 426 }
 427
 428 TEST_F(VolumeManagerTest, OnDeviceEvent_Scanned) {
 429   LoggingObserver observer;
 430   volume_manager_->AddObserver(&observer);
 431
 432   volume_manager_->OnDeviceEvent(
 433       chromeos::disks::DiskMountManager::DEVICE_SCANNED, "device1");
 434
 435   // SCANNED event is just ignored.
 436   EXPECT_EQ(0U, observer.events().size());
 437
 438   volume_manager_->RemoveObserver(&observer);
 439 }
 440
 441 TEST_F(VolumeManagerTest, OnMountEvent_MountingAndUnmounting) {
 442   LoggingObserver observer;
 443   volume_manager_->AddObserver(&observer);
 444
 445   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 446       "device1",
 447       "mount1",
 448       chromeos::MOUNT_TYPE_DEVICE,
 449       chromeos::disks::MOUNT_CONDITION_NONE);
 450
 451   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
 452                                 chromeos::MOUNT_ERROR_NONE,
 453                                 kMountPoint);
 454
 455   ASSERT_EQ(1U, observer.events().size());
 456   LoggingObserver::Event event = observer.events()[0];
 457   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 458   EXPECT_EQ("device1", event.device_path);
 459   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 460   EXPECT_FALSE(event.is_remounting);
 461
 462   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
 463                                 chromeos::MOUNT_ERROR_NONE,
 464                                 kMountPoint);
 465
 466   ASSERT_EQ(2U, observer.events().size());
 467   event = observer.events()[1];
 468   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 469   EXPECT_EQ("device1", event.device_path);
 470   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 471
 472   volume_manager_->RemoveObserver(&observer);
 473 }
 474
 475 TEST_F(VolumeManagerTest, OnMountEvent_Remounting) {
 476   scoped_ptr<chromeos::disks::DiskMountManager::Disk> disk(
 477       new chromeos::disks::DiskMountManager::Disk(
 478           "device1", "", "", "", "", "", "", "", "", "", "uuid1", "",
 479           chromeos::DEVICE_TYPE_UNKNOWN, 0,
 480           false, false, false, false, false));
 481   disk_mount_manager_->AddDiskForTest(disk.release());
 482   disk_mount_manager_->MountPath(
 483       "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 484
 485   // Emulate system suspend and then resume.
 486   {
 487     power_manager_client_->SendSuspendImminent();
 488     power_manager::SuspendState state;
 489     state.set_type(power_manager::SuspendState_Type_SUSPEND_TO_MEMORY);
 490     state.set_wall_time(0);
 491     power_manager_client_->SendSuspendStateChanged(state);
 492     state.set_type(power_manager::SuspendState_Type_RESUME);
 493     power_manager_client_->SendSuspendStateChanged(state);
 494
 495     // After resume, the device is unmounted and then mounted.
 496     disk_mount_manager_->UnmountPath(
 497         "device1", chromeos::UNMOUNT_OPTIONS_NONE,
 498         chromeos::disks::DiskMountManager::UnmountPathCallback());
 499     disk_mount_manager_->MountPath(
 500         "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 501   }
 502
 503   LoggingObserver observer;
 504   volume_manager_->AddObserver(&observer);
 505
 506   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 507       "device1",
 508       "mount1",
 509       chromeos::MOUNT_TYPE_DEVICE,
 510       chromeos::disks::MOUNT_CONDITION_NONE);
 511
 512   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
 513                                 chromeos::MOUNT_ERROR_NONE,
 514                                 kMountPoint);
 515
 516   ASSERT_EQ(1U, observer.events().size());
 517   const LoggingObserver::Event& event = observer.events()[0];
 518   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 519   EXPECT_EQ("device1", event.device_path);
 520   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 521   EXPECT_TRUE(event.is_remounting);
 522
 523   volume_manager_->RemoveObserver(&observer);
 524 }
 525
 526 TEST_F(VolumeManagerTest, OnMountEvent_UnmountingWithoutMounting) {
 527   LoggingObserver observer;
 528   volume_manager_->AddObserver(&observer);
 529
 530   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 531       "device1",
 532       "mount1",
 533       chromeos::MOUNT_TYPE_DEVICE,
 534       chromeos::disks::MOUNT_CONDITION_NONE);
 535
 536   volume_manager_->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
 537                                 chromeos::MOUNT_ERROR_NONE,
 538                                 kMountPoint);
 539
 540   // Unmount event for a disk not mounted in this manager is not reported.
 541   ASSERT_EQ(0U, observer.events().size());
 542
 543   volume_manager_->RemoveObserver(&observer);
 544 }
 545
 546 TEST_F(VolumeManagerTest, OnFormatEvent_Started) {
 547   LoggingObserver observer;
 548   volume_manager_->AddObserver(&observer);
 549
 550   volume_manager_->OnFormatEvent(
 551       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 552       chromeos::FORMAT_ERROR_NONE,
 553       "device1");
 554
 555   ASSERT_EQ(1U, observer.events().size());
 556   const LoggingObserver::Event& event = observer.events()[0];
 557   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 558   EXPECT_EQ("device1", event.device_path);
 559   EXPECT_TRUE(event.success);
 560
 561   volume_manager_->RemoveObserver(&observer);
 562 }
 563
 564 TEST_F(VolumeManagerTest, OnFormatEvent_StartFailed) {
 565   LoggingObserver observer;
 566   volume_manager_->AddObserver(&observer);
 567
 568   volume_manager_->OnFormatEvent(
 569       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 570       chromeos::FORMAT_ERROR_UNKNOWN,
 571       "device1");
 572
 573   ASSERT_EQ(1U, observer.events().size());
 574   const LoggingObserver::Event& event = observer.events()[0];
 575   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 576   EXPECT_EQ("device1", event.device_path);
 577   EXPECT_FALSE(event.success);
 578
 579   volume_manager_->RemoveObserver(&observer);
 580 }
 581
 582 TEST_F(VolumeManagerTest, OnFormatEvent_Completed) {
 583   LoggingObserver observer;
 584   volume_manager_->AddObserver(&observer);
 585
 586   volume_manager_->OnFormatEvent(
 587       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 588       chromeos::FORMAT_ERROR_NONE,
 589       "device1");
 590
 591   ASSERT_EQ(1U, observer.events().size());
 592   const LoggingObserver::Event& event = observer.events()[0];
 593   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 594   EXPECT_EQ("device1", event.device_path);
 595   EXPECT_TRUE(event.success);
 596
 597   // When "format" is successfully done, VolumeManager requests to mount it.
 598   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 599   const FakeDiskMountManager::MountRequest& mount_request =
 600       disk_mount_manager_->mount_requests()[0];
 601   EXPECT_EQ("device1", mount_request.source_path);
 602   EXPECT_EQ("", mount_request.source_format);
 603   EXPECT_EQ("", mount_request.mount_label);
 604   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 605
 606   volume_manager_->RemoveObserver(&observer);
 607 }
 608
 609 TEST_F(VolumeManagerTest, OnFormatEvent_CompletedFailed) {
 610   LoggingObserver observer;
 611   volume_manager_->AddObserver(&observer);
 612
 613   volume_manager_->OnFormatEvent(
 614       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 615       chromeos::FORMAT_ERROR_UNKNOWN,
 616       "device1");
 617
 618   ASSERT_EQ(1U, observer.events().size());
 619   const LoggingObserver::Event& event = observer.events()[0];
 620   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 621   EXPECT_EQ("device1", event.device_path);
 622   EXPECT_FALSE(event.success);
 623
 624   EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
 625
 626   volume_manager_->RemoveObserver(&observer);
 627 }
 628
 629 TEST_F(VolumeManagerTest, OnExternalStorageDisabledChanged) {
 630   // Here create two mount points.
 631   disk_mount_manager_->MountPath(
 632       "mount1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 633   disk_mount_manager_->MountPath(
 634       "mount2", "", "", chromeos::MOUNT_TYPE_DEVICE);
 635
 636   // Initially, there are two mount points.
 637   ASSERT_EQ(2U, disk_mount_manager_->mount_points().size());
 638   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 639
 640   // Emulate to set kExternalStorageDisabled to false.
 641   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 642   volume_manager_->OnExternalStorageDisabledChanged();
 643
 644   // Expect no effects.
 645   EXPECT_EQ(2U, disk_mount_manager_->mount_points().size());
 646   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 647
 648   // Emulate to set kExternalStorageDisabled to true.
 649   profile_->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 650   volume_manager_->OnExternalStorageDisabledChanged();
 651
 652   // The all mount points should be unmounted.
 653   EXPECT_EQ(0U, disk_mount_manager_->mount_points().size());
 654
 655   EXPECT_EQ(2U, disk_mount_manager_->unmount_requests().size());
 656   const FakeDiskMountManager::UnmountRequest& unmount_request1 =
 657       disk_mount_manager_->unmount_requests()[0];
 658   EXPECT_EQ("mount1", unmount_request1.mount_path);
 659
 660   const FakeDiskMountManager::UnmountRequest& unmount_request2 =
 661       disk_mount_manager_->unmount_requests()[1];
 662   EXPECT_EQ("mount2", unmount_request2.mount_path);
 663 }
 664
 665 TEST_F(VolumeManagerTest, GetVolumeInfoList) {
 666   volume_manager_->Initialize();  // Adds "Downloads"
 667   std::vector<VolumeInfo> info_list = volume_manager_->GetVolumeInfoList();
 668   ASSERT_EQ(1u, info_list.size());
 669   EXPECT_EQ("downloads:Downloads", info_list[0].volume_id);
 670   EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, info_list[0].type);
 671 }
 672
 673 TEST_F(VolumeManagerTest, FindVolumeInfoById) {
 674   volume_manager_->Initialize();  // Adds "Downloads"
 675   VolumeInfo volume_info;
 676   ASSERT_FALSE(volume_manager_->FindVolumeInfoById(
 677       "nonexistent", &volume_info));
 678   ASSERT_TRUE(volume_manager_->FindVolumeInfoById(
 679       "downloads:Downloads", &volume_info));
 680   EXPECT_EQ("downloads:Downloads", volume_info.volume_id);
 681   EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, volume_info.type);
 682 }
 683
 684 TEST_F(VolumeManagerTest, ArchiveSourceFiltering) {
 685   LoggingObserver observer;
 686   volume_manager_->AddObserver(&observer);
 687
 688   // Mount a USB stick.
 689   volume_manager_->OnMountEvent(
 690       chromeos::disks::DiskMountManager::MOUNTING,
 691       chromeos::MOUNT_ERROR_NONE,
 692       chromeos::disks::DiskMountManager::MountPointInfo(
 693           "/removable/usb",
 694           "/removable/usb",
 695           chromeos::MOUNT_TYPE_DEVICE,
 696           chromeos::disks::MOUNT_CONDITION_NONE));
 697
 698   // Mount a zip archive in the stick.
 699   volume_manager_->OnMountEvent(
 700       chromeos::disks::DiskMountManager::MOUNTING,
 701       chromeos::MOUNT_ERROR_NONE,
 702       chromeos::disks::DiskMountManager::MountPointInfo(
 703           "/removable/usb/1.zip",
 704           "/archive/1",
 705           chromeos::MOUNT_TYPE_ARCHIVE,
 706           chromeos::disks::MOUNT_CONDITION_NONE));
 707   VolumeInfo volume_info;
 708   ASSERT_TRUE(volume_manager_->FindVolumeInfoById("archive:1", &volume_info));
 709   EXPECT_EQ("/archive/1", volume_info.mount_path.AsUTF8Unsafe());
 710   EXPECT_EQ(2u, observer.events().size());
 711
 712   // Mount a zip archive in the previous zip archive.
 713   volume_manager_->OnMountEvent(
 714       chromeos::disks::DiskMountManager::MOUNTING,
 715       chromeos::MOUNT_ERROR_NONE,
 716       chromeos::disks::DiskMountManager::MountPointInfo(
 717           "/archive/1/2.zip",
 718           "/archive/2",
 719           chromeos::MOUNT_TYPE_ARCHIVE,
 720           chromeos::disks::MOUNT_CONDITION_NONE));
 721   ASSERT_TRUE(volume_manager_->FindVolumeInfoById("archive:2", &volume_info));
 722   EXPECT_EQ("/archive/2", volume_info.mount_path.AsUTF8Unsafe());
 723   EXPECT_EQ(3u, observer.events().size());
 724
 725   // A zip file is mounted from other profile. It must be ignored in the current
 726   // VolumeManager.
 727   volume_manager_->OnMountEvent(
 728       chromeos::disks::DiskMountManager::MOUNTING,
 729       chromeos::MOUNT_ERROR_NONE,
 730       chromeos::disks::DiskMountManager::MountPointInfo(
 731           "/other/profile/drive/folder/3.zip",
 732           "/archive/3",
 733           chromeos::MOUNT_TYPE_ARCHIVE,
 734           chromeos::disks::MOUNT_CONDITION_NONE));
 735   EXPECT_FALSE(volume_manager_->FindVolumeInfoById("archive:3", &volume_info));
 736   EXPECT_EQ(3u, observer.events().size());
 737 }
 738
 739 }  // namespace file_manager