ash/ambient/managed/screensaver_image_downloader.cc - chromium/src - Git at Google

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

 #include "ash/ambient/managed/screensaver_image_downloader.h"

 #include <string>

 #include "ash/ambient/metrics/managed_screensaver_metrics.h"
 #include "base/containers/flat_set.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/hash/sha1.h"
 #include "base/logging.h"
 #include "base/ranges/algorithm.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/thread_pool.h"
 #include "base/values.h"
 #include "net/http/http_request_headers.h"
 #include "services/network/public/cpp/resource_request.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/mojom/url_response_head.mojom.h"

 namespace ash {

 namespace {

 constexpr net::NetworkTrafficAnnotationTag
     kScreensaverImageDownloaderNetworkTag =
         net::DefineNetworkTrafficAnnotation("screensaver_image_downloader",
                                             R"(
         semantics {
           sender: "Managed Screensaver"
           description:
             "Fetch external image files that will be cached and displayed "
             "in the policy-controlled screensaver."
           trigger:
             "An update to the ScreensaverLockScreenImages policy that includes "
             "new references to external image files."
           data:
             "This request does not send any data from the device. It fetches"
             "images from URLs provided by the policy."
           destination: OTHER
           user_data {
             type: NONE
           }
           internal {
             contacts {
               email: "mpetrisor@google.com"
             }
           }
           last_reviewed: "2023-03-30"
         }
         policy {
           cookies_allowed: NO
           setting:
             "This feature is controlled by enterprise policies, and cannot"
             "be overridden by users. It is disabled by default."
           chrome_policy {
             ScreensaverLockScreenImages {
               ScreensaverLockScreenImages {
                   entries: ""
               }
             }
           }
         })");
 constexpr char kCacheFileExt[] = ".cache";
 constexpr char kCacheFileWildCardPattern[] = "*.cache";

 constexpr int64_t kMaxFileSizeInBytes = 8 * 1024 * 1024;  // 8 MB
 constexpr int kMaxUrlFetchRetries = 3;

 // This limit is specified in the policy definition for the policies
 // ScreensaverLockScreenImages and DeviceScreensaverLoginScreenImages.
 constexpr size_t kMaxUrlsToProcessFromPolicy = 25u;

 std::unique_ptr<network::SimpleURLLoader> CreateSimpleURLLoader(
     const std::string& url) {
   auto request = std::make_unique<network::ResourceRequest>();
   request->url = GURL(url);
   request->method = net::HttpRequestHeaders::kGetMethod;
   request->credentials_mode = network::mojom::CredentialsMode::kOmit;
   CHECK(request->url.SchemeIs(url::kHttpsScheme));

   auto loader = network::SimpleURLLoader::Create(
       std::move(request), kScreensaverImageDownloaderNetworkTag);
   const int retry_mode = network::SimpleURLLoader::RETRY_ON_5XX |
                          network::SimpleURLLoader::RETRY_ON_NETWORK_CHANGE;
   loader->SetRetryOptions(kMaxUrlFetchRetries, retry_mode);
   return loader;
 }

 // Helper function to extract response code from `SimpleURLLoader`.
 int GetResponseCode(network::SimpleURLLoader* simple_loader) {
   if (!simple_loader->ResponseInfo() ||
       !simple_loader->ResponseInfo()->headers) {
     return -1;
   }
   return simple_loader->ResponseInfo()->headers->response_code();
 }

 bool VerifyOrCreateDownloadDirectory(const base::FilePath& download_directory) {
   if (!base::DirectoryExists(download_directory) &&
       !base::CreateDirectory(download_directory)) {
     LOG(ERROR) << "Cannot create download directory";
     // TODO(b/276208772): Track result with metrics
     return false;
   }
   if (!base::PathIsWritable(download_directory)) {
     LOG(ERROR) << "Cannot write to download directory";
     // TODO(b/276208772): Track result with metrics
     return false;
   }
   return true;
 }

 std::string GetHashedFileNameForUrl(const std::string& url) {
   auto hash = base::SHA1HashSpan(base::as_byte_span(url));
   return base::HexEncode(hash) + kCacheFileExt;
 }

 std::vector<std::string> GetImageUrlsToProcess(
     const base::Value::List& image_url_list) {
   std::vector<std::string> urls;
   for (size_t i = 0;
        i < kMaxUrlsToProcessFromPolicy && i < image_url_list.size(); ++i) {
     const base::Value& value = image_url_list[i];
     if (!value.is_string() || value.GetString().empty()) {
       continue;
     }
     // Canonicalize URLs and require HTTPS.
     GURL url(value.GetString());
     if (!url.is_valid() || !url.SchemeIs(url::kHttpsScheme)) {
       LOG(WARNING) << "Ignored invalid URL: " << url;
       continue;
     }

     urls.emplace_back(url.spec());
   }
   return urls;
 }

 // Returns all the cached images in the provided directory.
 // This method does blocking IO and should only be run on a thread that
 // allows blocking IO.
 std::vector<base::FilePath> GetCachedImagesFromDisk(
     const base::FilePath& directory) {
   std::vector<base::FilePath> images_on_disk;
   base::FileEnumerator iterator(directory, /*recursive=*/false,
                                 base::FileEnumerator::FILES,
                                 FILE_PATH_LITERAL(kCacheFileWildCardPattern));
   base::FilePath current_path;
   for (base::FilePath path = iterator.Next(); !path.empty();
        path = iterator.Next()) {
     images_on_disk.push_back(path);
   }

   return images_on_disk;
 }

 // Deletes all the provided files in the `files_to_delete` parameter.
 // This method does blocking IO and should only be run on a thread that
 // allows blocking IO.
 // Note: In case all of the files are successfully deleted, this will return
 // true otherwise will return false.
 bool DeleteFiles(const std::vector<base::FilePath>& files_to_delete) {
   bool success = true;
   for (const auto& path : files_to_delete) {
     // Even if one file fails to delete mark this operation as not being
     // success.
     if (!base::DeleteFile(path)) {
       LOG(WARNING) << "Failed to clean up: " << path.BaseName().value();
       success = false;
     }
   }
   return success;
 }

 }  // namespace

 ScreensaverImageDownloader::ScreensaverImageDownloader(
     scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory,
     const base::FilePath& download_directory,
     ImageListUpdatedCallback image_list_updated_callback)
     : task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
           {base::MayBlock(), base::TaskPriority::BEST_EFFORT,
            base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})),
       shared_url_loader_factory_(shared_url_loader_factory),
       download_directory_(download_directory),
       image_list_updated_callback_(image_list_updated_callback) {}

 ScreensaverImageDownloader::~ScreensaverImageDownloader() = default;

 void ScreensaverImageDownloader::UpdateImageUrlList(
     const base::Value::List& image_url_list) {
   if (image_url_list.empty()) {
     // If the screensaver is listening to updates, notify that the images are no
     // longer available before deleting them.
     image_list_updated_callback_.Run(std::vector<base::FilePath>());

     ClearRequestQueue();
     weak_ptr_factory_.InvalidateWeakPtrs();
     DeleteDownloadedImages();
     downloaded_images_.clear();
     return;
   }

   const std::vector<std::string> new_image_urls =
       GetImageUrlsToProcess(image_url_list);

   // `this` is unretained here as `PostTaskAndReplyWithResult` does not work
   // with weak ptrs as weak ptrs do not work with functions that return a value.
   // The usage is safe as the task is executed immediately and `this` should
   // outlive the call.
   task_runner_->PostTaskAndReplyWithResult(
       FROM_HERE,
       base::BindOnce(&ScreensaverImageDownloader::DeleteUnreferencedImageFiles,
                      base::Unretained(this), new_image_urls),
       base::BindOnce(&ScreensaverImageDownloader::OnUnreferencedImagesDeleted,
                      weak_ptr_factory_.GetWeakPtr()));

   for (const std::string& image_url : new_image_urls) {
     DVLOG(1) << "Queue URL: " << image_url;
     QueueImageDownload(image_url);
   }
 }

 std::vector<base::FilePath>
 ScreensaverImageDownloader::DeleteUnreferencedImageFiles(
     const std::vector<std::string>& new_image_urls) {
   std::vector<std::string> hashed_image_urls = new_image_urls;
   // Hash the image url
   base::ranges::transform(hashed_image_urls.begin(), hashed_image_urls.end(),
                           hashed_image_urls.begin(), GetHashedFileNameForUrl);

   base::flat_set<std::string> hashed_image_file_paths(hashed_image_urls);

   auto cached_images_from_disk = GetCachedImagesFromDisk(download_directory_);

   std::vector<base::FilePath> file_paths_to_delete;
   for (const auto& downloaded_file : cached_images_from_disk) {
     if (!hashed_image_file_paths.contains(downloaded_file.BaseName().value())) {
       file_paths_to_delete.push_back(downloaded_file);
     }
   }
   if (!DeleteFiles(file_paths_to_delete)) {
     // TODO(b/276208772): Track result with metrics
     DLOG(WARNING) << "Failed to delete some of the files";
   }

   return file_paths_to_delete;
 }

 void ScreensaverImageDownloader::OnUnreferencedImagesDeleted(
     std::vector<base::FilePath> file_paths_deleted) {
   if (file_paths_deleted.empty()) {
     return;
   }
   for (const auto& path : file_paths_deleted) {
     downloaded_images_.erase(path);
     DVLOG(1) << "Removing path from in memory cache " << path;
   }

   image_list_updated_callback_.Run(std::vector<base::FilePath>(
       downloaded_images_.begin(), downloaded_images_.end()));
 }

 std::vector<base::FilePath> ScreensaverImageDownloader::GetScreensaverImages() {
   return std::vector<base::FilePath>(downloaded_images_.begin(),
                                      downloaded_images_.end());
 }

 void ScreensaverImageDownloader::SetImagesForTesting(
     const std::vector<base::FilePath>& images_file_paths) {
   downloaded_images_ = base::flat_set<base::FilePath>(images_file_paths);
 }

 base::FilePath ScreensaverImageDownloader::GetDowloadDirForTesting() {
   return download_directory_;
 }

 void ScreensaverImageDownloader::QueueImageDownload(
     const std::string& image_url) {
   // TODO(b/276208772): Track queue usage with metrics
   if (queue_state_ == QueueState::kWaiting) {
     CHECK(downloading_queue_.empty());
     StartImageDownload(image_url);
   } else {
     downloading_queue_.emplace(image_url);
   }
 }

 void ScreensaverImageDownloader::ClearRequestQueue() {
   base::queue<std::string> buffer_queue;
   buffer_queue.swap(downloading_queue_);
   queue_state_ = QueueState::kWaiting;

   while (!buffer_queue.empty()) {
     FinishImageDownload(buffer_queue.front(),
                         ScreensaverImageDownloadResult::kCancelled,
                         std::nullopt);
     buffer_queue.pop();
   }
 }

 void ScreensaverImageDownloader::DeleteDownloadedImages() {
   // TODO(b/278548884): Do not ignore callback result and track its result.
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(base::IgnoreResult(&base::DeletePathRecursively),
                      download_directory_));
 }

 void ScreensaverImageDownloader::StartImageDownload(
     const std::string& image_url) {
   queue_state_ = QueueState::kDownloading;
   task_runner_->PostTaskAndReplyWithResult(
       FROM_HERE,
       base::BindOnce(&VerifyOrCreateDownloadDirectory, download_directory_),
       base::BindOnce(
           &ScreensaverImageDownloader::OnVerifyDownloadDirectoryCompleted,
           weak_ptr_factory_.GetWeakPtr(), image_url));
 }

 void ScreensaverImageDownloader::OnVerifyDownloadDirectoryCompleted(
     const std::string& image_url,
     bool can_download_file) {
   if (!can_download_file) {
     FinishImageDownload(image_url,
                         ScreensaverImageDownloadResult::kFileSystemWriteError,
                         std::nullopt);
     return;
   }

   // The download folder exists, check if the file is already in cache before
   // attempting to download it.
   const base::FilePath file_path =
       download_directory_.AppendASCII(GetHashedFileNameForUrl(image_url));
   task_runner_->PostTaskAndReplyWithResult(
       FROM_HERE, base::BindOnce(&base::PathExists, file_path),
       base::BindOnce(&ScreensaverImageDownloader::OnCheckIsFileIsInCache,
                      weak_ptr_factory_.GetWeakPtr(), file_path, image_url));
 }

 void ScreensaverImageDownloader::OnCheckIsFileIsInCache(
     const base::FilePath& file_path,
     const std::string& image_url,
     bool is_file_present) {
   if (is_file_present) {
     FinishImageDownload(image_url, ScreensaverImageDownloadResult::kSuccess,
                         file_path);
     return;
   }

   CHECK(shared_url_loader_factory_);
   std::unique_ptr<network::SimpleURLLoader> simple_loader =
       CreateSimpleURLLoader(image_url);

   auto* loader = simple_loader.get();
   // Download to temp file first to guarantee entire image is written without
   // errors before attempting to read it.
   loader->DownloadToTempFile(
       shared_url_loader_factory_.get(),
       base::BindOnce(&ScreensaverImageDownloader::OnUrlDownloadedToTempFile,
                      weak_ptr_factory_.GetWeakPtr(), std::move(simple_loader),
                      image_url),
       kMaxFileSizeInBytes);
 }

 void ScreensaverImageDownloader::OnUrlDownloadedToTempFile(
     std::unique_ptr<network::SimpleURLLoader> simple_loader,
     const std::string& image_url,
     base::FilePath temp_path) {
   const base::FilePath desired_path =
       download_directory_.AppendASCII(GetHashedFileNameForUrl(image_url));
   if (simple_loader->NetError() != net::OK || temp_path.empty()) {
     LOG(ERROR) << "Downloading to file failed with error code: "
                << GetResponseCode(simple_loader.get()) << " with network error "
                << simple_loader->NetError();

     if (!temp_path.empty()) {
       // Clean up temporary file.
       task_runner_->PostTask(
           FROM_HERE,
           base::BindOnce(base::IgnoreResult(&base::DeleteFile), temp_path));
     }
     FinishImageDownload(
         image_url, ScreensaverImageDownloadResult::kNetworkError, std::nullopt);
     return;
   }

   // Swap the temporary file to the desired path, and then run the callback.
   task_runner_->PostTaskAndReplyWithResult(
       FROM_HERE, base::BindOnce(&base::Move, temp_path, desired_path),
       base::BindOnce(&ScreensaverImageDownloader::OnUrlDownloadToFileComplete,
                      weak_ptr_factory_.GetWeakPtr(), desired_path, image_url));
 }

 void ScreensaverImageDownloader::OnUrlDownloadToFileComplete(
     const base::FilePath& path,
     const std::string& image_url,
     bool file_is_present) {
   if (!file_is_present) {
     DLOG(WARNING) << "Could not save the downloaded file to " << path;
     FinishImageDownload(image_url,
                         ScreensaverImageDownloadResult::kFileSaveError,
                         std::nullopt);
     return;
   }

   FinishImageDownload(image_url, ScreensaverImageDownloadResult::kSuccess,
                       path);
 }

 void ScreensaverImageDownloader::FinishImageDownload(
     const std::string& image_url,
     ScreensaverImageDownloadResult result,
     std::optional<base::FilePath> path) {
   RecordManagedScreensaverImageDownloadResult(result);

   if (result == ScreensaverImageDownloadResult::kSuccess) {
     downloaded_images_.insert(*path);
     image_list_updated_callback_.Run(std::vector<base::FilePath>(
         downloaded_images_.begin(), downloaded_images_.end()));
   }

   if (downloading_queue_.empty()) {
     queue_state_ = QueueState::kWaiting;
   } else {
     StartImageDownload(std::move(downloading_queue_.front()));
     downloading_queue_.pop();
   }
 }

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

	#include "ash/ambient/managed/screensaver_image_downloader.h"

	#include <string>

	#include "ash/ambient/metrics/managed_screensaver_metrics.h"
	#include "base/containers/flat_set.h"
	#include "base/files/file_enumerator.h"
	#include "base/files/file_path.h"
	#include "base/files/file_util.h"
	#include "base/hash/sha1.h"
	#include "base/logging.h"
	#include "base/ranges/algorithm.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/task/thread_pool.h"
	#include "base/values.h"
	#include "net/http/http_request_headers.h"
	#include "services/network/public/cpp/resource_request.h"
	#include "services/network/public/cpp/shared_url_loader_factory.h"
	#include "services/network/public/mojom/url_response_head.mojom.h"

	namespace ash {

	namespace {

	constexpr net::NetworkTrafficAnnotationTag
	kScreensaverImageDownloaderNetworkTag =
	net::DefineNetworkTrafficAnnotation("screensaver_image_downloader",
	R"(
	semantics {
	sender: "Managed Screensaver"
	description:
	"Fetch external image files that will be cached and displayed "
	"in the policy-controlled screensaver."
	trigger:
	"An update to the ScreensaverLockScreenImages policy that includes "
	"new references to external image files."
	data:
	"This request does not send any data from the device. It fetches"
	"images from URLs provided by the policy."
	destination: OTHER
	user_data {
	type: NONE
	}
	internal {
	contacts {
	email: "mpetrisor@google.com"
	}
	}
	last_reviewed: "2023-03-30"
	}
	policy {
	cookies_allowed: NO
	setting:
	"This feature is controlled by enterprise policies, and cannot"
	"be overridden by users. It is disabled by default."
	chrome_policy {
	ScreensaverLockScreenImages {
	ScreensaverLockScreenImages {
	entries: ""
	}
	}
	}
	})");
	constexpr char kCacheFileExt[] = ".cache";
	constexpr char kCacheFileWildCardPattern[] = "*.cache";

	constexpr int64_t kMaxFileSizeInBytes = 8 * 1024 * 1024; // 8 MB
	constexpr int kMaxUrlFetchRetries = 3;

	// This limit is specified in the policy definition for the policies
	// ScreensaverLockScreenImages and DeviceScreensaverLoginScreenImages.
	constexpr size_t kMaxUrlsToProcessFromPolicy = 25u;

	std::unique_ptr<network::SimpleURLLoader> CreateSimpleURLLoader(
	const std::string& url) {
	auto request = std::make_unique<network::ResourceRequest>();
	request->url = GURL(url);
	request->method = net::HttpRequestHeaders::kGetMethod;
	request->credentials_mode = network::mojom::CredentialsMode::kOmit;
	CHECK(request->url.SchemeIs(url::kHttpsScheme));

	auto loader = network::SimpleURLLoader::Create(
	std::move(request), kScreensaverImageDownloaderNetworkTag);
	const int retry_mode = network::SimpleURLLoader::RETRY_ON_5XX \|
	network::SimpleURLLoader::RETRY_ON_NETWORK_CHANGE;
	loader->SetRetryOptions(kMaxUrlFetchRetries, retry_mode);
	return loader;
	}

	// Helper function to extract response code from `SimpleURLLoader`.
	int GetResponseCode(network::SimpleURLLoader* simple_loader) {
	if (!simple_loader->ResponseInfo() \|\|
	!simple_loader->ResponseInfo()->headers) {
	return -1;
	}
	return simple_loader->ResponseInfo()->headers->response_code();
	}

	bool VerifyOrCreateDownloadDirectory(const base::FilePath& download_directory) {
	if (!base::DirectoryExists(download_directory) &&
	!base::CreateDirectory(download_directory)) {
	LOG(ERROR) << "Cannot create download directory";
	// TODO(b/276208772): Track result with metrics
	return false;
	}
	if (!base::PathIsWritable(download_directory)) {
	LOG(ERROR) << "Cannot write to download directory";
	// TODO(b/276208772): Track result with metrics
	return false;
	}
	return true;
	}

	std::string GetHashedFileNameForUrl(const std::string& url) {
	auto hash = base::SHA1HashSpan(base::as_byte_span(url));
	return base::HexEncode(hash) + kCacheFileExt;
	}

	std::vector<std::string> GetImageUrlsToProcess(
	const base::Value::List& image_url_list) {
	std::vector<std::string> urls;
	for (size_t i = 0;
	i < kMaxUrlsToProcessFromPolicy && i < image_url_list.size(); ++i) {
	const base::Value& value = image_url_list[i];
	if (!value.is_string() \|\| value.GetString().empty()) {
	continue;
	}
	// Canonicalize URLs and require HTTPS.
	GURL url(value.GetString());
	if (!url.is_valid() \|\| !url.SchemeIs(url::kHttpsScheme)) {
	LOG(WARNING) << "Ignored invalid URL: " << url;
	continue;
	}

	urls.emplace_back(url.spec());
	}
	return urls;
	}

	// Returns all the cached images in the provided directory.
	// This method does blocking IO and should only be run on a thread that
	// allows blocking IO.
	std::vector<base::FilePath> GetCachedImagesFromDisk(
	const base::FilePath& directory) {
	std::vector<base::FilePath> images_on_disk;
	base::FileEnumerator iterator(directory, /recursive=/false,
	base::FileEnumerator::FILES,
	FILE_PATH_LITERAL(kCacheFileWildCardPattern));
	base::FilePath current_path;
	for (base::FilePath path = iterator.Next(); !path.empty();
	path = iterator.Next()) {
	images_on_disk.push_back(path);
	}

	return images_on_disk;
	}

	// Deletes all the provided files in the `files_to_delete` parameter.
	// This method does blocking IO and should only be run on a thread that
	// allows blocking IO.
	// Note: In case all of the files are successfully deleted, this will return
	// true otherwise will return false.
	bool DeleteFiles(const std::vector<base::FilePath>& files_to_delete) {
	bool success = true;
	for (const auto& path : files_to_delete) {
	// Even if one file fails to delete mark this operation as not being
	// success.
	if (!base::DeleteFile(path)) {
	LOG(WARNING) << "Failed to clean up: " << path.BaseName().value();
	success = false;
	}
	}
	return success;
	}

	} // namespace

	ScreensaverImageDownloader::ScreensaverImageDownloader(
	scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory,
	const base::FilePath& download_directory,
	ImageListUpdatedCallback image_list_updated_callback)
	: task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
	{base::MayBlock(), base::TaskPriority::BEST_EFFORT,
	base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})),
	shared_url_loader_factory_(shared_url_loader_factory),
	download_directory_(download_directory),
	image_list_updated_callback_(image_list_updated_callback) {}

	ScreensaverImageDownloader::~ScreensaverImageDownloader() = default;

	void ScreensaverImageDownloader::UpdateImageUrlList(
	const base::Value::List& image_url_list) {
	if (image_url_list.empty()) {
	// If the screensaver is listening to updates, notify that the images are no
	// longer available before deleting them.
	image_list_updated_callback_.Run(std::vector<base::FilePath>());

	ClearRequestQueue();
	weak_ptr_factory_.InvalidateWeakPtrs();
	DeleteDownloadedImages();
	downloaded_images_.clear();
	return;
	}

	const std::vector<std::string> new_image_urls =
	GetImageUrlsToProcess(image_url_list);

	// `this` is unretained here as `PostTaskAndReplyWithResult` does not work
	// with weak ptrs as weak ptrs do not work with functions that return a value.
	// The usage is safe as the task is executed immediately and `this` should
	// outlive the call.
	task_runner_->PostTaskAndReplyWithResult(
	FROM_HERE,
	base::BindOnce(&ScreensaverImageDownloader::DeleteUnreferencedImageFiles,
	base::Unretained(this), new_image_urls),
	base::BindOnce(&ScreensaverImageDownloader::OnUnreferencedImagesDeleted,
	weak_ptr_factory_.GetWeakPtr()));

	for (const std::string& image_url : new_image_urls) {
	DVLOG(1) << "Queue URL: " << image_url;
	QueueImageDownload(image_url);
	}
	}

	std::vector<base::FilePath>
	ScreensaverImageDownloader::DeleteUnreferencedImageFiles(
	const std::vector<std::string>& new_image_urls) {
	std::vector<std::string> hashed_image_urls = new_image_urls;
	// Hash the image url
	base::ranges::transform(hashed_image_urls.begin(), hashed_image_urls.end(),
	hashed_image_urls.begin(), GetHashedFileNameForUrl);

	base::flat_set<std::string> hashed_image_file_paths(hashed_image_urls);

	auto cached_images_from_disk = GetCachedImagesFromDisk(download_directory_);

	std::vector<base::FilePath> file_paths_to_delete;
	for (const auto& downloaded_file : cached_images_from_disk) {
	if (!hashed_image_file_paths.contains(downloaded_file.BaseName().value())) {
	file_paths_to_delete.push_back(downloaded_file);
	}
	}
	if (!DeleteFiles(file_paths_to_delete)) {
	// TODO(b/276208772): Track result with metrics
	DLOG(WARNING) << "Failed to delete some of the files";
	}

	return file_paths_to_delete;
	}

	void ScreensaverImageDownloader::OnUnreferencedImagesDeleted(
	std::vector<base::FilePath> file_paths_deleted) {
	if (file_paths_deleted.empty()) {
	return;
	}
	for (const auto& path : file_paths_deleted) {
	downloaded_images_.erase(path);
	DVLOG(1) << "Removing path from in memory cache " << path;
	}

	image_list_updated_callback_.Run(std::vector<base::FilePath>(
	downloaded_images_.begin(), downloaded_images_.end()));
	}

	std::vector<base::FilePath> ScreensaverImageDownloader::GetScreensaverImages() {
	return std::vector<base::FilePath>(downloaded_images_.begin(),
	downloaded_images_.end());
	}

	void ScreensaverImageDownloader::SetImagesForTesting(
	const std::vector<base::FilePath>& images_file_paths) {
	downloaded_images_ = base::flat_set<base::FilePath>(images_file_paths);
	}

	base::FilePath ScreensaverImageDownloader::GetDowloadDirForTesting() {
	return download_directory_;
	}

	void ScreensaverImageDownloader::QueueImageDownload(
	const std::string& image_url) {
	// TODO(b/276208772): Track queue usage with metrics
	if (queue_state_ == QueueState::kWaiting) {
	CHECK(downloading_queue_.empty());
	StartImageDownload(image_url);
	} else {
	downloading_queue_.emplace(image_url);
	}
	}

	void ScreensaverImageDownloader::ClearRequestQueue() {
	base::queue<std::string> buffer_queue;
	buffer_queue.swap(downloading_queue_);
	queue_state_ = QueueState::kWaiting;

	while (!buffer_queue.empty()) {
	FinishImageDownload(buffer_queue.front(),
	ScreensaverImageDownloadResult::kCancelled,
	std::nullopt);
	buffer_queue.pop();
	}
	}

	void ScreensaverImageDownloader::DeleteDownloadedImages() {
	// TODO(b/278548884): Do not ignore callback result and track its result.
	task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(base::IgnoreResult(&base::DeletePathRecursively),
	download_directory_));
	}

	void ScreensaverImageDownloader::StartImageDownload(
	const std::string& image_url) {
	queue_state_ = QueueState::kDownloading;
	task_runner_->PostTaskAndReplyWithResult(
	FROM_HERE,
	base::BindOnce(&VerifyOrCreateDownloadDirectory, download_directory_),
	base::BindOnce(
	&ScreensaverImageDownloader::OnVerifyDownloadDirectoryCompleted,
	weak_ptr_factory_.GetWeakPtr(), image_url));
	}

	void ScreensaverImageDownloader::OnVerifyDownloadDirectoryCompleted(
	const std::string& image_url,
	bool can_download_file) {
	if (!can_download_file) {
	FinishImageDownload(image_url,
	ScreensaverImageDownloadResult::kFileSystemWriteError,
	std::nullopt);
	return;
	}

	// The download folder exists, check if the file is already in cache before
	// attempting to download it.
	const base::FilePath file_path =
	download_directory_.AppendASCII(GetHashedFileNameForUrl(image_url));
	task_runner_->PostTaskAndReplyWithResult(
	FROM_HERE, base::BindOnce(&base::PathExists, file_path),
	base::BindOnce(&ScreensaverImageDownloader::OnCheckIsFileIsInCache,
	weak_ptr_factory_.GetWeakPtr(), file_path, image_url));
	}

	void ScreensaverImageDownloader::OnCheckIsFileIsInCache(
	const base::FilePath& file_path,
	const std::string& image_url,
	bool is_file_present) {
	if (is_file_present) {
	FinishImageDownload(image_url, ScreensaverImageDownloadResult::kSuccess,
	file_path);
	return;
	}

	CHECK(shared_url_loader_factory_);
	std::unique_ptr<network::SimpleURLLoader> simple_loader =
	CreateSimpleURLLoader(image_url);

	auto* loader = simple_loader.get();
	// Download to temp file first to guarantee entire image is written without
	// errors before attempting to read it.
	loader->DownloadToTempFile(
	shared_url_loader_factory_.get(),
	base::BindOnce(&ScreensaverImageDownloader::OnUrlDownloadedToTempFile,
	weak_ptr_factory_.GetWeakPtr(), std::move(simple_loader),
	image_url),
	kMaxFileSizeInBytes);
	}

	void ScreensaverImageDownloader::OnUrlDownloadedToTempFile(
	std::unique_ptr<network::SimpleURLLoader> simple_loader,
	const std::string& image_url,
	base::FilePath temp_path) {
	const base::FilePath desired_path =
	download_directory_.AppendASCII(GetHashedFileNameForUrl(image_url));
	if (simple_loader->NetError() != net::OK \|\| temp_path.empty()) {
	LOG(ERROR) << "Downloading to file failed with error code: "
	<< GetResponseCode(simple_loader.get()) << " with network error "
	<< simple_loader->NetError();

	if (!temp_path.empty()) {
	// Clean up temporary file.
	task_runner_->PostTask(
	FROM_HERE,
	base::BindOnce(base::IgnoreResult(&base::DeleteFile), temp_path));
	}
	FinishImageDownload(
	image_url, ScreensaverImageDownloadResult::kNetworkError, std::nullopt);
	return;
	}

	// Swap the temporary file to the desired path, and then run the callback.
	task_runner_->PostTaskAndReplyWithResult(
	FROM_HERE, base::BindOnce(&base::Move, temp_path, desired_path),
	base::BindOnce(&ScreensaverImageDownloader::OnUrlDownloadToFileComplete,
	weak_ptr_factory_.GetWeakPtr(), desired_path, image_url));
	}

	void ScreensaverImageDownloader::OnUrlDownloadToFileComplete(
	const base::FilePath& path,
	const std::string& image_url,
	bool file_is_present) {
	if (!file_is_present) {
	DLOG(WARNING) << "Could not save the downloaded file to " << path;
	FinishImageDownload(image_url,
	ScreensaverImageDownloadResult::kFileSaveError,
	std::nullopt);
	return;
	}

	FinishImageDownload(image_url, ScreensaverImageDownloadResult::kSuccess,
	path);
	}

	void ScreensaverImageDownloader::FinishImageDownload(
	const std::string& image_url,
	ScreensaverImageDownloadResult result,
	std::optional<base::FilePath> path) {
	RecordManagedScreensaverImageDownloadResult(result);

	if (result == ScreensaverImageDownloadResult::kSuccess) {
	downloaded_images_.insert(*path);
	image_list_updated_callback_.Run(std::vector<base::FilePath>(
	downloaded_images_.begin(), downloaded_images_.end()));
	}

	if (downloading_queue_.empty()) {
	queue_state_ = QueueState::kWaiting;
	} else {
	StartImageDownload(std::move(downloading_queue_.front()));
	downloading_queue_.pop();
	}
	}

	} // namespace ash