// Copyright 2020 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/ui/ash/holding_space/holding_space_file_system_delegate.h"

#include <algorithm>
#include <set>
#include <string>

#include "ash/constants/ash_features.h"
#include "ash/public/cpp/holding_space/holding_space_constants.h"
#include "ash/public/cpp/holding_space/holding_space_file.h"
#include "ash/public/cpp/holding_space/holding_space_item.h"
#include "ash/public/cpp/holding_space/holding_space_model.h"
#include "base/containers/contains.h"
#include "base/files/file_path.h"
#include "base/files/file_path_watcher.h"
#include "base/files/file_util.h"
#include "base/sequence_checker.h"
#include "base/task/sequenced_task_runner.h"
#include "base/task/task_traits.h"
#include "base/task/thread_pool.h"
#include "base/time/time.h"
#include "chrome/browser/ash/arc/arc_util.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/trash_common_util.h"
#include "chrome/browser/ash/file_manager/volume_manager.h"
#include "chrome/browser/ash/fileapi/file_change_service_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chromeos/ash/experiences/arc/session/arc_bridge_service.h"
#include "chromeos/ash/experiences/arc/session/arc_service_manager.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "url/gurl.h"

namespace ash {

namespace {

// Returns the absolute file path for the specified `drive_path`.
// NOTE: This method requires that the `DriveIntegrationService` be mounted.
base::FilePath ConvertDrivePathToAbsoluteFilePath(
    Profile* profile,
    const base::FilePath& drive_path) {
  const auto* drive_integration_service =
      drive::DriveIntegrationServiceFactory::FindForProfile(profile);
  if (drive_integration_service) {
    base::FilePath absolute_file_path =
        drive_integration_service->GetMountPointPath();
    if (base::FilePath("/").AppendRelativePath(drive_path,
                                               &absolute_file_path)) {
      return absolute_file_path;
    }
  }
  NOTREACHED();
}

// Returns a mojo connection to the ARC file system.
arc::ConnectionHolder<arc::mojom::FileSystemInstance,
                      arc::mojom::FileSystemHost>*
GetArcFileSystem() {
  if (!arc::ArcServiceManager::Get()) {
    return nullptr;
  }
  return arc::ArcServiceManager::Get()->arc_bridge_service()->file_system();
}

// Returns whether:
// *   the ARC is enabled for `profile`, and
// *   connection to ARC file system service is *not* established at the time.
bool IsArcFileSystemDisconnected(Profile* profile) {
  return arc::IsArcPlayStoreEnabledForProfile(profile) && GetArcFileSystem() &&
         !GetArcFileSystem()->IsConnected();
}

// Returns whether the item is backed by an Android file. Can be used with
// non-initialized items.
bool ItemBackedByAndroidFile(const HoldingSpaceItem* item) {
  return file_manager::util::GetAndroidFilesPath().IsParent(
      item->file().file_path);
}

}  // namespace

// HoldingSpaceFileSystemDelegate::FileSystemWatcher ---------------------------

class HoldingSpaceFileSystemDelegate::FileSystemWatcher {
 public:
  explicit FileSystemWatcher(base::FilePathWatcher::Callback callback)
      : callback_(callback) {
    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
    DETACH_FROM_SEQUENCE(sequence_checker_);
  }

  FileSystemWatcher(const FileSystemWatcher&) = delete;
  FileSystemWatcher& operator=(const FileSystemWatcher&) = delete;
  ~FileSystemWatcher() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); }

  void AddWatchForParent(const base::FilePath& file_path) {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

    // Observe the file path parent directory for changes - this reduces the
    // number of inotify requests, and works well enough for detecting file
    // deletion.
    const base::FilePath path_to_watch = file_path.DirName();

    auto it = watchers_.lower_bound(path_to_watch);
    if (it == watchers_.end() || it->first != path_to_watch) {
      it = watchers_.emplace_hint(it, std::piecewise_construct,
                                  std::forward_as_tuple(path_to_watch),
                                  std::forward_as_tuple());
      it->second.Watch(
          path_to_watch, base::FilePathWatcher::Type::kNonRecursive,
          base::BindRepeating(&FileSystemWatcher::OnFilePathChanged,
                              weak_factory_.GetWeakPtr()));
    }

    // If the target path got deleted while request to add a watcher was in
    // flight, notify observers of path change immediately.
    if (!base::PathExists(file_path)) {
      OnFilePathChanged(path_to_watch, /*error=*/false);
    }
  }

  void RemoveWatch(const base::FilePath& file_path) {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    watchers_.erase(file_path);
  }

  base::WeakPtr<FileSystemWatcher> GetWeakPtr() {
    return weak_factory_.GetWeakPtr();
  }

 private:
  void OnFilePathChanged(const base::FilePath& file_path, bool error) {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
    // In tests `OnFilePathChanged()` events are sometimes propagated before
    // `OnFileMoved()` events. Delay propagation of `OnFilePathChanged()`
    // events to give `OnFileMoved()` events time to propagate.
    content::GetUIThreadTaskRunner({})->PostDelayedTask(
        FROM_HERE, base::BindOnce(callback_, file_path, error),
        base::Milliseconds(1));
  }

  SEQUENCE_CHECKER(sequence_checker_);
  base::FilePathWatcher::Callback callback_;
  std::map<base::FilePath, base::FilePathWatcher> watchers_;
  base::WeakPtrFactory<FileSystemWatcher> weak_factory_{this};
};

