Files.app: Remove MountedDiskMonitor.

chrome/browser/chromeos/file_manager/volume_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system_interface.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/file_manager/mounted_disk_monitor.h"
 #include "chrome/browser/chromeos/file_manager/path_util.h"
 #include "chrome/browser/chromeos/file_manager/snapshot_manager.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager_factory.h"
 #include "chrome/browser/chromeos/file_manager/volume_manager_observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/local_discovery/storage/privet_filesystem_constants.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/disks/disk_mount_manager.h"
 #include "components/storage_monitor/storage_monitor.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 namespace file_manager {
 namespace {
 
-// A named constant to be passed to the |is_remounting| parameter.
-const bool kNotRemounting = false;
-
 const char kFileManagerMTPMountNamePrefix[] = "fileman-mtp-";
 const char kMtpVolumeIdPrefix [] = "mtp:";
 
 // Registers |path| as the "Downloads" folder to the FileSystem API backend.
 // If another folder is already mounted. It revokes and overrides the old one.
 bool RegisterDownloadsMountPoint(Profile* profile, const base::FilePath& path) {
   // Although we show only profile's own "Downloads" folder in Files.app,
   // in the backend we need to mount all profile's download directory globally.
   // Otherwise, Files.app cannot support cross-profile file copies, etc.
   // For this reason, we need to register to the global GetSystemInstance().
@@ skipping 194 matching lines @@
 
 VolumeManager::VolumeManager(
     Profile* profile,
     drive::DriveIntegrationService* drive_integration_service,
     chromeos::PowerManagerClient* power_manager_client,
     chromeos::disks::DiskMountManager* disk_mount_manager,
     chromeos::file_system_provider::Service* file_system_provider_service)
     : profile_(profile),
       drive_integration_service_(drive_integration_service),
       disk_mount_manager_(disk_mount_manager),
-      mounted_disk_monitor_(new MountedDiskMonitor(power_manager_client)),
       file_system_provider_service_(file_system_provider_service),
       snapshot_manager_(new SnapshotManager(profile_)),
       weak_ptr_factory_(this) {
   DCHECK(disk_mount_manager);
 }
 
 VolumeManager::~VolumeManager() {
 }
 
 VolumeManager* VolumeManager::Get(content::BrowserContext* context) {
@@ skipping 20 matching lines @@
                                       new_path);
   }
 
   // Register 'Downloads' folder for the profile to the file system.
   const base::FilePath downloads =
       file_manager::util::GetDownloadsFolderForProfile(profile_);
   const bool success = RegisterDownloadsMountPoint(profile_, downloads);
   DCHECK(success);
 
   DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-               CreateDownloadsVolumeInfo(downloads),
-               kNotRemounting);
+               CreateDownloadsVolumeInfo(downloads));
 
   // Subscribe to DriveIntegrationService.
   if (drive_integration_service_) {
     drive_integration_service_->AddObserver(this);
     if (drive_integration_service_->IsMounted()) {
       DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                   CreateDriveVolumeInfo(profile_),
-                   kNotRemounting);
+                   CreateDriveVolumeInfo(profile_));
     }
   }
 
   // Subscribe to DiskMountManager.
   disk_mount_manager_->AddObserver(this);
   disk_mount_manager_->EnsureMountInfoRefreshed(
       base::Bind(&VolumeManager::OnDiskMountManagerRefreshed,
                  weak_ptr_factory_.GetWeakPtr()));
 
   // Subscribe to FileSystemProviderService and register currently mounted
   // volumes for the profile.
   if (file_system_provider_service_) {
     using chromeos::file_system_provider::ProvidedFileSystemInfo;
     file_system_provider_service_->AddObserver(this);
 
     std::vector<ProvidedFileSystemInfo> file_system_info_list =
         file_system_provider_service_->GetProvidedFileSystemInfoList();
     for (size_t i = 0; i < file_system_info_list.size(); ++i) {
       VolumeInfo volume_info =
           CreateProvidedFileSystemVolumeInfo(file_system_info_list[i]);
-      DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, kNotRemounting);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
     }
   }
 
   // Subscribe to Profile Preference change.
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kExternalStorageDisabled,
       base::Bind(&VolumeManager::OnExternalStorageDisabledChanged,
                  weak_ptr_factory_.GetWeakPtr()));
 
