// 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_keyed_service.h"

#include <algorithm>
#include <vector>

#include "ash/constants/ash_features.h"
#include "ash/public/cpp/holding_space/holding_space_controller.h"
#include "ash/public/cpp/holding_space/holding_space_file.h"
#include "ash/public/cpp/holding_space/holding_space_image.h"
#include "ash/public/cpp/holding_space/holding_space_item.h"
#include "ash/public/cpp/holding_space/holding_space_model.h"
#include "ash/public/cpp/holding_space/holding_space_model_observer.h"
#include "ash/public/cpp/holding_space/holding_space_util.h"
#include "ash/public/cpp/holding_space/mock_holding_space_model_observer.h"
#include "base/files/file_path.h"
#include "base/files/file_path_watcher.h"
#include "base/files/file_util.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/path_service.h"
#include "base/run_loop.h"
#include "base/scoped_observation.h"
#include "base/strings/stringprintf.h"
#include "base/test/bind.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/scoped_path_override.h"
#include "base/unguessable_token.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/drivefs_test_support.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/file_manager/volume_manager.h"
#include "chrome/browser/extensions/component_loader.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_keyed_service_factory.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_test_util.h"
#include "chrome/browser/ui/ash/holding_space/holding_space_util.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chromeos/ash/components/browser_context_helper/browser_context_types.h"
#include "chromeos/dbus/power/fake_power_manager_client.h"
#include "content/public/test/browser_test.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"
#include "url/gurl.h"
#include "url/origin.h"