// HoldingSpaceFileSystemDelegate ----------------------------------------------

HoldingSpaceFileSystemDelegate::HoldingSpaceFileSystemDelegate(
    HoldingSpaceKeyedService* service,
    HoldingSpaceModel* model)
    : HoldingSpaceKeyedServiceDelegate(service, model),
      file_system_watcher_runner_(base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT})) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
}

HoldingSpaceFileSystemDelegate::~HoldingSpaceFileSystemDelegate() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  weak_factory_.InvalidateWeakPtrs();
  file_system_watcher_runner_->DeleteSoon(FROM_HERE,
                                          file_system_watcher_.release());
}

void HoldingSpaceFileSystemDelegate::OnConnectionReady() {
  // Schedule validity checks for android items.
  for (auto& item : model()->items()) {
    if (!ItemBackedByAndroidFile(item.get())) {
      continue;
    }

    holding_space_util::ValidityRequirement requirements;
    if (item->type() != HoldingSpaceItem::Type::kPinnedFile) {
      requirements.must_be_newer_than = kMaxFileAge;
    }
    ScheduleFilePathValidityCheck({item->file().file_path, requirements});
  }
}

void HoldingSpaceFileSystemDelegate::OnFilesChanged(
    const std::vector<drivefs::mojom::FileChange>& changes) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // When a file is moved, a `kDelete` change will be followed by a `kCreate`
  // change with the same `stable_id` in the same set of `changes`. In some
  // versions of the `DriveFsHost`, `stable_id` is not supported and will always
  // be `0` for backwards compatibility.
  std::map<int64_t, base::FilePath> deleted_paths_by_stable_id;
  std::set<base::FilePath> deleted_paths;

  for (const auto& change : changes) {
    // Holding space requires absolute file paths.
    const base::FilePath absolute_file_path =
        ConvertDrivePathToAbsoluteFilePath(profile(), change.path);
    if (absolute_file_path.empty()) {
      continue;
    }

    switch (change.type) {
      case drivefs::mojom::FileChange::Type::kCreate: {
        if (change.stable_id) {
          // If the `kCreate` change has an associated `stable_id`, it can
          // potentially be paired with a preceding `kDelete` change. In such
          // cases, the change sequence actually constitutes a move rather than
          // a delete of the underlying file.
          auto it = deleted_paths_by_stable_id.find(change.stable_id);
          if (it != deleted_paths_by_stable_id.end()) {
            OnFilePathMoved(/*src=*/it->second, /*dst=*/absolute_file_path);
            deleted_paths_by_stable_id.erase(it);
          }
        }
        break;
      }
      case drivefs::mojom::FileChange::Type::kDelete: {
        // If the change has a `stable_id` it can potentially constitute part of
        // a move rather than a delete of the underlying file. Whether the
        // change is move or a delete will not be known until a `kCreate` change
        // follows (or is confirmed *not* to follow). When `stable_id` is absent
        // it is not possible to detect a move.
        if (change.stable_id) {
          deleted_paths_by_stable_id[change.stable_id] = absolute_file_path;
        } else {
          deleted_paths.insert(absolute_file_path);
        }
        break;
      }
      case drivefs::mojom::FileChange::Type::kModify: {
        OnFilePathModified(absolute_file_path);
        break;
      }
    }
  }

  // At this point, all `kDelete` changes in `deleted_paths_by_stable_id` are
  // confirmed to be deletions, having already stripped out all changes that
  // were actually constituting moves.
  for (const auto& deleted_path_by_stable_id : deleted_paths_by_stable_id) {
    deleted_paths.insert(deleted_path_by_stable_id.second);
  }

  // Remove any holding space items backed by deleted file paths.
  model()->RemoveIf(base::BindRepeating(
      [](const std::set<base::FilePath>& deleted_paths,
         const HoldingSpaceItem* item) {
        return std::ranges::any_of(
            deleted_paths, [&](const base::FilePath& deleted_path) {
              return item->file().file_path == deleted_path ||
                     deleted_path.IsParent(item->file().file_path);
            });
      },
      std::cref(deleted_paths)));
}

