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

#include "chrome/browser/ash/file_system_provider/content_cache/content_cache_impl.h"

#include "base/barrier_callback.h"
#include "base/callback_list.h"
#include "base/files/file.h"
#include "base/files/file_enumerator.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/scoped_refptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "chrome/browser/ash/file_system_provider/cloud_file_system.h"
#include "chrome/browser/ash/file_system_provider/content_cache/cache_file_context.h"
#include "chrome/browser/ash/file_system_provider/content_cache/content_cache.h"
#include "chrome/browser/ash/file_system_provider/content_cache/content_lru_cache.h"
#include "chrome/browser/ash/file_system_provider/content_cache/context_database.h"
#include "chrome/browser/ash/file_system_provider/content_cache/local_fd.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "net/base/io_buffer.h"

namespace ash::file_system_provider {

namespace {

std::map<int, int64_t> GetFilesOnDisk(const base::FilePath& cache_directory) {
  std::map<int, int64_t> files_on_disk;
  if (cache_directory.empty()) {
    return files_on_disk;
  }

  base::FileEnumerator enumerator(cache_directory, /*recursive=*/false,
                                  base::FileEnumerator::FILES);
  while (!enumerator.Next().empty()) {
    base::FileEnumerator::FileInfo info = enumerator.GetInfo();
    base::FilePath path = info.GetName();
    if (base::StartsWith(path.BaseName().value(), "context.db")) {
      // The context database has multiple variants starting with context.db,
      // let's exclude those for now.
      continue;
    }
    int64_t id = -1;
    if (!base::StringToInt64(path.BaseName().value(), &id)) {
      LOG(ERROR) << "Couldn't extract ID from path";
      // TODO(b/335548274): Should we remove these files from disk, or ignore
      // them.
      continue;
    }
    files_on_disk.try_emplace(id, info.GetSize());
  }

  return files_on_disk;
}

bool RemoveFilesOnDiskByPath(std::set<base::FilePath> paths_on_disk_to_remove) {
  bool success = true;
  for (const base::FilePath& path : paths_on_disk_to_remove) {
    if (!base::DeleteFile(path)) {
      LOG(ERROR) << "Couldn't remove file on disk";
      success = false;
    }
  }
  return success;
}

}  // namespace

ContentCacheImpl::ContentCacheImpl(const base::FilePath& root_dir,
                                   BoundContextDatabase context_db,
                                   size_t max_cache_items)
    : root_dir_(root_dir),
      io_task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
          {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})),
      context_db_(std::move(context_db)),
      max_cache_items_(max_cache_items) {}

ContentCacheImpl::~ContentCacheImpl() {
  context_db_.Reset();
}

std::unique_ptr<ContentCache> ContentCacheImpl::Create(
    const base::FilePath& root_dir,
    BoundContextDatabase context_db,
    size_t max_cache_items) {
  return std::make_unique<ContentCacheImpl>(root_dir, std::move(context_db),
                                            max_cache_items);
}

void ContentCacheImpl::SetMaxCacheItems(size_t max_cache_items) {
  VLOG(1) << "Cache size changing from " << max_cache_items_ << " items to "
          << max_cache_items << " items";
  max_cache_items_ = max_cache_items;
  EvictExcessItems();
}

void ContentCacheImpl::Notify(ProvidedFileSystemObserver::Changes& changes) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  std::vector<base::FilePath> to_evict;
  for (const auto& change : changes) {
    ContentLRUCache::iterator it = lru_cache_.Peek(change.entry_path);
    if (it == lru_cache_.end()) {
      VLOG(1) << "File is not in cache";
      continue;
    }

    // Evict any deleted items or items with mismatched version tags from the
    // cache.
    if (change.change_type == storage::WatcherManager::ChangeType::DELETED) {
      VLOG(2) << "File is deleted, evict from the cache";
      to_evict.push_back(change.entry_path);
      continue;
    }

    if (!change.cloud_file_info) {
      // All cached files should have a version_tag.
      VLOG(2) << "No version_tag, evict from the cache";
      to_evict.push_back(change.entry_path);
      continue;
    }

    CacheFileContext& ctx = it->second;
    if (change.cloud_file_info->version_tag != ctx.version_tag()) {
      VLOG(2) << "File version is out of date, evict from the cache";
      to_evict.push_back(change.entry_path);
    }
  }
  EvictItems(to_evict);
}