namespace ash {
namespace {

// Types of file systems backing holding space items tested by
// HoldingSpaceKeyedServiceBrowserTest. The tests are parameterized by this
// enum.
enum class FileSystemType { kDownloads, kDriveFs };

// Helpers ---------------------------------------------------------------------

// Converts an `absolute_file_path` to its drive path.
base::FilePath ConvertAbsoluteFilePathToDrivePath(
    Profile* profile,
    const base::FilePath& absolute_file_path) {
  base::FilePath drive_path("/");
  EXPECT_TRUE(drive::DriveIntegrationServiceFactory::FindForProfile(profile)
                  ->GetMountPointPath()
                  .AppendRelativePath(absolute_file_path, &drive_path));
  return drive_path;
}

// Creates a DriveFs file change with the specified params. A `stable_id` of `0`
// signifies absence of a known `stable_id` for backwards compatibility with
// earlier versions of the `DriveFsHost`.
drivefs::mojom::FileChangePtr CreateDriveFsChange(
    drivefs::mojom::FileChange::Type type,
    const base::FilePath& drive_path,
    int64_t stable_id = 0) {
  auto change = drivefs::mojom::FileChange::New();
  change->path = drive_path;
  change->stable_id = stable_id;
  change->type = type;
  return change;
}

// Creates a txt file at the path of the downloads mount point for `profile`.
base::FilePath CreateTextFile(const base::FilePath& root_path,
                              const std::optional<std::string>& relative_path) {
  const base::FilePath path =
      root_path.Append(relative_path.value_or(base::StringPrintf(
          "%s.txt", base::UnguessableToken::Create().ToString().c_str())));

  base::ScopedAllowBlockingForTesting allow_blocking;
  if (!base::CreateDirectory(path.DirName())) {
    return base::FilePath();
  }
  if (!base::WriteFile(path, /*data=*/std::string())) {
    return base::FilePath();
  }

  return path;
}

// Waits for a holding space item matching the provided `predicate` to be added
// to the holding space model. Returns immediately if the item already exists.
void WaitForItemAddition(
    base::RepeatingCallback<bool(const HoldingSpaceItem*)> predicate) {
  auto* const model = HoldingSpaceController::Get()->model();
  if (std::ranges::any_of(model->items(), [&predicate](const auto& item) {
        return predicate.Run(item.get());
      })) {
    return;
  }

  testing::NiceMock<MockHoldingSpaceModelObserver> mock;
  base::ScopedObservation<HoldingSpaceModel, HoldingSpaceModelObserver>
      observer{&mock};
  observer.Observe(model);

  base::RunLoop run_loop;
  ON_CALL(mock, OnHoldingSpaceItemsAdded)
      .WillByDefault([&](const std::vector<const HoldingSpaceItem*>& items) {
        for (const HoldingSpaceItem* item : items) {
          if (predicate.Run(item)) {
            run_loop.Quit();
            return;
          }
        }
      });
  run_loop.Run();
}

// Waits for a holding space item matching the provided `predicate` to be added
// to the holding space model and initialized. Returns immediately if the item
// already exists and is initialized.
void WaitForItemInitialization(
    base::RepeatingCallback<bool(const HoldingSpaceItem*)> predicate) {
  WaitForItemAddition(predicate);

  auto* const model = HoldingSpaceController::Get()->model();
  auto item_it = std::ranges::find_if(
      model->items(),
      [&predicate](const auto& item) { return predicate.Run(item.get()); });

  DCHECK(item_it != model->items().end());
  if (item_it->get()->IsInitialized()) {
    return;
  }

  testing::NiceMock<MockHoldingSpaceModelObserver> mock;
  base::ScopedObservation<HoldingSpaceModel, HoldingSpaceModelObserver>
      observer{&mock};
  observer.Observe(model);

  base::RunLoop run_loop;
  ON_CALL(mock, OnHoldingSpaceItemInitialized)
      .WillByDefault([&](const HoldingSpaceItem* item) {
        if (item == item_it->get()) {
          run_loop.Quit();
        }
      });
  ON_CALL(mock, OnHoldingSpaceItemsRemoved)
      .WillByDefault([&](const std::vector<const HoldingSpaceItem*>& items) {
        for (const HoldingSpaceItem* item : items) {
          if (item != item_it->get()) {
            continue;
          }
          ADD_FAILURE() << "Item unexpectedly removed: " << item->id();
          run_loop.Quit();
          return;
        }
      });
  run_loop.Run();
}

// Waits for a holding space item with the provided `item_id` to be added to the
// holding space model and initialized. Returns immediately if the item already
// exists and is initialized.
void WaitForItemInitialization(const std::string& item_id) {
  WaitForItemInitialization(
      base::BindLambdaForTesting([&item_id](const HoldingSpaceItem* item) {
        return item->id() == item_id;
      }));
}

// Adds a holding space item backed by the file at `item_path` with optional
// `progress`. Returns a pointer to the added item.
const HoldingSpaceItem* AddHoldingSpaceItem(
    Profile* profile,
    const base::FilePath& item_path,
    const HoldingSpaceProgress& progress = HoldingSpaceProgress()) {
  EXPECT_TRUE(HoldingSpaceController::Get());

  auto* const holding_space_model = HoldingSpaceController::Get()->model();
  EXPECT_TRUE(holding_space_model);

  const GURL file_system_url =
      holding_space_util::ResolveFileSystemUrl(profile, item_path);
  const HoldingSpaceFile::FileSystemType file_system_type =
      holding_space_util::ResolveFileSystemType(profile, file_system_url);

  std::unique_ptr<HoldingSpaceItem> item =
      HoldingSpaceItem::CreateFileBackedItem(
          HoldingSpaceItem::Type::kDownload,
          HoldingSpaceFile(item_path, file_system_type, file_system_url),
          progress,
          base::BindLambdaForTesting([&](HoldingSpaceItem::Type type,
                                         const base::FilePath& file_path) {
            return std::make_unique<HoldingSpaceImage>(
                holding_space_util::GetMaxImageSizeForType(type), file_path,
                /*async_bitmap_resolver=*/base::DoNothing());
          }));

  const HoldingSpaceItem* const item_ptr = item.get();
  HoldingSpaceKeyedServiceFactory::GetInstance()->GetService(profile)->AddItem(
      std::move(item));
  return item_ptr;
}

// Removes a `holding_space_item` by running the specified `closure`.
void RemoveHoldingSpaceItemViaClosure(
    const HoldingSpaceItem* holding_space_item,
    base::OnceClosure closure) {
  EXPECT_TRUE(HoldingSpaceController::Get());

  const std::string item_id = holding_space_item->id();
  std::move(closure).Run();
  WaitForItemRemovalById(item_id);
}

}  // namespace

// HoldingSpaceKeyedServiceBrowserTest -----------------------------------------

class HoldingSpaceKeyedServiceBrowserTest : public InProcessBrowserTest {
 public:
  explicit HoldingSpaceKeyedServiceBrowserTest(
      FileSystemType file_system_type = FileSystemType::kDriveFs)
      : file_system_type_(file_system_type) {}

