// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "chrome/browser/ash/file_system_provider/fake_provided_file_system.h"

#include <stddef.h>

#include <memory>
#include <utility>

#include "base/functional/bind.h"
#include "base/task/single_thread_task_runner.h"
#include "base/time/time.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "components/services/filesystem/public/mojom/types.mojom.h"
#include "net/base/io_buffer.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace ash::file_system_provider {

const char kFakeFileText[] =
    "This is a testing file. Lorem ipsum dolor sit amet est.";

namespace {

const char kFakeFileName[] = "hello.txt";
const size_t kFakeFileSize = sizeof(kFakeFileText) - 1u;
const char kFakeFileModificationTime[] = "Fri, 25 Apr 2014 01:47:53";
const char kFakeFileMimeType[] = "text/plain";

constexpr base::FilePath::CharType kBadFakeEntryPath1[] =
    FILE_PATH_LITERAL("/bad1");
constexpr char kBadFakeEntryName1[] = "";
constexpr base::FilePath::CharType kBadFakeEntryPath2[] =
    FILE_PATH_LITERAL("/bad2");
constexpr char kBadFakeEntryName2[] = "bad2";

}  // namespace

const base::FilePath::CharType kFakeFilePath[] =
    FILE_PATH_LITERAL("/hello.txt");

constexpr char kFakeFileVersionTag[] = "versionA";

FakeEntry::FakeEntry() = default;

FakeEntry::FakeEntry(std::unique_ptr<EntryMetadata> metadata,
                     const std::string& contents)
    : metadata(std::move(metadata)), contents(contents) {}

FakeEntry::~FakeEntry() = default;

FakeProvidedFileSystem::FakeProvidedFileSystem(
    const ProvidedFileSystemInfo& file_system_info)
    : file_system_info_(file_system_info), last_file_handle_(0) {
  AddEntry(base::FilePath(FILE_PATH_LITERAL("/")), /*is_directory=*/true,
           /*name=*/"", /*size=*/0, /*modification_time=*/base::Time(),
           /*mime_type=*/"", /*cloud_file_info=*/nullptr, /*contents=*/"");

  base::Time modification_time;
  EXPECT_TRUE(
      base::Time::FromUTCString(kFakeFileModificationTime, &modification_time));
  AddEntry(base::FilePath(kFakeFilePath), false, kFakeFileName, kFakeFileSize,
           modification_time, kFakeFileMimeType,
           std::make_unique<CloudFileInfo>(kFakeFileVersionTag), kFakeFileText);

  // Add a set of bad entries, in the root directory, which should be filtered
  // out.
  AddEntry(base::FilePath(kBadFakeEntryPath1), false, kBadFakeEntryName1,
           kFakeFileSize, modification_time, kFakeFileMimeType,
           /*cloud_file_info=*/nullptr, kFakeFileText);
  AddEntry(base::FilePath(kBadFakeEntryPath2), false, kBadFakeEntryName2,
           kFakeFileSize, modification_time, kFakeFileMimeType,
           /*cloud_file_info=*/nullptr, kFakeFileText);
}

FakeProvidedFileSystem::~FakeProvidedFileSystem() = default;

void FakeProvidedFileSystem::AddEntry(
    const base::FilePath& entry_path,
    bool is_directory,
    const std::string& name,
    int64_t size,
    base::Time modification_time,
    std::string mime_type,
    std::unique_ptr<CloudFileInfo> cloud_file_info,
    std::string contents) {
  DCHECK(entries_.find(entry_path) == entries_.end())
      << "Already present " << entry_path;
  std::unique_ptr<EntryMetadata> metadata(new EntryMetadata);

  metadata->is_directory = std::make_unique<bool>(is_directory);
  metadata->name = std::make_unique<std::string>(name);
  metadata->size = std::make_unique<int64_t>(size);
  metadata->modification_time = std::make_unique<base::Time>(modification_time);
  metadata->mime_type = std::make_unique<std::string>(mime_type);
  metadata->cloud_file_info = std::move(cloud_file_info);

  entries_[entry_path] =
      std::make_unique<FakeEntry>(std::move(metadata), contents);
}