void ContentCacheImpl::ObservedVersionTag(const base::FilePath& entry_path,
                                          const std::string& version_tag) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  ContentLRUCache::iterator it = lru_cache_.Peek(entry_path);
  if (it == lru_cache_.end()) {
    VLOG(1) << "File is not in cache";
    return;
  }

  CacheFileContext& ctx = it->second;
  if (version_tag != ctx.version_tag()) {
    VLOG(2) << "File version is out of date, evict from the cache";
    Evict(entry_path);
  }
}

void ContentCacheImpl::Evict(const base::FilePath& file_path) {
  std::vector<base::FilePath> file_paths = {file_path};
  EvictItems(file_paths);
}

void ContentCacheImpl::RemoveItems(
    const std::vector<base::FilePath>& fsp_paths) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  std::vector<int64_t> item_ids;

  // If possible, remove each item from the disk and the database. Do not wait
  // for each removal to complete. In the case that some removals fail, orphaned
  // items will be cleaned up upon start-up.
  for (const base::FilePath& fsp_path : fsp_paths) {
    ContentLRUCache::iterator it = lru_cache_.Peek(fsp_path);
    if (it == lru_cache_.end()) {
      VLOG(1) << "Context for '" << fsp_path << "' is not in the cache";
      continue;
    }

    CacheFileContext& ctx = it->second;
    if (ctx.HasLocalFDs()) {
      VLOG(2) << "Item '" << fsp_path
              << "' cannot be removed whilst there is an open LocalFD";
      continue;
    }

    if (ctx.path_on_disk().empty()) {
      // TODO(b/339114587): Handle this case better. Remove from the lru_cache
      // immediately and erase from the database.
      VLOG(2) << "Item does not yet have a path on disk";
      continue;
    }

    if (ctx.removal_in_progress()) {
      VLOG(2) << "Item '" << fsp_path << "' is already being removed";
      continue;
    }

    VLOG(1) << "Removing '" << fsp_path << "'";
    ctx.set_removal_in_progress(true);
    item_ids.push_back(ctx.id());

    RemoveItemFromDisk(ctx.path_on_disk(), fsp_path);
  }

  RemoveItemsFromDatabase(item_ids);
}

void ContentCacheImpl::RemoveItemsFromDatabase(std::vector<int64_t>& item_ids) {
  if (item_ids.empty()) {
    return;
  }

  const size_t number_of_items = item_ids.size();

  // Remove items from the database by their ID.
  VLOG(1) << "Attempting to remove " << number_of_items
          << " item(s) from the database";
  context_db_.AsyncCall(&ContextDatabase::RemoveItemsByIds)
      .WithArgs(std::move(item_ids))
      .Then(base::BindOnce(&ContentCacheImpl::OnItemsRemovedFromDatabase,
                           weak_ptr_factory_.GetWeakPtr(), number_of_items));
}

void ContentCacheImpl::OnItemsRemovedFromDatabase(size_t number_of_items,
                                                  bool success) {
  if (success) {
    VLOG(1) << "Removed " << number_of_items << " item(s) from the database";
  } else {
    LOG(ERROR) << "Couldn't remove " << number_of_items
               << " items from database";
  }
  // Now all the items on the disk have been removed, if the database call
  // failed the next time the cache is rebuilt (via `LoadFromDisk`) these items
  // will be attempted to be removed again.
}

void ContentCacheImpl::RemoveItemFromDisk(const base::FilePath& path_on_disk,
                                          const base::FilePath& fsp_path) {
  VLOG(1) << "Attempting to remove " << path_on_disk << " from the disk";
  io_task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE, base::BindOnce(&base::DeleteFile, path_on_disk),
      base::BindOnce(&ContentCacheImpl::OnItemRemovedFromDisk,
                     weak_ptr_factory_.GetWeakPtr(), base::OwnedRef(fsp_path)));
}

void ContentCacheImpl::OnItemRemovedFromDisk(const base::FilePath& fsp_path,
                                             bool success) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  ContentLRUCache::iterator it = lru_cache_.Peek(fsp_path);
  if (it == lru_cache_.end()) {
    VLOG(1) << "Context for '" << fsp_path << "' is not in the cache";
    return;
  }

  if (!success) {
    LOG(ERROR) << "Failed to remove item with id " << it->second.id()
               << " from disk";
    return;
  }

  VLOG(1) << "Removed item with id " << it->second.id() << " from disk";
  const int64_t bytes_on_disk = it->second.bytes_on_disk();
  lru_cache_.Erase(it);
  DCHECK_GT(evicted_cache_items_, 0u);
  evicted_cache_items_--;

  // Notify all observers.
  for (auto& observer : observers_) {
    observer.OnItemRemovedFromDisk(fsp_path, bytes_on_disk);
  }
}