  // InProcessBrowserTest:
  bool SetUpUserDataDirectory() override {
    base::FilePath user_data_dir;
    if (!base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir)) {
      return false;
    }

    // Mount test volumes under user data dir to ensure it gets persisted after
    // PRE test runs.
    test_mount_point_ = user_data_dir.Append("test_mount").Append("test-user");

    return file_system_type_ == FileSystemType::kDriveFs
               ? drive::SetUpUserDataDirectoryForDriveFsTest()
               : InProcessBrowserTest::SetUpUserDataDirectory();
  }

  void SetUpInProcessBrowserTestFixture() override {
    InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
    extensions::ComponentLoader::EnableBackgroundExtensionsForTesting();

    // File system type specific setup.
    switch (file_system_type_) {
      case FileSystemType::kDownloads:
        // Override the default downloads path to point to the test mount point
        // within user data dir.
        downloads_override_ = std::make_unique<base::ScopedPathOverride>(
            chrome::DIR_DEFAULT_DOWNLOADS, test_mount_point_,
            /*is_absolute*/ true,
            /*create*/ false);
        break;

      case FileSystemType::kDriveFs:
        // Set up drive integration service for test.
        ASSERT_TRUE(test_cache_root_.CreateUniqueTempDir());
        create_drive_integration_service_ = base::BindRepeating(
            &HoldingSpaceKeyedServiceBrowserTest::CreateDriveIntegrationService,
            base::Unretained(this));
        drive_integration_service_factory_for_test_ = std::make_unique<
            drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>(
            &create_drive_integration_service_);
        break;
    }
  }

  base::FilePath GetTestMountPoint() { return test_mount_point_; }

  // Returns the cached file path if the file specified by `index` exists in
  // `predefined_test_files_`. If the file is not found, a new file path is
  // cached and returned.
  // NOTE: `index` should not exceed than the size of `predefined_test_files_`.
  base::FilePath GetPredefinedTestFile(size_t index) {
    CHECK_LE(index, predefined_test_files_.size());
    if (index == predefined_test_files_.size()) {
      predefined_test_files_.emplace_back(
          CreateTextFile(GetTestMountPoint(),
                         base::StrCat({"root/test_file_",
                                       base::NumberToString(index), ".txt"})));
    }
    return predefined_test_files_[index];
  }

  drive::DriveIntegrationService* CreateDriveIntegrationService(
      Profile* profile) {
    // Ignore signin and lock screen apps profile.
    if (ash::IsSigninBrowserContext(profile)) {
      return nullptr;
    }

    fake_drivefs_helper_ =
        std::make_unique<drive::FakeDriveFsHelper>(profile, test_mount_point_);
    drive_integration_service_ = new drive::DriveIntegrationService(
        profile, "", test_cache_root_.GetPath(),
        fake_drivefs_helper_->CreateFakeDriveFsListenerFactory());
    return drive_integration_service_;
  }

  drive::DriveIntegrationService* drive_integration_service() {
    return drive_integration_service_;
  }

  mojo::Remote<drivefs::mojom::DriveFsDelegate>& drivefs_delegate() {
    return fake_drivefs_helper_->fake_drivefs().delegate();
  }

 private:
  // List of files paths that are created by default by the test suite.
  std::vector<base::FilePath> predefined_test_files_;

  // The path under which test volume is mounted.
  base::FilePath test_mount_point_;

  // Used to override downloads mount point for downloads tests.
  std::unique_ptr<base::ScopedPathOverride> downloads_override_;

  // The file system used for an individual test case.
  FileSystemType file_system_type_;

  // Used to set up drive fs for for drive tests.
  base::ScopedTempDir test_cache_root_;
  std::unique_ptr<drive::FakeDriveFsHelper> fake_drivefs_helper_;
  raw_ptr<drive::DriveIntegrationService, DanglingUntriaged>
      drive_integration_service_ = nullptr;
  drive::DriveIntegrationServiceFactory::FactoryCallback
      create_drive_integration_service_;
  std::unique_ptr<drive::DriveIntegrationServiceFactory::ScopedFactoryForTest>
      drive_integration_service_factory_for_test_;
};

// Tests -----------------------------------------------------------------------

