// 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/cloud_file_system.h"
#include <memory>
#include <utility>
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/scoped_refptr.h"
#include "base/notreached.h"
#include "base/rand_util.h"
#include "base/strings/string_util.h"
#include "base/timer/timer.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/ash/file_system_provider/cloud_file_info.h"
#include "chrome/browser/ash/file_system_provider/provided_file_system_interface.h"
#include "chrome/browser/ash/file_system_provider/queue.h"
#include "net/base/io_buffer.h"
#include "url/origin.h"
namespace ash::file_system_provider {
namespace {
// The frequency that the FSP syncs with the cloud when the File Manager is a
// watcher.
constexpr base::TimeDelta kFileManagerWatcherInterval = base::Seconds(15);
// TODO(b/317137739): Remove this once a proper API call is introduced.
// Temp custom action to request ODFS sync with the cloud.
constexpr char kODFSSyncWithCloudAction[] = "HIDDEN_SYNC_WITH_CLOUD";
const GURL GetContentCacheURL() {
return GURL("chrome://content-cache/");
}
std::ostream& operator<<(std::ostream& out,
const std::vector<base::FilePath>& entry_paths) {
for (size_t i = 0; i < entry_paths.size(); ++i) {
out << entry_paths[i];
if (i < entry_paths.size() - 1) {
out << ", ";
}
}
return out;
}
std::ostream& operator<<(std::ostream& out, OpenFileMode mode) {
switch (mode) {
case OpenFileMode::OPEN_FILE_MODE_READ:
return out << "OPEN_FILE_MODE_READ";
case OpenFileMode::OPEN_FILE_MODE_WRITE:
return out << "OPEN_FILE_MODE_WRITE";
}
NOTREACHED() << "Unknown OpenFileMode: " << mode;
}
std::ostream& operator<<(std::ostream& out,
storage::WatcherManager::ChangeType type) {
using ChangeType = storage::WatcherManager::ChangeType;
switch (type) {
case ChangeType::CHANGED:
return out << "CHANGED";
case ChangeType::DELETED:
return out << "DELETED";
}
NOTREACHED() << "Unknown ChangeType: " << type;
}
std::ostream& operator<<(std::ostream& out, CloudFileInfo* cloud_file_info) {
if (!cloud_file_info) {
return out << "none";
}
return out << "{version_tag = '" << cloud_file_info->version_tag << "'}";
}
std::ostream& operator<<(std::ostream& out, EntryMetadata* metadata) {
if (!metadata) {
return out << "none";
}
out << "{ cloud_file_info = " << metadata->cloud_file_info.get();
if (metadata->size) {
out << ", size = '" << *metadata->size << "'";
}
return out << "}";
}
std::ostream& operator<<(std::ostream& out,
ProvidedFileSystemObserver::Changes* changes) {
if (!changes) {
return out << "none";
}
for (size_t i = 0; i < changes->size(); ++i) {
const auto& [entry_path, change_type, cloud_file_info] = (*changes)[i];
out << entry_path << ": change_type = " << change_type
<< ", cloud_file_info = " << cloud_file_info.get();
if (i < changes->size() - 1) {
out << ", ";
}
}
return out;
}
const std::string GetVersionTag(EntryMetadata* metadata) {
return (metadata && metadata->cloud_file_info)
? metadata->cloud_file_info->version_tag
: "";
}
std::optional<int64_t> GetCloudSize(EntryMetadata* metadata) {
// If the size doesn't exist, it may return -1, let's avoid this error case.
if (metadata && metadata->size && *metadata->size > -1) {
return *metadata->size;
}
return std::nullopt;
}
} // namespace
CloudFileSystem::CloudFileSystem(
std::unique_ptr<ProvidedFileSystemInterface> file_system)
: CloudFileSystem(std::move(file_system), nullptr) {}
CloudFileSystem::CloudFileSystem(
std::unique_ptr<ProvidedFileSystemInterface> file_system,
CacheManager* cache_manager)
: file_system_(std::move(file_system)) {
if (!cache_manager) {
return;
}
cache_manager->InitializeForProvider(
file_system_->GetFileSystemInfo(),
base::BindOnce(&CloudFileSystem::OnContentCacheInitialized,
weak_ptr_factory_.GetWeakPtr()));
}
CloudFileSystem::~CloudFileSystem() = default;
void CloudFileSystem::OnContentCacheInitialized(
base::FileErrorOr<std::unique_ptr<ContentCache>> error_or_cache) {
LOG_IF(ERROR, !error_or_cache.has_value())
<< "Error initializing the content cache: " << error_or_cache.error();
if (error_or_cache.has_value()) {
content_cache_ = std::move(error_or_cache.value());
content_cache_->AddObserver(this);
for (const base::FilePath& file_path :
content_cache_->GetCachedFilePaths()) {
AddWatcherOnCachedFile(file_path);
}
}
}
void CloudFileSystem::AddWatcherOnCachedFile(const base::FilePath& file_path) {
AddWatcherOnCachedFileImpl(file_path, /*attempts=*/0,
/*result=*/base::File::FILE_ERROR_SECURITY);
}
void CloudFileSystem::AddWatcherOnCachedFileImpl(
const base::FilePath& file_path,
int attempts,
base::File::Error result) {
if (result == base::File::FILE_OK) {
VLOG(1) << "Re-added file watcher on file '" << file_path << "'";
return;
}
if (result != base::File::FILE_ERROR_SECURITY || attempts > 6) {
LOG(ERROR) << "Failed to add file watcher on file with result: " << result
<< " after " << attempts << " attempts";
VLOG(2) << "Failed to add file watcher on file '" << file_path
<< "' with result: " << result << " after " << attempts
<< " attempts";
return;
}
// Set a random delay in the interval attempts*[0,2] seconds to stagger
// AddWatcher requests.
base::TimeDelta delay = attempts * base::Milliseconds(base::RandInt(1, 2000));
// Notifications are received though Notify() so no notification_callback
// is needed. Call this function recursively to continuously retry upon
// FILE_ERROR_SECURITY errors until the max number of attempts have been made.
base::SequencedTaskRunner::GetCurrentDefault()->PostDelayedTask(
FROM_HERE,
base::BindOnce(
IgnoreResult(&CloudFileSystem::AddWatcher),
weak_ptr_factory_.GetWeakPtr(), GetContentCacheURL(), file_path,
/*recursive=*/false, /*persistent=*/false,
base::BindOnce(&CloudFileSystem::AddWatcherOnCachedFileImpl,
weak_ptr_factory_.GetWeakPtr(), file_path,
attempts + 1),
base::DoNothing()),
delay);
}
AbortCallback CloudFileSystem::RequestUnmount(
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(2) << "RequestUnmount {fsid = " << GetFileSystemId() << "}";
return file_system_->RequestUnmount(std::move(callback));
}
AbortCallback CloudFileSystem::GetMetadata(const base::FilePath& entry_path,
MetadataFieldMask fields,
GetMetadataCallback callback) {
VLOG(2) << "GetMetadata {fsid = '" << GetFileSystemId() << "', entry_path = '"
<< entry_path << "', fields = '" << fields << "'}";
fields |= METADATA_FIELD_CLOUD_FILE_INFO;
return file_system_->GetMetadata(
entry_path, fields,
base::BindOnce(&CloudFileSystem::OnGetMetadataCompleted,
weak_ptr_factory_.GetWeakPtr(), entry_path,
std::move(callback)));
}
AbortCallback CloudFileSystem::GetActions(
const std::vector<base::FilePath>& entry_paths,
GetActionsCallback callback) {
VLOG(2) << "GetActions {fsid = '" << GetFileSystemId() << "', entry_paths = '"
<< entry_paths << "'}";
return file_system_->GetActions(entry_paths, std::move(callback));
}
AbortCallback CloudFileSystem::ExecuteAction(
const std::vector<base::FilePath>& entry_paths,
const std::string& action_id,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(2) << "ExecuteAction {fsid = '" << GetFileSystemId()
<< "', entry_paths = '" << entry_paths << "', action_id = '"
<< action_id << "'}";
return file_system_->ExecuteAction(entry_paths, action_id,
std::move(callback));
}
AbortCallback CloudFileSystem::ReadDirectory(
const base::FilePath& directory_path,
storage::AsyncFileUtil::ReadDirectoryCallback callback) {
VLOG(1) << "ReadDirectory {fsid = '" << GetFileSystemId()
<< "', directory_path = '" << directory_path << "'}";
return file_system_->ReadDirectory(directory_path, callback);
}
bool CloudFileSystem::ShouldAttemptToServeReadFileFromCache(
const OpenedCloudFileMap::const_iterator it) {
return content_cache_ && it != opened_files_.end() &&
it->second.mode == OpenFileMode::OPEN_FILE_MODE_READ &&
!it->second.version_tag.empty() &&
it->second.bytes_in_cloud.has_value();
}
AbortCallback CloudFileSystem::ReadFile(int file_handle,
net::IOBuffer* buffer,
int64_t offset,
int length,
ReadChunkReceivedCallback callback) {
VLOG(1) << "ReadFile {fsid = '" << GetFileSystemId() << "', file_handle = '"
<< file_handle << "', offset = '" << offset << "', length = '"
<< length << "'}";
// In the event the file isn't found in the `opened_files_` map, the content
// cache hasn't or won't be initialized OR there is an empty `version_tag`,
// then pass the request directly to the FSP.
const OpenedCloudFileMap::const_iterator it = opened_files_.find(file_handle);
if (!ShouldAttemptToServeReadFileFromCache(it)) {
return file_system_->ReadFile(file_handle, buffer, offset, length,
callback);
}
const OpenedCloudFile& opened_cloud_file = it->second;
scoped_refptr<net::IOBuffer> buffer_ref = base::WrapRefCounted(buffer);
content_cache_->ReadBytes(
opened_cloud_file, buffer_ref, offset, length,
base::BindRepeating(&CloudFileSystem::OnReadFileFromCacheCompleted,
weak_ptr_factory_.GetWeakPtr(), file_handle,
buffer_ref, offset, length, callback));
return AbortCallback();
}
void CloudFileSystem::OnReadFileFromCacheCompleted(
int file_handle,
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length,
ReadChunkReceivedCallback callback,
int bytes_read,
bool has_more,
base::File::Error result) {
VLOG(2) << "OnReadFileFromCacheCompleted {fsid = " << GetFileSystemId()
<< ", file_handle = '" << file_handle << "', result = '" << result
<< "}";
if (result == base::File::FILE_OK) {
// If the cached read file was successful, ensure that is passed to the
// caller.
callback.Run(bytes_read, has_more, result);
return;
}
if (result == base::File::FILE_ERROR_NOT_FOUND) {
// The file doesn't exist in the cache or is not available, we need to make
// a cloud request first and attempt to write the result into the cache upon
// successful return.
file_system_->ReadFile(
file_handle, buffer.get(), offset, length,
base::BindRepeating(&CloudFileSystem::OnReadFileCompleted,
weak_ptr_factory_.GetWeakPtr(), file_handle, buffer,
offset, length, callback));
return;
}
LOG(ERROR) << "Couldn't read the file from cache";
file_system_->ReadFile(file_handle, buffer.get(), offset, length,
std::move(callback));
}
void CloudFileSystem::OnReadFileCompleted(int file_handle,
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length,
ReadChunkReceivedCallback callback,
int bytes_read,
bool has_more,
base::File::Error result) {
VLOG(2) << "OnReadFileCompleted {fsid = " << GetFileSystemId()
<< ", file_handle = '" << file_handle << "', result = '" << result
<< ", bytes_read = " << bytes_read << "}";
const OpenedCloudFileMap::const_iterator it = opened_files_.find(file_handle);
if (it == opened_files_.end() || result != base::File::FILE_OK ||
!content_cache_) {
callback.Run(bytes_read, has_more, result);
return;
}
// The `ReadChunkReceivedCallback` should always respond with the result from
// the FSP. If the content cache write fails, we should always be serving this
// from the FSP.
auto readchunk_success_callback = base::BindRepeating(
std::move(callback), bytes_read, has_more, base::File::FILE_OK);
const OpenedCloudFile& opened_cloud_file = it->second;
content_cache_->WriteBytes(
opened_cloud_file, buffer, offset, bytes_read,
base::BindOnce(&CloudFileSystem::OnBytesWrittenToCache,
weak_ptr_factory_.GetWeakPtr(),
opened_cloud_file.file_path, readchunk_success_callback));
}
void CloudFileSystem::OnBytesWrittenToCache(
const base::FilePath& file_path,
base::RepeatingCallback<void()> readchunk_success_callback,
base::File::Error result) {
if (result == base::File::FILE_OK) {
Watchers::const_iterator watcher =
GetWatchers()->find(WatcherKey(file_path, /*recursive=*/false));
if (watcher == GetWatchers()->end() ||
!watcher->second.subscribers.contains(GetContentCacheURL())) {
// This file is newly added to the cache so watch it to track any changes.
// Notifications are received though Notify() so no notification_callback
// is needed.
AddWatcher(
GetContentCacheURL(), file_path,
/*recursive=*/false, /*persistent=*/false,
base::BindOnce(
[](const base::FilePath& file_path, base::File::Error result) {
VLOG(1) << "Added file watcher on '" << file_path
<< "' result: " << result;
},
file_path),
base::DoNothing());
}
}
readchunk_success_callback.Run();
}
AbortCallback CloudFileSystem::OpenFile(const base::FilePath& file_path,
OpenFileMode mode,
OpenFileCallback callback) {
VLOG(1) << "OpenFile {fsid = '" << GetFileSystemId() << "', file_path = '"
<< file_path << "', mode = '" << mode << "'}";
return file_system_->OpenFile(
file_path, mode,
base::BindOnce(&CloudFileSystem::OnOpenFileCompleted,
weak_ptr_factory_.GetWeakPtr(), file_path, mode,
std::move(callback)));
}
AbortCallback CloudFileSystem::CloseFile(
int file_handle,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "CloseFile {fsid = '" << GetFileSystemId() << "', file_handle = '"
<< file_handle << "'}";
return file_system_->CloseFile(
file_handle, base::BindOnce(&CloudFileSystem::OnCloseFileCompleted,
weak_ptr_factory_.GetWeakPtr(), file_handle,
std::move(callback)));
}
AbortCallback CloudFileSystem::CreateDirectory(
const base::FilePath& directory_path,
bool recursive,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "CreateDirectory {fsid = '" << GetFileSystemId()
<< "', directory_path = '" << directory_path << "', recursive = '"
<< recursive << "'}";
return file_system_->CreateDirectory(directory_path, recursive,
std::move(callback));
}
AbortCallback CloudFileSystem::DeleteEntry(
const base::FilePath& entry_path,
bool recursive,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "DeleteEntry {fsid = '" << GetFileSystemId() << "', entry_path = '"
<< entry_path << "', recursive = '" << recursive << "'}";
return file_system_->DeleteEntry(
entry_path, recursive,
base::BindOnce(&CloudFileSystem::OnDeleteEntryCompleted,
weak_ptr_factory_.GetWeakPtr(), entry_path,
std::move(callback)));
}
AbortCallback CloudFileSystem::CreateFile(
const base::FilePath& file_path,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "CreateFile {fsid = '" << GetFileSystemId() << "', file_path = '"
<< file_path << "'}";
return file_system_->CreateFile(file_path, std::move(callback));
}
AbortCallback CloudFileSystem::CopyEntry(
const base::FilePath& source_path,
const base::FilePath& target_path,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "CopyEntry {fsid = '" << GetFileSystemId() << "', source_path = '"
<< source_path << "', target_path = '" << target_path << "'}";
return file_system_->CopyEntry(source_path, target_path, std::move(callback));
}
AbortCallback CloudFileSystem::WriteFile(
int file_handle,
net::IOBuffer* buffer,
int64_t offset,
int length,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "WriteFile {fsid = '" << GetFileSystemId() << "', file_handle = '"
<< file_handle << "', offset = '" << offset << "', length = '"
<< length << "'}";
return file_system_->WriteFile(
file_handle, buffer, offset, length,
base::BindOnce(&CloudFileSystem::OnWriteFileCompleted,
weak_ptr_factory_.GetWeakPtr(), file_handle,
std::move(callback)));
}
AbortCallback CloudFileSystem::FlushFile(
int file_handle,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "FlushFile {fsid = '" << GetFileSystemId() << "', file_handle = '"
<< file_handle << "'}";
return file_system_->FlushFile(file_handle, std::move(callback));
}
AbortCallback CloudFileSystem::MoveEntry(
const base::FilePath& source_path,
const base::FilePath& target_path,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "MoveEntry {fsid = '" << GetFileSystemId() << "', source_path = '"
<< source_path << "', target_path = '" << target_path << "'}";
return file_system_->MoveEntry(source_path, target_path, std::move(callback));
}
AbortCallback CloudFileSystem::Truncate(
const base::FilePath& file_path,
int64_t length,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(1) << "Truncate {fsid = '" << GetFileSystemId() << "', file_path = '"
<< file_path << "', length = '" << length << "'}";
return file_system_->Truncate(file_path, length, std::move(callback));
}
AbortCallback CloudFileSystem::AddWatcher(
const GURL& origin,
const base::FilePath& entry_path,
bool recursive,
bool persistent,
storage::AsyncFileUtil::StatusCallback callback,
storage::WatcherManager::NotificationCallback notification_callback) {
VLOG(2) << "AddWatcher {fsid = '" << GetFileSystemId() << "', origin = '"
<< origin.spec() << "', entry_path = '" << entry_path
<< "', recursive = '" << recursive << "', persistent = '"
<< persistent << "'}";
// Set timer if the File Manager is a watcher.
file_manager_watchers_ +=
file_manager::util::IsFileManagerURL(origin) ? 1 : 0;
if (file_manager_watchers_ > 0 && !timer_.IsRunning()) {
timer_.Start(FROM_HERE, kFileManagerWatcherInterval,
base::BindRepeating(&CloudFileSystem::OnTimer,
weak_ptr_factory_.GetWeakPtr()));
}
return file_system_->AddWatcher(origin, entry_path, recursive, persistent,
std::move(callback),
std::move(notification_callback));
}
void CloudFileSystem::RemoveWatcher(
const GURL& origin,
const base::FilePath& entry_path,
bool recursive,
storage::AsyncFileUtil::StatusCallback callback) {
VLOG(2) << "RemoveWatcher {fsid = '" << GetFileSystemId() << "', origin = '"
<< origin.spec() << "', entry_path = '" << entry_path
<< "', recursive = '" << recursive << "'}";
// Stop timer if the File Manager is not a watcher.
file_manager_watchers_ -=
file_manager::util::IsFileManagerURL(origin) ? 1 : 0;
if (file_manager_watchers_ == 0 && timer_.IsRunning()) {
timer_.Stop();
}
file_system_->RemoveWatcher(origin, entry_path, recursive,
std::move(callback));
}
const ProvidedFileSystemInfo& CloudFileSystem::GetFileSystemInfo() const {
return file_system_->GetFileSystemInfo();
}
OperationRequestManager* CloudFileSystem::GetRequestManager() {
return file_system_->GetRequestManager();
}
Watchers* CloudFileSystem::GetWatchers() {
return file_system_->GetWatchers();
}
const OpenedFiles& CloudFileSystem::GetOpenedFiles() const {
return file_system_->GetOpenedFiles();
}
void CloudFileSystem::AddObserver(ProvidedFileSystemObserver* observer) {
file_system_->AddObserver(observer);
}
void CloudFileSystem::RemoveObserver(ProvidedFileSystemObserver* observer) {
file_system_->RemoveObserver(observer);
}
void CloudFileSystem::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) {
VLOG(2) << "Notify {fsid = '" << GetFileSystemId() << "', recursive = '"
<< recursive << "', change_type = '" << change_type << "', tag = '"
<< tag << "', changes = {" << changes.get() << "}}";
if (content_cache_ && changes) {
content_cache_->Notify(*changes);
}
return file_system_->Notify(entry_path, recursive, change_type,
std::move(changes), tag, std::move(callback));
}
void CloudFileSystem::Configure(
storage::AsyncFileUtil::StatusCallback callback) {
return file_system_->Configure(std::move(callback));
}
base::WeakPtr<ProvidedFileSystemInterface> CloudFileSystem::GetWeakPtr() {
return weak_ptr_factory_.GetWeakPtr();
}
std::unique_ptr<ScopedUserInteraction>
CloudFileSystem::StartUserInteraction() {
return file_system_->StartUserInteraction();
}
const std::string CloudFileSystem::GetFileSystemId() const {
return file_system_->GetFileSystemInfo().file_system_id();
}
void CloudFileSystem::OnTimer() {
VLOG(2) << "OnTimer";
// TODO(b/317137739): Replace this with a proper API call once one is
// introduced.
// Request that the file system syncs with the Cloud. The entry path is
// insignficant, just pass it root.
ExecuteAction({base::FilePath("/")}, kODFSSyncWithCloudAction,
base::BindOnce([](base::File::Error result) {
VLOG(1) << "Action " << kODFSSyncWithCloudAction
<< " completed: " << result;
}));
}
void CloudFileSystem::OnOpenFileCompleted(
const base::FilePath& file_path,
OpenFileMode mode,
OpenFileCallback callback,
int file_handle,
base::File::Error result,
std::unique_ptr<EntryMetadata> metadata) {
VLOG(2) << "OnOpenFileCompleted {fsid = " << GetFileSystemId()
<< ", file_handle = '" << file_handle << "', result = '" << result
<< "', metadata = " << metadata.get() << "}";
if (result == base::File::FILE_OK) {
const std::string version_tag = GetVersionTag(metadata.get());
opened_files_.try_emplace(
file_handle, OpenedCloudFile(file_path, mode, file_handle, version_tag,
GetCloudSize(metadata.get())));
// Notify the cache with the observed version tag.
content_cache_->ObservedVersionTag(file_path, version_tag);
} else if (content_cache_ && result == base::File::FILE_ERROR_NOT_FOUND) {
// The file doesn't exist on the FSP, evict it from the cache.
content_cache_->Evict(file_path);
}
std::move(callback).Run(file_handle, result, std::move(metadata));
}
void CloudFileSystem::OnCloseFileCompleted(
int file_handle,
storage::AsyncFileUtil::StatusCallback callback,
base::File::Error result) {
VLOG(2) << "OnCloseFileCompleted {fsid = " << GetFileSystemId()
<< ", file_handle = '" << file_handle << "', result = '" << result
<< "}";
// Closing is always final. Even if an error happened, we remove it from the
// list of opened files.
if (content_cache_) {
const auto& opened_file = opened_files_.extract(file_handle);
if (!opened_file.empty()) {
content_cache_->CloseFile(opened_file.mapped());
}
}
std::move(callback).Run(result);
}
void CloudFileSystem::OnGetMetadataCompleted(
const base::FilePath& entry_path,
GetMetadataCallback callback,
std::unique_ptr<EntryMetadata> entry_metadata,
base::File::Error result) {
VLOG(2) << "OnGetMetadataCompleted {fsid = " << GetFileSystemId()
<< ", entry_path = '" << entry_path << "', result = '" << result
<< "', metadata = " << entry_metadata.get() << "}";
if (content_cache_) {
if (result == base::File::FILE_ERROR_NOT_FOUND) {
// The file doesn't exist on the FSP, evict it from the cache.
content_cache_->Evict(entry_path);
} else if (result == base::File::FILE_OK) {
// Notify the cache with the observed version tag.
content_cache_->ObservedVersionTag(entry_path,
GetVersionTag(entry_metadata.get()));
}
}
std::move(callback).Run(std::move(entry_metadata), result);
}
void CloudFileSystem::OnWriteFileCompleted(
int file_handle,
storage::AsyncFileUtil::StatusCallback callback,
base::File::Error result) {
VLOG(2) << "OnWriteFileCompleted {fsid = " << GetFileSystemId()
<< ", file_handle = '" << file_handle << "', result = '" << result
<< "}";
if (content_cache_ && result == base::File::FILE_OK) {
const auto& opened_file = opened_files_.extract(file_handle);
if (!opened_file.empty()) {
// The cached file is now out of date.
content_cache_->Evict(opened_file.mapped().file_path);
}
}
std::move(callback).Run(result);
}
void CloudFileSystem::OnDeleteEntryCompleted(
const base::FilePath& entry_path,
storage::AsyncFileUtil::StatusCallback callback,
base::File::Error result) {
VLOG(2) << "OnDeleteEntryCompleted {fsid = " << GetFileSystemId()
<< ", entry_path = '" << entry_path << "', result = '" << result
<< "}";
if (content_cache_ && result == base::File::FILE_OK) {
// The cached file should be deleted.
content_cache_->Evict(entry_path);
}
std::move(callback).Run(result);
}
void CloudFileSystem::OnItemEvicted(const base::FilePath& fsp_path) {
VLOG(1) << fsp_path << " evicted from the content cache";
RemoveWatcher(
GetContentCacheURL(), fsp_path, /*recursive=*/false,
base::BindOnce(
[](const base::FilePath& fsp_path, base::File::Error result) {
VLOG(1) << "Removed file watcher on '" << fsp_path
<< "' result: " << result;
},
fsp_path));
}
} // namespace ash::file_system_provider
Codebase Browser
chromium