@@ skipping 77 matching lines @@
 
   base::FilePath old_path;
   if (FindDownloadsMountPointPath(profile_, &old_path)) {
     DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
                    CreateDownloadsVolumeInfo(old_path));
   }
 
   bool success = RegisterDownloadsMountPoint(profile_, path);
   DoMountEvent(
       success ? chromeos::MOUNT_ERROR_NONE : chromeos::MOUNT_ERROR_INVALID_PATH,
-      CreateDownloadsVolumeInfo(path),
-      kNotRemounting);
+      CreateDownloadsVolumeInfo(path));
   return success;
 }
 
 void VolumeManager::AddVolumeInfoForTesting(const base::FilePath& path,
                                             VolumeType volume_type,
                                             chromeos::DeviceType device_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-               CreateTestingVolumeInfo(path, volume_type, device_type),
-               kNotRemounting);
+               CreateTestingVolumeInfo(path, volume_type, device_type));
 }
 
 void VolumeManager::OnFileSystemMounted() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Raise mount event.
   // We can pass chromeos::MOUNT_ERROR_NONE even when authentication is failed
   // or network is unreachable. These two errors will be handled later.
   VolumeInfo volume_info = CreateDriveVolumeInfo(profile_);
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, kNotRemounting);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
 }
 
 void VolumeManager::OnFileSystemBeingUnmounted() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   VolumeInfo volume_info = CreateDriveVolumeInfo(profile_);
   DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
 }
 
 void VolumeManager::OnDiskEvent(
     chromeos::disks::DiskMountManager::DiskEvent event,
     const chromeos::disks::DiskMountManager::Disk* disk) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  mounted_disk_monitor_->OnDiskEvent(event, disk);
