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 "base/strings/utf_string_conversions.h"
  13 #include "chrome/browser/chromeos/file_manager/fake_disk_mount_manager.h"
  14 #include "chrome/browser/chromeos/file_manager/volume_manager_observer.h"
  15 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
  16 #include "chrome/browser/chromeos/file_system_provider/service.h"
  17 #include "chrome/common/pref_names.h"
  18 #include "chrome/test/base/testing_profile.h"
  19 #include "chromeos/dbus/fake_power_manager_client.h"
  20 #include "chromeos/disks/disk_mount_manager.h"
  21 #include "components/storage_monitor/storage_info.h"
  22 #include "content/public/test/test_browser_thread_bundle.h"
  23 #include "extensions/browser/extension_registry.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 namespace file_manager {
  27 namespace {
  28
  29 class LoggingObserver : public VolumeManagerObserver {
  30  public:
  31   struct Event {
  32     enum EventType {
  33       DISK_ADDED,
  34       DISK_REMOVED,
  35       DEVICE_ADDED,
  36       DEVICE_REMOVED,
  37       VOLUME_MOUNTED,
  38       VOLUME_UNMOUNTED,
  39       FORMAT_STARTED,
  40       FORMAT_COMPLETED,
  41     } type;
  42
  43     // Available on DEVICE_ADDED, DEVICE_REMOVED, VOLUME_MOUNTED,
  44     // VOLUME_UNMOUNTED, FORMAT_STARTED and FORMAT_COMPLETED.
  45     std::string device_path;
  46
  47     // Available on DISK_ADDED.
  48     bool mounting;
  49
  50     // Available on VOLUME_MOUNTED and VOLUME_UNMOUNTED.
  51     chromeos::MountError mount_error;
  52
  53     // Available on FORMAT_STARTED and FORMAT_COMPLETED.
  54     bool success;
  55   };
  56
  57   LoggingObserver() {}
  58   virtual ~LoggingObserver() {}
  59
  60   const std::vector<Event>& events() const { return events_; }
  61
  62   // VolumeManagerObserver overrides.
  63   virtual void OnDiskAdded(const chromeos::disks::DiskMountManager::Disk& disk,
  64                            bool mounting) OVERRIDE {
  65     Event event;
  66     event.type = Event::DISK_ADDED;
  67     event.device_path = disk.device_path();  // Keep only device_path.
  68     event.mounting = mounting;
  69     events_.push_back(event);
  70   }
  71
  72   virtual void OnDiskRemoved(
  73       const chromeos::disks::DiskMountManager::Disk& disk) OVERRIDE {
  74     Event event;
  75     event.type = Event::DISK_REMOVED;
  76     event.device_path = disk.device_path();  // Keep only device_path.
  77     events_.push_back(event);
  78   }
  79
  80   virtual void OnDeviceAdded(const std::string& device_path) OVERRIDE {
  81     Event event;
  82     event.type = Event::DEVICE_ADDED;
  83     event.device_path = device_path;
  84     events_.push_back(event);
  85   }
  86
  87   virtual void OnDeviceRemoved(const std::string& device_path) OVERRIDE {
  88     Event event;
  89     event.type = Event::DEVICE_REMOVED;
  90     event.device_path = device_path;
  91     events_.push_back(event);
  92   }
  93
  94   virtual void OnVolumeMounted(chromeos::MountError error_code,
  95                                const VolumeInfo& volume_info) OVERRIDE {
  96     Event event;
  97     event.type = Event::VOLUME_MOUNTED;
  98     event.device_path = volume_info.source_path.AsUTF8Unsafe();
  99     event.mount_error = error_code;
 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   // Helper class that contains per-profile objects.
 141   class ProfileEnvironment {
 142    public:
 143     ProfileEnvironment(chromeos::PowerManagerClient* power_manager_client,
 144                        chromeos::disks::DiskMountManager* disk_manager)
 145         : profile_(new TestingProfile),
 146           extension_registry_(
 147               new extensions::ExtensionRegistry(profile_.get())),
 148           file_system_provider_service_(
 149               new chromeos::file_system_provider::Service(
 150                   profile_.get(),
 151                   extension_registry_.get())),
 152           volume_manager_(
 153               new VolumeManager(profile_.get(),
 154                                 NULL,  // DriveIntegrationService
 155                                 power_manager_client,
 156                                 disk_manager,
 157                                 file_system_provider_service_.get())) {
 158       file_system_provider_service_->SetFileSystemFactoryForTesting(base::Bind(
 159           &chromeos::file_system_provider::FakeProvidedFileSystem::Create));
 160     }
 161
 162     Profile* profile() const { return profile_.get(); }
 163     VolumeManager* volume_manager() const { return volume_manager_.get(); }
 164
 165    private:
 166     scoped_ptr<TestingProfile> profile_;
 167     scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
 168     scoped_ptr<chromeos::file_system_provider::Service>
 169         file_system_provider_service_;
 170     scoped_ptr<VolumeManager> volume_manager_;
 171   };
 172
 173   virtual void SetUp() OVERRIDE {
 174     power_manager_client_.reset(new chromeos::FakePowerManagerClient);
 175     disk_mount_manager_.reset(new FakeDiskMountManager);
 176     main_profile_.reset(new ProfileEnvironment(power_manager_client_.get(),
 177                                                disk_mount_manager_.get()));
 178   }
 179
 180   Profile* profile() const { return main_profile_->profile(); }
 181   VolumeManager* volume_manager() const {
 182     return main_profile_->volume_manager();
 183   }
 184
 185   content::TestBrowserThreadBundle thread_bundle_;
 186   scoped_ptr<chromeos::FakePowerManagerClient> power_manager_client_;
 187   scoped_ptr<FakeDiskMountManager> disk_mount_manager_;
 188   scoped_ptr<ProfileEnvironment> main_profile_;
 189 };
 190
 191 TEST_F(VolumeManagerTest, OnDriveFileSystemMountAndUnmount) {
 192   LoggingObserver observer;
 193   volume_manager()->AddObserver(&observer);
 194
 195   volume_manager()->OnFileSystemMounted();
 196
 197   ASSERT_EQ(1U, observer.events().size());
 198   LoggingObserver::Event event = observer.events()[0];
 199   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 200   EXPECT_EQ(drive::util::GetDriveMountPointPath(profile()).AsUTF8Unsafe(),
 201             event.device_path);
 202   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 203
 204   volume_manager()->OnFileSystemBeingUnmounted();
 205
 206   ASSERT_EQ(2U, observer.events().size());
 207   event = observer.events()[1];
 208   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 209   EXPECT_EQ(drive::util::GetDriveMountPointPath(profile()).AsUTF8Unsafe(),
 210             event.device_path);
 211   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 212
 213   volume_manager()->RemoveObserver(&observer);
 214 }
 215
 216 TEST_F(VolumeManagerTest, OnDriveFileSystemUnmountWithoutMount) {
 217   LoggingObserver observer;
 218   volume_manager()->AddObserver(&observer);
 219   volume_manager()->OnFileSystemBeingUnmounted();
 220
 221   // Unmount event for non-mounted volume is not reported.
 222   ASSERT_EQ(0U, observer.events().size());
 223   volume_manager()->RemoveObserver(&observer);
 224 }
 225
 226 TEST_F(VolumeManagerTest, OnDiskEvent_Hidden) {
 227   LoggingObserver observer;
 228   volume_manager()->AddObserver(&observer);
 229
 230   const bool kIsHidden = true;
 231   const chromeos::disks::DiskMountManager::Disk kDisk(
 232       "device1", "", "", "", "", "", "", "", "", "", "", "",
 233       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false,
 234       kIsHidden);
 235
 236   volume_manager()->OnDiskEvent(
 237       chromeos::disks::DiskMountManager::DISK_ADDED, &kDisk);
 238   EXPECT_EQ(0U, observer.events().size());
 239
 240   volume_manager()->OnDiskEvent(
 241       chromeos::disks::DiskMountManager::DISK_REMOVED, &kDisk);
 242   EXPECT_EQ(0U, observer.events().size());
 243
 244   volume_manager()->OnDiskEvent(
 245       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 246   EXPECT_EQ(0U, observer.events().size());
 247
 248   volume_manager()->RemoveObserver(&observer);
 249 }
 250
 251 TEST_F(VolumeManagerTest, OnDiskEvent_Added) {
 252   // Enable external storage.
 253   profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 254
 255   LoggingObserver observer;
 256   volume_manager()->AddObserver(&observer);
 257
 258   const chromeos::disks::DiskMountManager::Disk kEmptyDevicePathDisk(
 259       "",  // empty device path.
 260       "", "", "", "", "", "", "", "", "", "", "",
 261       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false,
 262       false);
 263   volume_manager()->OnDiskEvent(
 264       chromeos::disks::DiskMountManager::DISK_ADDED, &kEmptyDevicePathDisk);
 265   EXPECT_EQ(0U, observer.events().size());
 266
 267   const bool kHasMedia = true;
 268   const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 269       "device1", "", "", "", "", "", "", "", "", "", "", "",
 270       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, kHasMedia, false, false,
 271       false);
 272   volume_manager()->OnDiskEvent(
 273       chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 274   ASSERT_EQ(1U, observer.events().size());
 275   const LoggingObserver::Event& event = observer.events()[0];
 276   EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 277   EXPECT_EQ("device1", event.device_path);
 278   EXPECT_TRUE(event.mounting);
 279
 280   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 281   const FakeDiskMountManager::MountRequest& mount_request =
 282       disk_mount_manager_->mount_requests()[0];
 283   EXPECT_EQ("device1", mount_request.source_path);
 284   EXPECT_EQ("", mount_request.source_format);
 285   EXPECT_EQ("", mount_request.mount_label);
 286   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 287
 288   volume_manager()->RemoveObserver(&observer);
 289 }
 290
 291 TEST_F(VolumeManagerTest, OnDiskEvent_AddedNonMounting) {
 292   // Enable external storage.
 293   profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 294
 295   // Device which is already mounted.
 296   {
 297     LoggingObserver observer;
 298     volume_manager()->AddObserver(&observer);
 299
 300     const bool kHasMedia = true;
 301     const chromeos::disks::DiskMountManager::Disk kMountedMediaDisk(
 302         "device1", "mounted", "", "", "", "", "", "", "", "", "", "",
 303         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 304         kHasMedia, false, false, false);
 305     volume_manager()->OnDiskEvent(
 306         chromeos::disks::DiskMountManager::DISK_ADDED, &kMountedMediaDisk);
 307     ASSERT_EQ(1U, observer.events().size());
 308     const LoggingObserver::Event& event = observer.events()[0];
 309     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 310     EXPECT_EQ("device1", event.device_path);
 311     EXPECT_FALSE(event.mounting);
 312
 313     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 314
 315     volume_manager()->RemoveObserver(&observer);
 316   }
 317
 318   // Device without media.
 319   {
 320     LoggingObserver observer;
 321     volume_manager()->AddObserver(&observer);
 322
 323     const bool kWithoutMedia = false;
 324     const chromeos::disks::DiskMountManager::Disk kNoMediaDisk(
 325         "device1", "", "", "", "", "", "", "", "", "", "", "",
 326         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 327         kWithoutMedia, false, false, false);
 328     volume_manager()->OnDiskEvent(
 329         chromeos::disks::DiskMountManager::DISK_ADDED, &kNoMediaDisk);
 330     ASSERT_EQ(1U, observer.events().size());
 331     const LoggingObserver::Event& event = observer.events()[0];
 332     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 333     EXPECT_EQ("device1", event.device_path);
 334     EXPECT_FALSE(event.mounting);
 335
 336     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 337
 338     volume_manager()->RemoveObserver(&observer);
 339   }
 340
 341   // External storage is disabled.
 342   {
 343     profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 344
 345     LoggingObserver observer;
 346     volume_manager()->AddObserver(&observer);
 347
 348     const bool kHasMedia = true;
 349     const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 350         "device1", "", "", "", "", "", "", "", "", "", "", "",
 351         chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false,
 352         kHasMedia, false, false, false);
 353     volume_manager()->OnDiskEvent(
 354         chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 355     ASSERT_EQ(1U, observer.events().size());
 356     const LoggingObserver::Event& event = observer.events()[0];
 357     EXPECT_EQ(LoggingObserver::Event::DISK_ADDED, event.type);
 358     EXPECT_EQ("device1", event.device_path);
 359     EXPECT_FALSE(event.mounting);
 360
 361     ASSERT_EQ(0U, disk_mount_manager_->mount_requests().size());
 362
 363     volume_manager()->RemoveObserver(&observer);
 364   }
 365 }
 366
 367 TEST_F(VolumeManagerTest, OnDiskEvent_Removed) {
 368   LoggingObserver observer;
 369   volume_manager()->AddObserver(&observer);
 370
 371   const chromeos::disks::DiskMountManager::Disk kMountedDisk(
 372       "device1", "mount_path", "", "", "", "", "", "", "", "", "", "",
 373       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false,
 374       false);
 375   volume_manager()->OnDiskEvent(
 376       chromeos::disks::DiskMountManager::DISK_REMOVED, &kMountedDisk);
 377
 378   ASSERT_EQ(1U, observer.events().size());
 379   const LoggingObserver::Event& event = observer.events()[0];
 380   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 381   EXPECT_EQ("device1", event.device_path);
 382
 383   ASSERT_EQ(1U, disk_mount_manager_->unmount_requests().size());
 384   const FakeDiskMountManager::UnmountRequest& unmount_request =
 385       disk_mount_manager_->unmount_requests()[0];
 386   EXPECT_EQ("mount_path", unmount_request.mount_path);
 387   EXPECT_EQ(chromeos::UNMOUNT_OPTIONS_LAZY, unmount_request.options);
 388
 389   volume_manager()->RemoveObserver(&observer);
 390 }
 391
 392 TEST_F(VolumeManagerTest, OnDiskEvent_RemovedNotMounted) {
 393   LoggingObserver observer;
 394   volume_manager()->AddObserver(&observer);
 395
 396   const chromeos::disks::DiskMountManager::Disk kNotMountedDisk(
 397       "device1", "", "", "", "", "", "", "", "", "", "", "",
 398       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, false, false, false,
 399       false);
 400   volume_manager()->OnDiskEvent(
 401       chromeos::disks::DiskMountManager::DISK_REMOVED, &kNotMountedDisk);
 402
 403   ASSERT_EQ(1U, observer.events().size());
 404   const LoggingObserver::Event& event = observer.events()[0];
 405   EXPECT_EQ(LoggingObserver::Event::DISK_REMOVED, event.type);
 406   EXPECT_EQ("device1", event.device_path);
 407
 408   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 409
 410   volume_manager()->RemoveObserver(&observer);
 411 }
 412
 413 TEST_F(VolumeManagerTest, OnDiskEvent_Changed) {
 414   // Changed event should cause mounting (if possible).
 415   LoggingObserver observer;
 416   volume_manager()->AddObserver(&observer);
 417
 418   const chromeos::disks::DiskMountManager::Disk kDisk(
 419       "device1", "", "", "", "", "", "", "", "", "", "", "",
 420       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, true, false, false,
 421       false);
 422   volume_manager()->OnDiskEvent(
 423       chromeos::disks::DiskMountManager::DISK_CHANGED, &kDisk);
 424
 425   EXPECT_EQ(1U, observer.events().size());
 426   EXPECT_EQ(1U, disk_mount_manager_->mount_requests().size());
 427   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 428
 429   volume_manager()->RemoveObserver(&observer);
 430 }
 431
 432 TEST_F(VolumeManagerTest, OnDeviceEvent_Added) {
 433   LoggingObserver observer;
 434   volume_manager()->AddObserver(&observer);
 435
 436   volume_manager()->OnDeviceEvent(
 437       chromeos::disks::DiskMountManager::DEVICE_ADDED, "device1");
 438
 439   ASSERT_EQ(1U, observer.events().size());
 440   const LoggingObserver::Event& event = observer.events()[0];
 441   EXPECT_EQ(LoggingObserver::Event::DEVICE_ADDED, event.type);
 442   EXPECT_EQ("device1", event.device_path);
 443
 444   volume_manager()->RemoveObserver(&observer);
 445 }
 446
 447 TEST_F(VolumeManagerTest, OnDeviceEvent_Removed) {
 448   LoggingObserver observer;
 449   volume_manager()->AddObserver(&observer);
 450
 451   volume_manager()->OnDeviceEvent(
 452       chromeos::disks::DiskMountManager::DEVICE_REMOVED, "device1");
 453
 454   ASSERT_EQ(1U, observer.events().size());
 455   const LoggingObserver::Event& event = observer.events()[0];
 456   EXPECT_EQ(LoggingObserver::Event::DEVICE_REMOVED, event.type);
 457   EXPECT_EQ("device1", event.device_path);
 458
 459   volume_manager()->RemoveObserver(&observer);
 460 }
 461
 462 TEST_F(VolumeManagerTest, OnDeviceEvent_Scanned) {
 463   LoggingObserver observer;
 464   volume_manager()->AddObserver(&observer);
 465
 466   volume_manager()->OnDeviceEvent(
 467       chromeos::disks::DiskMountManager::DEVICE_SCANNED, "device1");
 468
 469   // SCANNED event is just ignored.
 470   EXPECT_EQ(0U, observer.events().size());
 471
 472   volume_manager()->RemoveObserver(&observer);
 473 }
 474
 475 TEST_F(VolumeManagerTest, OnMountEvent_MountingAndUnmounting) {
 476   LoggingObserver observer;
 477   volume_manager()->AddObserver(&observer);
 478
 479   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 480       "device1",
 481       "mount1",
 482       chromeos::MOUNT_TYPE_DEVICE,
 483       chromeos::disks::MOUNT_CONDITION_NONE);
 484
 485   volume_manager()->OnMountEvent(chromeos::disks::DiskMountManager::MOUNTING,
 486                                 chromeos::MOUNT_ERROR_NONE,
 487                                 kMountPoint);
 488
 489   ASSERT_EQ(1U, observer.events().size());
 490   LoggingObserver::Event event = observer.events()[0];
 491   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 492   EXPECT_EQ("device1", event.device_path);
 493   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 494
 495   volume_manager()->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
 496                                 chromeos::MOUNT_ERROR_NONE,
 497                                 kMountPoint);
 498
 499   ASSERT_EQ(2U, observer.events().size());
 500   event = observer.events()[1];
 501   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED, event.type);
 502   EXPECT_EQ("device1", event.device_path);
 503   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 504
 505   volume_manager()->RemoveObserver(&observer);
 506 }
 507
 508 TEST_F(VolumeManagerTest, OnMountEvent_Remounting) {
 509   scoped_ptr<chromeos::disks::DiskMountManager::Disk> disk(
 510       new chromeos::disks::DiskMountManager::Disk(
 511           "device1", "", "", "", "", "", "", "", "", "", "uuid1", "",
 512           chromeos::DEVICE_TYPE_UNKNOWN, 0,
 513           false, false, false, false, false, false));
 514   disk_mount_manager_->AddDiskForTest(disk.release());
 515   disk_mount_manager_->MountPath(
 516       "device1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 517
 518   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 519       "device1",
 520       "mount1",
 521       chromeos::MOUNT_TYPE_DEVICE,
 522       chromeos::disks::MOUNT_CONDITION_NONE);
 523
 524   volume_manager()->OnMountEvent(
 525       chromeos::disks::DiskMountManager::MOUNTING,
 526       chromeos::MOUNT_ERROR_NONE,
 527       kMountPoint);
 528
 529   LoggingObserver observer;
 530
 531   // Emulate system suspend and then resume.
 532   {
 533     power_manager_client_->SendSuspendImminent();
 534     power_manager_client_->SendSuspendDone();
 535
 536     // After resume, the device is unmounted and then mounted.
 537     volume_manager()->OnMountEvent(
 538         chromeos::disks::DiskMountManager::UNMOUNTING,
 539         chromeos::MOUNT_ERROR_NONE,
 540         kMountPoint);
 541
 542     // Observe what happened for the mount event.
 543     volume_manager()->AddObserver(&observer);
 544
 545     volume_manager()->OnMountEvent(
 546         chromeos::disks::DiskMountManager::MOUNTING,
 547         chromeos::MOUNT_ERROR_NONE,
 548         kMountPoint);
 549   }
 550
 551   ASSERT_EQ(1U, observer.events().size());
 552   const LoggingObserver::Event& event = observer.events()[0];
 553   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, event.type);
 554   EXPECT_EQ("device1", event.device_path);
 555   EXPECT_EQ(chromeos::MOUNT_ERROR_NONE, event.mount_error);
 556
 557   volume_manager()->RemoveObserver(&observer);
 558 }
 559
 560 TEST_F(VolumeManagerTest, OnMountEvent_UnmountingWithoutMounting) {
 561   LoggingObserver observer;
 562   volume_manager()->AddObserver(&observer);
 563
 564   const chromeos::disks::DiskMountManager::MountPointInfo kMountPoint(
 565       "device1",
 566       "mount1",
 567       chromeos::MOUNT_TYPE_DEVICE,
 568       chromeos::disks::MOUNT_CONDITION_NONE);
 569
 570   volume_manager()->OnMountEvent(chromeos::disks::DiskMountManager::UNMOUNTING,
 571                                 chromeos::MOUNT_ERROR_NONE,
 572                                 kMountPoint);
 573
 574   // Unmount event for a disk not mounted in this manager is not reported.
 575   ASSERT_EQ(0U, observer.events().size());
 576
 577   volume_manager()->RemoveObserver(&observer);
 578 }
 579
 580 TEST_F(VolumeManagerTest, OnFormatEvent_Started) {
 581   LoggingObserver observer;
 582   volume_manager()->AddObserver(&observer);
 583
 584   volume_manager()->OnFormatEvent(
 585       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 586       chromeos::FORMAT_ERROR_NONE,
 587       "device1");
 588
 589   ASSERT_EQ(1U, observer.events().size());
 590   const LoggingObserver::Event& event = observer.events()[0];
 591   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 592   EXPECT_EQ("device1", event.device_path);
 593   EXPECT_TRUE(event.success);
 594
 595   volume_manager()->RemoveObserver(&observer);
 596 }
 597
 598 TEST_F(VolumeManagerTest, OnFormatEvent_StartFailed) {
 599   LoggingObserver observer;
 600   volume_manager()->AddObserver(&observer);
 601
 602   volume_manager()->OnFormatEvent(
 603       chromeos::disks::DiskMountManager::FORMAT_STARTED,
 604       chromeos::FORMAT_ERROR_UNKNOWN,
 605       "device1");
 606
 607   ASSERT_EQ(1U, observer.events().size());
 608   const LoggingObserver::Event& event = observer.events()[0];
 609   EXPECT_EQ(LoggingObserver::Event::FORMAT_STARTED, event.type);
 610   EXPECT_EQ("device1", event.device_path);
 611   EXPECT_FALSE(event.success);
 612
 613   volume_manager()->RemoveObserver(&observer);
 614 }
 615
 616 TEST_F(VolumeManagerTest, OnFormatEvent_Completed) {
 617   LoggingObserver observer;
 618   volume_manager()->AddObserver(&observer);
 619
 620   volume_manager()->OnFormatEvent(
 621       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 622       chromeos::FORMAT_ERROR_NONE,
 623       "device1");
 624
 625   ASSERT_EQ(1U, observer.events().size());
 626   const LoggingObserver::Event& event = observer.events()[0];
 627   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 628   EXPECT_EQ("device1", event.device_path);
 629   EXPECT_TRUE(event.success);
 630
 631   // When "format" is successfully done, VolumeManager requests to mount it.
 632   ASSERT_EQ(1U, disk_mount_manager_->mount_requests().size());
 633   const FakeDiskMountManager::MountRequest& mount_request =
 634       disk_mount_manager_->mount_requests()[0];
 635   EXPECT_EQ("device1", mount_request.source_path);
 636   EXPECT_EQ("", mount_request.source_format);
 637   EXPECT_EQ("", mount_request.mount_label);
 638   EXPECT_EQ(chromeos::MOUNT_TYPE_DEVICE, mount_request.type);
 639
 640   volume_manager()->RemoveObserver(&observer);
 641 }
 642
 643 TEST_F(VolumeManagerTest, OnFormatEvent_CompletedFailed) {
 644   LoggingObserver observer;
 645   volume_manager()->AddObserver(&observer);
 646
 647   volume_manager()->OnFormatEvent(
 648       chromeos::disks::DiskMountManager::FORMAT_COMPLETED,
 649       chromeos::FORMAT_ERROR_UNKNOWN,
 650       "device1");
 651
 652   ASSERT_EQ(1U, observer.events().size());
 653   const LoggingObserver::Event& event = observer.events()[0];
 654   EXPECT_EQ(LoggingObserver::Event::FORMAT_COMPLETED, event.type);
 655   EXPECT_EQ("device1", event.device_path);
 656   EXPECT_FALSE(event.success);
 657
 658   EXPECT_EQ(0U, disk_mount_manager_->mount_requests().size());
 659
 660   volume_manager()->RemoveObserver(&observer);
 661 }
 662
 663 TEST_F(VolumeManagerTest, OnExternalStorageDisabledChanged) {
 664   // Here create two mount points.
 665   disk_mount_manager_->MountPath(
 666       "mount1", "", "", chromeos::MOUNT_TYPE_DEVICE);
 667   disk_mount_manager_->MountPath(
 668       "mount2", "", "", chromeos::MOUNT_TYPE_DEVICE);
 669
 670   // Initially, there are two mount points.
 671   ASSERT_EQ(2U, disk_mount_manager_->mount_points().size());
 672   ASSERT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 673
 674   // Emulate to set kExternalStorageDisabled to false.
 675   profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 676   volume_manager()->OnExternalStorageDisabledChanged();
 677
 678   // Expect no effects.
 679   EXPECT_EQ(2U, disk_mount_manager_->mount_points().size());
 680   EXPECT_EQ(0U, disk_mount_manager_->unmount_requests().size());
 681
 682   // Emulate to set kExternalStorageDisabled to true.
 683   profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, true);
 684   volume_manager()->OnExternalStorageDisabledChanged();
 685
 686   // The all mount points should be unmounted.
 687   EXPECT_EQ(0U, disk_mount_manager_->mount_points().size());
 688
 689   EXPECT_EQ(2U, disk_mount_manager_->unmount_requests().size());
 690   const FakeDiskMountManager::UnmountRequest& unmount_request1 =
 691       disk_mount_manager_->unmount_requests()[0];
 692   EXPECT_EQ("mount1", unmount_request1.mount_path);
 693
 694   const FakeDiskMountManager::UnmountRequest& unmount_request2 =
 695       disk_mount_manager_->unmount_requests()[1];
 696   EXPECT_EQ("mount2", unmount_request2.mount_path);
 697 }
 698
 699 TEST_F(VolumeManagerTest, ExternalStorageDisabledPolicyMultiProfile) {
 700   ProfileEnvironment secondary(power_manager_client_.get(),
 701                                disk_mount_manager_.get());
 702   volume_manager()->Initialize();
 703   secondary.volume_manager()->Initialize();
 704
 705   // Simulates the case that the main profile has kExternalStorageDisabled set
 706   // as false, and the secondary profile has the config set to true.
 707   profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled, false);
 708   secondary.profile()->GetPrefs()->SetBoolean(prefs::kExternalStorageDisabled,
 709                                               true);
 710
 711   LoggingObserver main_observer, secondary_observer;
 712   volume_manager()->AddObserver(&main_observer);
 713   secondary.volume_manager()->AddObserver(&secondary_observer);
 714
 715   // Add 1 disk.
 716   const chromeos::disks::DiskMountManager::Disk kMediaDisk(
 717       "device1", "", "", "", "", "", "", "", "", "", "", "",
 718       chromeos::DEVICE_TYPE_UNKNOWN, 0, false, false, true, false, false,
 719       false);
 720   volume_manager()->OnDiskEvent(
 721       chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 722   secondary.volume_manager()->OnDiskEvent(
 723       chromeos::disks::DiskMountManager::DISK_ADDED, &kMediaDisk);
 724
 725   // The profile with external storage enabled should have mounted the volume.
 726   bool has_volume_mounted = false;
 727   for (size_t i = 0; i < main_observer.events().size(); ++i) {
 728     if (main_observer.events()[i].type ==
 729         LoggingObserver::Event::VOLUME_MOUNTED)
 730       has_volume_mounted = true;
 731   }
 732   EXPECT_TRUE(has_volume_mounted);
 733
 734   // The other profiles with external storage disabled should have not.
 735   has_volume_mounted = false;
 736   for (size_t i = 0; i < secondary_observer.events().size(); ++i) {
 737     if (secondary_observer.events()[i].type ==
 738         LoggingObserver::Event::VOLUME_MOUNTED)
 739       has_volume_mounted = true;
 740   }
 741   EXPECT_FALSE(has_volume_mounted);
 742
 743   volume_manager()->RemoveObserver(&main_observer);
 744   secondary.volume_manager()->RemoveObserver(&secondary_observer);
 745 }
 746
 747 TEST_F(VolumeManagerTest, GetVolumeInfoList) {
 748   volume_manager()->Initialize();  // Adds "Downloads"
 749   std::vector<VolumeInfo> info_list = volume_manager()->GetVolumeInfoList();
 750   ASSERT_EQ(1u, info_list.size());
 751   EXPECT_EQ("downloads:Downloads", info_list[0].volume_id);
 752   EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, info_list[0].type);
 753 }
 754
 755 TEST_F(VolumeManagerTest, FindVolumeInfoById) {
 756   volume_manager()->Initialize();  // Adds "Downloads"
 757   VolumeInfo volume_info;
 758   ASSERT_FALSE(volume_manager()->FindVolumeInfoById(
 759       "nonexistent", &volume_info));
 760   ASSERT_TRUE(volume_manager()->FindVolumeInfoById(
 761       "downloads:Downloads", &volume_info));
 762   EXPECT_EQ("downloads:Downloads", volume_info.volume_id);
 763   EXPECT_EQ(VOLUME_TYPE_DOWNLOADS_DIRECTORY, volume_info.type);
 764 }
 765
 766 TEST_F(VolumeManagerTest, ArchiveSourceFiltering) {
 767   LoggingObserver observer;
 768   volume_manager()->AddObserver(&observer);
 769
 770   // Mount a USB stick.
 771   volume_manager()->OnMountEvent(
 772       chromeos::disks::DiskMountManager::MOUNTING,
 773       chromeos::MOUNT_ERROR_NONE,
 774       chromeos::disks::DiskMountManager::MountPointInfo(
 775           "/removable/usb",
 776           "/removable/usb",
 777           chromeos::MOUNT_TYPE_DEVICE,
 778           chromeos::disks::MOUNT_CONDITION_NONE));
 779
 780   // Mount a zip archive in the stick.
 781   volume_manager()->OnMountEvent(
 782       chromeos::disks::DiskMountManager::MOUNTING,
 783       chromeos::MOUNT_ERROR_NONE,
 784       chromeos::disks::DiskMountManager::MountPointInfo(
 785           "/removable/usb/1.zip",
 786           "/archive/1",
 787           chromeos::MOUNT_TYPE_ARCHIVE,
 788           chromeos::disks::MOUNT_CONDITION_NONE));
 789   VolumeInfo volume_info;
 790   ASSERT_TRUE(volume_manager()->FindVolumeInfoById("archive:1", &volume_info));
 791   EXPECT_EQ("/archive/1", volume_info.mount_path.AsUTF8Unsafe());
 792   EXPECT_EQ(2u, observer.events().size());
 793
 794   // Mount a zip archive in the previous zip archive.
 795   volume_manager()->OnMountEvent(
 796       chromeos::disks::DiskMountManager::MOUNTING,
 797       chromeos::MOUNT_ERROR_NONE,
 798       chromeos::disks::DiskMountManager::MountPointInfo(
 799           "/archive/1/2.zip",
 800           "/archive/2",
 801           chromeos::MOUNT_TYPE_ARCHIVE,
 802           chromeos::disks::MOUNT_CONDITION_NONE));
 803   ASSERT_TRUE(volume_manager()->FindVolumeInfoById("archive:2", &volume_info));
 804   EXPECT_EQ("/archive/2", volume_info.mount_path.AsUTF8Unsafe());
 805   EXPECT_EQ(3u, observer.events().size());
 806
 807   // A zip file is mounted from other profile. It must be ignored in the current
 808   // VolumeManager.
 809   volume_manager()->OnMountEvent(
 810       chromeos::disks::DiskMountManager::MOUNTING,
 811       chromeos::MOUNT_ERROR_NONE,
 812       chromeos::disks::DiskMountManager::MountPointInfo(
 813           "/other/profile/drive/folder/3.zip",
 814           "/archive/3",
 815           chromeos::MOUNT_TYPE_ARCHIVE,
 816           chromeos::disks::MOUNT_CONDITION_NONE));
 817   EXPECT_FALSE(volume_manager()->FindVolumeInfoById("archive:3", &volume_info));
 818   EXPECT_EQ(3u, observer.events().size());
 819 }
 820
 821 TEST_F(VolumeManagerTest, MTPPlugAndUnplug) {
 822   LoggingObserver observer;
 823   volume_manager()->AddObserver(&observer);
 824
 825   storage_monitor::StorageInfo info(
 826       storage_monitor::StorageInfo::MakeDeviceId(
 827           storage_monitor::StorageInfo::MTP_OR_PTP, "dummy-device-id"),
 828       FILE_PATH_LITERAL("/dummy/device/location"),
 829       base::UTF8ToUTF16("label"),
 830       base::UTF8ToUTF16("vendor"),
 831       base::UTF8ToUTF16("model"),
 832       12345 /* size */);
 833
 834   storage_monitor::StorageInfo non_mtp_info(
 835       storage_monitor::StorageInfo::MakeDeviceId(
 836           storage_monitor::StorageInfo::IPHOTO, "dummy-device-id2"),
 837       FILE_PATH_LITERAL("/dummy/device/location2"),
 838       base::UTF8ToUTF16("label2"),
 839       base::UTF8ToUTF16("vendor2"),
 840       base::UTF8ToUTF16("model2"),
 841       12345 /* size */);
 842
 843   // Attach
 844   volume_manager()->OnRemovableStorageAttached(info);
 845   ASSERT_EQ(1u, observer.events().size());
 846   EXPECT_EQ(LoggingObserver::Event::VOLUME_MOUNTED, observer.events()[0].type);
 847
 848   VolumeInfo volume_info;
 849   ASSERT_TRUE(volume_manager()->FindVolumeInfoById("mtp:model", &volume_info));
 850   EXPECT_EQ(VOLUME_TYPE_MTP, volume_info.type);
 851
 852   // Non MTP events from storage monitor are ignored.
 853   volume_manager()->OnRemovableStorageAttached(non_mtp_info);
 854   EXPECT_EQ(1u, observer.events().size());
 855
 856   // Detach
 857   volume_manager()->OnRemovableStorageDetached(info);
 858   ASSERT_EQ(2u, observer.events().size());
 859   EXPECT_EQ(LoggingObserver::Event::VOLUME_UNMOUNTED,
 860             observer.events()[1].type);
 861
 862   EXPECT_FALSE(volume_manager()->FindVolumeInfoById("mtp:model", &volume_info));
 863 }
 864
 865 }  // namespace file_manager