// Verifies item addition during holding space keyed service suspension.
IN_PROC_BROWSER_TEST_F(HoldingSpaceKeyedServiceBrowserTest,
                       AddItemDuringSuspension) {
  // Add a holding space item before service suspension.
  const auto* const holding_space_item = AddHoldingSpaceItem(
      browser()->profile(), GetPredefinedTestFile(/*index=*/0));
  const auto* const holding_space_model =
      HoldingSpaceController::Get()->model();
  ASSERT_TRUE(holding_space_model);
  EXPECT_TRUE(holding_space_model->GetItem(holding_space_item->id()));
  const std::string existing_item_id = holding_space_item->id();

  // Suspend the holding space keyed service. Wait until the existing holding
  // space item is removed.
  auto* const fake_power_manager_client =
      chromeos::FakePowerManagerClient::Get();
  ASSERT_TRUE(fake_power_manager_client);
  fake_power_manager_client->SendSuspendImminent(
      power_manager::SuspendImminent::IDLE);
  WaitForItemRemovalById(existing_item_id);
  EXPECT_TRUE(holding_space_model->items().empty());

  // Try to add a new holding space item.
  AddHoldingSpaceItem(browser()->profile(), GetPredefinedTestFile(/*index=*/1));

  // Verify the absence of any new items.
  EXPECT_TRUE(holding_space_model->items().empty());

  // End suspension. Wait until `holding_space_item` is restored.
  fake_power_manager_client->SendSuspendDone();
  WaitForItemInitialization(existing_item_id);
  EXPECT_TRUE(holding_space_model->GetItem(existing_item_id));

  // Add a holding space item after suspension. Verify that a new item is added.
  const HoldingSpaceItem* const item = AddHoldingSpaceItem(
      browser()->profile(), GetPredefinedTestFile(/*index=*/1));
  ASSERT_TRUE(item);
  WaitForItemInitialization(item->id());
  EXPECT_TRUE(holding_space_model->GetItem(item->id()));
}