FakeEntry* FakeProvidedFileSystem::GetEntry(
    const base::FilePath& entry_path) const {
  const Entries::const_iterator entry_it = entries_.find(entry_path);
  if (entry_it == entries_.end())
    return nullptr;

  return entry_it->second.get();
}

base::File::Error FakeProvidedFileSystem::CopyOrMoveEntry(
    const base::FilePath& source_path,
    const base::FilePath& target_path,
    bool is_move) {
  // Check that the source entry exists.
  const FakeEntry* source_entry = GetEntry(source_path);
  if (!source_entry) {
    return base::File::FILE_ERROR_NOT_FOUND;
  }
  // Delete `target_path` if it already exists, since AddEntry DCHECKs that
  // there's no existing entry.
  switch (auto err = DoDeleteEntry(target_path, /*recursive=*/false)) {
    case base::File::Error::FILE_OK:
    case base::File::Error::FILE_ERROR_NOT_FOUND:
      break;
    default:
      return err;
  }
  // Copy source entry.
  DCHECK_NE(source_entry->metadata, nullptr);
  DCHECK_NE(source_entry->metadata->is_directory, nullptr);
  DCHECK_NE(source_entry->metadata->name, nullptr);
  DCHECK_NE(source_entry->metadata->size, nullptr);
  DCHECK_NE(source_entry->metadata->modification_time, nullptr);
  DCHECK_NE(source_entry->metadata->mime_type, nullptr);

  auto cloud_file_info =
      (source_entry->metadata->cloud_file_info)
          ? std::make_unique<CloudFileInfo>(
                source_entry->metadata->cloud_file_info->version_tag)
          : nullptr;

  AddEntry(target_path, *(source_entry->metadata->is_directory),
           *(source_entry->metadata->name), *(source_entry->metadata->size),
           *(source_entry->metadata->modification_time),
           *(source_entry->metadata->mime_type), std::move(cloud_file_info),
           source_entry->contents);
  if (is_move) {
    entries_.erase(source_path);
  }
  return base::File::FILE_OK;
}

