Google Git
Sign in
chromium / chromium / src / main / . / chrome / browser / ash / file_manager / volume_manager.cc
blob: f613d80517e7b2341dda9e594ae6300837e22759 [file] [log] [blame]
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/file_manager/volume_manager.h"
#include <optional>
#include <string_view>
#include "ash/constants/ash_features.h"
#include "base/auto_reset.h"
#include "base/base64url.h"
#include "base/check_deref.h"
#include "base/check_is_test.h"
#include "base/containers/span.h"
#include "base/feature_list.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/pickle.h"
#include "base/strings/strcat.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/system/sys_info.h"
#include "base/task/thread_pool.h"
#include "base/types/optional_util.h"
#include "chrome/browser/ash/arc/arc_util.h"
#include "chrome/browser/ash/arc/fileapi/arc_documents_provider_root_map.h"
#include "chrome/browser/ash/arc/fileapi/arc_documents_provider_util.h"
#include "chrome/browser/ash/arc/fileapi/arc_file_system_operation_runner.h"
#include "chrome/browser/ash/arc/fileapi/arc_media_view_util.h"
#include "chrome/browser/ash/crostini/crostini_manager.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/snapshot_manager.h"
#include "chrome/browser/ash/file_manager/volume_manager_factory.h"
#include "chrome/browser/ash/file_manager/volume_manager_observer.h"
#include "chrome/browser/ash/policy/skyvault/local_files_migration_manager.h"
#include "chrome/browser/ash/policy/skyvault/policy_utils.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chrome/browser/media_galleries/fileapi/mtp_device_map_service.h"
#include "chrome/common/chrome_features.h"
#include "chromeos/ash/components/policy/external_storage/device_id.h"
#include "chromeos/ash/components/policy/external_storage/external_storage_policy_controller.h"
#include "chromeos/ash/experiences/arc/arc_util.h"
#include "chromeos/components/disks/disks_prefs.h"
#include "components/prefs/pref_service.h"
#include "components/storage_monitor/storage_info_utils.h"
#include "components/storage_monitor/storage_monitor.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "crypto/sha2.h"
#include "services/device/public/mojom/mtp_storage_info.mojom.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "ui/base/clipboard/clipboard_data.h"
#include "ui/base/clipboard/clipboard_format_type.h"
#include "ui/base/clipboard/clipboard_monitor.h"
#include "ui/base/clipboard/clipboard_non_backed.h"
namespace file_manager {
namespace {
const uint32_t kAccessCapabilityReadWrite = 0;
const uint32_t kFilesystemTypeGenericHierarchical = 2;
const char kFileManagerMTPMountNamePrefix[] = "fileman-mtp-";
const char kMtpVolumeIdPrefix[] = "mtp:";
const char kRootPath[] = "/";
// 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 the Files app,
// in the backend we need to mount all profile's download directory globally.
// Otherwise, the Files app cannot support cross-profile file copies, etc.
// For this reason, we need to register to the global GetSystemInstance().
const std::string mount_point_name =
file_manager::util::GetDownloadsMountPointName(profile);
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
// In some tests we want to override existing Downloads mount point, so we
// first revoke the existing mount point (if any).
mount_points->RevokeFileSystem(mount_point_name);
return mount_points->RegisterFileSystem(
mount_point_name, storage::kFileSystemTypeLocal,
storage::FileSystemMountOption(), path);
}
// Revokes |path| as the "Downloads" folder from the FileSystem API backend,
// if mounted.
void RevokeDownloadsMountPoint(Profile* profile, const base::FilePath& path) {
const std::string mount_point_name =
file_manager::util::GetDownloadsMountPointName(profile);
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
mount_points->RevokeFileSystem(mount_point_name);
}
// Registers a mount point for Android files to ExternalMountPoints.
bool RegisterAndroidFilesMountPoint() {
if (arc::IsArcVmEnabled()) {
return false;
}
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
return mount_points->RegisterFileSystem(
file_manager::util::GetAndroidFilesMountPointName(),
storage::kFileSystemTypeLocal, storage::FileSystemMountOption(),
base::FilePath(util::kAndroidFilesPath));
}
// Revokes Android files mount point, if mounted.
void RevokeAndroidFilesMountPoint() {
if (arc::IsArcVmEnabled()) {
return;
}
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
mount_points->RevokeFileSystem(
file_manager::util::GetAndroidFilesMountPointName());
}
bool RegisterShareCacheMountPoint(Profile* profile) {
const std::string mount_point_name =
file_manager::util::GetShareCacheMountPointName(profile);
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
mount_points->RevokeFileSystem(mount_point_name);
return mount_points->RegisterFileSystem(
mount_point_name, storage::kFileSystemTypeLocal,
storage::FileSystemMountOption(), util::GetShareCacheFilePath(profile));
}
// Finds the path register as the "Downloads" folder to FileSystem API backend.
// Returns false if it is not registered.
bool FindDownloadsMountPointPath(Profile* profile, base::FilePath* path) {
const std::string mount_point_name =
util::GetDownloadsMountPointName(profile);
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
return mount_points->GetRegisteredPath(mount_point_name, path);
}
// Returns true if the mount point is registered with FileSystem API backend.
// Return false if it is not registered.
bool FindExternalMountPoint(const std::string& mount_point_name) {
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
base::FilePath path;
return mount_points->GetRegisteredPath(mount_point_name, &path);
}
std::string FuseBoxSubdirADP(const std::string& authority,
const std::string& root_id) {
// Hash the authority and document ID
// - because the ID can be quite long (400+ bytes) and
// - to avoid sharing the ID in the file system.
std::string hash = crypto::SHA256HashString(
arc::GetDocumentsProviderMountPathSuffix(authority, root_id)
.AsUTF8Unsafe());
std::string b64;
base::Base64UrlEncode(hash, base::Base64UrlEncodePolicy::OMIT_PADDING, &b64);
return base::StrCat({util::kFuseBoxSubdirPrefixADP, b64});
}
std::string FuseBoxSubdirFSP(
const ash::file_system_provider::ProvidedFileSystemInfo& file_system_info) {
std::string hash =
crypto::SHA256HashString(file_system_info.mount_path().value());
std::string b64;
base::Base64UrlEncode(hash, base::Base64UrlEncodePolicy::OMIT_PADDING, &b64);
return base::StrCat({util::kFuseBoxSubdirPrefixFSP, b64});
}
std::string FuseBoxSubdirLOC(const base::FilePath& path) {
std::string hash = crypto::SHA256HashString(path.value());
std::string b64;
base::Base64UrlEncode(hash, base::Base64UrlEncodePolicy::OMIT_PADDING, &b64);
return base::StrCat({util::kFuseBoxSubdirPrefixLOC, b64});
}
std::string FuseBoxSubdirMTP(const std::string& device_id) {
// Derive the subdir name from the MTP device ID (which is stable even after
// unplugging and replugging a phone). It's a hash of the ID, not the ID
// itself, to avoid sharing the device's unique ID in the file system.
std::string hash = crypto::SHA256HashString(device_id);
std::string b64;
base::Base64UrlEncode(hash, base::Base64UrlEncodePolicy::OMIT_PADDING, &b64);
return base::StrCat({util::kFuseBoxSubdirPrefixMTP, b64});
}
std::string GetMountPointNameForMediaStorage(
const storage_monitor::StorageInfo& info) {
std::string name(kFileManagerMTPMountNamePrefix);
name += info.device_id();
return name;
}
ash::MountAccessMode GetExternalStorageAccessMode(
const Profile* profile,
std::optional<policy::DeviceId> device_id) {
return policy::ExternalStoragePolicyController::IsDeviceReadOnly(
CHECK_DEREF(profile->GetPrefs()), std::move(device_id))
? ash::MountAccessMode::kReadOnly
: ash::MountAccessMode::kReadWrite;
}
void RecordDownloadsDiskUsageStats(base::FilePath downloads_path) {
constexpr int64_t kOneMiB = 1024 * 1024;
// For now assume a maximum bucket size of 512GB, which exceeds all current
// chromeOS hard disk sizes.
constexpr int64_t k512GiBInMiB = 512 * 1024;
int64_t download_directory_size_in_bytes =
base::ComputeDirectorySize(downloads_path);
base::UmaHistogramCustomCounts(
"FileBrowser.Downloads.DirectorySizeMiB",
static_cast<int>(download_directory_size_in_bytes / kOneMiB), 1,
k512GiBInMiB, 100);
int64_t total_disk_space_in_bytes =
base::SysInfo::AmountOfTotalDiskSpace(downloads_path);
// total_disk_space_in_bytes can be -1 on error.
if (total_disk_space_in_bytes > 0) {
int percentage_space_used = std::lround(
(download_directory_size_in_bytes * 100.0) / total_disk_space_in_bytes);
base::UmaHistogramPercentageObsoleteDoNotUse(
"FileBrowser.Downloads.DirectoryPercentageOfDiskUsage",
percentage_space_used);
}
}
std::unique_ptr<Volume> CreateForFuseBoxDownloads(
Profile* profile,
file_manager::FuseBoxDaemon* fusebox_daemon,
const char* fusebox_volume_label) {
if (!profile || !fusebox_daemon) {
return nullptr;
}
// Get the FileSystemURL for the underlying Downloads folder.
GURL gurl;
base::FilePath downloads_path = util::GetDownloadsFolderForProfile(profile);
if (!util::ConvertAbsoluteFilePathToFileSystemUrl(
profile, downloads_path, util::GetFileManagerURL(), &gurl)) {
LOG(ERROR) << "could not convert Downloads to FileSystemURL";
return nullptr;
}
// Attach the Downloads directory to the fusebox daemon.
std::string subdir = FuseBoxSubdirLOC(downloads_path);
static constexpr bool read_only = false;
fusebox_daemon->AttachStorage(subdir, gurl.spec(), read_only);
// Create a Volume for the fusebox edition of Downloads.
std::unique_ptr<Volume> fusebox_volume = Volume::CreateForDownloads(
{}, base::FilePath(util::kFuseBoxMediaPath).Append(subdir),
fusebox_volume_label);
// Register the fusebox file system with chrome::storage.
const std::string fusebox_fsid =
base::StrCat({util::kFuseBoxMountNamePrefix, subdir});
if (!FindExternalMountPoint(fusebox_fsid)) {
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
bool result = mount_points->RegisterFileSystem(
fusebox_fsid, storage::kFileSystemTypeFuseBox,
storage::FileSystemMountOption(), fusebox_volume->mount_path());
LOG_IF(ERROR, !result) << "invalid FuseBox Downloads mount path";
DCHECK(result);
}
return fusebox_volume;
}
bool IsArcEnabled(Profile* profile) {
return arc::IsArcAllowedForProfile(profile);
}
bool IsSkyVaultV2Enabled() {
return base::FeatureList::IsEnabled(features::kSkyVaultV2);
}
} // namespace
int VolumeManager::counter_ = 0;
VolumeManager::VolumeManager(
Profile* profile,
drive::DriveIntegrationService* drive_integration_service,
chromeos::PowerManagerClient* power_manager_client,
ash::disks::DiskMountManager* disk_mount_manager,
ash::file_system_provider::Service* file_system_provider_service,
GetMtpStorageInfoCallback get_mtp_storage_info_callback)
: profile_(profile),
drive_integration_service_(drive_integration_service),
disk_mount_manager_(disk_mount_manager),
file_system_provider_service_(file_system_provider_service),
get_mtp_storage_info_callback_(get_mtp_storage_info_callback),
snapshot_manager_(new SnapshotManager(profile_)),
documents_provider_root_manager_(
std::make_unique<DocumentsProviderRootManager>(
profile_,
arc::ArcFileSystemOperationRunner::GetForBrowserContext(
profile_))) {
DCHECK(profile_);
DCHECK(disk_mount_manager_);
VLOG(1) << *this << "::Constructor with Profile: " << profile->GetDebugName();
}
VolumeManager::~VolumeManager() {
VLOG(1) << *this << "::Destructor";
}
VolumeManager* VolumeManager::Get(content::BrowserContext* context) {
return VolumeManagerFactory::Get(context);
}
void VolumeManager::Initialize() {
VLOG(1) << *this << "::Initialize";
// If in the Sign in profile or the lock screen app profile or lock screen
// profile, skip mounting and listening for mount events.
if (!ash::ProfileHelper::IsUserProfile(profile_)) {
VLOG(1) << *this << ": Not a user profile: " << profile_->GetDebugName();
return;
}
if (!fusebox_daemon_) {
fusebox_daemon_ = file_manager::FuseBoxDaemon::GetInstance();
}
local_user_files_allowed_ = policy::local_user_files::LocalUserFilesAllowed();
if (local_user_files_allowed_) {
// Add local folders - MyFiles and ARC if enabled.
OnLocalUserFilesEnabled();
} else {
OnLocalUserFilesDisabled();
}
// For GA, also subscribe to SkyVault LocalFilesMigrationManager.
if (IsSkyVaultV2Enabled()) {
if (policy::local_user_files::
LocalFilesMigrationManager* migration_manager =
policy::local_user_files::LocalFilesMigrationManagerFactory::
GetForBrowserContext(profile_)) {
migration_manager->AddObserver(this);
}
}
// Subscribe to DriveIntegrationService.
Observe(drive_integration_service_);
if (drive_integration_service_->IsMounted()) {
DoMountEvent(Volume::CreateForDrive(GetDriveMountPointPath()));
}
// Subscribe to DiskMountManager.
disk_mount_manager_->AddObserver(this);
disk_mount_manager_->EnsureMountInfoRefreshed(
base::BindOnce(&VolumeManager::OnDiskMountManagerRefreshed,
weak_ptr_factory_.GetWeakPtr()),
false /* force */);
// Subscribe to FileSystemProviderService and register currently mounted
// volumes for the profile.
if (file_system_provider_service_) {
file_system_provider_service_->AddObserver(this);
std::vector<ash::file_system_provider::ProvidedFileSystemInfo>
file_system_info_list =
file_system_provider_service_->GetProvidedFileSystemInfoList();
for (const auto& file_system_info : file_system_info_list) {
OnProvidedFileSystemMount(
file_system_info, ash::file_system_provider::MOUNT_CONTEXT_RESTORE,
base::File::FILE_OK);
}
}
// Subscribe to Profile Preference change.
pref_change_registrar_.Init(profile_->GetPrefs());
pref_change_registrar_.Add(
disks::prefs::kExternalStorageDisabled,
base::BindRepeating(&VolumeManager::OnExternalStorageDisabledChanged,
weak_ptr_factory_.GetWeakPtr()));
pref_change_registrar_.Add(
disks::prefs::kExternalStorageReadOnly,
base::BindRepeating(&VolumeManager::OnExternalStorageReadOnlyChanged,
weak_ptr_factory_.GetWeakPtr()));
pref_change_registrar_.Add(
disks::prefs::kExternalStorageAllowlist,
base::BindRepeating(&VolumeManager::OnExternalStorageAllowlistChanged,
weak_ptr_factory_.GetWeakPtr()));
// Subscribe to storage monitor for MTP notifications.
if (storage_monitor::StorageMonitor::GetInstance()) {
storage_monitor::StorageMonitor::GetInstance()->EnsureInitialized(
base::BindOnce(&VolumeManager::OnStorageMonitorInitialized,
weak_ptr_factory_.GetWeakPtr()));
}
// Subscribe to clipboard events.
ui::ClipboardMonitor::GetInstance()->AddObserver(this);
RegisterShareCacheMountPoint(profile_);
DoMountEvent(
Volume::CreateForShareCache(util::GetShareCacheFilePath(profile_)));
// Start Trash autocleanup.
if (!base::FeatureList::IsEnabled(ash::features::kFilesTrashAutoCleanup)) {
trash_auto_cleanup_ = trash::TrashAutoCleanup::Create(profile_);
}
}
void VolumeManager::Shutdown() {
VLOG(1) << *this << "::Shutdown";
for (auto& observer : observers_) {
observer.OnShutdownStart(this);
}
weak_ptr_factory_.InvalidateWeakPtrs();
snapshot_manager_.reset();
pref_change_registrar_.RemoveAll();
disk_mount_manager_->RemoveObserver(this);
documents_provider_root_manager_->RemoveObserver(this);
documents_provider_root_manager_.reset();
trash_auto_cleanup_.reset();
if (storage_monitor::StorageMonitor* const p =
storage_monitor::StorageMonitor::GetInstance()) {
p->RemoveObserver(this);
}
drive::DriveIntegrationService::Observer::Reset();
if (file_system_provider_service_) {
file_system_provider_service_->RemoveObserver(this);
}
UnsubscribeFromArcEvents();
ui::ClipboardMonitor::GetInstance()->RemoveObserver(this);
// If GA, unsubscribe from SkyVault LocalFilesMigrationManager.
if (IsSkyVaultV2Enabled()) {
if (policy::local_user_files::
LocalFilesMigrationManager* migration_manager =
policy::local_user_files::LocalFilesMigrationManagerFactory::
GetForBrowserContext(profile_, /*create=*/false)) {
migration_manager->RemoveObserver(this);
}
}
}
void VolumeManager::AddObserver(VolumeManagerObserver* observer) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK(observer);
observers_.AddObserver(observer);
}
void VolumeManager::RemoveObserver(VolumeManagerObserver* observer) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK(observer);
observers_.RemoveObserver(observer);
}
std::vector<base::WeakPtr<Volume>> VolumeManager::GetVolumeList() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
std::vector<base::WeakPtr<Volume>> result;
result.reserve(mounted_volumes_.size());
for (const auto& volume : mounted_volumes_) {
DCHECK(volume);
result.push_back(volume->AsWeakPtr());
}
return result;
}
base::WeakPtr<Volume> VolumeManager::FindVolumeById(
const std::string& volume_id) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
if (const Volumes::const_iterator it = mounted_volumes_.find(volume_id);
it != mounted_volumes_.end()) {
DCHECK(*it);
return (*it)->AsWeakPtr();
}
return nullptr;
}
base::WeakPtr<Volume> VolumeManager::FindVolumeFromPath(
const base::FilePath& path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
for (const auto& volume : mounted_volumes_) {
DCHECK(volume);
const base::FilePath& volume_mount_path = volume->mount_path();
if (path == volume_mount_path || volume_mount_path.IsParent(path)) {
return volume->AsWeakPtr();
}
}
return nullptr;
}
void VolumeManager::AddSshfsCrostiniVolume(
const base::FilePath& sshfs_mount_path,
const base::FilePath& remote_mount_path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Ignore if volume already exists.
if (!DoMountEvent(Volume::CreateForSshfsCrostini(sshfs_mount_path,
remote_mount_path))) {
return;
}
// Listen for crostini container shutdown and remove volume.
crostini::CrostiniManager::GetForProfile(profile_)
->AddShutdownContainerCallback(
crostini::DefaultContainerId(),
base::BindOnce(&VolumeManager::RemoveSshfsCrostiniVolume,
weak_ptr_factory_.GetWeakPtr(), sshfs_mount_path,
base::BindOnce([](bool result) {
if (!result) {
LOG(ERROR) << "Failed to remove sshfs mount";
}
})));
}
void VolumeManager::AddSftpGuestOsVolume(
std::string display_name,
const base::FilePath& sftp_mount_path,
const base::FilePath& remote_mount_path,
const guest_os::VmType vm_type) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoMountEvent(Volume::CreateForSftpGuestOs(
std::move(display_name), sftp_mount_path, remote_mount_path, vm_type));
}
void VolumeManager::RemoveSshfsCrostiniVolume(
const base::FilePath& sshfs_mount_path,
RemoveSshfsCrostiniVolumeCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
disk_mount_manager_->UnmountPath(
sshfs_mount_path.value(),
base::BindOnce(&VolumeManager::OnSshfsCrostiniUnmountCallback,
weak_ptr_factory_.GetWeakPtr(), sshfs_mount_path,
std::move(callback)));
}
void VolumeManager::RemoveSftpGuestOsVolume(
const base::FilePath& sftp_mount_path,
const guest_os::VmType vm_type,
RemoveSshfsCrostiniVolumeCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
disk_mount_manager_->UnmountPath(
sftp_mount_path.value(),
base::BindOnce(&VolumeManager::OnSftpGuestOsUnmountCallback,
weak_ptr_factory_.GetWeakPtr(), sftp_mount_path, vm_type,
std::move(callback)));
}
bool VolumeManager::RegisterAndroidFilesDirectoryForTesting(
const base::FilePath& path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
bool result =
storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
file_manager::util::GetAndroidFilesMountPointName(),
storage::kFileSystemTypeLocal, storage::FileSystemMountOption(),
path);
DCHECK(result);
return DoMountEvent(Volume::CreateForAndroidFiles(path));
}
bool VolumeManager::RegisterMediaViewForTesting(
const std::string& root_document_id) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
return DoMountEvent(Volume::CreateForMediaView(root_document_id));
}
bool VolumeManager::RemoveAndroidFilesDirectoryForTesting(
const base::FilePath& path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoUnmountEvent(*Volume::CreateForAndroidFiles(path));
return true;
}
void VolumeManager::RemoveDownloadsDirectoryForTesting() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
base::FilePath path;
if (FindDownloadsMountPointPath(profile_, &path)) {
DoUnmountEvent(*Volume::CreateForDownloads(path));
}
}
bool VolumeManager::RegisterDownloadsDirectoryForTesting(
const base::FilePath& path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
base::FilePath old_path;
if (FindDownloadsMountPointPath(profile_, &old_path)) {
DoUnmountEvent(*Volume::CreateForDownloads(old_path));
}
const bool ok = RegisterDownloadsMountPoint(profile_, path);
// Determine if the local user files directory should be mounted as read-only:
// - SkyVault GA is enabled
// - Local storage of user files is disallowed by policy
const bool read_only = IsSkyVaultV2Enabled() && !local_user_files_allowed_;
// In production, once read_only_local_folders_ is false, the
// MyFiles/Downloads are unmounted and not mounted again. However, in tests,
// it's possible to call this function after the SkyVault migration has
// completed.
if (read_only && !read_only_local_folders_) {
LOG(WARNING) << "Adding Downloads volume for testing, even though it "
"should've been removed because of SkyVault.";
}
return DoMountEvent(
Volume::CreateForDownloads(path, {}, nullptr, read_only),
ok ? ash::MountError::kSuccess : ash::MountError::kInvalidPath);
}
bool VolumeManager::RegisterCrostiniDirectoryForTesting(
const base::FilePath& path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
const bool ok =
storage::ExternalMountPoints::GetSystemInstance()->RegisterFileSystem(
file_manager::util::GetCrostiniMountPointName(profile_),
storage::kFileSystemTypeLocal, storage::FileSystemMountOption(),
path);
return DoMountEvent(
Volume::CreateForSshfsCrostini(path, base::FilePath("/home/testuser")),
ok ? ash::MountError::kSuccess : ash::MountError::kInvalidPath);
}
bool VolumeManager::AddVolumeForTesting(base::FilePath path,
VolumeType volume_type,
ash::DeviceType device_type,
bool read_only,
base::FilePath device_path,
std::string drive_label,
std::string file_system_type,
bool hidden,
bool watchable) {
return AddVolumeForTesting(Volume::CreateForTesting(
std::move(path), volume_type, device_type, read_only,
std::move(device_path), std::move(drive_label),
std::move(file_system_type), hidden, watchable));
}
bool VolumeManager::AddVolumeForTesting(std::unique_ptr<Volume> volume) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
return DoMountEvent(std::move(volume));
}
void VolumeManager::RemoveVolumeForTesting(
const base::FilePath& path,
VolumeType volume_type,
ash::DeviceType device_type,
bool read_only,
const base::FilePath& device_path,
const std::string& drive_label,
const std::string& file_system_type) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoUnmountEvent(*Volume::CreateForTesting(path, volume_type, device_type,
read_only, device_path, drive_label,
file_system_type));
}
void VolumeManager::RemoveVolumeForTesting(const std::string& volume_id) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoUnmountEvent(volume_id);
}
void VolumeManager::OnFileSystemMounted() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Raise mount event.
// We can pass ash::MountError::kNone even when authentication is failed
// or network is unreachable. These two errors will be handled later.
DoMountEvent(Volume::CreateForDrive(GetDriveMountPointPath()));
}
void VolumeManager::OnFileSystemBeingUnmounted() {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoUnmountEvent(*Volume::CreateForDrive(GetDriveMountPointPath()));
}
void VolumeManager::OnAutoMountableDiskEvent(
ash::disks::DiskMountManager::DiskEvent event,
const ash::disks::Disk& disk) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Disregard hidden devices.
if (disk.is_hidden()) {
return;
}
switch (event) {
case ash::disks::DiskMountManager::DISK_ADDED:
case ash::disks::DiskMountManager::DISK_CHANGED: {
if (disk.device_path().empty()) {
DVLOG(1) << "Empty system path for disk " << disk.device_number();
return;
}
bool mounting = false;
if (disk.mount_path().empty() && disk.has_media()) {
const auto device_id = policy::DeviceId::FromDisk(&disk);
if (policy::ExternalStoragePolicyController::IsDeviceDisabled(
CHECK_DEREF(profile_->GetPrefs()), device_id)) {
observers_.Notify(&VolumeManagerObserver::OnDiskAddBlockedByPolicy,
disk.device_path());
return;
}
// If disk is not mounted yet and it has media and there is no policy
// forbidding external storage, give it a try.
// Initiate disk mount operation. MountPath auto-detects the filesystem
// format if the second argument is empty.
disk_mount_manager_->MountPath(
disk.device_path(), {}, disk.device_label(), {},
ash::MountType::kDevice,
GetExternalStorageAccessMode(profile_, device_id),
base::DoNothing());
mounting = true;
}
// Notify to observers.
for (auto& observer : observers_) {
observer.OnDiskAdded(disk, mounting);
}
return;
}
case ash::disks::DiskMountManager::DISK_REMOVED:
// If the disk is already mounted, unmount it.
if (!disk.mount_path().empty()) {
disk_mount_manager_->UnmountPath(disk.mount_path(), base::DoNothing());
}
// Notify to observers.
for (auto& observer : observers_) {
observer.OnDiskRemoved(disk);
}
return;
}
NOTREACHED();
}
void VolumeManager::OnDeviceEvent(
ash::disks::DiskMountManager::DeviceEvent event,
const std::string& device_path) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DVLOG(1) << "OnDeviceEvent: " << event << ", " << device_path;
switch (event) {
case ash::disks::DiskMountManager::DEVICE_ADDED:
for (auto& observer : observers_) {
observer.OnDeviceAdded(device_path);
}
return;
case ash::disks::DiskMountManager::DEVICE_REMOVED: {
for (auto& observer : observers_) {
observer.OnDeviceRemoved(device_path);
}
return;
}
case ash::disks::DiskMountManager::DEVICE_SCANNED:
DVLOG(1) << "Ignore SCANNED event: " << device_path;
return;
}
NOTREACHED();
}
void VolumeManager::OnMountEvent(
ash::disks::DiskMountManager::MountEvent event,
ash::MountError error,
const ash::disks::DiskMountManager::MountPoint& mount_info) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Network storage is responsible for doing its own mounting.
if (mount_info.mount_type == ash::MountType::kNetworkStorage) {
return;
}
// Notify a mounting/unmounting event to observers.
const ash::disks::Disk* const disk =
disk_mount_manager_->FindDiskBySourcePath(mount_info.source_path);
std::unique_ptr<Volume> volume = Volume::CreateForRemovable(mount_info, disk);
switch (event) {
case ash::disks::DiskMountManager::MOUNTING: {
DoMountEvent(std::move(volume), error);
return;
}
case ash::disks::DiskMountManager::UNMOUNTING:
DoUnmountEvent(*volume, error);
return;
}
NOTREACHED() << "Unexpected event type " << event;
}
void VolumeManager::OnFormatEvent(
ash::disks::DiskMountManager::FormatEvent event,
ash::FormatError error,
const std::string& device_path,
const std::string& device_label) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DVLOG(1) << "OnFormatEvent: " << event << ", error = " << error
<< ", device_path = " << device_path;
switch (event) {
case ash::disks::DiskMountManager::FORMAT_STARTED:
for (auto& observer : observers_) {
observer.OnFormatStarted(device_path, device_label,
error == ash::FormatError::kSuccess);
}
return;
case ash::disks::DiskMountManager::FORMAT_COMPLETED:
// Even if format did not complete successfully, try to mount the device
// so the user can retry.
// MountPath auto-detects filesystem format if second argument is
// empty. The third argument (mount label) is not used in a disk mount
// operation.
disk_mount_manager_->MountPath(
device_path, {}, {}, {}, ash::MountType::kDevice,
GetExternalStorageAccessMode(profile_,
GetDeviceIdFromDevicePath(device_path)),
base::DoNothing());
for (auto& observer : observers_) {
observer.OnFormatCompleted(device_path, device_label,
error == ash::FormatError::kSuccess);
}
return;
}
NOTREACHED() << "Unexpected FormatEvent " << event;
}
void VolumeManager::OnPartitionEvent(
ash::disks::DiskMountManager::PartitionEvent event,
ash::PartitionError error,
const std::string& device_path,
const std::string& device_label) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DVLOG(1) << "OnPartitionEvent: " << event << ", error = " << error
<< ", device_path = " << device_path;
switch (event) {
case ash::disks::DiskMountManager::PARTITION_STARTED:
for (auto& observer : observers_) {
observer.OnPartitionStarted(device_path, device_label,
error == ash::PartitionError::kSuccess);
}
return;
case ash::disks::DiskMountManager::PARTITION_COMPLETED:
// If partitioning failed, try to mount the device so the user can retry.
// MountPath auto-detects filesystem format if second argument is
// empty. The third argument (mount label) is not used in a disk mount
// operation.
if (error != ash::PartitionError::kSuccess) {
disk_mount_manager_->MountPath(
device_path, {}, {}, {}, ash::MountType::kDevice,
GetExternalStorageAccessMode(
profile_, GetDeviceIdFromDevicePath(device_path)),
base::DoNothing());
}
for (auto& observer : observers_) {
observer.OnPartitionCompleted(device_path, device_label,
error == ash::PartitionError::kSuccess);
}
return;
}
NOTREACHED() << "Unexpected PartitionEvent " << event;
}
void VolumeManager::OnRenameEvent(
ash::disks::DiskMountManager::RenameEvent event,
ash::RenameError error,
const std::string& device_path,
const std::string& device_label) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DVLOG(1) << "OnRenameEvent: " << event << ", error = " << error
<< ", device_path = " << device_path;
switch (event) {
case ash::disks::DiskMountManager::RENAME_STARTED:
for (auto& observer : observers_) {
observer.OnRenameStarted(device_path, device_label,
error == ash::RenameError::kSuccess);
}
return;
case ash::disks::DiskMountManager::RENAME_COMPLETED:
// Find previous mount point label if it exists
std::string mount_label;
auto disk_map_iter = disk_mount_manager_->disks().find(device_path);
if (disk_map_iter != disk_mount_manager_->disks().end() &&
!disk_map_iter->get()->base_mount_path().empty()) {
mount_label = base::FilePath(disk_map_iter->get()->base_mount_path())
.BaseName()
.AsUTF8Unsafe();
}
// Try to mount the device. MountPath auto-detects filesystem format if
// second argument is empty. Third argument is a mount point name of the
// disk when it was first time mounted (to preserve mount point regardless
// of the volume name).
disk_mount_manager_->MountPath(
device_path, {}, mount_label, {}, ash::MountType::kDevice,
GetExternalStorageAccessMode(profile_,
GetDeviceIdFromDevicePath(device_path)),
base::DoNothing());
bool successfully_renamed = error == ash::RenameError::kSuccess;
for (auto& observer : observers_) {
observer.OnRenameCompleted(device_path, device_label,
successfully_renamed);
}
return;
}
NOTREACHED() << "Unexpected RenameEvent " << event;
}
void VolumeManager::OnProvidedFileSystemMount(
const ash::file_system_provider::ProvidedFileSystemInfo& file_system_info,
ash::file_system_provider::MountContext context,
base::File::Error error) {
MountContext volume_context = MOUNT_CONTEXT_UNKNOWN;
switch (context) {
case ash::file_system_provider::MOUNT_CONTEXT_USER:
volume_context = MOUNT_CONTEXT_USER;
break;
case ash::file_system_provider::MOUNT_CONTEXT_RESTORE:
volume_context = MOUNT_CONTEXT_AUTO;
break;
}
std::unique_ptr<Volume> volume =
Volume::CreateForProvidedFileSystem(file_system_info, volume_context);
ash::MountError mount_error;
switch (error) {
case base::File::FILE_OK:
mount_error = ash::MountError::kSuccess;
break;
case base::File::FILE_ERROR_EXISTS:
mount_error = ash::MountError::kPathAlreadyMounted;
break;
default:
mount_error = ash::MountError::kUnknownError;
break;
}
DoMountEvent(std::move(volume), mount_error);
// The FSP is not added to chrome::storage if mounting failed.
if (error != base::File::FILE_OK) {
return;
}
// Get the FuseBoxDaemon instance.
if (!fusebox_daemon_) {
fusebox_daemon_ = file_manager::FuseBoxDaemon::GetInstance();
}
// Get the FileSystemURL of the FSP storage device.
const std::string fsid =
file_system_info.mount_path().BaseName().AsUTF8Unsafe();
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
auto fsp_file_system_url = mount_points->CreateExternalFileSystemURL(
blink::StorageKey::CreateFirstParty(util::GetFilesAppOrigin()), fsid, {});
const std::string url = fsp_file_system_url.ToGURL().spec();
DCHECK(fsp_file_system_url.is_valid());
// Attach the FSP storage device to the fusebox daemon.
const std::string subdir = FuseBoxSubdirFSP(file_system_info);
fusebox_daemon_->AttachStorage(subdir, url, !file_system_info.writable());
// Create a Volume for the fusebox FSP storage device.
std::unique_ptr<Volume> fusebox_volume = Volume::CreateForProvidedFileSystem(
file_system_info, volume_context,
base::FilePath(util::kFuseBoxMediaPath).Append(subdir));
// Register the fusebox FSP storage device with chrome::storage.
const std::string fusebox_fsid = base::StrCat(
{util::kFuseBoxMountNamePrefix, util::kFuseBoxSubdirPrefixFSP, fsid});
if (!FindExternalMountPoint(fusebox_fsid)) {
bool result = mount_points->RegisterFileSystem(
fusebox_fsid, storage::kFileSystemTypeFuseBox,
storage::FileSystemMountOption(), fusebox_volume->mount_path());
LOG_IF(ERROR, !result) << "invalid FuseBox FSP mount path";
DCHECK(result);
}
// Mount the fusebox FSP storage device in files app.
DoMountEvent(std::move(fusebox_volume));
}
void VolumeManager::ConvertFuseBoxFSPVolumeIdToFSPIfNeeded(
std::string* volume_id) const {
DCHECK(volume_id);
static const base::FilePath::CharType kFuseBoxFSPVolumeIdPrefix[] =
FILE_PATH_LITERAL("fuseboxprovided:fsp:");
if (!base::StartsWith(*volume_id, kFuseBoxFSPVolumeIdPrefix)) {
return;
}
int prefix = strlen(kFuseBoxFSPVolumeIdPrefix);
*volume_id = volume_id->substr(prefix).insert(0, "provided:");
}
// TODO(aidazolic): Figure out why it's called twice for every update.
void VolumeManager::OnLocalUserFilesPolicyChanged() {
if (!base::FeatureList::IsEnabled(features::kSkyVault)) {
return;
}
bool allowed = policy::local_user_files::LocalUserFilesAllowed();
if (allowed == local_user_files_allowed_) {
return;
}
local_user_files_allowed_ = allowed;
if (allowed) {
OnLocalUserFilesEnabled();
} else {
OnLocalUserFilesDisabled();
}
}
void VolumeManager::OnProvidedFileSystemUnmount(
const ash::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 ash::MountError mount_error = error == base::File::FILE_OK
? ash::MountError::kSuccess
: ash::MountError::kUnknownError;
std::unique_ptr<Volume> volume = Volume::CreateForProvidedFileSystem(
file_system_info, MOUNT_CONTEXT_UNKNOWN);
DoUnmountEvent(*volume, mount_error);
// Get FSP chrome::storage |fsid| and fusebox daemon |subdir|.
const std::string fsid =
file_system_info.mount_path().BaseName().AsUTF8Unsafe();
const std::string subdir = FuseBoxSubdirFSP(file_system_info);
// Unmount the fusebox FSP storage device in files app.
std::unique_ptr<Volume> fusebox_volume = Volume::CreateForProvidedFileSystem(
file_system_info, MOUNT_CONTEXT_UNKNOWN,
base::FilePath(util::kFuseBoxMediaPath).Append(subdir));
DoUnmountEvent(*fusebox_volume, mount_error);
// Remove the fusebox FSP storage device from chrome::storage.
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
const std::string fusebox_fsid = base::StrCat(
{util::kFuseBoxMountNamePrefix, util::kFuseBoxSubdirPrefixFSP, fsid});
mount_points->RevokeFileSystem(fusebox_fsid);
// Detach the fusebox FSP storage device from the fusebox daemon.
if (fusebox_daemon_) {
fusebox_daemon_->DetachStorage(subdir);
}
}
void VolumeManager::OnExternalStorageDisabledChangedUnmountCallback(
std::vector<std::string> remaining_mount_paths,
ash::MountError error) {
LOG_IF(ERROR, error != ash::MountError::kSuccess)
<< "Unmount on ExternalStorageDisabled policy change failed: " << error;
while (!remaining_mount_paths.empty()) {
std::string mount_path = remaining_mount_paths.back();
remaining_mount_paths.pop_back();
if (!base::Contains(disk_mount_manager_->mount_points(), mount_path)) {
// The mount point could have already been removed for another reason
// (i.e. the disk was removed by the user).
continue;
}
disk_mount_manager_->UnmountPath(
mount_path,
base::BindOnce(
&VolumeManager::OnExternalStorageDisabledChangedUnmountCallback,
weak_ptr_factory_.GetWeakPtr(), std::move(remaining_mount_paths)));
return;
}
}
void VolumeManager::OnArcPlayStoreEnabledChanged(bool enabled) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK(IsArcEnabled(profile_));
const bool mounting =
arc::ShouldAlwaysMountAndroidVolumesInFilesForTesting() || enabled;
if (mounting == arc_volumes_mounted_) {
return;
}
if (mounting) {
MountArcRoots();
} else {
UnmountArcRoots();
}
documents_provider_root_manager_->SetEnabled(mounting);
arc_volumes_mounted_ = mounting;
}
void VolumeManager::OnShutdown() {
arc_session_manager_observation_.Reset();
}
void VolumeManager::OnExternalStorageDisabledChanged() {
// If the policy just got set to disabled we have to unmount every device
// currently mounted which is not allowlisted. The opposite is fine - we can
// let the user re-plug their device to make it available.
const PrefService& pref_service = CHECK_DEREF(profile_->GetPrefs());
// We do not iterate on mount_points directly, because mount_points can be
// changed by UnmountPath(). Also, a failing unmount shouldn't be retried
// indefinitely. So make a set of all the mount points that should be
// unmounted (all external media mounts which aren't allowlisted), and iterate
// through them.
std::vector<std::string> remaining_mount_paths;
for (const auto& mount_point : disk_mount_manager_->mount_points()) {
if (mount_point.mount_type == ash::MountType::kDevice &&
policy::ExternalStoragePolicyController::IsDeviceDisabled(
pref_service, GetDeviceIdFromDevicePath(mount_point.source_path))) {
remaining_mount_paths.push_back(mount_point.mount_path);
}
}
if (remaining_mount_paths.empty()) {
return;
}
std::string mount_path = remaining_mount_paths.back();
remaining_mount_paths.pop_back();
disk_mount_manager_->UnmountPath(
mount_path,
base::BindOnce(
&VolumeManager::OnExternalStorageDisabledChangedUnmountCallback,
weak_ptr_factory_.GetWeakPtr(), std::move(remaining_mount_paths)));
}
void VolumeManager::OnExternalStorageReadOnlyChanged() {
for (const auto& disk : disk_mount_manager_->disks()) {
const ash::MountAccessMode access_mode = GetExternalStorageAccessMode(
profile_, policy::DeviceId::FromDisk(disk.get()));
disk_mount_manager_->RemountRemovableDrive(*disk, access_mode);
}
}
void VolumeManager::OnExternalStorageAllowlistChanged() {
// The Allowlist overrides both Disabled and ReadOnly policies, fire both of
// their listener events.
OnExternalStorageDisabledChanged();
OnExternalStorageReadOnlyChanged();
}
void VolumeManager::OnRemovableStorageAttached(
const storage_monitor::StorageInfo& info) {
if (!storage_monitor::StorageInfo::IsMTPDevice(info.device_id())) {
return;
}
// Resolve mtp storage name and get MtpStorageInfo.
std::string storage_name;
base::RemoveChars(info.location(), kRootPath, &storage_name);
DCHECK(!storage_name.empty());
if (get_mtp_storage_info_callback_.is_null()) {
storage_monitor::StorageMonitor::GetInstance()
->media_transfer_protocol_manager()
->GetStorageInfo(storage_name,
base::BindOnce(&VolumeManager::DoAttachMtpStorage,
weak_ptr_factory_.GetWeakPtr(), info));
} else {
get_mtp_storage_info_callback_.Run(
storage_name, base::BindOnce(&VolumeManager::DoAttachMtpStorage,
weak_ptr_factory_.GetWeakPtr(), info));
}
}
void VolumeManager::DoAttachMtpStorage(
const storage_monitor::StorageInfo& info,
device::mojom::MtpStorageInfoPtr mtp_storage_info) {
if (!mtp_storage_info) {
// |mtp_storage_info| can be null. e.g. As OnRemovableStorageAttached and
// DoAttachMtpStorage are called asynchronously, there can be a race
// condition where the storage has been already removed in
// MediaTransferProtocolManager at the time when this method is called.
return;
}
// `mtp_storage_info` is a protocol buffer and proto file syntax has a uint32
// type, but not a uint16 type.
const policy::DeviceId device_id =
policy::DeviceId(static_cast<uint16_t>(mtp_storage_info->vendor_id),
static_cast<uint16_t>(mtp_storage_info->product_id));
if (policy::ExternalStoragePolicyController::IsDeviceDisabled(
CHECK_DEREF(profile_->GetPrefs()), device_id)) {
const std::string device_location =
storage_monitor::GetDeviceLocationFromStorageName(
mtp_storage_info->storage_name);
observers_.Notify(&VolumeManagerObserver::OnDiskAddBlockedByPolicy,
device_location);
return;
}
// Mtp write is enabled only when the device is writable, supports generic
// hierarchical file system, and writing to external storage devices is not
// prohibited by the preference.
const bool read_only =
mtp_storage_info->access_capability != kAccessCapabilityReadWrite ||
mtp_storage_info->filesystem_type != kFilesystemTypeGenericHierarchical ||
policy::ExternalStoragePolicyController::IsDeviceReadOnly(
CHECK_DEREF(profile_->GetPrefs()), device_id);
const base::FilePath path = base::FilePath::FromUTF8Unsafe(info.location());
const std::string fsid = GetMountPointNameForMediaStorage(info);
const std::string base_name = base::UTF16ToUTF8(info.model_name());
// Assign a fresh volume ID based on the volume name.
std::string label = base_name;
for (int i = 2; mounted_volumes_.count(kMtpVolumeIdPrefix + label) != 0;
++i) {
label = base_name + base::StringPrintf(" (%d)", i);
}
// Register the MTP storage device with chrome::storage.
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
if (!FindExternalMountPoint(fsid)) {
bool result = mount_points->RegisterFileSystem(
fsid, storage::kFileSystemTypeDeviceMediaAsFileStorage,
storage::FileSystemMountOption(), path);
LOG_IF(ERROR, !result) << "invalid MTP mount path";
DCHECK(result);
}
// Register the MTP storage device with the MTPDeviceMapService.
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&MTPDeviceMapService::RegisterMTPFileSystem,
base::Unretained(MTPDeviceMapService::GetInstance()),
info.location(), fsid, read_only));
// Mount the MTP storage device in files app.
std::unique_ptr<Volume> volume = Volume::CreateForMTP(path, label, read_only);
DoMountEvent(std::move(volume));
// Get the FuseBoxDaemon instance.
if (!fusebox_daemon_) {
fusebox_daemon_ = file_manager::FuseBoxDaemon::GetInstance();
}
// Get the FileSystemURL of the MTP storage device.
auto mtp_file_system_url = mount_points->CreateExternalFileSystemURL(
blink::StorageKey::CreateFirstParty(util::GetFilesAppOrigin()), fsid, {});
const std::string url = mtp_file_system_url.ToGURL().spec();
DCHECK(mtp_file_system_url.is_valid());
// Attach the MTP storage device to the fusebox daemon.
std::string subdir = FuseBoxSubdirMTP(info.device_id());
fusebox_daemon_->AttachStorage(subdir, url, read_only);
// Create a Volume for the fusebox MTP storage device.
std::unique_ptr<Volume> fusebox_volume = Volume::CreateForMTP(
base::FilePath(util::kFuseBoxMediaPath).Append(subdir), label, read_only,
/*use_fusebox=*/true);
// Register the fusebox MTP storage device with chrome::storage.
const std::string fusebox_fsid =
base::StrCat({util::kFuseBoxMountNamePrefix, subdir});
if (!FindExternalMountPoint(fusebox_fsid)) {
bool result = mount_points->RegisterFileSystem(
fusebox_fsid, storage::kFileSystemTypeFuseBox,
storage::FileSystemMountOption(), fusebox_volume->mount_path());
LOG_IF(ERROR, !result) << "invalid FuseBox MTP mount path";
DCHECK(result);
}
// Mount the fusebox MTP storage device in files app.
DoMountEvent(std::move(fusebox_volume));
}
void VolumeManager::OnRemovableStorageDetached(
const storage_monitor::StorageInfo& info) {
if (!storage_monitor::StorageInfo::IsMTPDevice(info.device_id())) {
return;
}
Volumes::const_iterator it = mounted_volumes_.begin();
for (const Volumes::const_iterator end = mounted_volumes_.end();; ++it) {
if (it == end) {
return;
}
DCHECK(*it);
if ((*it)->source_path().value() == info.location()) {
break;
}
}
// Unmount the MTP storage device in files app.
const std::string volume_id = (*it)->volume_id();
DoUnmountEvent(std::move(it));
// Remove the MTP storage device from chrome::storage.
const std::string fsid = GetMountPointNameForMediaStorage(info);
storage::ExternalMountPoints* const mount_points =
storage::ExternalMountPoints::GetSystemInstance();
mount_points->RevokeFileSystem(fsid);
// Remove the MTP storage device from the MTPDeviceMapService.
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&MTPDeviceMapService::RevokeMTPFileSystem,
base::Unretained(MTPDeviceMapService::GetInstance()),
fsid));
// Unmount the fusebox MTP storage device in files app.
base::WeakPtr<Volume> fusebox_volume =
FindVolumeById(util::kFuseBox + volume_id);
if (fusebox_volume) {
DoUnmountEvent(*fusebox_volume);
}
// Remove the fusebox MTP storage device from chrome::storage.
std::string subdir = FuseBoxSubdirMTP(info.device_id());
const std::string fusebox_fsid =
base::StrCat({util::kFuseBoxMountNamePrefix, subdir});
mount_points->RevokeFileSystem(fusebox_fsid);
// Detach the fusebox MTP storage device from the fusebox daemon.
if (fusebox_daemon_) {
fusebox_daemon_->DetachStorage(subdir);
}
}
void VolumeManager::OnDocumentsProviderRootAdded(
const std::string& authority,
const std::string& root_id,
const std::string& document_id,
const std::string& title,
const std::string& summary,
const GURL& icon_url,
bool read_only,
const std::vector<std::string>& mime_types) {
arc::ArcDocumentsProviderRootMap::GetForArcBrowserContext()->RegisterRoot(
authority, document_id, root_id, read_only, mime_types);
DoMountEvent(Volume::CreateForDocumentsProvider(
authority, root_id, title, summary, icon_url, read_only,
/*optional_fusebox_subdir=*/std::string()));
// Get the FuseBoxDaemon instance.
if (!fusebox_daemon_) {
fusebox_daemon_ = file_manager::FuseBoxDaemon::GetInstance();
}
// Get the FileSystemURL of the ADP storage device.
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
auto adp_file_system_url = mount_points->CreateExternalFileSystemURL(
blink::StorageKey::CreateFirstParty(util::GetFilesAppOrigin()),
arc::kDocumentsProviderMountPointName,
arc::GetDocumentsProviderMountPathSuffix(authority, root_id));
const std::string url = adp_file_system_url.ToGURL().spec();
DCHECK(adp_file_system_url.is_valid());
// Attach the ADP storage device to the fusebox daemon.
std::string subdir = FuseBoxSubdirADP(authority, root_id);
fusebox_daemon_->AttachStorage(subdir, url, read_only);
// Create a Volume for the fusebox ADP storage device.
std::unique_ptr<Volume> fusebox_volume = Volume::CreateForDocumentsProvider(
authority, root_id, title, summary, icon_url, read_only, subdir);
// Register the fusebox ADP storage device with chrome::storage.
const std::string fusebox_fsid =
base::StrCat({util::kFuseBoxMountNamePrefix, subdir});
if (!FindExternalMountPoint(fusebox_fsid)) {
bool result = mount_points->RegisterFileSystem(
fusebox_fsid, storage::kFileSystemTypeFuseBox,
storage::FileSystemMountOption(), fusebox_volume->mount_path());
LOG_IF(ERROR, !result) << "invalid FuseBox ADP mount path";
DCHECK(result);
}
// Mount the fusebox ADP storage device in files app.
DoMountEvent(std::move(fusebox_volume));
}
void VolumeManager::OnDocumentsProviderRootRemoved(const std::string& authority,
const std::string& root_id) {
DoUnmountEvent(*Volume::CreateForDocumentsProvider(
authority, root_id, std::string(), std::string(), GURL(), false,
/*optional_fusebox_subdir=*/std::string()));
arc::ArcDocumentsProviderRootMap::GetForArcBrowserContext()->UnregisterRoot(
authority, root_id);
// Unmount the fusebox ADP storage device in files app.
std::string volume_id = arc::GetDocumentsProviderVolumeId(authority, root_id);
base::WeakPtr<Volume> fusebox_volume =
FindVolumeById(util::kFuseBox + volume_id);
if (fusebox_volume) {
DoUnmountEvent(*fusebox_volume);
}
// Remove the fusebox ADP storage device from chrome::storage.
std::string subdir = FuseBoxSubdirADP(authority, root_id);
auto* mount_points = storage::ExternalMountPoints::GetSystemInstance();
const std::string fusebox_fsid =
base::StrCat({util::kFuseBoxMountNamePrefix, subdir});
mount_points->RevokeFileSystem(fusebox_fsid);
// Detach the fusebox ADP storage device from the fusebox daemon.
if (fusebox_daemon_) {
fusebox_daemon_->DetachStorage(subdir);
}
}
void VolumeManager::OnClipboardDataChanged() {
// Ignore the event created when we change the clipboard.
if (ignore_clipboard_changed_) {
return;
}
auto* clipboard = ui::ClipboardNonBacked::GetForCurrentThread();
if (!clipboard) {
return;
}
ui::DataTransferEndpoint dte(ui::EndpointType::kClipboardHistory);
std::string web_custom_data;
const ui::ClipboardData* data = clipboard->GetClipboardData(&dte);
if (data) {
web_custom_data = data->GetDataTransferCustomData();
}
if (web_custom_data.empty()) {
return;
}
base::Pickle pickle =
base::Pickle::WithUnownedBuffer(base::as_byte_span(web_custom_data));
std::vector<ui::FileInfo> file_info =
file_manager::util::ParseFileSystemSources(
base::OptionalToPtr(data->source()), pickle);
if (!file_info.empty()) {
auto with_files = std::make_unique<ui::ClipboardData>(*data);
with_files->set_filenames(std::move(file_info));
base::AutoReset<bool> reset(&ignore_clipboard_changed_, true);
clipboard->WriteClipboardData(std::move(with_files));
}
}
void VolumeManager::AddSmbFsVolume(const base::FilePath& mount_point,
const std::string& display_name) {
DoMountEvent(Volume::CreateForSmb(mount_point, display_name));
}
void VolumeManager::RemoveSmbFsVolume(const base::FilePath& mount_point) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DoUnmountEvent(*Volume::CreateForSmb(mount_point, ""));
}
void VolumeManager::OnMigrationSucceededForTesting() {
read_only_local_folders_ = false;
// Don't call OnLocalUserFilesPolicyChanged() because it's no-op if there's no
// change, and we want to force mount/unmount.
if (local_user_files_allowed_) {
OnLocalUserFilesEnabled();
} else {
OnLocalUserFilesDisabled();
}
}
void VolumeManager::OnDiskMountManagerRefreshed(bool success) {
if (!success) {
LOG(ERROR) << "Cannot refresh disk mount manager";
return;
}
std::vector<std::unique_ptr<Volume>> archives;
const ash::disks::DiskMountManager::MountPoints& mount_points =
disk_mount_manager_->mount_points();
for (const auto& mount_point : mount_points) {
switch (mount_point.mount_type) {
case ash::MountType::kArchive: {
// Archives are mounted after other types of volume. See below.
archives.push_back(Volume::CreateForRemovable(mount_point, nullptr));
break;
}
case ash::MountType::kDevice: {
DoMountEvent(Volume::CreateForRemovable(
mount_point, disk_mount_manager_->FindDiskBySourcePath(
mount_point.source_path)));
break;
}
case ash::MountType::kNetworkStorage: {
break;
}
case ash::MountType::kInvalid: {
NOTREACHED();
}
}
}
// 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<std::unique_ptr<Volume>> chain;
// done[x] = true means archives[x] is null and that volume is in |chain|.
done[i] = true;
chain.push_back(std::move(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] started false, so archives[parent] is non-null.
done[parent] = true;
chain.push_back(std::move(archives[parent]));
parent = i + 1; // Search archives[parent]'s parent from the beginning.
}
}
// Mount from the tail of chain.
while (!chain.empty()) {
DoMountEvent(std::move(chain.back()));
chain.pop_back();
}
}
}
void VolumeManager::OnStorageMonitorInitialized() {
VLOG(1) << *this << "::OnStorageMonitorInitialized";
const std::vector<storage_monitor::StorageInfo> storages =
storage_monitor::StorageMonitor::GetInstance()->GetAllAvailableStorages();
for (const storage_monitor::StorageInfo& storage : storages) {
OnRemovableStorageAttached(storage);
}
storage_monitor::StorageMonitor::GetInstance()->AddObserver(this);
}
bool VolumeManager::DoMountEvent(std::unique_ptr<Volume> volume_ptr,
ash::MountError error) {
DCHECK(volume_ptr);
const Volume& volume = *volume_ptr;
// 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.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.source_path());
for (const auto& mounted_volume : mounted_volumes_) {
DCHECK(mounted_volume);
if (mounted_volume->mount_path().IsParent(volume.source_path())) {
from_current_profile = true;
break;
}
}
if (!from_current_profile) {
return false;
}
}
// Filter out removable disks if forbidden by policy for this profile.
if (volume.type() == VOLUME_TYPE_REMOVABLE_DISK_PARTITION &&
policy::ExternalStoragePolicyController::IsDeviceDisabled(
CHECK_DEREF(profile_->GetPrefs()),
GetDeviceIdFromDevicePath(volume.source_path().AsUTF8Unsafe()))) {
observers_.Notify(&VolumeManagerObserver::OnDiskAddBlockedByPolicy,
volume.source_path().AsUTF8Unsafe());
return false;
}
bool inserted = false;
if (error == ash::MountError::kSuccess ||
volume.mount_condition() != ash::MountError::kSuccess) {
const auto [it, ok] = mounted_volumes_.insert(std::move(volume_ptr));
if (ok) {
inserted = true;
VLOG(1) << "Added volume '" << volume.volume_id() << "'";
UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType", volume.type(),
NUM_VOLUME_TYPE);
} else {
DCHECK(volume_ptr);
DCHECK_EQ((*it)->volume_id(), volume.volume_id());
// It is possible for a Volume object with different properties to be
// inserted here. Replace the Volume in |mounted_volumes_|.
const_cast<std::unique_ptr<Volume>&>(*it) = std::move(volume_ptr);
VLOG(1) << "Replaced volume '" << volume.volume_id() << "'";
}
DCHECK_EQ(&volume, it->get());
}
for (auto& observer : observers_) {
observer.OnVolumeMounted(error, volume);
}
return inserted;
}
void VolumeManager::DoUnmountEvent(Volumes::const_iterator it,
const ash::MountError error) {
DCHECK(it != mounted_volumes_.end());
// Hold a reference to the removed Volume from |mounted_volumes_|, because
// OnVolumeMounted() will access it.
const Volume& volume = **it;
Volumes::node_type node_to_delete;
if (error == ash::MountError::kSuccess) {
node_to_delete = mounted_volumes_.extract(std::move(it));
}
VLOG_IF(1, node_to_delete) << "Removed volume '" << volume.volume_id() << "'";
for (auto& observer : observers_) {
observer.OnVolumeUnmounted(error, volume);
}
}
base::FilePath VolumeManager::GetDriveMountPointPath() const {
return drive_integration_service_->GetMountPointPath();
}
void VolumeManager::DoUnmountEvent(std::string_view volume_id,
ash::MountError error) {
Volumes::const_iterator it = mounted_volumes_.find(volume_id);
if (it == mounted_volumes_.end()) {
LOG(WARNING) << "Cannot find volume '" << volume_id << "' to unmount it";
return;
}
DoUnmountEvent(std::move(it), error);
}
void VolumeManager::OnSshfsCrostiniUnmountCallback(
const base::FilePath& sshfs_mount_path,
RemoveSshfsCrostiniVolumeCallback callback,
ash::MountError error) {
if ((error == ash::MountError::kSuccess) ||
(error == ash::MountError::kPathNotMounted)) {
// Remove metadata associated with the mount. It will be a no-op if it
// wasn't mounted or unmounted out of band.
DoUnmountEvent(
*Volume::CreateForSshfsCrostini(sshfs_mount_path, base::FilePath()));
if (callback) {
std::move(callback).Run(true);
}
return;
}
LOG(ERROR) << "Cannot unmount '" << sshfs_mount_path << "'";
if (callback) {
std::move(callback).Run(false);
}
}
void VolumeManager::OnSftpGuestOsUnmountCallback(
const base::FilePath& sftp_mount_path,
const guest_os::VmType vm_type,
RemoveSftpGuestOsVolumeCallback callback,
ash::MountError error) {
if ((error == ash::MountError::kSuccess) ||
(error == ash::MountError::kPathNotMounted)) {
// Remove metadata associated with the mount. It will be a no-op if it
// wasn't mounted or unmounted out of band. We need the VolumeId to be
// consistent, which means the mount path needs to be the same.
// display_name, remote_mount_path and vm_type aren't needed and we don't
// know them at unmount so leave them blank.
DoUnmountEvent(*Volume::CreateForSftpGuestOs("", sftp_mount_path,
base::FilePath(), vm_type));
if (callback) {
std::move(callback).Run(true);
}
return;
}
LOG(ERROR) << "Cannot unmount SFTP path '" << sftp_mount_path
<< "': " << error;
if (callback) {
std::move(callback).Run(false);
}
}
void VolumeManager::MountDownloadsVolume(bool read_only) {
const base::FilePath localVolume =
file_manager::util::GetMyFilesFolderForProfile(profile_);
const bool success = RegisterDownloadsMountPoint(profile_, localVolume);
DCHECK(success);
DoMountEvent(Volume::CreateForDownloads(localVolume, {}, nullptr, read_only));
if (ash::features::IsFileManagerFuseBoxDebugEnabled()) {
if (auto volume = CreateForFuseBoxDownloads(profile_, fusebox_daemon_.get(),
"fusebox Downloads")) {
DoMountEvent(std::move(volume));
}
}
// Asynchronously record the disk usage for the downloads path.
base::ThreadPool::PostTask(
FROM_HERE,
{base::MayBlock(), base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN,
base::TaskPriority::BEST_EFFORT},
base::BindOnce(&RecordDownloadsDiskUsageStats, std::move(localVolume)));
}
void VolumeManager::UnmountDownloadsVolume() {
const base::FilePath localVolume =
file_manager::util::GetMyFilesFolderForProfile(profile_);
RevokeDownloadsMountPoint(profile_, localVolume);
DoUnmountEvent(*Volume::CreateForDownloads(localVolume));
if (ash::features::IsFileManagerFuseBoxDebugEnabled()) {
if (auto volume = CreateForFuseBoxDownloads(profile_, fusebox_daemon_.get(),
"fusebox Downloads")) {
DoUnmountEvent(*volume);
}
}
}
void VolumeManager::MountArcRoots() {
DCHECK(IsArcEnabled(profile_));
if (arc_volumes_mounted_) {
return;
}
DoMountEvent(Volume::CreateForMediaView(arc::kImagesRootId));
DoMountEvent(Volume::CreateForMediaView(arc::kVideosRootId));
DoMountEvent(Volume::CreateForMediaView(arc::kAudioRootId));
DoMountEvent(Volume::CreateForMediaView(arc::kDocumentsRootId));
if (!arc::IsArcVmEnabled()) {
DoMountEvent(
Volume::CreateForAndroidFiles(base::FilePath(util::kAndroidFilesPath)));
}
arc_volumes_mounted_ = true;
}
void VolumeManager::UnmountArcRoots() {
DCHECK(IsArcEnabled(profile_));
if (!arc_volumes_mounted_) {
return;
}
DoUnmountEvent(*Volume::CreateForMediaView(arc::kImagesRootId));
DoUnmountEvent(*Volume::CreateForMediaView(arc::kVideosRootId));
DoUnmountEvent(*Volume::CreateForMediaView(arc::kAudioRootId));
DoUnmountEvent(*Volume::CreateForMediaView(arc::kDocumentsRootId));
if (!arc::IsArcVmEnabled()) {
DoUnmountEvent(*Volume::CreateForAndroidFiles(
base::FilePath(util::kAndroidFilesPath)));
}
arc_volumes_mounted_ = false;
}
void VolumeManager::UnsubscribeFromArcEvents() {
if (!IsArcEnabled(profile_)) {
return;
}
// TODO(crbug.com/40497410): We need nullptr check here because
// ArcSessionManager may or may not be alive at this point.
if (arc::ArcSessionManager::Get()) {
arc_session_manager_observation_.Reset();
}
}
void VolumeManager::SubscribeAndMountArc() {
if (!IsArcEnabled(profile_)) {
return;
}
documents_provider_root_manager_->AddObserver(this);
// Registers a mount point for Android files only when the flag is enabled.
RegisterAndroidFilesMountPoint();
if (arc::ArcSessionManager::Get()) {
arc_session_manager_observation_.Observe(arc::ArcSessionManager::Get());
} else {
// Can be NULL only in tests.
CHECK_IS_TEST();
}
// Trigger mounting if enabled by policy.
OnArcPlayStoreEnabledChanged(arc::IsArcPlayStoreEnabledForProfile(profile_));
}
void VolumeManager::UnsubscribeAndUnmountArc() {
if (!IsArcEnabled(profile_)) {
return;
}
documents_provider_root_manager_->RemoveObserver(this);
UnsubscribeFromArcEvents();
UnmountArcRoots();
RevokeAndroidFilesMountPoint();
}
void VolumeManager::OnLocalUserFilesEnabled() {
CHECK(policy::local_user_files::LocalUserFilesAllowed());
MountDownloadsVolume();
SubscribeAndMountArc();
}
void VolumeManager::OnLocalUserFilesDisabled() {
CHECK(!policy::local_user_files::LocalUserFilesAllowed());
UnsubscribeAndUnmountArc();
UnmountDownloadsVolume();
if (IsSkyVaultV2Enabled() && read_only_local_folders_) {
// Keep the volume in GA version. It will be removed after migration.
MountDownloadsVolume(/*read_only=*/true);
}
}
void VolumeManager::OnMigrationSucceeded() {
if (policy::local_user_files::LocalUserFilesAllowed()) {
LOG(ERROR)
<< "OnMigrationSucceeded() called but local files allowed, ignoring.";
return;
}
read_only_local_folders_ = false;
OnLocalUserFilesDisabled();
}
void VolumeManager::OnMigrationReset() {
if (!read_only_local_folders_) {
read_only_local_folders_ = true;
OnLocalUserFilesPolicyChanged();
}
}
std::optional<policy::DeviceId> VolumeManager::GetDeviceIdFromDevicePath(
std::string_view device_path) {
const ash::disks::Disk* disk =
disk_mount_manager_->FindDiskBySourcePath(device_path);
return policy::DeviceId::FromDisk(disk);
}
} // namespace file_manager