// Verifies that holding space is updated in response to DriveFs file changes.
IN_PROC_BROWSER_TEST_F(HoldingSpaceKeyedServiceBrowserTest,
                       UpdateItemsOnDriveFsFileChange) {
  // Verify holding space service exists.
  HoldingSpaceKeyedService* const holding_space_service =
      HoldingSpaceKeyedServiceFactory::GetInstance()->GetService(
          browser()->profile());
  ASSERT_TRUE(holding_space_service);

  // Verify holding space model exists.
  const auto* holding_space_model = holding_space_service->model_for_testing();
  ASSERT_TRUE(holding_space_model);

  // Add an item to holding space.
  base::FilePath src = GetPredefinedTestFile(/*index=*/0);
  auto* item = AddHoldingSpaceItem(browser()->profile(), src);
  std::string item_id = item->id();

  std::vector<const HoldingSpaceItem*> items_excluding_suggestions;
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Verify the item exists in the model.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, src);

  base::FilePath dst = GetPredefinedTestFile(/*index=*/1);

  // Prep a batch of `changes` to indicate that `src` has moved to `dst`. Note
  // the consistent `stable_id` to link the `kDelete` with the `kCreate` change.
  std::vector<drivefs::mojom::FileChangePtr> changes;
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src),
      /*stable_id=*/1));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kCreate,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst),
      /*stable_id=*/1));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  items_excluding_suggestions.clear();
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Expect the holding space item to have been updated in place to reflect
  // the new location of its backing file.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, dst);

  std::swap(src, dst);

  // Prep a batch of `changes` to indicate that `src` has been deleted and that
  // `dst` has been created. Note the different `stable_id` to indicate that the
  // `kDelete` and `kCreate` changes refer to different documents.
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src),
      /*stable_id=*/1));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kCreate,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst),
      /*stable_id=*/2));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  // Because `src` was deleted, the holding space item should be removed.
  WaitForItemRemovalById(item_id);

  // Add another holding space item, again pointing to `src`.
  item = AddHoldingSpaceItem(browser()->profile(), src);
  item_id = item->id();

  items_excluding_suggestions.clear();
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Verify the item exists in the model.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, src);

  // Prep a batch of `changes` to indicate that `src` has been deleted and that
  // `dst` has been created. Note the absence of `stable_id`. The `kDelete` and
  // `kCreate` events may constitute a move of the same document, but because
  // `stable_id` is absent, we can't assume that to be the case.
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src)));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kCreate,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst)));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  // Because `src` was deleted and cannot be determined to refer to the same
  // document that was created at `dst`, the holding space item should be
  // removed.
  WaitForItemRemovalById(item_id);

  // Add another holding space item, again pointing to `src`.
  item = AddHoldingSpaceItem(browser()->profile(), src);
  item_id = item->id();

  items_excluding_suggestions.clear();
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Verify the item exists in the model.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, src);

  // Prep a batch of `changes` to indicate that `src` has moved to `dst` and has
  // then been deleted. Note the consistent `stable_id` to associate all changes
  // with the same document.
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src),
      /*stable_id=*/1));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kCreate,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst),
      /*stable_id=*/1));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst),
      /*stable_id=*/1));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  // Because the document was ultimately deleted, the holding space item should
  // be removed.
  WaitForItemRemovalById(item_id);

  // Add another holding space item, pointing to `src` in `src_dir`.
  base::FilePath src_dir = GetTestMountPoint().Append("src/");
  src = CreateTextFile(src_dir, /*relative_path=*/std::nullopt);
  item = AddHoldingSpaceItem(browser()->profile(), src);
  item_id = item->id();

  items_excluding_suggestions.clear();
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Verify the item exists in the model.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, src);

  base::FilePath dst_dir = GetTestMountPoint().Append("dst/");
  dst = CreateTextFile(
      dst_dir,
      /*relative_path=*/base::UTF16ToUTF8(src.BaseName().LossyDisplayName()));

  // Prep a batch of `changes` to indicate that `src_dir` has moved to
  // `dst_dir`. Note the consistent `stable_id` to link the `kDelete` with the
  // `kCreate` change.
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src_dir),
      /*stable_id=*/1));
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kCreate,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), dst_dir),
      /*stable_id=*/1));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  items_excluding_suggestions.clear();
  for (const auto& candidate : holding_space_model->items()) {
    if (!HoldingSpaceItem::IsSuggestionType(candidate->type())) {
      items_excluding_suggestions.emplace_back(candidate.get());
    }
  }

  // Expect the holding space item to have been updated in place to reflect
  // the new location of its backing file.
  ASSERT_EQ(items_excluding_suggestions.size(), 1u);
  EXPECT_EQ(items_excluding_suggestions.front(), item);
  EXPECT_EQ(item->file().file_path, dst);

  std::swap(src_dir, dst_dir);
  std::swap(src, dst);

  // Prep a batch of `changes` to indicate that `src_dir` has been deleted.
  changes.push_back(CreateDriveFsChange(
      drivefs::mojom::FileChange::Type::kDelete,
      ConvertAbsoluteFilePathToDrivePath(browser()->profile(), src_dir)));

  // Simulate the `changes` being sent from the server.
  drivefs_delegate()->OnFilesChanged(std::move(changes));
  drivefs_delegate().FlushForTesting();

  // Because the parent directory in which the holding space item's backing file
  // is contained has been deleted, the holding space item should be removed.
  WaitForItemRemovalById(item_id);
}

// Verifies that drive files pinned to holding space are pinned for offline use.
IN_PROC_BROWSER_TEST_F(HoldingSpaceKeyedServiceBrowserTest,
                       PinningDriveFilesOfflineAccess) {
  const GURL url = holding_space_util::ResolveFileSystemUrl(
      browser()->profile(), GetPredefinedTestFile(/*index=*/0));
  storage::FileSystemURL file_system_url =
      storage::ExternalMountPoints::GetSystemInstance()->CrackURL(
          url, blink::StorageKey::CreateFirstParty(url::Origin::Create(url)));
  ASSERT_TRUE(file_system_url.is_valid());
  ASSERT_EQ(storage::kFileSystemTypeDriveFs, file_system_url.type());

  // Add item from HoldingSpaceKeyedService to handle the pinning behaviour.
  HoldingSpaceKeyedService* const holding_space_service =
      HoldingSpaceKeyedServiceFactory::GetInstance()->GetService(
          browser()->profile());
  holding_space_service->AddPinnedFiles({file_system_url});

  base::FilePath relative_path;
  ASSERT_TRUE(drive_integration_service()->GetRelativeDrivePath(
      file_system_url.path(), &relative_path));
  base::RunLoop loop;
  bool is_pinned = false;
  drive_integration_service()->GetDriveFsInterface()->GetMetadata(
      relative_path,
      base::BindOnce(
          [](base::RunLoop* loop, bool* is_pinned, ::drive::FileError error,
             drivefs::mojom::FileMetadataPtr metadata) {
            *is_pinned = metadata->pinned;
            loop->Quit();
          },
          &loop, &is_pinned));
  loop.Run();
  EXPECT_TRUE(is_pinned);
}