AbortCallback FakeProvidedFileSystem::RequestUnmount(
    storage::AsyncFileUtil::StatusCallback callback) {
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::GetMetadata(
    const base::FilePath& entry_path,
    ProvidedFileSystemInterface::MetadataFieldMask fields,
    ProvidedFileSystemInterface::GetMetadataCallback callback) {
  const Entries::const_iterator entry_it = entries_.find(entry_path);

  if (entry_it == entries_.end()) {
    return PostAbortableTask(base::BindOnce(std::move(callback), nullptr,
                                            base::File::FILE_ERROR_NOT_FOUND));
  }

  std::unique_ptr<EntryMetadata> metadata(new EntryMetadata);
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_IS_DIRECTORY) {
    metadata->is_directory =
        std::make_unique<bool>(*entry_it->second->metadata->is_directory);
  }
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_NAME)
    metadata->name =
        std::make_unique<std::string>(*entry_it->second->metadata->name);
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_SIZE)
    metadata->size =
        std::make_unique<int64_t>(*entry_it->second->metadata->size);
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MODIFICATION_TIME) {
    metadata->modification_time = std::make_unique<base::Time>(
        *entry_it->second->metadata->modification_time);
  }
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_MIME_TYPE &&
      entry_it->second->metadata->mime_type.get()) {
    metadata->mime_type =
        std::make_unique<std::string>(*entry_it->second->metadata->mime_type);
  }
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_THUMBNAIL &&
      entry_it->second->metadata->thumbnail.get()) {
    metadata->thumbnail =
        std::make_unique<std::string>(*entry_it->second->metadata->thumbnail);
  }
  // Make a copy of the `CloudFileInfo` to pass to the callback.
  if (fields & ProvidedFileSystemInterface::METADATA_FIELD_CLOUD_FILE_INFO &&
      entry_it->second->metadata->cloud_file_info.get()) {
    metadata->cloud_file_info = std::make_unique<CloudFileInfo>(
        entry_it->second->metadata->cloud_file_info->version_tag);
  }

  return PostAbortableTask(base::BindOnce(
      std::move(callback), std::move(metadata), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::GetActions(
    const std::vector<base::FilePath>& entry_paths,
    ProvidedFileSystemInterface::GetActionsCallback callback) {
  const std::vector<Action> actions;
  return PostAbortableTask(
      base::BindOnce(std::move(callback), actions, base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::ExecuteAction(
    const std::vector<base::FilePath>& entry_paths,
    const std::string& action_id,
    storage::AsyncFileUtil::StatusCallback callback) {
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::ReadDirectory(
    const base::FilePath& directory_path,
    storage::AsyncFileUtil::ReadDirectoryCallback callback) {
  storage::AsyncFileUtil::EntryList entry_list;

  for (Entries::const_iterator it = entries_.begin(); it != entries_.end();
       ++it) {
    const base::FilePath file_path = it->first;
    if (directory_path == file_path.DirName()) {
      const EntryMetadata* const metadata = it->second->metadata.get();
      filesystem::mojom::FsFileType entry_type =
          *metadata->is_directory ? filesystem::mojom::FsFileType::DIRECTORY
                                  : filesystem::mojom::FsFileType::REGULAR_FILE;
      if (*metadata->name == kBadFakeEntryName2) {
        entry_type = static_cast<filesystem::mojom::FsFileType>(7);
      }
      auto name = base::SafeBaseName::Create(*metadata->name);
      CHECK(name) << *metadata->name;
      entry_list.emplace_back(*name, std::string(), entry_type);
    }
  }

  return PostAbortableTask(base::BindOnce(callback, base::File::FILE_OK,
                                          entry_list, /*has_more=*/false));
}

AbortCallback FakeProvidedFileSystem::OpenFile(const base::FilePath& entry_path,
                                               OpenFileMode mode,
                                               OpenFileCallback callback) {
  const Entries::const_iterator entry_it = entries_.find(entry_path);

  if (entry_it == entries_.end()) {
    return PostAbortableTask(base::BindOnce(
        std::move(callback), /*file_handle=*/0,
        base::File::FILE_ERROR_NOT_FOUND, /*cloud_file_info=*/nullptr));
  }

  FakeEntry& entry = *entry_it->second;
  if (mode == OPEN_FILE_MODE_WRITE && flush_required_) {
    DCHECK(!entry.write_buffer);
    entry.write_buffer = entry.contents;
  }

  // Make a copy of the `EntryMetadata` to pass to the callback.
  std::unique_ptr<EntryMetadata> metadata =
      (entry.metadata) ? std::make_unique<EntryMetadata>() : nullptr;
  if (entry.metadata && entry.metadata->cloud_file_info) {
    metadata->cloud_file_info = std::make_unique<CloudFileInfo>(
        entry.metadata->cloud_file_info->version_tag);
  }
  if (entry.metadata && entry.metadata->size) {
    metadata->size = std::make_unique<int64_t>(*entry.metadata->size);
  }

  const int file_handle = ++last_file_handle_;
  opened_files_[file_handle] = OpenedFile(entry_path, mode);
  return PostAbortableTask(base::BindOnce(std::move(callback), file_handle,
                                          base::File::FILE_OK,
                                          std::move(metadata)));
}

AbortCallback FakeProvidedFileSystem::CloseFile(
    int file_handle,
    storage::AsyncFileUtil::StatusCallback callback) {
  const auto opened_file_it = opened_files_.find(file_handle);

  if (opened_file_it == opened_files_.end()) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_ERROR_NOT_FOUND));
  }

  opened_files_.erase(opened_file_it);
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::ReadFile(
    int file_handle,
    net::IOBuffer* buffer,
    int64_t offset,
    int length,
    ProvidedFileSystemInterface::ReadChunkReceivedCallback callback) {
  const auto opened_file_it = opened_files_.find(file_handle);

  if (opened_file_it == opened_files_.end() ||
      opened_file_it->second.file_path.AsUTF8Unsafe() != kFakeFilePath) {
    return PostAbortableTask(
        base::BindOnce(callback, /*chunk_length=*/0, /*has_more=*/false,
                       base::File::FILE_ERROR_INVALID_OPERATION));
  }

  const Entries::const_iterator entry_it =
      entries_.find(opened_file_it->second.file_path);
  if (entry_it == entries_.end()) {
    return PostAbortableTask(
        base::BindOnce(callback, /*chunk_length=*/0, /*has_more=*/false,
                       base::File::FILE_ERROR_INVALID_OPERATION));
  }

  // Send the response byte by byte.
  int64_t current_offset = offset;
  int current_length = length;

  // Reading behind EOF is fine, it will just return 0 bytes.
  if (current_offset >= *entry_it->second->metadata->size || !current_length) {
    return PostAbortableTask(base::BindOnce(callback, /*chunk_length=*/0,
                                            /*has_more=*/false,
                                            base::File::FILE_OK));
  }

  const FakeEntry* const entry = entry_it->second.get();
  std::vector<int> task_ids;
  while (current_offset < *entry->metadata->size && current_length) {
    buffer->data()[current_offset - offset] = entry->contents[current_offset];
    const bool has_more =
        (current_offset + 1 < *entry->metadata->size) && (current_length - 1);
    const int task_id = tracker_.PostTask(
        base::SingleThreadTaskRunner::GetCurrentDefault().get(), FROM_HERE,
        base::BindOnce(callback, /*chunk_length=*/1, has_more,
                       base::File::FILE_OK));
    task_ids.push_back(task_id);
    current_offset++;
    current_length--;
  }

  return base::BindOnce(&FakeProvidedFileSystem::AbortMany,
                        weak_ptr_factory_.GetWeakPtr(), task_ids);
}

AbortCallback FakeProvidedFileSystem::CreateDirectory(
    const base::FilePath& directory_path,
    bool recursive,
    storage::AsyncFileUtil::StatusCallback callback) {
  // No-op if the directory already exists.
  if (GetEntry(directory_path)) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_OK));
  }
  // Create directories recursively.
  std::vector<base::FilePath::StringType> components =
      directory_path.GetComponents();
  CHECK_EQ(components[0], "/");
  base::FilePath path(components[0]);
  for (size_t i = 1; i < components.size(); ++i) {
    path = path.AppendASCII(components[i]);
    if (GetEntry(path)) {
      continue;
    }
    // If `recursive` is set to false, only the last component of the provided
    // path should be new.
    if (!recursive && i < components.size() - 1) {
      return PostAbortableTask(base::BindOnce(
          std::move(callback), base::File::FILE_ERROR_INVALID_OPERATION));
    }
    AddEntry(path, /*is_directory=*/true, path.BaseName().value(), /*size=*/0,
             base::Time(), /*mime_type=*/"", /*cloud_file_info=*/nullptr,
             /*contents=*/"");
  }
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::DeleteEntry(
    const base::FilePath& entry_path,
    bool recursive,
    storage::AsyncFileUtil::StatusCallback callback) {
  auto err = DoDeleteEntry(entry_path, recursive);
  return PostAbortableTask(base::BindOnce(std::move(callback), err));
}

base::File::Error FakeProvidedFileSystem::DoDeleteEntry(
    const base::FilePath& entry_path,
    bool recursive) {
  // Check that the entry to remove exists.
  if (!GetEntry(entry_path)) {
    return base::File::FILE_ERROR_NOT_FOUND;
  }
  // If `recursive` is false, check that `entry_path` is not parent of any entry
  // path in `entries_`.
  if (!recursive) {
    const Entries::const_iterator it =
        std::ranges::find_if(entries_, [entry_path](auto& entry_it) {
          return entry_path.IsParent(entry_it.first);
        });
    if (it != entries_.end()) {
      return base::File::FILE_ERROR_INVALID_OPERATION;
    }
  }
  // Erase the entry with path `entry_path`, as well as all child entries.
  for (Entries::const_iterator entry_it = entries_.begin();
       entry_it != entries_.end();) {
    if (entry_path == entry_it->first || entry_path.IsParent(entry_it->first)) {
      entry_it = entries_.erase(entry_it);
    } else {
      ++entry_it;
    }
  }
  return base::File::FILE_OK;
}

AbortCallback FakeProvidedFileSystem::CreateFile(
    const base::FilePath& file_path,
    storage::AsyncFileUtil::StatusCallback callback) {
  if (GetEntry(file_path)) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_ERROR_EXISTS));
  }
  AddEntry(file_path, /*is_directory=*/false, file_path.BaseName().value(),
           /*size=*/0, base::Time(), kFakeFileMimeType,
           /*cloud_file_info=*/nullptr, std::string());
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::CopyEntry(
    const base::FilePath& source_path,
    const base::FilePath& target_path,
    storage::AsyncFileUtil::StatusCallback callback) {
  return PostAbortableTask(base::BindOnce(
      std::move(callback),
      CopyOrMoveEntry(source_path, target_path, /*is_move=*/false)));
}