void HoldingSpaceFileSystemDelegate::Init() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  file_system_watcher_ = std::make_unique<FileSystemWatcher>(
      base::BindRepeating(&HoldingSpaceFileSystemDelegate::OnFilePathChanged,
                          weak_factory_.GetWeakPtr()));

  // Arc file system.
  auto* const arc_file_system = GetArcFileSystem();
  if (arc_file_system) {
    arc_file_system_observer_.Observe(arc_file_system);
  }

  // Drive file system.
  if (drive::DriveIntegrationService* const service =
          drive::DriveIntegrationServiceFactory::FindForProfile(profile())) {
    Observe(service->GetDriveFsHost());
  }

  // Local file system.
  file_change_service_observer_.Observe(
      FileChangeServiceFactory::GetInstance()->GetService(profile()));

  // Volume manager.
  auto* const volume_manager = file_manager::VolumeManager::Get(profile());
  if (volume_manager) {
    volume_manager_observer_.Observe(volume_manager);
  }

  // Schedule a task to clean up items that belong to volumes that haven't been
  // mounted in a reasonable amount of time. The primary goal of handling the
  // delayed volume mount is to support volumes that are mounted asynchronously
  // during the startup.
  clear_non_initialized_items_timer_.Start(
      FROM_HERE, base::Minutes(1),
      base::BindOnce(&HoldingSpaceFileSystemDelegate::ClearNonInitializedItems,
                     base::Unretained(this)));
}

void HoldingSpaceFileSystemDelegate::OnHoldingSpaceItemsAdded(
    const std::vector<const HoldingSpaceItem*>& items) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  const bool arc_file_system_disconnected =
      IsArcFileSystemDisconnected(profile());
  for (const HoldingSpaceItem* item : items) {
    if (item->IsInitialized() && item->progress().IsComplete()) {
      // Watch the directory containing `item`'s backing file. If the directory
      // is already being watched, this will no-op. Note that it is not
      // necessary to register a watch if the `item` is in-progress since
      // in-progress items are not subject to validity checks.
      AddWatchForParent(item->file().file_path);
      continue;
    }

    // In-progress items are not subject to validity checks.
    if (!item->progress().IsComplete()) {
      continue;
    }

    // If the item has not yet been initialized, check whether it's path can be
    // resolved to a file system URL - failure to do so may indicate that the
    // volume to which it path belongs is not mounted there. If the file system
    // URL cannot be resolved, leave the item in partially initialized state.
    // Validity will be checked when the associated mount point is mounted.
    // NOTE: Items will not be kept in partially initialized state indefinitely
    // - see `clear_non_initialized_items_timer_`.
    // NOTE: This does not work well for removable devices, as all removable
    // devices have the same top level "external" mount point (media/removable),
    // so a removable device path will be successfully resolved even if the
    // device is not currently mounted. The logic will have to be updated if
    // support for restoring items across removable device mounts becomes a
    // requirement.
    const GURL file_system_url = holding_space_util::ResolveFileSystemUrl(
        profile(), item->file().file_path);
    if (file_system_url.is_empty()) {
      continue;
    }

    // Defer validity checks (and initialization) for android files if the ARC
    // file system connection is not yet ready.
    if (arc_file_system_disconnected && ItemBackedByAndroidFile(item)) {
      continue;
    }

    holding_space_util::ValidityRequirement requirements;
    if (item->type() != HoldingSpaceItem::Type::kPinnedFile) {
      requirements.must_be_newer_than = kMaxFileAge;
    }
    ScheduleFilePathValidityCheck({item->file().file_path, requirements});
  }
}

