ash/components/disks/disk_mount_manager.cc

// Copyright (c) 2012 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 "ash/components/disks/disk_mount_manager.h"

#include <stddef.h>
#include <stdint.h>

#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include "ash/components/disks/disk.h"
#include "ash/components/disks/suspend_unmount_manager.h"
#include "ash/constants/ash_features.h"
#include "base/barrier_closure.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/observer_list.h"
#include "base/strings/string_util.h"
#include "chromeos/ash/components/dbus/cros_disks/cros_disks_client.h"

namespace ash::disks {
namespace {

using base::BindOnce;

DiskMountManager* g_disk_mount_manager = nullptr;

struct UnmountDeviceRecursivelyCallbackData {
  explicit UnmountDeviceRecursivelyCallbackData(
      DiskMountManager::UnmountDeviceRecursivelyCallbackType in_callback)
      : callback(std::move(in_callback)) {}

  DiskMountManager::UnmountDeviceRecursivelyCallbackType callback;
  MountError error_code = MOUNT_ERROR_NONE;
};

void OnAllUnmountDeviceRecursively(
    std::unique_ptr<UnmountDeviceRecursivelyCallbackData> cb_data) {
  std::move(cb_data->callback).Run(cb_data->error_code);
}

std::string FormatFileSystemTypeToString(FormatFileSystemType filesystem) {
  switch (filesystem) {
    case FormatFileSystemType::kUnknown:
      return "";
    case FormatFileSystemType::kVfat:
      return "vfat";
    case FormatFileSystemType::kExfat:
      return "exfat";
    case FormatFileSystemType::kNtfs:
      return "ntfs";
  }
  NOTREACHED() << "Unknown filesystem type " << static_cast<int>(filesystem);
  return "";
}

// The DiskMountManager implementation.
class DiskMountManagerImpl : public DiskMountManager,
                             public CrosDisksClient::Observer {
 public:
  DiskMountManagerImpl() {
    cros_disks_client_ = chromeos::CrosDisksClient::Get();
    suspend_unmount_manager_ = std::make_unique<SuspendUnmountManager>(this);

    cros_disks_client_->AddObserver(this);
  }

  DiskMountManagerImpl(const DiskMountManagerImpl&) = delete;
  DiskMountManagerImpl& operator=(const DiskMountManagerImpl&) = delete;

  ~DiskMountManagerImpl() override { cros_disks_client_->RemoveObserver(this); }

  // DiskMountManager override.
  void AddObserver(DiskMountManager::Observer* observer) override {
    observers_.AddObserver(observer);
  }

  // DiskMountManager override.
  void RemoveObserver(DiskMountManager::Observer* observer) override {
    observers_.RemoveObserver(observer);
  }

  // DiskMountManager override.
  void MountPath(const std::string& source_path,
                 const std::string& source_format,
                 const std::string& mount_label,
                 const std::vector<std::string>& mount_options,
                 MountType type,
                 MountAccessMode access_mode,
                 MountPathCallback callback) override {
    if (const auto [_, ok] =
            mount_callbacks_.try_emplace(source_path, std::move(callback));
        !ok) {
      std::move(callback).Run(
          MOUNT_ERROR_PATH_ALREADY_MOUNTED,
          MountPointInfo(source_path, "", type, MOUNT_CONDITION_NONE));
      return;
    }

    // Hidden and non-existent devices should not be mounted.
    if (type == MOUNT_TYPE_DEVICE) {
      DiskMap::const_iterator it = disks_.find(source_path);
      if (it == disks_.end() || it->second->is_hidden()) {
        OnMountCompleted(
            MountEntry(MOUNT_ERROR_INTERNAL, source_path, type, ""));
        return;
      }
    }

    cros_disks_client_->Mount(
        source_path, source_format, mount_label, mount_options, access_mode,
        REMOUNT_OPTION_MOUNT_NEW_DEVICE,
        BindOnce(&DiskMountManagerImpl::OnMount, weak_ptr_factory_.GetWeakPtr(),
                 source_path, type));

    // Record the access mode option passed to CrosDisks.
    // This is needed because CrosDisks service methods doesn't return the info
    // via DBus.
    access_modes_.emplace(source_path, access_mode);
  }

  // DiskMountManager override.
  void UnmountPath(const std::string& mount_path,
                   UnmountPathCallback callback) override {
    UnmountChildMounts(mount_path);
    cros_disks_client_->Unmount(mount_path,
                                BindOnce(&DiskMountManagerImpl::OnUnmountPath,
                                         weak_ptr_factory_.GetWeakPtr(),
                                         std::move(callback), mount_path));
  }

  void RemountAllRemovableDrives(MountAccessMode mode) override {
    // TODO(yamaguchi): Retry for tentative remount failures. crbug.com/661455
    for (const auto& device_path_and_disk : disks_) {
      const Disk& disk = *device_path_and_disk.second;
      if (disk.is_read_only_hardware()) {
        // Read-only devices can be mounted in RO mode only. No need to remount.
        continue;
      }
      if (!disk.is_mounted()) {
        continue;
      }
      RemountRemovableDrive(disk, mode);
    }
  }

  // DiskMountManager override.
  void FormatMountedDevice(const std::string& mount_path,
                           FormatFileSystemType filesystem,
                           const std::string& label) override {
    MountPointMap::const_iterator mount_point = mount_points_.find(mount_path);
    if (mount_point == mount_points_.end()) {
      LOG(ERROR) << "Cannot find mount point '" << mount_path << "'";
      // We can't call OnFormatCompleted until |pending_format_changes_| has
      // been populated.
      NotifyFormatStatusUpdate(FORMAT_COMPLETED, FORMAT_ERROR_UNKNOWN,
                               mount_path, label);
      return;
    }

    std::string device_path = mount_point->second.source_path;
    const std::string filesystem_str = FormatFileSystemTypeToString(filesystem);
    pending_format_changes_[device_path] = {filesystem_str, label};

    DiskMap::const_iterator disk = disks_.find(device_path);
    if (disk == disks_.end()) {
      LOG(ERROR) << "Cannot find device '" << device_path << "'";
      OnFormatCompleted(FORMAT_ERROR_UNKNOWN, device_path);
      return;
    }
    if (disk->second->is_read_only()) {
      LOG(ERROR) << "Device '" << device_path << "' is read-only";
      OnFormatCompleted(FORMAT_ERROR_DEVICE_NOT_ALLOWED, device_path);
      return;
    }

    if (filesystem == FormatFileSystemType::kUnknown) {
      LOG(ERROR) << "Unknown filesystem passed to FormatMountedDevice";
      OnFormatCompleted(FORMAT_ERROR_UNSUPPORTED_FILESYSTEM, device_path);
      return;
    }

    UnmountPath(disk->second->mount_path(),
                BindOnce(&DiskMountManagerImpl::OnUnmountPathForFormat,
                         weak_ptr_factory_.GetWeakPtr(), device_path,
                         filesystem, label));
  }

  // DiskMountManager override.
  void SinglePartitionFormatDevice(const std::string& device_path,
                                   FormatFileSystemType filesystem,
                                   const std::string& label) override {
    DiskMap::const_iterator disk_iter = disks_.find(device_path);
    if (disk_iter == disks_.end()) {
      LOG(ERROR) << "Cannot find device '" << device_path << "'";
      OnPartitionCompleted(device_path, filesystem, label,
                           PARTITION_ERROR_INVALID_DEVICE_PATH);
      return;
    }

    UnmountDeviceRecursively(
        device_path,
        BindOnce(&DiskMountManagerImpl::OnUnmountDeviceForSinglePartitionFormat,
                 weak_ptr_factory_.GetWeakPtr(), device_path, filesystem,
                 label));
  }

  void RenameMountedDevice(const std::string& mount_path,
                           const std::string& volume_name) override {
    MountPointMap::const_iterator mount_point = mount_points_.find(mount_path);
    if (mount_point == mount_points_.end()) {
      LOG(ERROR) << "Cannot find mount point '" << mount_path << "'";
      // We can't call OnRenameCompleted until |pending_rename_changes_| has
      // been populated.
      NotifyRenameStatusUpdate(RENAME_COMPLETED, RENAME_ERROR_UNKNOWN,
                               mount_path, volume_name);
      return;
    }

    std::string device_path = mount_point->second.source_path;
    pending_rename_changes_[device_path] = volume_name;

    DiskMap::const_iterator iter = disks_.find(device_path);
    if (iter == disks_.end()) {
      LOG(ERROR) << "Cannot find device '" << device_path << "'";
      OnRenameCompleted(RENAME_ERROR_UNKNOWN, device_path);
      return;
    }

    if (iter->second->is_read_only()) {
      LOG(ERROR) << "Device '" << device_path << "' is read-only";
      OnRenameCompleted(RENAME_ERROR_DEVICE_NOT_ALLOWED, device_path);
      return;
    }

    UnmountPath(
        iter->second->mount_path(),
        BindOnce(&DiskMountManagerImpl::OnUnmountPathForRename,
                 weak_ptr_factory_.GetWeakPtr(), device_path, volume_name));
  }

  // DiskMountManager override.
  void UnmountDeviceRecursively(
      const std::string& device_path,
      UnmountDeviceRecursivelyCallbackType callback) override {
    std::vector<std::string> devices_to_unmount;

    // Get list of all devices to unmount.
    int device_path_len = device_path.length();
    for (const auto& [_, disk] : disks_) {
      if (!disk->mount_path().empty() &&
          strncmp(device_path.c_str(), disk->device_path().c_str(),
                  device_path_len) == 0) {
        devices_to_unmount.push_back(disk->mount_path());
      }
    }

    // We should detect at least original device.
    if (devices_to_unmount.empty()) {
      if (disks_.find(device_path) == disks_.end()) {
        LOG(WARNING) << "Cannot find device '" << device_path << "'";
        std::move(callback).Run(MOUNT_ERROR_INVALID_DEVICE_PATH);
        return;
      }

      // Nothing to unmount.
      std::move(callback).Run(MOUNT_ERROR_NONE);
      return;
    }

    std::unique_ptr<UnmountDeviceRecursivelyCallbackData> cb_data =
        std::make_unique<UnmountDeviceRecursivelyCallbackData>(
            std::move(callback));
    UnmountDeviceRecursivelyCallbackData* raw_cb_data = cb_data.get();
    base::RepeatingClosure done_callback = base::BarrierClosure(
        devices_to_unmount.size(),
        BindOnce(&OnAllUnmountDeviceRecursively, std::move(cb_data)));

    for (const std::string& device : devices_to_unmount) {
      cros_disks_client_->Unmount(
          device, BindOnce(&DiskMountManagerImpl::OnUnmountDeviceRecursively,
                           weak_ptr_factory_.GetWeakPtr(), raw_cb_data, device,
                           done_callback));
    }
  }

  // DiskMountManager override.
  void EnsureMountInfoRefreshed(EnsureMountInfoRefreshedCallback callback,
                                bool force) override {
    if (!force && already_refreshed_) {
      std::move(callback).Run(true);
      return;
    }

    refresh_callbacks_.push_back(std::move(callback));
    if (refresh_callbacks_.size() == 1) {
      // If there's no in-flight refreshing task, start it.
      cros_disks_client_->EnumerateDevices(
          BindOnce(&DiskMountManagerImpl::RefreshAfterEnumerateDevices,
                   weak_ptr_factory_.GetWeakPtr()),
          BindOnce(&DiskMountManagerImpl::RefreshCompleted,
                   weak_ptr_factory_.GetWeakPtr(), false));
    }
  }

  // DiskMountManager override.
  const DiskMap& disks() const override { return disks_; }

  // DiskMountManager override.
  const Disk* FindDiskBySourcePath(
      const std::string& source_path) const override {
    DiskMap::const_iterator disk_it = disks_.find(source_path);
    return disk_it == disks_.end() ? nullptr : disk_it->second.get();
  }

  // DiskMountManager override.
  const MountPointMap& mount_points() const override { return mount_points_; }

  // DiskMountManager override.
  bool AddDiskForTest(std::unique_ptr<Disk> disk) override {
    if (disks_.find(disk->device_path()) != disks_.end()) {
      LOG(ERROR) << "Attempt to add a duplicate disk";
      return false;
    }

    disks_.emplace(disk->device_path(), std::move(disk));
    return true;
  }

  // DiskMountManager override.
  // Corresponding disk should be added to the manager before this is called.
  bool AddMountPointForTest(const MountPointInfo& mount_point) override {
    if (mount_points_.find(mount_point.mount_path) != mount_points_.end()) {
      LOG(ERROR) << "Attempt to add a duplicate mount point";
      return false;
    }
    if (mount_point.mount_type == chromeos::MOUNT_TYPE_DEVICE &&
        disks_.find(mount_point.source_path) == disks_.end()) {
      LOG(ERROR) << "Device mount points must have a disk entry";
      return false;
    }

    mount_points_.emplace(mount_point.mount_path, mount_point);
    return true;
  }

 private:
  // A struct to represent information about a format changes.
  struct FormatChange {
    // new file system type
    std::string file_system_type;
    // New volume name
    std::string volume_name;
  };

  // Stores new volume name and file system type for a device on which
  // formatting is invoked on, so that OnFormatCompleted can set it back to
  // |disks_|. The key is a device_path and the value is a FormatChange.
  std::map<std::string, FormatChange> pending_format_changes_;

  // Stores device path are being partitioning.
  // It allows preventing auto-mount of the disks in this set.
  std::set<std::string> pending_partitioning_disks_;

  // Stores new volume name for a device on which renaming is invoked on, so
  // that OnRenameCompleted can set it back to |disks_|. The key is a
  // device_path and the value is new volume_name.
  std::map<std::string, std::string> pending_rename_changes_;

  // Called on D-Bus CrosDisksClient::Mount() is done.
  void OnMount(const std::string& source_path, MountType type, bool result) {
    // When succeeds, OnMountCompleted will be called by "MountCompleted",
    // signal instead. Do nothing now.
    if (result)
      return;

    OnMountCompleted(
        MountEntry(MOUNT_ERROR_INTERNAL, source_path, type, std::string()));
  }

  void RemountRemovableDrive(const Disk& disk, MountAccessMode access_mode) {
    const std::string& mount_path = disk.mount_path();
    MountPointMap::const_iterator mount_point = mount_points_.find(mount_path);
    if (mount_point == mount_points_.end()) {
      // Not in mount_points_. This happens when the mount_points and disks_ are
      // inconsistent.
      LOG(ERROR) << "Cannot find mount point '" << mount_path << "'";
      OnMountCompleted(MountEntry(MOUNT_ERROR_PATH_NOT_MOUNTED,
                                  disk.device_path(), MOUNT_TYPE_DEVICE,
                                  mount_path));
      return;
    }
    const std::string& source_path = mount_point->second.source_path;

    // Update the access mode option passed to CrosDisks.
    // This is needed because CrosDisks service methods doesn't return the info
    // via DBus, and must be updated before issuing Mount command as it'll be
    // read by the handler of MountCompleted signal.
    access_modes_[source_path] = access_mode;

    cros_disks_client_->Mount(
        mount_point->second.source_path, std::string(), std::string(), {},
        access_mode, REMOUNT_OPTION_REMOUNT_EXISTING_DEVICE,
        BindOnce(&DiskMountManagerImpl::OnMount, weak_ptr_factory_.GetWeakPtr(),
                 source_path, mount_point->second.mount_type));
  }

  // Unmounts all mount points whose source path is transitively parented by
  // |mount_path|.
  void UnmountChildMounts(std::string mount_path) {
    DCHECK(!mount_path.empty());

    // Let's make sure mount path has trailing slash.
    if (mount_path.back() != '/')
      mount_path += '/';

    for (const auto& [_, mount_point] : mount_points_) {
      if (base::StartsWith(mount_point.source_path, mount_path,
                           base::CompareCase::SENSITIVE)) {
        UnmountPath(mount_point.mount_path,
                    BindOnce(
                        [](const std::string& path, MountError error) {
                          LOG(ERROR)
                              << "Cannot unmount '" << path << "': " << error;
                        },
                        mount_point.mount_path));
      }
    }
  }

  // Callback for UnmountDeviceRecursively.
  void OnUnmountDeviceRecursively(UnmountDeviceRecursivelyCallbackData* cb_data,
                                  const std::string& mount_path,
                                  base::OnceClosure done_callback,
                                  MountError error_code) {
    if (error_code == MOUNT_ERROR_PATH_NOT_MOUNTED ||
        error_code == MOUNT_ERROR_INVALID_PATH) {
      // The path was already unmounted by something else.
      error_code = MOUNT_ERROR_NONE;
    }

    if (error_code == MOUNT_ERROR_NONE) {
      // Do standard processing for Unmount event.
      OnUnmountPath(UnmountPathCallback(), mount_path, MOUNT_ERROR_NONE);
      VLOG(1) << "Unmounted '" << mount_path << "'";
    } else {
      // This causes the last non-success error to be reported.
      cb_data->error_code = error_code;
    }

    std::move(done_callback).Run();
  }

  // CrosDisksClient::Observer override.
  void OnMountCompleted(const MountEntry& entry) override {
    auto iter = deferred_mount_events_.find(entry.source_path());
    if (iter != deferred_mount_events_.end()) {
      iter->second.push_back(entry);
      return;
    }

    MountCondition mount_condition = MOUNT_CONDITION_NONE;
    if (entry.mount_type() == MOUNT_TYPE_DEVICE) {
      if (entry.error_code() == MOUNT_ERROR_UNKNOWN_FILESYSTEM) {
        mount_condition = MOUNT_CONDITION_UNKNOWN_FILESYSTEM;
      }
      if (entry.error_code() == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
        mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
      }
    }
    const MountPointInfo mount_info(entry.source_path(), entry.mount_path(),
                                    entry.mount_type(), mount_condition);

    // If the device is corrupted but it's still possible to format it, it will
    // be fake mounted.
    if (entry.error_code() == MOUNT_ERROR_NONE || mount_info.mount_condition) {
      mount_points_.emplace(mount_info.mount_path, mount_info);
    }

    Disk* disk = nullptr;
    if ((entry.error_code() == MOUNT_ERROR_NONE ||
         mount_info.mount_condition) &&
        mount_info.mount_type == MOUNT_TYPE_DEVICE &&
        !mount_info.source_path.empty() && !mount_info.mount_path.empty()) {
      DiskMap::iterator disk_map_iter = disks_.find(mount_info.source_path);
      if (disk_map_iter != disks_.end()) {  // disk might have been removed?
        disk = disk_map_iter->second.get();
        DCHECK(disk);
        // Currently the MountCompleted signal doesn't tell whether the device
        // is mounted in read-only mode or not. Instead use the mount option
        // recorded by DiskMountManagerImpl::MountPath().
        // |source_path| should be same as |disk->device_path| because
        // |VolumeManager::OnDiskEvent()| passes the latter to cros-disks as a
        // source path when mounting a device.
        AccessModeMap::iterator it = access_modes_.find(entry.source_path());

        // Store whether the disk was mounted in read-only mode due to a policy.
        disk->set_write_disabled_by_policy(
            it != access_modes_.end() && !disk->is_read_only_hardware() &&
            it->second == MOUNT_ACCESS_MODE_READ_ONLY);
        disk->SetMountPath(mount_info.mount_path);
        // Only set the mount path if the disk is actually mounted. Right now, a
        // number of code paths (format, rename, unmount) rely on the mount path
        // being set even if the disk isn't mounted. cros-disks also does some
        // tracking of non-mounted mount paths. Making this change is
        // non-trivial.
        // TODO(amistry): Change these code paths to use device path instead of
        // mount path.
        disk->set_mounted(entry.error_code() == MOUNT_ERROR_NONE);
      }
    }
    // Observers may read the values of disks_. So notify them after tweaking
    // values of disks_.
    auto it = mount_callbacks_.find(entry.source_path());
    if (it != mount_callbacks_.end()) {
      std::move(it->second).Run(entry.error_code(), mount_info);
      mount_callbacks_.erase(it);
    }
    NotifyMountStatusUpdate(MOUNTING, entry.error_code(), mount_info);

    if (disk) {
      disk->set_is_first_mount(false);
    }
  }

  // Callback for UnmountPath.
  void OnUnmountPath(UnmountPathCallback callback,
                     const std::string& mount_path,
                     MountError error) {
    if (error == MOUNT_ERROR_PATH_NOT_MOUNTED ||
        error == MOUNT_ERROR_INVALID_PATH) {
      // The path was already unmounted by something else.
      error = MOUNT_ERROR_NONE;
    }

    if (const MountPointMap::const_iterator mp_it =
            mount_points_.find(mount_path);
        mp_it != mount_points_.end()) {
      const MountPointInfo& mp = mp_it->second;
      NotifyMountStatusUpdate(UNMOUNTING, error, mp);

      if (error == MOUNT_ERROR_NONE) {
        if (const DiskMap::iterator disk_it = disks_.find(mp.source_path);
            disk_it != disks_.end()) {
          Disk* const disk = disk_it->second.get();
          DCHECK(disk);
          disk->clear_mount_path();
          disk->set_mounted(false);
        }

        mount_points_.erase(mp_it);
      }
    }

    if (callback)
      std::move(callback).Run(error);
  }

  void OnUnmountPathForFormat(const std::string& device_path,
                              FormatFileSystemType filesystem,
                              const std::string& label,
                              MountError error_code) {
    if (error_code == MOUNT_ERROR_NONE &&
        disks_.find(device_path) != disks_.end()) {
      FormatUnmountedDevice(device_path, filesystem, label);
    } else {
      OnFormatCompleted(FORMAT_ERROR_UNKNOWN, device_path);
    }
  }

  void OnUnmountDeviceForSinglePartitionFormat(const std::string& device_path,
                                               FormatFileSystemType filesystem,
                                               const std::string& label,
                                               MountError error_code) {
    if (error_code != MOUNT_ERROR_NONE ||
        disks_.find(device_path) == disks_.end()) {
      OnPartitionCompleted(device_path, filesystem, label,
                           PARTITION_ERROR_UNKNOWN);
      return;
    }

    SinglePartitionFormatUnmountedDevice(device_path, filesystem, label);
  }

  // Starts device formatting.
  void FormatUnmountedDevice(const std::string& device_path,
                             FormatFileSystemType filesystem,
                             const std::string& label) {
    DiskMap::const_iterator disk = disks_.find(device_path);
    DCHECK(disk != disks_.end() && disk->second->mount_path().empty());

    base::UmaHistogramEnumeration("FileBrowser.FormatFileSystemType",
                                  filesystem);

    cros_disks_client_->Format(
        device_path, FormatFileSystemTypeToString(filesystem), label,
        BindOnce(&DiskMountManagerImpl::OnFormatStarted,
                 weak_ptr_factory_.GetWeakPtr(), device_path, label));
  }

  // Callback for Format.
  void OnFormatStarted(const std::string& device_path,
                       const std::string& device_label,
                       bool success) {
    if (!success) {
      OnFormatCompleted(FORMAT_ERROR_UNKNOWN, device_path);
      return;
    }

    NotifyFormatStatusUpdate(FORMAT_STARTED, FORMAT_ERROR_NONE, device_path,
                             device_label);
  }

  // CrosDisksClient::Observer override.
  void OnFormatCompleted(FormatError error_code,
                         const std::string& device_path) override {
    std::string device_label;
    auto pending_change = pending_format_changes_.find(device_path);
    if (pending_change != pending_format_changes_.end()) {
      device_label = pending_change->second.volume_name;
    }

    auto iter = disks_.find(device_path);

    // disk might have been removed by now?
    if (iter != disks_.end()) {
      Disk* disk = iter->second.get();
      DCHECK(disk);

      if (pending_change != pending_format_changes_.end() &&
          error_code == FORMAT_ERROR_NONE) {
        disk->set_device_label(pending_change->second.volume_name);
        disk->set_file_system_type(pending_change->second.file_system_type);
      }
    }

    pending_format_changes_.erase(device_path);

    EnsureMountInfoRefreshed(base::DoNothing(), true /* force */);

    NotifyFormatStatusUpdate(FORMAT_COMPLETED, error_code, device_path,
                             device_label);
  }

  void SinglePartitionFormatUnmountedDevice(const std::string& device_path,
                                            FormatFileSystemType filesystem,
                                            const std::string& label) {
    DiskMap::const_iterator disk = disks_.find(device_path);
    DCHECK(disk != disks_.end() && disk->second->mount_path().empty());

    pending_partitioning_disks_.insert(disk->second->device_path());

    NotifyPartitionStatusUpdate(PARTITION_STARTED, PARTITION_ERROR_NONE,
                                device_path, label);

    cros_disks_client_->SinglePartitionFormat(
        disk->second->file_path(),
        BindOnce(&DiskMountManagerImpl::OnPartitionCompleted,
                 weak_ptr_factory_.GetWeakPtr(), device_path, filesystem,
                 label));
  }

  void OnPartitionCompleted(const std::string& device_path,
                            FormatFileSystemType filesystem,
                            const std::string& label,
                            PartitionError error_code) {
    auto iter = disks_.find(device_path);

    // disk might have been removed by now?
    if (iter != disks_.end()) {
      Disk* disk = iter->second.get();
      DCHECK(disk);

      if (error_code == PARTITION_ERROR_NONE) {
        EnsureMountInfoRefreshed(
            BindOnce(&DiskMountManagerImpl::OnRefreshAfterPartition,
                     weak_ptr_factory_.GetWeakPtr(), device_path, filesystem,
                     label),
            true /* force */);
      }

    } else {
      // Remove disk from pending partitioning list if disk removed.
      pending_partitioning_disks_.erase(iter->second->device_path());
    }

    NotifyPartitionStatusUpdate(PARTITION_COMPLETED, error_code, device_path,
                                label);
  }

  void OnRefreshAfterPartition(const std::string& device_path,
                               FormatFileSystemType filesystem,
                               const std::string& label,
                               bool success) {
    DiskMap::const_iterator device_disk = disks_.find(device_path);
    if (device_disk == disks_.end()) {
      LOG(ERROR) << "Device not found, maybe ejected";
      pending_partitioning_disks_.erase(device_path);
      NotifyPartitionStatusUpdate(PARTITION_COMPLETED,
                                  PARTITION_ERROR_INVALID_DEVICE_PATH,
                                  device_path, label);
      return;
    }

    std::string new_partition_device_path;
    // Find new partition using common storage path with parent device.
    for (DiskMountManager::DiskMap::const_iterator it = disks_.begin();
         it != disks_.end(); ++it) {
      if (it->second->storage_device_path() ==
              device_disk->second->storage_device_path() &&
          !it->second->is_parent()) {
        new_partition_device_path = it->second->device_path();
        break;
      }
    }

    if (new_partition_device_path.empty()) {
      LOG(ERROR) << "New partition couldn't be found";
      pending_partitioning_disks_.erase(device_path);
      NotifyPartitionStatusUpdate(PARTITION_COMPLETED,
                                  PARTITION_ERROR_INVALID_DEVICE_PATH,
                                  device_path, label);
      return;
    }

    const std::string filesystem_str = FormatFileSystemTypeToString(filesystem);
    pending_format_changes_[new_partition_device_path] = {filesystem_str,
                                                          label};

    // It's expected the disks (parent device and new partition) are not
    // mounted, but try unmounting before starting format if it got
    // mounted through another flow.
    UnmountDeviceRecursively(
        device_path, BindOnce(&DiskMountManagerImpl::OnUnmountPathForFormat,
                              weak_ptr_factory_.GetWeakPtr(),
                              new_partition_device_path, filesystem, label));

    // It's ok to remove it from pending partitioning as format flow started.
    pending_partitioning_disks_.erase(device_path);
  }

  void OnUnmountPathForRename(const std::string& device_path,
                              const std::string& volume_name,
                              MountError error_code) {
    if (error_code != MOUNT_ERROR_NONE ||
        disks_.find(device_path) == disks_.end()) {
      OnRenameCompleted(RENAME_ERROR_UNKNOWN, device_path);
      return;
    }

    RenameUnmountedDevice(device_path, volume_name);
  }

  // Start device renaming
  void RenameUnmountedDevice(const std::string& device_path,
                             const std::string& volume_name) {
    DiskMap::const_iterator disk = disks_.find(device_path);
    DCHECK(disk != disks_.end() && disk->second->mount_path().empty());

    cros_disks_client_->Rename(
        device_path, volume_name,
        BindOnce(&DiskMountManagerImpl::OnRenameStarted,
                 weak_ptr_factory_.GetWeakPtr(), device_path, volume_name));
  }

  // Callback for Rename.
  void OnRenameStarted(const std::string& device_path,
                       const std::string& volume_name,
                       bool success) {
    if (!success) {
      OnRenameCompleted(RENAME_ERROR_UNKNOWN, device_path);
      return;
    }

    NotifyRenameStatusUpdate(RENAME_STARTED, RENAME_ERROR_NONE, device_path,
                             volume_name);
  }

  // CrosDisksClient::Observer override.
  void OnRenameCompleted(RenameError error_code,
                         const std::string& device_path) override {
    std::string device_label;
    auto pending_change = pending_rename_changes_.find(device_path);
    if (pending_change != pending_rename_changes_.end()) {
      device_label = pending_change->second;
    }

    auto iter = disks_.find(device_path);

    // disk might have been removed by now?
    if (iter != disks_.end()) {
      Disk* disk = iter->second.get();
      DCHECK(disk);

      if (pending_change != pending_rename_changes_.end() &&
          error_code == RENAME_ERROR_NONE)
        disk->set_device_label(pending_change->second);
    }

    pending_rename_changes_.erase(device_path);

    NotifyRenameStatusUpdate(RENAME_COMPLETED, error_code, device_path,
                             device_label);
  }

  // Fire observer mount events that were deferred due to an in-progress
  // GetDeviceProperties() call.
  void RunDeferredMountEvents(const std::string& device_path) {
    auto mount_events_iter = deferred_mount_events_.find(device_path);
    if (mount_events_iter == deferred_mount_events_.end())
      return;
    std::vector<MountEntry> entries = std::move(mount_events_iter->second);
    deferred_mount_events_.erase(mount_events_iter);
    for (const MountEntry& entry : entries)
      OnMountCompleted(entry);
  }

  // Callback for GetDeviceProperties.
  void OnGetDeviceProperties(const DiskInfo& disk_info) {
    if (disk_info.is_virtual()) {
      RunDeferredMountEvents(disk_info.device_path());
      return;
    }

    DVLOG(1) << "Found disk " << disk_info.device_path();
    // Delete previous disk info for this path:
    bool is_new = true;
    bool is_first_mount = false;
    std::string base_mount_path = std::string();
    DiskMap::iterator iter = disks_.find(disk_info.device_path());
    if (iter != disks_.end()) {
      is_first_mount = iter->second->is_first_mount();
      base_mount_path = iter->second->base_mount_path();
      disks_.erase(iter);
      is_new = false;
    }

    // If the device was mounted by the instance, apply recorded parameter.
    // Otherwise, default to false.
    // Lookup by |device_path| which we pass to cros-disks when mounting a
    // device in |VolumeManager::OnDiskEvent()|.
    auto access_mode = access_modes_.find(disk_info.device_path());
    bool write_disabled_by_policy =
        access_mode != access_modes_.end() &&
        access_mode->second == chromeos::MOUNT_ACCESS_MODE_READ_ONLY;
    Disk* disk = new Disk(disk_info, write_disabled_by_policy, base_mount_path);
    if (!is_new) {
      disk->set_is_first_mount(is_first_mount);
    }
    disks_.emplace(disk_info.device_path(), base::WrapUnique(disk));
    NotifyDiskStatusUpdate(is_new ? DISK_ADDED : DISK_CHANGED, *disk);
    RunDeferredMountEvents(disk_info.device_path());
  }

  // Part of EnsureMountInfoRefreshed(). Called after the list of devices are
  // enumerated.
  void RefreshAfterEnumerateDevices(const std::vector<std::string>& devices) {
    std::set<std::string> current_device_set(devices.begin(), devices.end());
    for (DiskMap::iterator iter = disks_.begin(); iter != disks_.end();) {
      if (current_device_set.find(iter->first) == current_device_set.end()) {
        iter = disks_.erase(iter);
      } else {
        ++iter;
      }
    }
    RefreshDeviceAtIndex(devices, 0);
  }

  // Part of EnsureMountInfoRefreshed(). Called for each device to refresh info.
  void RefreshDeviceAtIndex(const std::vector<std::string>& devices,
                            size_t index) {
    if (index == devices.size()) {
      // All devices info retrieved. Proceed to enumerate mount point info.
      cros_disks_client_->EnumerateMountEntries(
          BindOnce(&DiskMountManagerImpl::RefreshAfterEnumerateMountEntries,
                   weak_ptr_factory_.GetWeakPtr()),
          BindOnce(&DiskMountManagerImpl::RefreshCompleted,
                   weak_ptr_factory_.GetWeakPtr(), false));
      return;
    }

    cros_disks_client_->GetDeviceProperties(
        devices[index],
        BindOnce(&DiskMountManagerImpl::RefreshAfterGetDeviceProperties,
                 weak_ptr_factory_.GetWeakPtr(), devices, index + 1),
        BindOnce(&DiskMountManagerImpl::RefreshDeviceAtIndex,
                 weak_ptr_factory_.GetWeakPtr(), devices, index + 1));
  }

  // Part of EnsureMountInfoRefreshed().
  void RefreshAfterGetDeviceProperties(const std::vector<std::string>& devices,
                                       size_t next_index,
                                       const DiskInfo& disk_info) {
    OnGetDeviceProperties(disk_info);
    RefreshDeviceAtIndex(devices, next_index);
  }

  // Part of EnsureMountInfoRefreshed(). Called after mount entries are listed.
  void RefreshAfterEnumerateMountEntries(
      const std::vector<MountEntry>& entries) {
    for (const auto& entry : entries)
      OnMountCompleted(entry);
    RefreshCompleted(true);
  }

  // Part of EnsureMountInfoRefreshed(). Called when the refreshing is done.
  void RefreshCompleted(bool success) {
    already_refreshed_ = true;
    for (auto& callback : refresh_callbacks_)
      std::move(callback).Run(success);
    refresh_callbacks_.clear();
  }

  // CrosDisksClient::Observer override.
  void OnMountEvent(MountEventType event,
                    const std::string& device_path_arg) override {
    // Take a copy of the argument so we can modify it below.
    std::string device_path = device_path_arg;
    switch (event) {
      case CROS_DISKS_DISK_ADDED: {
        // Ensure we have an entry indicating we're waiting for
        // GetDeviceProperties() to complete.
        deferred_mount_events_[device_path];
        cros_disks_client_->GetDeviceProperties(
            device_path,
            BindOnce(&DiskMountManagerImpl::OnGetDeviceProperties,
                     weak_ptr_factory_.GetWeakPtr()),
            base::DoNothing());
        break;
      }
      case CROS_DISKS_DISK_REMOVED: {
        // Search and remove disks that are no longer present.
        DiskMountManager::DiskMap::iterator iter = disks_.find(device_path);
        if (iter != disks_.end()) {
          Disk* disk = iter->second.get();
          NotifyDiskStatusUpdate(DISK_REMOVED, *disk);
          disks_.erase(iter);
        }
        break;
      }
      case CROS_DISKS_DEVICE_ADDED: {
        NotifyDeviceStatusUpdate(DEVICE_ADDED, device_path);
        break;
      }
      case CROS_DISKS_DEVICE_REMOVED: {
        NotifyDeviceStatusUpdate(DEVICE_REMOVED, device_path);
        break;
      }
      case CROS_DISKS_DEVICE_SCANNED: {
        NotifyDeviceStatusUpdate(DEVICE_SCANNED, device_path);
        break;
      }
      default: {
        LOG(ERROR) << "Unknown event: " << event;
      }
    }
  }

  // Notifies all observers about disk status update.
  void NotifyDiskStatusUpdate(DiskEvent event, const Disk& disk) {
    for (auto& observer : observers_) {
      // Skip mounting of new partitioned disks while waiting for the format.
      if (IsPendingPartitioningDisk(disk.device_path())) {
        continue;
      }
      disk.is_auto_mountable() ? observer.OnAutoMountableDiskEvent(event, disk)
                               : observer.OnBootDeviceDiskEvent(event, disk);
    }
  }

  // Notifies all observers about device status update.
  void NotifyDeviceStatusUpdate(DeviceEvent event,
                                const std::string& device_path) {
    for (auto& observer : observers_)
      observer.OnDeviceEvent(event, device_path);
  }

  // Notifies all observers about mount completion.
  void NotifyMountStatusUpdate(MountEvent event,
                               MountError error_code,
                               const MountPointInfo& mount_info) {
    for (auto& observer : observers_)
      observer.OnMountEvent(event, error_code, mount_info);
  }

  void NotifyFormatStatusUpdate(FormatEvent event,
                                FormatError error_code,
                                const std::string& device_path,
                                const std::string& device_label) {
    for (auto& observer : observers_)
      observer.OnFormatEvent(event, error_code, device_path, device_label);
  }

  void NotifyPartitionStatusUpdate(PartitionEvent event,
                                   PartitionError error_code,
                                   const std::string& device_path,
                                   const std::string& device_label) {
    for (auto& observer : observers_)
      observer.OnPartitionEvent(event, error_code, device_path, device_label);
  }

  void NotifyRenameStatusUpdate(RenameEvent event,
                                RenameError error_code,
                                const std::string& device_path,
                                const std::string& device_label) {
    for (auto& observer : observers_)
      observer.OnRenameEvent(event, error_code, device_path, device_label);
  }

  bool IsPendingPartitioningDisk(const std::string& device_path) {
    if (pending_partitioning_disks_.find(device_path) !=
        pending_partitioning_disks_.end()) {
      return true;
    }

    // If device path doesn't match check whether if it's a child path.
    for (const auto& disk : pending_partitioning_disks_) {
      if (base::StartsWith(device_path, disk, base::CompareCase::SENSITIVE)) {
        return true;
      }
    }
    return false;
  }

  // Mount event change observers.
  base::ObserverList<DiskMountManager::Observer> observers_;

  CrosDisksClient* cros_disks_client_;

  // The list of disks found.
  DiskMountManager::DiskMap disks_;

  std::map<std::string, MountPathCallback> mount_callbacks_;
  DiskMountManager::MountPointMap mount_points_;

  // A map entry with a key of the device path will be created upon calling
  // GetDeviceProperties(), for deferring mount events, and removed once it has
  // completed. This prevents a race resulting in mount events being fired with
  // the corresponding Disk entry unexpectedly missing.
  std::map<std::string, std::vector<MountEntry>> deferred_mount_events_;

  bool already_refreshed_ = false;
  std::vector<EnsureMountInfoRefreshedCallback> refresh_callbacks_;

  std::unique_ptr<SuspendUnmountManager> suspend_unmount_manager_;

  // Whether the instance attempted to mount a device in read-only mode for
  // each source path.
  typedef std::map<std::string, chromeos::MountAccessMode> AccessModeMap;
  AccessModeMap access_modes_;

  base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_{this};
};

}  // namespace

DiskMountManager::Observer::~Observer() {
  DCHECK(!IsInObserverList());
}

bool DiskMountManager::AddDiskForTest(std::unique_ptr<Disk> disk) {
  return false;
}

bool DiskMountManager::AddMountPointForTest(const MountPointInfo& mount_point) {
  return false;
}

// static
std::string DiskMountManager::MountConditionToString(MountCondition condition) {
  switch (condition) {
    case MOUNT_CONDITION_NONE:
      return "";
    case MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
      return "unknown_filesystem";
    case MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
      return "unsupported_filesystem";
    default:
      NOTREACHED();
  }
  return "";
}

// static
std::string DiskMountManager::DeviceTypeToString(DeviceType type) {
  switch (type) {
    case DEVICE_TYPE_USB:
      return "usb";
    case DEVICE_TYPE_SD:
      return "sd";
    case DEVICE_TYPE_OPTICAL_DISC:
      return "optical";
    case DEVICE_TYPE_MOBILE:
      return "mobile";
    default:
      return "unknown";
  }
}

// static
void DiskMountManager::Initialize() {
  if (g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager was already initialized";
    return;
  }
  g_disk_mount_manager = new DiskMountManagerImpl();
  VLOG(1) << "DiskMountManager initialized";
}

// static
void DiskMountManager::InitializeForTesting(
    DiskMountManager* disk_mount_manager) {
  if (g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager was already initialized";
    return;
  }
  g_disk_mount_manager = disk_mount_manager;
  VLOG(1) << "DiskMountManager initialized";
}

// static
void DiskMountManager::Shutdown() {
  if (!g_disk_mount_manager) {
    LOG(WARNING) << "DiskMountManager::Shutdown() called with NULL manager";
    return;
  }
  delete g_disk_mount_manager;
  g_disk_mount_manager = nullptr;
  VLOG(1) << "DiskMountManager Shutdown completed";
}

// static
DiskMountManager* DiskMountManager::GetInstance() {
  return g_disk_mount_manager;
}

}  // namespace ash::disks