AbortCallback FakeProvidedFileSystem::MoveEntry(
    const base::FilePath& source_path,
    const base::FilePath& target_path,
    storage::AsyncFileUtil::StatusCallback callback) {
  return PostAbortableTask(base::BindOnce(
      std::move(callback),
      CopyOrMoveEntry(source_path, target_path, /*is_move=*/true)));
}

AbortCallback FakeProvidedFileSystem::Truncate(
    const base::FilePath& file_path,
    int64_t length,
    storage::AsyncFileUtil::StatusCallback callback) {
  FakeEntry* const entry = GetEntry(file_path);
  if (!entry) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_ERROR_NOT_FOUND));
  }
  *entry->metadata->size = length;
  entry->contents.resize(*entry->metadata->size);
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::WriteFile(
    int file_handle,
    net::IOBuffer* buffer,
    int64_t offset,
    int length,
    storage::AsyncFileUtil::StatusCallback callback) {
  const auto opened_file_it = opened_files_.find(file_handle);

  if (opened_file_it == opened_files_.end() ||
      !GetEntry(opened_file_it->second.file_path)) {
    return PostAbortableTask(base::BindOnce(
        std::move(callback), base::File::FILE_ERROR_INVALID_OPERATION));
  }

  FakeEntry* const entry = GetEntry(opened_file_it->second.file_path);
  if (!entry) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_ERROR_NOT_FOUND));
  }
  std::string& write_buffer =
      entry->write_buffer ? *entry->write_buffer : entry->contents;
  int64_t buffer_size = static_cast<int64_t>(write_buffer.size());
  if (offset > buffer_size) {
    return PostAbortableTask(base::BindOnce(
        std::move(callback), base::File::FILE_ERROR_INVALID_OPERATION));
  }

  // Allocate the string size in advance.
  if (offset + length > buffer_size) {
    if (!entry->write_buffer) {
      // Only update metadata if we are writing contents directly.
      *entry->metadata->size = offset + length;
      // Update the version when the contents change.
      if (entry->metadata->cloud_file_info.get()) {
        entry->metadata->cloud_file_info->version_tag += "1";
      }
    }
    write_buffer.resize(*entry->metadata->size);
  }

  write_buffer.replace(offset, length, buffer->data(), length);

  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::FlushFile(
    int file_handle,
    storage::AsyncFileUtil::StatusCallback callback) {
  const auto opened_file_it = opened_files_.find(file_handle);

  if (opened_file_it == opened_files_.end() ||
      !GetEntry(opened_file_it->second.file_path)) {
    return PostAbortableTask(base::BindOnce(
        std::move(callback), base::File::FILE_ERROR_INVALID_OPERATION));
  }

  FakeEntry* const entry = GetEntry(opened_file_it->second.file_path);
  if (!entry) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_ERROR_NOT_FOUND));
  }

  if (entry->write_buffer) {
    *entry->metadata->size = entry->write_buffer->size();
    entry->contents = std::move(*entry->write_buffer);
    entry->write_buffer = std::nullopt;
  }
  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