void HoldingSpaceFileSystemDelegate::OnHoldingSpaceItemsRemoved(
    const std::vector<const HoldingSpaceItem*>& items) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  for (const HoldingSpaceItem* item : items) {
    MaybeRemoveWatch(item->file().file_path.DirName());
  }
}

void HoldingSpaceFileSystemDelegate::OnHoldingSpaceItemUpdated(
    const HoldingSpaceItem* item,
    const HoldingSpaceItemUpdatedFields& updated_fields) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // In-progress items are not subject to validity checks.
  if (item->progress().IsComplete()) {
    AddWatchForParent(item->file().file_path);
  }
}

void HoldingSpaceFileSystemDelegate::OnHoldingSpaceItemInitialized(
    const HoldingSpaceItem* item) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  AddWatchForParent(item->file().file_path);
}

void HoldingSpaceFileSystemDelegate::OnVolumeMounted(
    MountError error_code,
    const file_manager::Volume& volume) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  holding_space_util::FilePathsWithValidityRequirements
      file_paths_with_requirements;
  // Check validity of partially initialized items under the volume's mount
  // path.
  for (auto& item : model()->items()) {
    if (item->IsInitialized()) {
      continue;
    }
    if (!volume.mount_path().IsParent(item->file().file_path)) {
      continue;
    }
    holding_space_util::ValidityRequirement requirements;
    if (item->type() != HoldingSpaceItem::Type::kPinnedFile) {
      requirements.must_be_newer_than = kMaxFileAge;
    }
    ScheduleFilePathValidityCheck({item->file().file_path, requirements});
  }
}

void HoldingSpaceFileSystemDelegate::OnVolumeUnmounted(
    MountError error_code,
    const file_manager::Volume& volume) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // Drive FS may restart from time to time, so only remove items if drive is
  // disabled.
  if (volume.type() == file_manager::VOLUME_TYPE_GOOGLE_DRIVE) {
    const auto* drive_integration_service =
        drive::DriveIntegrationServiceFactory::FindForProfile(profile());
    if (drive_integration_service && drive_integration_service->is_enabled()) {
      return;
    }
  }
  // Schedule task to remove items under the unmounted file path from the model.
  // During suspend, some volumes get unmounted - for example, drive FS. The
  // file system delegate gets shutdown to avoid removing items from unmounted
  // volumes, but depending on the order in which observers are added to power
  // manager dbus client, the file system delegate may get shutdown after
  // unmounting a volume. To avoid observer ordering issues, schedule
  // asynchronous task to remove unmounted items from the model.
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(&HoldingSpaceFileSystemDelegate::RemoveItemsParentedByPath,
                     weak_factory_.GetWeakPtr(), volume.mount_path()));
}

void HoldingSpaceFileSystemDelegate::OnFileCreatedFromShowSaveFilePicker(
    const GURL& file_picker_binding_context,
    const storage::FileSystemURL& url) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  holding_space_metrics::RecordFileCreatedFromShowSaveFilePicker(
      file_picker_binding_context, url.path());

  if (file_picker_binding_context.DomainIs("photoshop.adobe.com")) {
    service()->AddItemOfType(HoldingSpaceItem::Type::kPhotoshopWeb, url.path());
  }
}

void HoldingSpaceFileSystemDelegate::OnFileModified(
    const storage::FileSystemURL& url) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  OnFilePathModified(url.path());
}

void HoldingSpaceFileSystemDelegate::OnFileMoved(
    const storage::FileSystemURL& src,
    const storage::FileSystemURL& dst) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  OnFilePathMoved(src.path(), dst.path());
}

void HoldingSpaceFileSystemDelegate::OnFilePathChanged(
    const base::FilePath& file_path,
    bool error) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  DCHECK(!error);

  // The `file_path` that changed is a directory containing backing files for
  // one or more holding space items. Changes to this directory may indicate
  // that some, all, or none of these backing files have been removed. Verify
  // the existence of these backing files to trigger removal of any holding
  // space items that no longer exist.
  for (const auto& item : model()->items()) {
    if (file_path.IsParent(item->file().file_path)) {
      ScheduleFilePathValidityCheck(
          {item->file().file_path, /*requirements=*/{}});
    }
  }
}

