// 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/fileapi/diversion_backend_delegate.h"
#include <unistd.h>
#include "base/metrics/histogram_functions.h"
#include "chrome/browser/ash/fileapi/copy_from_fd.h"
#include "chrome/browser/ash/fusebox/fusebox_errno.h"
#include "chrome/browser/ash/fusebox/fusebox_histograms.h"
#include "content/public/browser/browser_thread.h"
#include "storage/browser/file_system/file_system_url.h"
#include "storage/common/file_system/file_system_util.h"
namespace ash {
namespace {
constexpr auto kDiversionFileIdleTimeout = base::Seconds(5);
DiversionBackendDelegate::Policy ShouldDivert(
const storage::FileSystemURL& url) {
// For now (January 2024), we'll be conservative and only apply diversion to
// "crdownload" files (from browser downloads) or "crswap" files (as
// generated by File System Access code) that are freshly created. Later, we
// could roll out diversion more widely.
//
// If we were to divert previously-existing files (not only diverting freshly
// created files), as kDivertMingled (not kDivertIsolated), then we'd need to
// initialize the Diversion File's contents (via a FileStreamWriter), just
// after the StartDiverting call, before running the
// EnsureFileExistsCallback. There would be the usual trade-offs here between
// lazy and eager initialization of those file contents.
const std::string& extension = url.virtual_path().FinalExtension();
if ((extension == ".crdownload") || (extension == ".crswap")) {
return DiversionBackendDelegate::Policy::kDivertIsolated;
} else if (extension == ".cros_divert_mingled_test") {
return DiversionBackendDelegate::Policy::kDivertMingled;
}
return DiversionBackendDelegate::Policy::kDoNotDivert;
}
// Duplicates a FileSystemOperationContext, returning something (a unique_ptr)
// with independent ownership.
std::unique_ptr<storage::FileSystemOperationContext>
DuplicateFileSystemOperationContext(
const storage::FileSystemOperationContext& original) {
return std::make_unique<storage::FileSystemOperationContext>(
original.file_system_context(), original.task_runner());
}
storage::AsyncFileUtil::StatusCallback HistogramWrap(
const char* histogram_name,
storage::AsyncFileUtil::StatusCallback callback) {
static constexpr auto func =
[](const char* histogram_name,
storage::AsyncFileUtil::StatusCallback wrappee,
base::File::Error error) {
base::UmaHistogramEnumeration(histogram_name,
fusebox::GetHistogramEnumPosixErrorCode(
fusebox::FileErrorToErrno(error)));
if (wrappee) {
std::move(wrappee).Run(error);
}
};
return base::BindOnce(func, histogram_name, std::move(callback));
}
} // namespace
DiversionBackendDelegate::DiversionBackendDelegate(
std::unique_ptr<FileSystemBackendDelegate> wrappee)
: wrappee_(std::move(wrappee)),
diversion_file_manager_(base::MakeRefCounted<DiversionFileManager>()) {
CHECK(wrappee_);
}
DiversionBackendDelegate::~DiversionBackendDelegate() = default;
storage::AsyncFileUtil* DiversionBackendDelegate::GetAsyncFileUtil(
storage::FileSystemType type) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
return this;
}
std::unique_ptr<storage::FileStreamReader>
DiversionBackendDelegate::CreateFileStreamReader(
const storage::FileSystemURL& url,
int64_t offset,
int64_t max_bytes_to_read,
const base::Time& expected_modification_time,
storage::FileSystemContext* context) {
// TODO: honor max_bytes_to_read. On the other hand,
// storage::FileStreamReader::CreateForLocalFile also doesn't honor it.
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (std::unique_ptr<storage::FileStreamReader> fs_reader =
diversion_file_manager_->CreateDivertedFileStreamReader(url,
offset)) {
return fs_reader;
}
return wrappee_->CreateFileStreamReader(url, offset, max_bytes_to_read,
expected_modification_time, context);
}
std::unique_ptr<storage::FileStreamWriter>
DiversionBackendDelegate::CreateFileStreamWriter(
const storage::FileSystemURL& url,
int64_t offset,
storage::FileSystemContext* context) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (std::unique_ptr<storage::FileStreamWriter> fs_writer =
diversion_file_manager_->CreateDivertedFileStreamWriter(url,
offset)) {
return fs_writer;
}
return wrappee_->CreateFileStreamWriter(url, offset, context);
}
storage::WatcherManager* DiversionBackendDelegate::GetWatcherManager(
storage::FileSystemType type) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
return wrappee_->GetWatcherManager(type);
}
void DiversionBackendDelegate::CreateOrOpen(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
uint32_t file_flags,
CreateOrOpenCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->CreateOrOpen(std::move(context), url, file_flags,
std::move(callback));
}
void DiversionBackendDelegate::EnsureFileExists(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
EnsureFileExistsCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
if (!url.is_valid()) {
std::move(callback).Run(base::File::FILE_ERROR_INVALID_URL,
/*created=*/false);
return;
}
const Policy policy = ShouldDivert(url);
base::UmaHistogramBoolean(
"FileBrowser.Diversion.EnsureFileExists.ShouldDivert",
policy != Policy::kDoNotDivert);
if (policy == Policy::kDoNotDivert) {
af_util->EnsureFileExists(std::move(context), url, std::move(callback));
return;
} else if (diversion_file_manager_->IsDiverting(url)) {
std::move(callback).Run(base::File::FILE_OK, /*created=*/false);
return;
} else if (policy == Policy::kDivertIsolated) {
auto sd_result = diversion_file_manager_->StartDiverting(
url, kDiversionFileIdleTimeout,
base::BindOnce(&DiversionBackendDelegate::OnDiversionFinished,
weak_ptr_factory_.GetWeakPtr(),
OnDiversionFinishedCallSite::kEnsureFileExists,
std::move(context), url,
storage::AsyncFileUtil::StatusCallback()));
bool created = sd_result == DiversionFileManager::StartDivertingResult::kOK;
std::move(callback).Run(base::File::FILE_OK, created);
return;
}
static constexpr auto on_get_file_info =
[](base::WeakPtr<DiversionBackendDelegate> weak_ptr,
scoped_refptr<DiversionFileManager> diversion_file_manager,
std::unique_ptr<storage::FileSystemOperationContext>
duplicated_context,
const storage::FileSystemURL& url, EnsureFileExistsCallback callback,
base::File::Error gfi_result, const base::File::Info& file_info) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
bool created = false;
if (gfi_result == base::File::FILE_OK) {
std::move(callback).Run(file_info.is_directory
? base::File::FILE_ERROR_NOT_A_FILE
: base::File::FILE_OK,
created);
} else if (gfi_result == base::File::FILE_ERROR_NOT_FOUND) {
auto sd_result = diversion_file_manager->StartDiverting(
url, kDiversionFileIdleTimeout,
base::BindOnce(&DiversionBackendDelegate::OnDiversionFinished,
std::move(weak_ptr),
OnDiversionFinishedCallSite::kEnsureFileExists,
std::move(duplicated_context), url,
storage::AsyncFileUtil::StatusCallback()));
created =
sd_result == DiversionFileManager::StartDivertingResult::kOK;
std::move(callback).Run(base::File::FILE_OK, created);
} else {
std::move(callback).Run(gfi_result, created);
}
};
std::unique_ptr<storage::FileSystemOperationContext> fsoc0 =
DuplicateFileSystemOperationContext(*context);
std::unique_ptr<storage::FileSystemOperationContext> fsoc1 =
std::move(context);
af_util->GetFileInfo(
std::move(fsoc0), url,
{storage::FileSystemOperation::GetMetadataField::kIsDirectory},
base::BindOnce(on_get_file_info, weak_ptr_factory_.GetWeakPtr(),
diversion_file_manager_, std::move(fsoc1), url,
std::move(callback)));
}
void DiversionBackendDelegate::CreateDirectory(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
bool exclusive,
bool recursive,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->CreateDirectory(std::move(context), url, exclusive, recursive,
std::move(callback));
}
void DiversionBackendDelegate::GetFileInfo(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
GetMetadataFieldSet fields,
GetFileInfoCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (diversion_file_manager_->IsDiverting(url)) {
diversion_file_manager_->GetDivertedFileInfo(url, fields,
std::move(callback));
return;
} else if (ShouldDivert(url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND,
base::File::Info());
return;
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->GetFileInfo(std::move(context), url, fields, std::move(callback));
}
void DiversionBackendDelegate::ReadDirectory(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
ReadDirectoryCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->ReadDirectory(std::move(context), url, std::move(callback));
}
void DiversionBackendDelegate::Touch(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
const base::Time& last_access_time,
const base::Time& last_modified_time,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (diversion_file_manager_->IsDiverting(url)) {
// TODO: touch the O_TMPFILE file.
} else if (ShouldDivert(url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
return;
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->Touch(std::move(context), url, last_access_time, last_modified_time,
std::move(callback));
}
void DiversionBackendDelegate::Truncate(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
int64_t length,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (diversion_file_manager_->IsDiverting(url)) {
diversion_file_manager_->TruncateDivertedFile(url, length,
std::move(callback));
return;
} else if (ShouldDivert(url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
return;
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->Truncate(std::move(context), url, length, std::move(callback));
}
void DiversionBackendDelegate::CopyFileLocal(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
CopyOrMoveOptionSet options,
CopyFileProgressCallback progress_callback,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (!src_url.is_valid() || !dest_url.is_valid()) {
std::move(callback).Run(base::File::FILE_ERROR_INVALID_URL);
return;
} else if (src_url == dest_url) {
std::move(callback).Run(base::File::FILE_OK);
return;
}
if (diversion_file_manager_->IsDiverting(dest_url)) {
// Passing a null DiversionFileManager::Callback deletes the diversion file.
diversion_file_manager_->FinishDiverting(dest_url,
DiversionFileManager::Callback());
}
if (diversion_file_manager_->IsDiverting(src_url)) {
diversion_file_manager_->FinishDiverting(
src_url,
base::BindOnce(&DiversionBackendDelegate::OnDiversionFinished,
weak_ptr_factory_.GetWeakPtr(),
OnDiversionFinishedCallSite::kCopyFileLocal,
std::move(context), dest_url, std::move(callback)));
return;
} else if (ShouldDivert(src_url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
return;
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(dest_url.type());
af_util->CopyFileLocal(std::move(context), src_url, dest_url,
std::move(options), std::move(progress_callback),
std::move(callback));
}
void DiversionBackendDelegate::MoveFileLocal(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
CopyOrMoveOptionSet options,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (!src_url.is_valid() || !dest_url.is_valid()) {
std::move(callback).Run(base::File::FILE_ERROR_INVALID_URL);
return;
} else if (src_url == dest_url) {
std::move(callback).Run(base::File::FILE_OK);
return;
}
if (diversion_file_manager_->IsDiverting(src_url)) {
diversion_file_manager_->FinishDiverting(
src_url,
base::BindOnce(&DiversionBackendDelegate::OnDiversionFinished,
weak_ptr_factory_.GetWeakPtr(),
OnDiversionFinishedCallSite::kMoveFileLocal,
std::move(context), dest_url, std::move(callback)));
return;
} else if (ShouldDivert(src_url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
return;
} else if (diversion_file_manager_->IsDiverting(dest_url)) {
// Passing a null DiversionFileManager::Callback deletes the diversion file.
diversion_file_manager_->FinishDiverting(dest_url,
DiversionFileManager::Callback());
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(dest_url.type());
af_util->MoveFileLocal(std::move(context), src_url, dest_url,
std::move(options), std::move(callback));
}
void DiversionBackendDelegate::CopyInForeignFile(
std::unique_ptr<storage::FileSystemOperationContext> context,
const base::FilePath& src_file_path,
const storage::FileSystemURL& dest_url,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(dest_url.type());
af_util->CopyInForeignFile(std::move(context), src_file_path, dest_url,
std::move(callback));
}
void DiversionBackendDelegate::DeleteFile(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (diversion_file_manager_->IsDiverting(url)) {
// Passing a null DiversionFileManager::Callback deletes the diversion file.
diversion_file_manager_->FinishDiverting(url,
DiversionFileManager::Callback());
if (callback) {
callback = base::BindOnce(
[](StatusCallback inner_callback, base::File::Error result) {
if (result == base::File::FILE_ERROR_NOT_FOUND) {
result = base::File::FILE_OK;
}
std::move(inner_callback).Run(result);
},
std::move(callback));
}
} else if (ShouldDivert(url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_FOUND);
return;
}
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->DeleteFile(std::move(context), url, std::move(callback));
}
void DiversionBackendDelegate::DeleteDirectory(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->DeleteDirectory(std::move(context), url, std::move(callback));
}
void DiversionBackendDelegate::DeleteRecursively(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
StatusCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
// TODO: this could be tricky if a diverted-file is a descendent of the "url
// to be deleted recursively".
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->DeleteRecursively(std::move(context), url, std::move(callback));
}
void DiversionBackendDelegate::CreateSnapshotFile(
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& url,
CreateSnapshotFileCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
// TODO: do we need to do anything here??
storage::AsyncFileUtil* af_util = wrappee_->GetAsyncFileUtil(url.type());
af_util->CreateSnapshotFile(std::move(context), url, std::move(callback));
}
void DiversionBackendDelegate::OverrideTmpfileDirForTesting(
const base::FilePath& tmpfile_dir) {
diversion_file_manager_->OverrideTmpfileDirForTesting( // IN-TEST
tmpfile_dir);
}
// static
DiversionBackendDelegate::Policy
DiversionBackendDelegate::ShouldDivertForTesting(
const storage::FileSystemURL& url) {
return ShouldDivert(url);
}
// static
base::TimeDelta DiversionBackendDelegate::IdleTimeoutForTesting() {
return kDiversionFileIdleTimeout;
}
// static
void DiversionBackendDelegate::OnDiversionFinished(
base::WeakPtr<DiversionBackendDelegate> weak_ptr,
OnDiversionFinishedCallSite call_site,
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& dest_url,
storage::AsyncFileUtil::StatusCallback callback,
DiversionFileManager::StoppedReason stopped_reason,
const storage::FileSystemURL& src_url,
base::ScopedFD scoped_fd,
int64_t file_size,
base::File::Error error) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
CHECK(dest_url.is_valid());
CHECK(src_url.is_valid());
switch (stopped_reason) {
case DiversionFileManager::StoppedReason::kExplicitFinish:
base::UmaHistogramEnumeration(
"FileBrowser.Diversion.Commit.ExplicitFinish.PartOne",
fusebox::GetHistogramEnumPosixErrorCode(
fusebox::FileErrorToErrno(error)));
callback =
HistogramWrap("FileBrowser.Diversion.Commit.ExplicitFinish.PartTwo",
std::move(callback));
break;
case DiversionFileManager::StoppedReason::kImplicitIdle:
base::UmaHistogramEnumeration(
"FileBrowser.Diversion.Commit.ImplicitIdle.PartOne",
fusebox::GetHistogramEnumPosixErrorCode(
fusebox::FileErrorToErrno(error)));
callback =
HistogramWrap("FileBrowser.Diversion.Commit.ImplicitIdle.PartTwo",
std::move(callback));
break;
}
if (error != base::File::FILE_OK) {
if (callback) {
std::move(callback).Run(error);
}
return;
} else if (!weak_ptr || !context || !scoped_fd.is_valid()) {
if (callback) {
std::move(callback).Run(base::File::FILE_ERROR_FAILED);
}
return;
}
// TODO(b/289322939): when wrapping a FileSystemProvider backend, can it
// accept a Blob instead of using CopyFromFileDescriptor? The latter might
// need the FileSystemProvider JS implementation to buffer the entire file's
// contents in memory at once, which will obviously fail if those contents
// are larger than the amount of available RAM.
static constexpr auto ignore_file_error_not_found =
[](storage::AsyncFileUtil::StatusCallback callback,
base::File::Error file_error) {
if (file_error == base::File::FILE_ERROR_NOT_FOUND) {
file_error = base::File::FILE_OK;
}
if (callback) {
std::move(callback).Run(file_error);
}
};
static constexpr auto on_copy_complete =
[](base::WeakPtr<DiversionBackendDelegate> weak_ptr,
OnDiversionFinishedCallSite call_site,
std::unique_ptr<storage::FileSystemOperationContext> context,
const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
storage::AsyncFileUtil::StatusCallback callback,
DiversionFileManager::StoppedReason stopped_reason, int64_t file_size,
base::ScopedFD scoped_fd,
std::unique_ptr<storage::FileStreamWriter> fs_writer,
net::Error net_error) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (src_url == dest_url) {
if (callback) {
std::move(callback).Run(storage::NetErrorToFileError(net_error));
}
return;
}
CHECK_NE(call_site, OnDiversionFinishedCallSite::kEnsureFileExists);
if (callback && (net_error != net::OK)) {
base::File::Error first_error =
storage::NetErrorToFileError(net_error);
callback = base::BindOnce(
[](storage::AsyncFileUtil::StatusCallback inner_callback,
base::File::Error first_error_is_passed_on,
base::File::Error second_error_is_ignored) {
std::move(inner_callback).Run(first_error_is_passed_on);
},
std::move(callback), first_error);
}
if (!weak_ptr) {
if (callback) {
std::move(callback).Run(base::File::FILE_ERROR_FAILED);
}
return;
}
switch (call_site) {
case OnDiversionFinishedCallSite::kEnsureFileExists:
NOTREACHED();
case OnDiversionFinishedCallSite::kCopyFileLocal: {
if (!scoped_fd.is_valid()) {
std::move(callback).Run(base::File::FILE_ERROR_FAILED);
return;
}
// Copy from that scoped_fd again, but this time to src_url instead
// of to dest_url.
lseek(scoped_fd.get(), 0, SEEK_SET);
weak_ptr->OnDiversionFinished(
weak_ptr, call_site, std::move(context), src_url,
std::move(callback), stopped_reason, src_url,
std::move(scoped_fd), file_size, base::File::FILE_OK);
break;
}
case OnDiversionFinishedCallSite::kMoveFileLocal:
if (ShouldDivert(src_url) == Policy::kDivertIsolated) {
std::move(callback).Run(base::File::FILE_OK);
} else {
weak_ptr->wrappee_->GetAsyncFileUtil(src_url.type())
->DeleteFile(std::move(context), src_url,
base::BindOnce(ignore_file_error_not_found,
std::move(callback)));
}
break;
}
};
static constexpr auto on_truncated =
[](base::WeakPtr<DiversionBackendDelegate> weak_ptr,
OnDiversionFinishedCallSite call_site,
std::unique_ptr<storage::FileSystemOperationContext> context,
base::ScopedFD scoped_fd, const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
storage::AsyncFileUtil::StatusCallback callback,
DiversionFileManager::StoppedReason stopped_reason, int64_t file_size,
base::File::Error result) {
if (result != base::File::FILE_OK) {
if (callback) {
std::move(callback).Run(result);
}
return;
} else if (!weak_ptr) {
if (callback) {
std::move(callback).Run(base::File::FILE_ERROR_FAILED);
}
return;
}
// TODO: for now, we are assuming that "write to foo.dat" is atomic:
// other clients reading "foo.dat" will either see the complete old
// version (if it existed) or the complete new version but not a
// partial prefix of the new version. Specifically for ODFS+FSP, file
// upload is indeed atomic.
//
// More generally, we may have to take multiple steps (the Google Drive
// team call this a "File Dance"), first writing to a temporary sibling
// file and then moving the sibling over the ultimate destination. But
// this is obviously more complicated and has more failure states.
//
// Ideally, the wrappee FileSystemBackendDelegate or AsyncFileUtil
// would be able to say whether it is capable of atomic upload (see
// also b/289322939). Absent that, it's simplest to assume that it can.
std::unique_ptr<storage::FileStreamWriter> fs_writer =
weak_ptr->wrappee_->CreateFileStreamWriter(
dest_url, 0, context->file_system_context());
CopyFromFileDescriptor(
std::move(scoped_fd), std::move(fs_writer),
dest_url.mount_option().flush_policy(),
base::BindOnce(on_copy_complete, std::move(weak_ptr), call_site,
std::move(context), src_url, dest_url,
std::move(callback), stopped_reason, file_size));
};
static constexpr auto on_ensure_file_exists =
[](base::WeakPtr<DiversionBackendDelegate> weak_ptr,
OnDiversionFinishedCallSite call_site,
std::unique_ptr<storage::FileSystemOperationContext> context,
base::ScopedFD scoped_fd, const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
storage::AsyncFileUtil::StatusCallback callback,
DiversionFileManager::StoppedReason stopped_reason, int64_t file_size,
base::File::Error result, bool created) {
if (result != base::File::FILE_OK) {
if (callback) {
std::move(callback).Run(result);
}
return;
} else if (!weak_ptr) {
if (callback) {
std::move(callback).Run(base::File::FILE_ERROR_FAILED);
}
return;
} else if (created) {
on_truncated(std::move(weak_ptr), call_site, std::move(context),
std::move(scoped_fd), src_url, dest_url,
std::move(callback), stopped_reason, file_size,
base::File::FILE_OK);
return;
}
std::unique_ptr<storage::FileSystemOperationContext> fsoc0 =
DuplicateFileSystemOperationContext(*context);
std::unique_ptr<storage::FileSystemOperationContext> fsoc1 =
std::move(context);
FileSystemBackendDelegate* wrappee = weak_ptr->wrappee_.get();
wrappee->GetAsyncFileUtil(dest_url.type())
->Truncate(
std::move(fsoc0), dest_url, 0,
base::BindOnce(on_truncated, std::move(weak_ptr), call_site,
std::move(fsoc1), std::move(scoped_fd), src_url,
dest_url, std::move(callback), stopped_reason,
file_size));
};
static constexpr auto on_get_file_info =
[](base::WeakPtr<DiversionBackendDelegate> weak_ptr,
OnDiversionFinishedCallSite call_site,
std::unique_ptr<storage::FileSystemOperationContext> context,
base::ScopedFD scoped_fd, const storage::FileSystemURL& src_url,
const storage::FileSystemURL& dest_url,
storage::AsyncFileUtil::StatusCallback callback,
DiversionFileManager::StoppedReason stopped_reason, int64_t file_size,
base::File::Error result, const base::File::Info& file_info) {
if (result == base::File::FILE_ERROR_NOT_FOUND) {
// No-op. Every other if-else branch returns.
} else if (result != base::File::FILE_OK) {
if (callback) {
std::move(callback).Run(result);
}
return;
} else if (file_info.is_directory) {
if (callback) {
std::move(callback).Run(base::File::FILE_ERROR_NOT_A_FILE);
}
return;
} else if (file_info.size != 0) {
on_ensure_file_exists(std::move(weak_ptr), call_site,
std::move(context), std::move(scoped_fd),
src_url, dest_url, std::move(callback),
stopped_reason, file_size, base::File::FILE_OK,
/*created=*/false);
return;
} else {
on_truncated(std::move(weak_ptr), call_site, std::move(context),
std::move(scoped_fd), src_url, dest_url,
std::move(callback), stopped_reason, file_size,
base::File::FILE_OK);
return;
}
std::unique_ptr<storage::FileSystemOperationContext> fsoc0 =
DuplicateFileSystemOperationContext(*context);
std::unique_ptr<storage::FileSystemOperationContext> fsoc1 =
std::move(context);
FileSystemBackendDelegate* wrappee = weak_ptr->wrappee_.get();
wrappee->GetAsyncFileUtil(dest_url.type())
->EnsureFileExists(
std::move(fsoc0), dest_url,
base::BindOnce(on_ensure_file_exists, std::move(weak_ptr),
call_site, std::move(fsoc1),
std::move(scoped_fd), src_url, dest_url,
std::move(callback), stopped_reason, file_size));
};
std::unique_ptr<storage::FileSystemOperationContext> fsoc0 =
DuplicateFileSystemOperationContext(*context);
std::unique_ptr<storage::FileSystemOperationContext> fsoc1 =
std::move(context);
FileSystemBackendDelegate* wrappee = weak_ptr->wrappee_.get();
wrappee->GetAsyncFileUtil(dest_url.type())
->GetFileInfo(
std::move(fsoc0), dest_url,
{storage::FileSystemOperation::GetMetadataField::kSize,
storage::FileSystemOperation::GetMetadataField::kIsDirectory},
base::BindOnce(on_get_file_info, std::move(weak_ptr), call_site,
std::move(fsoc1), std::move(scoped_fd), src_url,
dest_url, std::move(callback), stopped_reason,
file_size));
}
} // namespace ash
Codebase Browser
chromium