AbortCallback FakeProvidedFileSystem::AddWatcher(
    const GURL& origin,
    const base::FilePath& entry_watcher,
    bool recursive,
    bool persistent,
    storage::AsyncFileUtil::StatusCallback callback,
    storage::WatcherManager::NotificationCallback notification_callback) {
  // Check if watcher already exists.
  const WatcherKey key(entry_watcher, recursive);
  const Watchers::iterator it = watchers_.find(key);
  if (it != watchers_.end()) {
    return PostAbortableTask(
        base::BindOnce(std::move(callback), base::File::FILE_OK));
  }

  Subscriber subscriber;
  subscriber.origin = origin;
  subscriber.persistent = persistent;
  subscriber.notification_callback = std::move(notification_callback);

  // Add watcher.
  Watcher* const watcher = &watchers_[key];
  watcher->entry_path = entry_watcher;
  watcher->recursive = recursive;
  watcher->subscribers[origin] = subscriber;

  // Notify observers.
  for (auto& observer : observers_) {
    observer.OnWatcherListChanged(file_system_info_, watchers_);
  }

  return PostAbortableTask(
      base::BindOnce(std::move(callback), base::File::FILE_OK));
}

void FakeProvidedFileSystem::RemoveWatcher(
    const GURL& origin,
    const base::FilePath& entry_path,
    bool recursive,
    storage::AsyncFileUtil::StatusCallback callback) {
  // Remove watcher.
  const WatcherKey key(entry_path, recursive);
  const auto it = watchers_.find(key);
  if (it != watchers_.end()) {
    watchers_.erase(it);
  }

  // Notify observers.
  for (auto& observer : observers_) {
    observer.OnWatcherListChanged(file_system_info_, watchers_);
  }

  std::move(callback).Run(base::File::FILE_OK);
}