void ContentCacheImpl::EvictItems(
    const std::vector<base::FilePath>& file_paths) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  for (const base::FilePath& file_path : file_paths) {
    ContentLRUCache::iterator it = lru_cache_.Peek(file_path);
    if (it == lru_cache_.end()) {
      VLOG(2) << "Context for '" << file_path << "' is not in the cache";
      continue;
    }

    CacheFileContext& ctx = it->second;
    if (ctx.evicted()) {
      VLOG(2) << "Item '" << file_path << "' is already evicted";
      continue;
    }

    VLOG(1) << "Evicting '" << file_path << "'";
    ctx.set_evicted(true);
    evicted_cache_items_++;
    // Notify all observers.
    for (auto& observer : observers_) {
      observer.OnItemEvicted(file_path);
    }
  }
  RemoveItems(file_paths);
}

void ContentCacheImpl::EvictExcessItems() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  // The cache size should not include the items that are expected to be evicted
  // as these will get removed on the next removal cycle.
  size_t cache_items_without_evicted_items =
      lru_cache_.size() - evicted_cache_items_;
  if (cache_items_without_evicted_items <= max_cache_items_) {
    VLOG(2) << "No items to evict: {cache_items_without_evicted_items = "
            << cache_items_without_evicted_items
            << ", max_cache_items = " << max_cache_items_ << "}";
    return;
  }

  size_t items_to_evict = cache_items_without_evicted_items - max_cache_items_;
  VLOG(2) << items_to_evict << " items to be evicted, not including "
          << evicted_cache_items_ << " already evicted";

  // Evict items starting from the least-recently-used until the total number of
  // evicted items brings the size of the cache (without these items) to below
  // the `max_cache_items_`.
  ContentLRUCache::reverse_iterator it = lru_cache_.rbegin();
  std::vector<base::FilePath> to_evict;
  while (to_evict.size() < items_to_evict) {
    CacheFileContext& ctx = it->second;
    if (!ctx.evicted()) {
      to_evict.push_back(it->first);
    }
    it++;
  }
  EvictItems(to_evict);
}

void ContentCacheImpl::ReadBytes(
    const OpenedCloudFile& file,
    scoped_refptr<net::IOBuffer> buffer,
    int64_t offset,
    int length,
    ProvidedFileSystemInterface::ReadChunkReceivedCallback callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  VLOG(1) << "ReadBytes {path = '" << file.file_path << "', version_tag = '"
          << file.version_tag << "', offset = '" << offset << "', length = '"
          << length << "'}";

  ContentLRUCache::iterator it = lru_cache_.Peek(file.file_path);
  if (it == lru_cache_.end()) {
    VLOG(1) << "Cache miss: entire file is not in cache";
    callback.Run(/*bytes_read=*/-1, /*has_more=*/false,
                 base::File::FILE_ERROR_NOT_FOUND);
    return;
  }

  CacheFileContext& ctx = it->second;

  if (offset == ctx.bytes_on_disk() && offset == file.bytes_in_cloud) {
    VLOG(1) << "Ignored request: offset is at EOF";
    callback.Run(/*bytes_read=*/0, /*has_more=*/false, base::File::FILE_OK);
    return;
  }

  // In the event the offset exceeds the known `bytes_on_disk` then we can't
  // reliably serve this data from the content cache.
  if (offset >= ctx.bytes_on_disk()) {
    VLOG(1) << "Cache miss: requested byte range {offset = '" << offset
            << "', length = '" << length
            << "'} not available {bytes_on_disk = '" << ctx.bytes_on_disk()
            << "'}";
    callback.Run(/*bytes_read=*/-1, /*has_more=*/false,
                 base::File::FILE_ERROR_NOT_FOUND);
    return;
  }

  if (!ctx.CanGetLocalFD(file)) {
    VLOG(1) << "Cache miss: not possible to read the file on disk";
    callback.Run(/*bytes_read=*/-1, /*has_more=*/false,
                 base::File::FILE_ERROR_NOT_FOUND);
    return;
  }

  // It's possible that the file on disk can't entirely fulfill the offset +
  // length bytes request. In this instance, the callback will be invoked with
  // `bytes_read` (which will be less than length) and it's up to the caller to
  // make a follow up call for the remainder (which will then be served from the
  // underlying FSP).
  VLOG(1) << "Cache hit: Range {offset = '" << offset << "', length = '"
          << length << "', bytes_on_disk = '" << ctx.bytes_on_disk()
          << "'} is available";

  LocalFD& local_fd = ctx.GetLocalFD(file, io_task_runner_);
  local_fd.ReadBytes(
      buffer, offset, length,
      base::BindOnce(&ContentCacheImpl::OnBytesRead,
                     weak_ptr_factory_.GetWeakPtr(), file.file_path, callback));
}