// HoldingSpaceKeyedServiceFlexibleFsBrowserTest -------------------------------

class HoldingSpaceKeyedServiceFlexibleFsBrowserTest
    : public HoldingSpaceKeyedServiceBrowserTest,
      public ::testing::WithParamInterface<FileSystemType> {
 public:
  HoldingSpaceKeyedServiceFlexibleFsBrowserTest()
      : HoldingSpaceKeyedServiceBrowserTest(GetParam()) {}

 private:
  // HoldingSpaceKeyedServiceBrowserTest:
  void SetUpInProcessBrowserTestFixture() override {
    HoldingSpaceKeyedServiceBrowserTest::SetUpInProcessBrowserTestFixture();

    // Ensure the existence of a test file to verify persistence restoration.
    GetPredefinedTestFile(/*index=*/0);
  }
};

INSTANTIATE_TEST_SUITE_P(FileSystem,
                         HoldingSpaceKeyedServiceFlexibleFsBrowserTest,
                         ::testing::Values(FileSystemType::kDownloads,
                                           FileSystemType::kDriveFs));

// Tests -----------------------------------------------------------------------

// Verifies that completed holding space items are removed when their backing
// files "disappear". Note that a "disappearance" could be due to a file move or
// delete. In-progress holding space items are not subject to the same backing
// file path validity checks and may outlive their backing files.
IN_PROC_BROWSER_TEST_P(HoldingSpaceKeyedServiceFlexibleFsBrowserTest,
                       RemovesItemsWhenBackingFileDisappears) {
  // Create an `in_progress_holding_space_item_to_delete`.
  const auto* in_progress_holding_space_item_to_delete = AddHoldingSpaceItem(
      browser()->profile(),
      CreateTextFile(GetTestMountPoint(),
                     /*relative_path=*/std::nullopt),
      HoldingSpaceProgress(/*current_bytes=*/0, /*total_bytes=*/100));

  {
    // Delete its backing file. Later we will confirm that the associated
    // holding space item still exists after we are sure that scheduled validity
    // checks have run.
    base::ScopedAllowBlockingForTesting allow_blocking;
    EXPECT_TRUE(base::DeleteFile(
        in_progress_holding_space_item_to_delete->file().file_path));
  }

  // Create a completed `holding_space_item_to_delete`.
  const auto* holding_space_item_to_delete = AddHoldingSpaceItem(
      browser()->profile(), CreateTextFile(GetTestMountPoint(),
                                           /*relative_path=*/std::nullopt));

  // Delete its backing file and verify that it is removed from holding space.
  // Note that this guarantees that scheduled validity checks will have run.
  RemoveHoldingSpaceItemViaClosure(
      holding_space_item_to_delete, base::BindLambdaForTesting([&]() {
        base::ScopedAllowBlockingForTesting allow_blocking;
        EXPECT_TRUE(
            base::DeleteFile(holding_space_item_to_delete->file().file_path));
      }));

  // Now that scheduled validity checks have run, verify that the in-progress
  // item whose backing file was deleted still exists in the model.
  auto* model = HoldingSpaceController::Get()->model();
  EXPECT_TRUE(model->GetItem(in_progress_holding_space_item_to_delete->id()));

  // Create an `in_progress_holding_space_item_to_move`.
  const auto* in_progress_holding_space_item_to_move = AddHoldingSpaceItem(
      browser()->profile(),
      CreateTextFile(GetTestMountPoint(),
                     /*relative_path=*/std::nullopt),
      HoldingSpaceProgress(/*current_bytes=*/0, /*total_bytes=*/100));

  {
    // Move its backing file. Later we will confirm that the associated holding
    // space item still exists after we are sure that scheduled validity checks
    // have run.
    base::ScopedAllowBlockingForTesting allow_blocking;
    EXPECT_TRUE(
        base::Move(in_progress_holding_space_item_to_move->file().file_path,
                   GetTestMountPoint().Append(
                       base::UnguessableToken::Create().ToString())));
  }

  // Create a completed `holding_space_item_to_move`.
  const auto* holding_space_item_to_move = AddHoldingSpaceItem(
      browser()->profile(), CreateTextFile(GetTestMountPoint(),
                                           /*relative_path=*/std::nullopt));

  // Move its backing file and verify that it is removed from holding space.
  // Note that this guarantees that scheduled validity checks will have run.
  RemoveHoldingSpaceItemViaClosure(
      holding_space_item_to_move, base::BindLambdaForTesting([&]() {
        base::ScopedAllowBlockingForTesting allow_blocking;
        EXPECT_TRUE(
            base::Move(holding_space_item_to_move->file().file_path,
                       GetTestMountPoint().Append(
                           base::UnguessableToken::Create().ToString())));
      }));

  // Now that scheduled validity checks have run, verify that the in-progress
  // item whose backing file was moved still exists in the model.
  EXPECT_TRUE(model->GetItem(in_progress_holding_space_item_to_move->id()));

  // Remove all holding space items. This will clear all file system watches.
  model->RemoveAll();
  EXPECT_EQ(model->items().size(), 0u);

  // Add an `in_progress_holding_space_item_to_complete`. Because the item is
  // in-progress, no file system watch should have been registered.
  const auto* in_progress_holding_space_item_to_complete = AddHoldingSpaceItem(
      browser()->profile(),
      CreateTextFile(GetTestMountPoint(),
                     /*relative_path=*/std::nullopt),
      HoldingSpaceProgress(/*current_bytes=*/0, /*total_bytes=*/100));

  // Complete the item. This should result in a file system watch being
  // registered for the backing file's parent directory.
  model->UpdateItem(in_progress_holding_space_item_to_complete->id())
      ->SetProgress(
          HoldingSpaceProgress(/*current_bytes=*/100, /*total_bytes=*/100));

  // Delete its backing file and verify that it is removed from holding space
  // since the now completed item will be subject to validity checks.
  RemoveHoldingSpaceItemViaClosure(
      in_progress_holding_space_item_to_complete,
      base::BindLambdaForTesting([&]() {
        base::ScopedAllowBlockingForTesting allow_blocking;
        EXPECT_TRUE(base::DeleteFile(
            in_progress_holding_space_item_to_complete->file().file_path));
      }));
}