-
   // Disregard hidden devices.
   if (disk->is_hidden())
     return;
 
   switch (event) {
     case chromeos::disks::DiskMountManager::DISK_ADDED:
     case chromeos::disks::DiskMountManager::DISK_CHANGED: {
       if (disk->device_path().empty()) {
         DVLOG(1) << "Empty system path for " << disk->device_path();
         return;
@@ skipping 24 matching lines @@
       if (!disk->mount_path().empty()) {
         disk_mount_manager_->UnmountPath(
             disk->mount_path(),
             chromeos::UNMOUNT_OPTIONS_LAZY,
             chromeos::disks::DiskMountManager::UnmountPathCallback());
       }
 
       // Notify to observers.
       FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                         OnDiskRemoved(*disk));
-      const std::string& device_path = disk->system_path_prefix();
-      if (mounted_disk_monitor_->DeviceIsHardUnpluggedButNotReported(
-              device_path)) {
-        mounted_disk_monitor_->MarkAsHardUnpluggedReported(device_path);
-      }
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnDeviceEvent(
     chromeos::disks::DiskMountManager::DeviceEvent event,
     const std::string& device_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  mounted_disk_monitor_->OnDeviceEvent(event, device_path);
-
   DVLOG(1) << "OnDeviceEvent: " << event << ", " << device_path;
   switch (event) {
     case chromeos::disks::DiskMountManager::DEVICE_ADDED:
       FOR_EACH_OBSERVER(VolumeManagerObserver, observers_,
                         OnDeviceAdded(device_path));
       return;
     case chromeos::disks::DiskMountManager::DEVICE_REMOVED: {
       FOR_EACH_OBSERVER(
           VolumeManagerObserver, observers_, OnDeviceRemoved(device_path));
       return;
     }
     case chromeos::disks::DiskMountManager::DEVICE_SCANNED:
       DVLOG(1) << "Ignore SCANNED event: " << device_path;
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnMountEvent(
     chromeos::disks::DiskMountManager::MountEvent event,
     chromeos::MountError error_code,
     const chromeos::disks::DiskMountManager::MountPointInfo& mount_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK_NE(chromeos::MOUNT_TYPE_INVALID, mount_info.mount_type);
 
-  const chromeos::disks::DiskMountManager::Disk* disk =
-      disk_mount_manager_->FindDiskBySourcePath(mount_info.source_path);
-  mounted_disk_monitor_->OnMountEvent(event, error_code, mount_info, disk);
-
   if (mount_info.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
     // If the file is not mounted now, tell it to drive file system so that
     // it can handle file caching correctly.
     // Note that drive file system knows if the file is managed by drive file
     // system or not, so here we report all paths.
     if ((event == chromeos::disks::DiskMountManager::MOUNTING &&
          error_code != chromeos::MOUNT_ERROR_NONE) ||
         (event == chromeos::disks::DiskMountManager::UNMOUNTING &&
          error_code == chromeos::MOUNT_ERROR_NONE)) {
-      drive::FileSystemInterface* file_system =
+      drive::FileSystemInterface* const file_system =
           drive::util::GetFileSystemByProfile(profile_);
       if (file_system) {
         file_system->MarkCacheFileAsUnmounted(
             base::FilePath(mount_info.source_path),
             base::Bind(&drive::util::EmptyFileOperationCallback));
       }
     }
   }
 
   // Notify a mounting/unmounting event to observers.
-  VolumeInfo volume_info =
+  const chromeos::disks::DiskMountManager::Disk* const disk =
+      disk_mount_manager_->FindDiskBySourcePath(mount_info.source_path);
+  const VolumeInfo volume_info =
       CreateVolumeInfoFromMountPointInfo(mount_info, disk);
   switch (event) {
     case chromeos::disks::DiskMountManager::MOUNTING: {
-      bool is_remounting =
-          disk && mounted_disk_monitor_->DiskIsRemounting(*disk);
-      DoMountEvent(error_code, volume_info, is_remounting);
+      DoMountEvent(error_code, volume_info);
       return;
     }
     case chromeos::disks::DiskMountManager::UNMOUNTING:
       DoUnmountEvent(error_code, volume_info);
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnFormatEvent(
@@ skipping 35 matching lines @@
 void VolumeManager::OnProvidedFileSystemMount(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     base::File::Error error) {
   VolumeInfo volume_info = CreateProvidedFileSystemVolumeInfo(file_system_info);
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   const chromeos::MountError mount_error = error == base::File::FILE_OK
                                                ? chromeos::MOUNT_ERROR_NONE
                                                : chromeos::MOUNT_ERROR_UNKNOWN;
-  DoMountEvent(mount_error, volume_info, kNotRemounting);
+  DoMountEvent(mount_error, volume_info);
 }
 
 void VolumeManager::OnProvidedFileSystemUnmount(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     base::File::Error error) {
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   const chromeos::MountError mount_error = error == base::File::FILE_OK
                                                ? chromeos::MOUNT_ERROR_NONE
@@ skipping 19 matching lines @@
           chromeos::disks::DiskMountManager::UnmountPathCallback());
     }
   }
 }
 
 void VolumeManager::OnPrivetVolumesAvailable(
     const local_discovery::PrivetVolumeLister::VolumeList& volumes) {
   for (local_discovery::PrivetVolumeLister::VolumeList::const_iterator i =
            volumes.begin(); i != volumes.end(); i++) {
     VolumeInfo volume_info = CreatePrivetVolumeInfo(*i);
-    DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, false);
+    DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
   }
 }
 
 void VolumeManager::OnRemovableStorageAttached(
     const storage_monitor::StorageInfo& info) {
   if (!storage_monitor::StorageInfo::IsMTPDevice(info.device_id()))
     return;
   if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled))
     return;
 
@@ skipping 22 matching lines @@
   VolumeInfo volume_info;
   volume_info.type = VOLUME_TYPE_MTP;
   volume_info.mount_path = path;
   volume_info.mount_condition = chromeos::disks::MOUNT_CONDITION_NONE;
   volume_info.is_parent = true;
   volume_info.is_read_only = true;
   volume_info.volume_id = kMtpVolumeIdPrefix + label;
   volume_info.volume_label = label;
   volume_info.source_path = path;
   volume_info.device_type = chromeos::DEVICE_TYPE_MOBILE;
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info, false);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume_info);
 }
 
 void VolumeManager::OnRemovableStorageDetached(
     const storage_monitor::StorageInfo& info) {
   if (!storage_monitor::StorageInfo::IsMTPDevice(info.device_id()))
     return;
 
   for (std::map<std::string, VolumeInfo>::iterator it =
            mounted_volumes_.begin(); it != mounted_volumes_.end(); ++it) {
     if (it->second.source_path.value() == info.location()) {
@@ skipping 27 matching lines @@
        ++it) {
     if (it->second.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
       // Archives are mounted after other types of volume. See below.
       archives.push_back(CreateVolumeInfoFromMountPointInfo(it->second, NULL));
       continue;
     }
     DoMountEvent(
         chromeos::MOUNT_ERROR_NONE,
         CreateVolumeInfoFromMountPointInfo(
             it->second,
-            disk_mount_manager_->FindDiskBySourcePath(it->second.source_path)),
-            kNotRemounting);
+            disk_mount_manager_->FindDiskBySourcePath(it->second.source_path)));
   }
 
   // We mount archives only if they are opened from currently mounted volumes.
   // To check the condition correctly in DoMountEvent, we care about the order.
   std::vector<bool> done(archives.size(), false);
   for (size_t i = 0; i < archives.size(); ++i) {
     if (done[i])
       continue;
 
     std::vector<VolumeInfo> chain;
     done[i] = true;
     chain.push_back(archives[i]);
 
     // If archives[i]'s source_path is in another archive, mount it first.
     for (size_t parent = i + 1; parent < archives.size(); ++parent) {
       if (!done[parent] &&
           archives[parent].mount_path.IsParent(chain.back().source_path)) {
         done[parent] = true;
         chain.push_back(archives[parent]);
         parent = i + 1;  // Search archives[parent]'s parent from the beginning.
       }
     }
 
     // Mount from the tail of chain.
     for (size_t i = chain.size(); i > 0; --i)
-      DoMountEvent(chromeos::MOUNT_ERROR_NONE, chain[i - 1], kNotRemounting);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE, chain[i - 1]);
   }
 }
 
 void VolumeManager::OnStorageMonitorInitialized() {
   std::vector<storage_monitor::StorageInfo> storages =
       storage_monitor::StorageMonitor::GetInstance()->GetAllAvailableStorages();
   for (size_t i = 0; i < storages.size(); ++i)
     OnRemovableStorageAttached(storages[i]);
   storage_monitor::StorageMonitor::GetInstance()->AddObserver(this);
 }
 
 void VolumeManager::DoMountEvent(chromeos::MountError error_code,
-                                 const VolumeInfo& volume_info,
-                                 bool is_remounting) {
+                                 const VolumeInfo& volume_info) {
   // Archive files are mounted globally in system. We however don't want to show
   // archives from profile-specific folders (Drive/Downloads) of other users in
   // multi-profile session. To this end, we filter out archives not on the
   // volumes already mounted on this VolumeManager instance.
   if (volume_info.type == VOLUME_TYPE_MOUNTED_ARCHIVE_FILE) {
     // Source may be in Drive cache folder under the current profile directory.
     bool from_current_profile =
         profile_->GetPath().IsParent(volume_info.source_path);
     for (std::map<std::string, VolumeInfo>::const_iterator iter =
              mounted_volumes_.begin();
          !from_current_profile && iter != mounted_volumes_.end();
          ++iter) {
       if (iter->second.mount_path.IsParent(volume_info.source_path))
         from_current_profile = true;
     }
     if (!from_current_profile)
       return;
   }
 
   // Filter out removable disks if forbidden by policy for this profile.
   if (volume_info.type == VOLUME_TYPE_REMOVABLE_DISK_PARTITION &&
       profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     return;
   }
 
   if (error_code == chromeos::MOUNT_ERROR_NONE || volume_info.mount_condition) {
     mounted_volumes_[volume_info.volume_id] = volume_info;
 
-    if (!is_remounting) {
-      UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType",
-                                volume_info.type,
-                                NUM_VOLUME_TYPE);
-    }
+
+    UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType",
+                              volume_info.type,
+                              NUM_VOLUME_TYPE);
   }
 
   FOR_EACH_OBSERVER(VolumeManagerObserver,
                     observers_,
-                    OnVolumeMounted(error_code, volume_info, is_remounting));
+                    OnVolumeMounted(error_code, volume_info));
 }
 
 void VolumeManager::DoUnmountEvent(chromeos::MountError error_code,
                                    const VolumeInfo& volume_info) {
   if (mounted_volumes_.find(volume_info.volume_id) == mounted_volumes_.end())
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
     mounted_volumes_.erase(volume_info.volume_id);
 
   FOR_EACH_OBSERVER(VolumeManagerObserver,
                     observers_,
                     OnVolumeUnmounted(error_code, volume_info));
 }
 
 }  // namespace file_manager