void ContentCacheImpl::OnBytesRead(
    const base::FilePath& file_path,
    ProvidedFileSystemInterface::ReadChunkReceivedCallback callback,
    FileErrorOrBytesRead error_or_bytes_read) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  base::File::Error result = error_or_bytes_read.error_or(base::File::FILE_OK);
  if (result != base::File::FILE_OK) {
    VLOG(2) << "OnBytesRead result: " << base::File::ErrorToString(result);
    callback.Run(/*bytes_read=*/0, /*has_more=*/false, result);
    return;
  }

  ContentLRUCache::iterator it = lru_cache_.Get(file_path);
  DCHECK(it != lru_cache_.end());

  // Update the accessed time to now, but don't wait for the database to return,
  // just fire and forget.
  CacheFileContext& ctx = it->second;
  ctx.set_accessed_time(base::Time::Now());
  context_db_.AsyncCall(&ContextDatabase::UpdateAccessedTime)
      .WithArgs(ctx.id(), ctx.accessed_time())
      .Then(base::BindOnce([](bool success) {
        LOG_IF(ERROR, !success) << "Couldn't update access time on read";
      }));

  int bytes_read = error_or_bytes_read.value();
  VLOG(2) << "OnBytesRead {bytes_read = '" << bytes_read << "'}";
  callback.Run(bytes_read, /*has_more=*/false, base::File::FILE_OK);
}

void ContentCacheImpl::WriteBytes(const OpenedCloudFile& file,
                                  scoped_refptr<net::IOBuffer> buffer,
                                  int64_t offset,
                                  int length,
                                  FileErrorCallback callback) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  ContentLRUCache::iterator it = lru_cache_.Peek(file.file_path);
  if (it != lru_cache_.end()) {
    WriteBytesToDisk(file, buffer, offset, length, std::move(callback));
    return;
  }

  // The file doesn't exist in the cache yet.
  if (file.version_tag.empty()) {
    VLOG(1) << "Empty version tag can't be written to cache";
    std::move(callback).Run(base::File::FILE_ERROR_INVALID_OPERATION);
    return;
  }

  // Add a new CacheFileContext to the lru_cache.
  VLOG(1) << "Adding '" << file.file_path << "' to the cache";
  it = lru_cache_.Put(
      PathContextPair(file.file_path, CacheFileContext(file.version_tag)));
  EvictExcessItems();

  // Add a new entry to the database then retrieve the ID and use it to create
  // a file on disk before writing the bytes to disk.
  std::unique_ptr<int64_t> inserted_id = std::make_unique<int64_t>(-1);
  context_db_.AsyncCall(&ContextDatabase::AddItem)
      .WithArgs(file.file_path, file.version_tag, it->second.accessed_time(),
                inserted_id.get())
      .Then(base::BindOnce(&ContentCacheImpl::OnFileIdGenerated,
                           weak_ptr_factory_.GetWeakPtr(), file, buffer, offset,
                           length, std::move(callback),
                           std::move(inserted_id)));
  }

  void ContentCacheImpl::WriteBytesToDisk(const OpenedCloudFile& file,
                                          scoped_refptr<net::IOBuffer> buffer,
                                          int64_t offset,
                                          int length,
                                          FileErrorCallback callback) {
    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

    ContentLRUCache::iterator it = lru_cache_.Peek(file.file_path);
    if (it == lru_cache_.end()) {
      VLOG(2) << "File removed between WriteBytes and WriteBytesToDisk calls";
      std::move(callback).Run(base::File::FILE_ERROR_INVALID_OPERATION);
      return;
    }
    CacheFileContext& ctx = it->second;

    if (ctx.bytes_on_disk() != offset) {
      VLOG(1) << "Unsupported write offset supplied {bytes_on_disk = '"
              << ctx.bytes_on_disk() << "', offset = '" << offset << "'}";
      std::move(callback).Run(base::File::FILE_ERROR_INVALID_OPERATION);
      return;
    }

    if (!ctx.CanGetLocalFD(file)) {
      VLOG(1) << "Not possible to write to the file on disk";
      std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
      return;
    }

    if (ctx.has_writer()) {
      VLOG(1) << "Writer is in progress already, multi offset writers not "
                 "supported";
      std::move(callback).Run(base::File::FILE_ERROR_IN_USE);
      return;
    }
    ctx.set_has_writer(true);

    auto on_bytes_written_callback = base::BindOnce(
        &ContentCacheImpl::OnBytesWritten, weak_ptr_factory_.GetWeakPtr(),
        file.file_path, offset, length, std::move(callback));

    LocalFD& local_fd = ctx.GetLocalFD(file, io_task_runner_);
    local_fd.WriteBytes(buffer, offset, length,
                        std::move(on_bytes_written_callback));
  }