IN_PROC_BROWSER_TEST_P(HoldingSpaceKeyedServiceFlexibleFsBrowserTest,
                       ItemsNotRemovedDuringSuspend) {
  const auto* holding_space_item =
      AddHoldingSpaceItem(browser()->profile(), GetPredefinedTestFile(0));

  auto* holding_space_model = HoldingSpaceController::Get()->model();
  EXPECT_TRUE(holding_space_model);
  ASSERT_TRUE(holding_space_model->GetItem(holding_space_item->id()));
  const std::string item_id = holding_space_item->id();

  chromeos::FakePowerManagerClient::Get()->SendSuspendImminent(
      power_manager::SuspendImminent::IDLE);
  base::RunLoop().RunUntilIdle();

  // Holding space model gets cleared on suspend.
  EXPECT_TRUE(holding_space_model->items().empty());

  // Verify that holding space model gets restored on resume.
  chromeos::FakePowerManagerClient::Get()->SendSuspendDone();

  WaitForItemInitialization(item_id);
  EXPECT_TRUE(holding_space_model->GetItem(item_id));
}

// Test that creates a holding space item during PRE_ part, and verifies that
// the item gets restored after restart.
IN_PROC_BROWSER_TEST_P(HoldingSpaceKeyedServiceFlexibleFsBrowserTest,
                       PRE_RestoreItemsOnRestart) {
  const auto* holding_space_item =
      AddHoldingSpaceItem(browser()->profile(), GetPredefinedTestFile(0));

  auto* holding_space_model = HoldingSpaceController::Get()->model();
  ASSERT_TRUE(holding_space_model);
  EXPECT_TRUE(holding_space_model->GetItem(holding_space_item->id()));
}

IN_PROC_BROWSER_TEST_P(HoldingSpaceKeyedServiceFlexibleFsBrowserTest,
                       RestoreItemsOnRestart) {
  WaitForItemInitialization(
      base::BindLambdaForTesting([this](const HoldingSpaceItem* item) {
        return item->type() == HoldingSpaceItem::Type::kDownload &&
               item->file().file_path == GetPredefinedTestFile(0);
      }));
}

}  // namespace ash