void HoldingSpaceFileSystemDelegate::OnFilePathModified(
    const base::FilePath& file_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  model()->InvalidateItemImageIf(base::BindRepeating(
      [](const base::FilePath& file_path, const HoldingSpaceItem* item) {
        return item->file().file_path == file_path;
      },
      file_path));
}

void HoldingSpaceFileSystemDelegate::OnFilePathMoved(
    const base::FilePath& src,
    const base::FilePath& dst) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  // Collect items that should be moved to a new path. This includes:
  // *   Items whose path matches the source path.
  // *   Items parented by the source path.
  // Maps item ID to the item's new file path.
  std::vector<std::pair<std::string, base::FilePath>> items_to_move;
  for (auto& item : model()->items()) {
    if (src == item->file().file_path) {
      items_to_move.push_back(std::make_pair(item->id(), dst));
      continue;
    }

    if (src.IsParent(item->file().file_path)) {
      base::FilePath target_path(dst);
      if (!src.AppendRelativePath(item->file().file_path, &target_path)) {
        NOTREACHED();
      }
      items_to_move.push_back(std::make_pair(item->id(), target_path));
    }
  }

  // Handle existing holding space items under the target file path.
  // Moving an existing item to a new path may create conflict within the
  // holding space if an item with the target path already exists within the
  // holding space. If this is the case, assume that the original item was
  // overwritten, and remove it from the holding space.

  // NOTE: Don't remove items at destination if no holding space items have to
  // be updated due to the file move. The reason for this is to:
  // *   Support use case where apps change files by moving temp file with
  //     modifications to the file path.
  // *   Handle duplicate file path move notifications.
  // Instead, update the items as if the target path was modified.
  if (items_to_move.empty()) {
    OnFilePathModified(dst);
    return;
  }

  // Get a list of the enabled Trash locations. Trash can be enabled and
  // disabled via policy, so ensure the latest list is retrieved.
  file_manager::trash::TrashPathsMap enabled_trash_locations =
      file_manager::trash::GenerateEnabledTrashLocationsForProfile(profile());

  // Mark items that were moved to an enabled Trash location for removal.
  std::set<std::string> item_ids_to_remove;
  for (const auto& it : enabled_trash_locations) {
    const base::FilePath& trash_location =
        it.first.Append(it.second.relative_folder_path);
    for (const auto& [id, file_path] : items_to_move) {
      if (trash_location.IsParent(file_path)) {
        item_ids_to_remove.insert(id);
      }
    }
  }

  // Mark conflicts with existing items that arise from the move for removal.
  for (auto& item : model()->items()) {
    if (dst == item->file().file_path || dst.IsParent(item->file().file_path)) {
      item_ids_to_remove.insert(item->id());
    }
  }

  // Remove items which have been marked for removal.
  model()->RemoveItems(item_ids_to_remove);

  // Finally, update the files that have been moved.
  for (const auto& [id, file_path] : items_to_move) {
    if (item_ids_to_remove.count(id)) {
      continue;
    }

    // File.
    const GURL file_system_url =
        holding_space_util::ResolveFileSystemUrl(profile(), file_path);
    const HoldingSpaceFile::FileSystemType file_system_type =
        holding_space_util::ResolveFileSystemType(profile(), file_system_url);

    // Update.
    model()->UpdateItem(id)->SetBackingFile(
        HoldingSpaceFile(file_path, file_system_type, file_system_url));
  }

  // If a backing file update occurred, it's possible that there are no longer
  // any holding space items associated with `src`. When that is the case, `src`
  // no longer needs to be watched.
  MaybeRemoveWatch(src);
}

void HoldingSpaceFileSystemDelegate::ScheduleFilePathValidityCheck(
    holding_space_util::FilePathWithValidityRequirement requirement) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  pending_file_path_validity_checks_.push_back(std::move(requirement));
  if (file_path_validity_checks_scheduled_) {
    return;
  }

  file_path_validity_checks_scheduled_ = true;

  // Schedule file validity check for pending items. The check is scheduled
  // asynchronously so path checks added in quick succession are handled in a
  // single batch.
  base::SequencedTaskRunner::GetCurrentDefault()->PostTask(
      FROM_HERE,
      base::BindOnce(
          &HoldingSpaceFileSystemDelegate::RunPendingFilePathValidityChecks,
          weak_factory_.GetWeakPtr()));
}