void ContentCacheImpl::CloseFile(const OpenedCloudFile& file) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  VLOG(1) << "Closing " << file.file_path;
  if (auto it = lru_cache_.Peek(file.file_path); it != lru_cache_.end()) {
    CacheFileContext& ctx = it->second;
    ctx.CloseLocalFD(file.request_id);
    if (ctx.evicted()) {
      // File was evicted when reading. Remove it.
      std::vector<base::FilePath> file_paths = {file.file_path};
      RemoveItems(file_paths);
    }
  }
}

void ContentCacheImpl::OnFileIdGenerated(const OpenedCloudFile& file,
                                         scoped_refptr<net::IOBuffer> buffer,
                                         int64_t offset,
                                         int length,
                                         FileErrorCallback callback,
                                         std::unique_ptr<int64_t> inserted_id,
                                         bool item_add_success) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  if (!item_add_success) {
    LOG(ERROR) << "Failed to add item to the database";
    std::move(callback).Run(base::File::FILE_ERROR_FAILED);
    return;
  }

  ContentLRUCache::iterator it = lru_cache_.Peek(file.file_path);
  // TODO(b/339114587): Handle the case where the context gets removed during
  // the file ID generation.
  DCHECK(it != lru_cache_.end());
  DCHECK(inserted_id);
  DCHECK_GT(*inserted_id, 0);
  CacheFileContext& ctx = it->second;
  ctx.set_id(*inserted_id);
  ctx.set_path_on_disk(GetPathOnDiskFromId((*inserted_id)));

  WriteBytesToDisk(file, buffer, offset, length, std::move(callback));
}

void ContentCacheImpl::OnBytesWritten(const base::FilePath& file_path,
                                      int64_t offset,
                                      int length,
                                      FileErrorCallback callback,
                                      base::File::Error result) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  ContentLRUCache::iterator it = lru_cache_.Get(file_path);
  DCHECK(it != lru_cache_.end());

  CacheFileContext& ctx = it->second;
  if (result == base::File::FILE_OK) {
    ctx.set_bytes_on_disk(offset + length);
    ctx.set_accessed_time(base::Time::Now());

    // Keep the accessed time up to date.
    context_db_.AsyncCall(&ContextDatabase::UpdateAccessedTime)
        .WithArgs(ctx.id(), ctx.accessed_time())
        .Then(base::BindOnce([](bool success) {
          LOG_IF(ERROR, !success) << "Couldn't update access time on write";
        }));
  }
  ctx.set_has_writer(false);

  VLOG(2) << "OnBytesWritten: {offset = '" << offset << "', length = '"
          << length << "', result = '" << base::File::ErrorToString(result)
          << "'}";
  std::move(callback).Run(result);
}

const base::FilePath ContentCacheImpl::GetPathOnDiskFromId(int64_t id) {
  return root_dir_.Append(base::NumberToString(id));
}