const ProvidedFileSystemInfo& FakeProvidedFileSystem::GetFileSystemInfo()
    const {
  return file_system_info_;
}

OperationRequestManager* FakeProvidedFileSystem::GetRequestManager() {
  NOTREACHED();
}

Watchers* FakeProvidedFileSystem::GetWatchers() {
  return &watchers_;
}

const OpenedFiles& FakeProvidedFileSystem::GetOpenedFiles() const {
  return opened_files_;
}

void FakeProvidedFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
  DCHECK(observer);
  observers_.AddObserver(observer);
}

void FakeProvidedFileSystem::RemoveObserver(
    ProvidedFileSystemObserver* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

void FakeProvidedFileSystem::Notify(
    const base::FilePath& entry_path,
    bool recursive,
    storage::WatcherManager::ChangeType change_type,
    std::unique_ptr<ProvidedFileSystemObserver::Changes> changes,
    const std::string& tag,
    storage::AsyncFileUtil::StatusCallback callback) {
  // Very simple implementation that unconditionally calls notification
  // callbacks and notifies observers of the change.

  const WatcherKey key(entry_path, recursive);
  const auto& watcher_it = watchers_.find(key);
  if (watcher_it == watchers_.end()) {
    std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
    return;
  }

  const ProvidedFileSystemObserver::Changes& changes_ref = *changes.get();

  // Call all notification callbacks (if any).
  for (const auto& subscriber_it : watcher_it->second.subscribers) {
    const storage::WatcherManager::NotificationCallback& notification_callback =
        subscriber_it.second.notification_callback;
    if (!notification_callback.is_null()) {
      notification_callback.Run(change_type);
    }
  }

  // Notify all observers.
  for (auto& observer : observers_) {
    observer.OnWatcherChanged(file_system_info_, watcher_it->second,
                              change_type, changes_ref, base::DoNothing());
  }
}

void FakeProvidedFileSystem::Configure(
    storage::AsyncFileUtil::StatusCallback callback) {
  NOTREACHED();
}

base::WeakPtr<ProvidedFileSystemInterface>
FakeProvidedFileSystem::GetWeakPtr() {
  return weak_ptr_factory_.GetWeakPtr();
}

std::unique_ptr<ScopedUserInteraction>
FakeProvidedFileSystem::StartUserInteraction() {
  return nullptr;
}

base::WeakPtr<FakeProvidedFileSystem> FakeProvidedFileSystem::GetFakeWeakPtr() {
  return weak_ptr_factory_.GetWeakPtr();
}

AbortCallback FakeProvidedFileSystem::PostAbortableTask(
    base::OnceClosure callback) {
  const int task_id =
      tracker_.PostTask(base::SingleThreadTaskRunner::GetCurrentDefault().get(),
                        FROM_HERE, std::move(callback));
  return base::BindOnce(&FakeProvidedFileSystem::Abort,
                        weak_ptr_factory_.GetWeakPtr(), task_id);
}

void FakeProvidedFileSystem::Abort(int task_id) {
  tracker_.TryCancel(task_id);
}

void FakeProvidedFileSystem::AbortMany(const std::vector<int>& task_ids) {
  for (int task_id : task_ids) {
    tracker_.TryCancel(task_id);
  }
}

}  // namespace ash::file_system_provider