void HoldingSpaceFileSystemDelegate::RunPendingFilePathValidityChecks() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  holding_space_util::FilePathsWithValidityRequirements requirements;
  requirements.swap(pending_file_path_validity_checks_);

  file_path_validity_checks_scheduled_ = false;
  holding_space_util::PartitionFilePathsByValidity(
      profile(), std::move(requirements),
      base::BindOnce(
          &HoldingSpaceFileSystemDelegate::OnFilePathValidityChecksComplete,
          weak_factory_.GetWeakPtr()));
}

void HoldingSpaceFileSystemDelegate::OnFilePathValidityChecksComplete(
    std::vector<base::FilePath> valid_paths,
    std::vector<base::FilePath> invalid_paths) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);

  const bool arc_file_system_disconnected =
      IsArcFileSystemDisconnected(profile());

  // Remove items with invalid paths.
  model()->RemoveIf(base::BindRepeating(
      [](bool arc_file_system_disconnected,
         const std::vector<base::FilePath>* invalid_paths,
         const HoldingSpaceItem* item) {
        // In-progress items are not subject to validity checks.
        if (!item->progress().IsComplete()) {
          return false;
        }

        // Avoid removing Android files if connection to ARC file system has
        // been lost (e.g. Android container might have crashed). Validity
        // checks will be re-run once the file system gets connected.
        if (arc_file_system_disconnected && ItemBackedByAndroidFile(item)) {
          return false;
        }

        return base::Contains(*invalid_paths, item->file().file_path);
      },
      arc_file_system_disconnected, &invalid_paths));

  std::vector<const HoldingSpaceItem*> items_to_initialize;
  for (auto& item : model()->items()) {
    // Defer initialization of items backed by android files if the connection
    // to ARC file system service has been lost.
    if (arc_file_system_disconnected && ItemBackedByAndroidFile(item.get())) {
      continue;
    }

    if (!item->IsInitialized() &&
        base::Contains(valid_paths, item->file().file_path)) {
      items_to_initialize.push_back(item.get());
    }
  }

  for (auto* item : items_to_initialize) {
    const base::FilePath& file_path = item->file().file_path;
    const GURL file_system_url =
        holding_space_util::ResolveFileSystemUrl(profile(), file_path);
    const HoldingSpaceFile::FileSystemType file_system_type =
        holding_space_util::ResolveFileSystemType(profile(), file_system_url);

    model()->InitializeOrRemoveItem(
        item->id(),
        HoldingSpaceFile(file_path, file_system_type, file_system_url));
  }
}

void HoldingSpaceFileSystemDelegate::AddWatchForParent(
    const base::FilePath& file_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  file_system_watcher_runner_->PostTask(
      FROM_HERE, base::BindOnce(&FileSystemWatcher::AddWatchForParent,
                                file_system_watcher_->GetWeakPtr(), file_path));
}

void HoldingSpaceFileSystemDelegate::MaybeRemoveWatch(
    const base::FilePath& file_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  // The watch for `file_path` should only be removed if no holding space items
  // exist in the model which are backed by files it directly parents.
  const bool remove_watch =
      std::ranges::none_of(model()->items(), [&file_path](const auto& item) {
        return item->IsInitialized() &&
               item->file().file_path.DirName() == file_path;
      });

  if (!remove_watch) {
    return;
  }

  file_system_watcher_runner_->PostTask(
      FROM_HERE, base::BindOnce(&FileSystemWatcher::RemoveWatch,
                                file_system_watcher_->GetWeakPtr(), file_path));
}

void HoldingSpaceFileSystemDelegate::RemoveItemsParentedByPath(
    const base::FilePath& parent_path) {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  model()->RemoveIf(base::BindRepeating(
      [](const base::FilePath& parent_path, const HoldingSpaceItem* item) {
        return parent_path.IsParent(item->file().file_path);
      },
      parent_path));
}

void HoldingSpaceFileSystemDelegate::ClearNonInitializedItems() {
  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  model()->RemoveIf(base::BindRepeating(
      [](Profile* profile, const HoldingSpaceItem* item) {
        if (item->IsInitialized()) {
          return false;
        }

        // Do not remove items whose path can be resolved to a file system URL.
        // In this case, the associated mount point has been mounted, but the
        // initialization may have been delayed - for example due to
        // issues/delays with initializing ARC.
        const GURL url = holding_space_util::ResolveFileSystemUrl(
            profile, item->file().file_path);
        return url.is_empty();
      },
      profile()));
}

}  // namespace ash