void ContentCacheImpl::LoadFromDisk(base::OnceClosure callback) {
  // Identify all the files from the `root_dir_`.
  io_task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE, base::BindOnce(&GetFilesOnDisk, root_dir_),
      base::BindOnce(&ContentCacheImpl::GotFilesFromDisk,
                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}

void ContentCacheImpl::GotFilesFromDisk(base::OnceClosure callback,
                                        std::map<int, int64_t> files_on_disk) {
  // Get all the items from the database.
  context_db_.AsyncCall(&ContextDatabase::GetAllItems)
      .Then(base::BindOnce(&ContentCacheImpl::GotItemsFromContextDatabase,
                           weak_ptr_factory_.GetWeakPtr(), std::move(callback),
                           std::move(files_on_disk)));
}

void ContentCacheImpl::GotItemsFromContextDatabase(
    base::OnceClosure callback,
    std::map<int, int64_t> files_on_disk,
    ContextDatabase::IdToItemMap items_in_db) {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

  std::set<base::FilePath> paths_on_disk_to_remove;
  std::list<PathContextPair> cached_files;
  for (auto& [id, bytes_on_disk] : files_on_disk) {
    ContextDatabase::IdToItemMap::const_iterator item_it = items_in_db.find(id);
    if (item_it == items_in_db.end()) {
      // Remove files on disk that have no entry in the database.
      paths_on_disk_to_remove.emplace(
          root_dir_.Append(base::NumberToString(id)));
    } else {
      // Create contexts for each non-orphaned file on the disk using the
      // database entry.
      CacheFileContext ctx(item_it->second.version_tag, bytes_on_disk, id,
                           GetPathOnDiskFromId(id));
      ctx.set_accessed_time(item_it->second.accessed_time);
      cached_files.emplace_back(item_it->second.fsp_path, std::move(ctx));
    }
  }

  std::vector<int64_t> ids_in_db_to_remove;
  for (const auto& [id, item] : items_in_db) {
    if (!files_on_disk.contains(id)) {
      // Remove SQL entries that have no file on disk.
      ids_in_db_to_remove.emplace_back(id);
    }
  }

  cached_files.sort([](const PathContextPair& lhs, const PathContextPair& rhs) {
    // The files should be in least-recently used order, the underlying data
    // structure maintains them in order on access but not on initialization so
    // we have to ensure order now. This means the most-recently used is the
    // 0-th item, where eviction will take place on the last element.
    return lhs.second.accessed_time() > rhs.second.accessed_time();
  });

  VLOG(1) << "Initializing content cache with " << cached_files.size()
          << " items";
  lru_cache_.Init(std::move(cached_files));

  const auto barrier_callback = base::BarrierCallback<bool>(
      2, base::BindOnce(&ContentCacheImpl::OnStaleItemsPruned,
                        weak_ptr_factory_.GetWeakPtr(), std::move(callback)));

  VLOG_IF(1, !ids_in_db_to_remove.empty())
      << "Attempting to remove " << ids_in_db_to_remove.size()
      << " item(s) from the database";
  context_db_.AsyncCall(&ContextDatabase::RemoveItemsByIds)
      .WithArgs(ids_in_db_to_remove)
      .Then(barrier_callback);

  VLOG_IF(1, !paths_on_disk_to_remove.empty())
      << "Attempting to remove " << paths_on_disk_to_remove.size()
      << " path(s) from the disk";
  io_task_runner_->PostTaskAndReplyWithResult(
      FROM_HERE,
      base::BindOnce(&RemoveFilesOnDiskByPath, paths_on_disk_to_remove),
      barrier_callback);
}

void ContentCacheImpl::OnStaleItemsPruned(base::OnceClosure callback,
                                          std::vector<bool> prune_success) {
  DCHECK_EQ(prune_success.size(), 2u);
  bool db_success = prune_success.at(0);
  bool fs_success = prune_success.at(1);

  LOG_IF(ERROR, !db_success) << "Couldn't remove all stale items from db";
  LOG_IF(ERROR, !fs_success) << "Couldn't remove all stale items from disk";

  // Failing to remove files from db/disk doesn't stop the cache being
  // successfully setup.
  std::move(callback).Run();
}

std::vector<base::FilePath> ContentCacheImpl::GetCachedFilePaths() {
  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  std::vector<base::FilePath> cached_file_paths;
  for (const auto& [file_path, cache_file_context] : lru_cache_) {
    if (!cache_file_context.evicted()) {
      cached_file_paths.push_back(file_path);
    }
  }
  return cached_file_paths;
}

void ContentCacheImpl::AddObserver(ContentCache::Observer* observer) {
  DCHECK(observer);
  observers_.AddObserver(observer);
}

void ContentCacheImpl::RemoveObserver(ContentCache::Observer* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

}  // namespace ash::file_system_provider