// Copyright 2022 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/fusebox/fusebox_read_writer.h"
#include <fcntl.h>
#include <unistd.h>
#include "base/files/file_util.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/stringprintf.h"
#include "base/task/thread_pool.h"
#include "base/threading/scoped_blocking_call.h"
#include "chrome/browser/ash/fusebox/fusebox_copy_to_fd.h"
#include "chrome/browser/ash/fusebox/fusebox_errno.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "net/base/net_errors.h"
#include "storage/browser/file_system/file_system_operation_runner.h"
namespace fusebox {
namespace {
void RunFlushCallback(ReadWriter::FlushCallback callback,
int posix_error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
FlushResponseProto response_proto;
if (posix_error_code) {
response_proto.set_posix_error_code(posix_error_code);
}
std::move(callback).Run(response_proto);
}
void RunRead2CallbackFailure(ReadWriter::Read2Callback callback,
base::File::Error error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
Read2ResponseProto response_proto;
response_proto.set_posix_error_code(FileErrorToErrno(error_code));
std::move(callback).Run(response_proto);
}
void RunRead2CallbackTypical(ReadWriter::Read2Callback callback,
scoped_refptr<net::IOBuffer> buffer,
int length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
Read2ResponseProto response_proto;
if (length < 0) {
response_proto.set_posix_error_code(NetErrorToErrno(length));
} else {
*response_proto.mutable_data() = std::string(buffer->data(), length);
}
std::move(callback).Run(response_proto);
content::GetIOThreadTaskRunner({})->ReleaseSoon(FROM_HERE, std::move(buffer));
}
void RunWrite2CallbackFailure(ReadWriter::Write2Callback callback,
int posix_error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
Write2ResponseProto response_proto;
response_proto.set_posix_error_code(posix_error_code);
std::move(callback).Run(response_proto);
}
void RunWrite2CallbackTypical(ReadWriter::Write2Callback callback, int length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
Write2ResponseProto response_proto;
if (length < 0) {
response_proto.set_posix_error_code(NetErrorToErrno(length));
}
std::move(callback).Run(response_proto);
}
ReadWriter::WriteTempFileResult WriteTempFile(
base::ScopedFD&& scoped_fd,
scoped_refptr<net::StringIOBuffer> buffer,
int64_t offset,
int length) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
int fd = scoped_fd.get();
char* ptr = buffer->data();
if ((HANDLE_EINTR(lseek(fd, static_cast<off_t>(offset), SEEK_SET)) == -1) ||
(HANDLE_EINTR(write(fd, ptr, static_cast<size_t>(length))) == -1)) {
return std::make_pair(std::move(scoped_fd), errno);
}
return std::make_pair(std::move(scoped_fd), 0);
}
void SaveCallback2(base::ScopedFD scoped_fd,
scoped_refptr<storage::FileSystemContext> fs_context,
ReadWriter::Close2Callback callback,
base::File::Error file_error) {
Close2ResponseProto response_proto;
if (file_error != base::File::Error::FILE_OK) {
response_proto.set_posix_error_code(FileErrorToErrno(file_error));
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
}
void SaveCallback1(const std::string src_path,
storage::FileSystemURL fs_url,
base::ScopedFD scoped_fd,
scoped_refptr<storage::FileSystemContext> fs_context,
ReadWriter::Close2Callback callback,
base::File::Error file_error) {
// Ignore file_error. We're essentially doing "/usr/bin/rm -f" instead
// of a bare "/usr/bin/rm".
fs_context->operation_runner()->CopyInForeignFile(
base::FilePath(src_path), fs_url,
base::BindOnce(&SaveCallback2, std::move(scoped_fd), fs_context,
std::move(callback)));
}
using EOFFlushFsWriterCallback = base::OnceCallback<void(
std::unique_ptr<storage::FileStreamWriter> fs_writer,
int posix_error_code)>;
// Calls fs_writer->Flush(kEndOfFile), running the callback afterwards, if
// needs_eof_flushing is true. If false, it just runs the callback immediately.
//
// The fs_writer and write_offset are passed through to the callback.
void EOFFlushFsWriterIfNecessary(
std::unique_ptr<storage::FileStreamWriter> fs_writer,
int64_t write_offset,
bool needs_eof_flushing,
EOFFlushFsWriterCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (!fs_writer || !needs_eof_flushing) {
std::move(callback).Run(std::move(fs_writer), 0);
return;
}
// Save the pointer before we std::move fs_writer into a base::OnceCallback.
// The std::move keeps the underlying storage::FileStreamWriter alive while
// any network I/O is pending. Without the std::move, the underlying
// storage::FileStreamWriter would get destroyed at the end of this function.
storage::FileStreamWriter* fs_writer_ptr = fs_writer.get();
auto pair = base::SplitOnceCallback(base::BindOnce(
[](std::unique_ptr<storage::FileStreamWriter> fs_writer,
int64_t write_offset, EOFFlushFsWriterCallback callback, int result) {
int posix_error_code = (result < 0) ? NetErrorToErrno(result) : 0;
std::move(callback).Run(std::move(fs_writer), posix_error_code);
},
std::move(fs_writer), write_offset, std::move(callback)));
int result = fs_writer_ptr->Flush(storage::FlushMode::kEndOfFile,
std::move(pair.first));
if (result != net::ERR_IO_PENDING) { // The flush was synchronous.
std::move(pair.second).Run(result);
}
}
} // namespace
ReadWriter::ReadWriter(const storage::FileSystemURL& fs_url,
const std::string& profile_path,
bool use_temp_file,
bool temp_file_starts_with_copy)
: fs_url_(fs_url),
profile_path_(profile_path),
use_temp_file_(use_temp_file),
temp_file_starts_with_copy_(temp_file_starts_with_copy) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
}
ReadWriter::~ReadWriter() {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
}
// Some functions (marked with a §) below, take an fs_context argument that
// looks unused, but we need to keep the storage::FileSystemContext reference
// alive until the callbacks are run.
void ReadWriter::Close(scoped_refptr<storage::FileSystemContext> fs_context,
Close2Callback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
if (closed_) {
Close2ResponseProto response_proto;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
closed_ = true;
EOFFlushFsWriterIfNecessary(
std::move(fs_writer_), std::exchange(write_offset_, -1),
std::exchange(fs_writer_needs_eof_flushing_, false),
base::BindOnce(&ReadWriter::OnEOFFlushBeforeActualClose,
weak_ptr_factory_.GetWeakPtr(), std::move(callback),
std::move(fs_context)));
}
// static
void ReadWriter::OnEOFFlushBeforeActualClose(
base::WeakPtr<ReadWriter> weak_ptr,
Close2Callback callback,
scoped_refptr<storage::FileSystemContext> fs_context,
std::unique_ptr<storage::FileStreamWriter> fs_writer,
int flush_posix_error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
flush_posix_error_code = EBUSY;
}
if (flush_posix_error_code) {
Close2ResponseProto response_proto;
response_proto.set_posix_error_code(flush_posix_error_code);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
if (!self->use_temp_file_) {
Close2ResponseProto response_proto;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
self->close2_fs_context_ = std::move(fs_context);
self->close2_callback_ = std::move(callback);
if (!self->is_loaning_temp_file_scoped_fd_) {
self->Save();
}
}
void ReadWriter::Save() {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
DCHECK(close2_fs_context_);
DCHECK(close2_callback_);
DCHECK(!is_loaning_temp_file_scoped_fd_);
DCHECK(use_temp_file_);
if (write_posix_error_code_ != 0) {
Close2ResponseProto response_proto;
response_proto.set_posix_error_code(write_posix_error_code_);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(close2_callback_), response_proto));
return;
}
std::string src_path =
created_temp_file_
? base::StringPrintf("/proc/self/fd/%d", temp_file_.get())
: "/dev/null";
// Delete the file if it already it exists, or a no-op if it doesn't. Either
// way, SaveCallback1 will then copy from src_path to fs_url_, before
// SaveCallback2 runs the close2_callback_.
close2_fs_context_->operation_runner()->RemoveFile(
fs_url_,
base::BindOnce(&SaveCallback1, src_path, fs_url_, std::move(temp_file_),
close2_fs_context_, std::move(close2_callback_)));
}
void ReadWriter::Flush(scoped_refptr<storage::FileSystemContext> fs_context,
FlushCallback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
DCHECK(!is_in_flight_);
is_in_flight_ = true;
if (closed_) {
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&RunFlushCallback, std::move(callback), EFAULT));
return;
}
if (use_temp_file_ || !fs_writer_) {
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunFlushCallback, std::move(callback), 0));
return;
}
auto pair = base::SplitOnceCallback(base::BindOnce(
&ReadWriter::OnDefaultFlush, weak_ptr_factory_.GetWeakPtr(),
std::move(callback), fs_context));
int result =
fs_writer_->Flush(storage::FlushMode::kDefault, std::move(pair.first));
if (result != net::ERR_IO_PENDING) { // The flush was synchronous.
std::move(pair.second).Run(result);
}
}
void ReadWriter::Read(scoped_refptr<storage::FileSystemContext> fs_context,
int64_t offset,
int64_t length,
Read2Callback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
DCHECK(!is_in_flight_);
is_in_flight_ = true;
if (closed_) {
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunRead2CallbackFailure, std::move(callback),
base::File::Error::FILE_ERROR_FAILED));
return;
}
// See if we can re-use the previous storage::FileStreamReader.
std::unique_ptr<storage::FileStreamReader> fs_reader;
if (fs_reader_ && (read_offset_ == offset)) {
fs_reader = std::move(fs_reader_);
read_offset_ = -1;
} else {
fs_reader = fs_context->CreateFileStreamReader(fs_url_, offset, INT64_MAX,
base::Time());
if (!fs_reader) {
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&RunRead2CallbackFailure, std::move(callback),
base::File::Error::FILE_ERROR_INVALID_URL));
return;
}
}
constexpr int64_t min_length = 256;
constexpr int64_t max_length = 262144; // 256 KiB.
auto buffer = base::MakeRefCounted<net::IOBufferWithSize>(
std::max(min_length, std::min(max_length, length)));
// Save the pointer before we std::move fs_reader into a base::OnceCallback.
// The std::move keeps the underlying storage::FileStreamReader alive while
// any network I/O is pending. Without the std::move, the underlying
// storage::FileStreamReader would get destroyed at the end of this function.
auto* saved_fs_reader = fs_reader.get();
auto pair = base::SplitOnceCallback(base::BindOnce(
&ReadWriter::OnRead, weak_ptr_factory_.GetWeakPtr(), std::move(callback),
fs_context, std::move(fs_reader), buffer, offset));
int result =
saved_fs_reader->Read(buffer.get(), length, std::move(pair.first));
if (result != net::ERR_IO_PENDING) { // The read was synchronous.
std::move(pair.second).Run(result);
}
}
// static
void ReadWriter::OnRead(
base::WeakPtr<ReadWriter> weak_ptr,
Read2Callback callback,
scoped_refptr<storage::FileSystemContext> fs_context, // See § above.
std::unique_ptr<storage::FileStreamReader> fs_reader,
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
Read2ResponseProto response_proto;
response_proto.set_posix_error_code(EBUSY);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
DCHECK(self->is_in_flight_);
self->is_in_flight_ = false;
if (length >= 0) {
self->fs_reader_ = std::move(fs_reader);
self->read_offset_ = offset + length;
} else {
self->fs_reader_.reset();
self->read_offset_ = -1;
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunRead2CallbackTypical, std::move(callback),
std::move(buffer), length));
}
void ReadWriter::Write(scoped_refptr<storage::FileSystemContext> fs_context,
scoped_refptr<net::StringIOBuffer> buffer,
int64_t offset,
int length,
Write2Callback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
DCHECK(!is_in_flight_);
is_in_flight_ = true;
if (closed_ || (write_posix_error_code_ != 0)) {
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&RunWrite2CallbackFailure, std::move(callback),
closed_ ? EFAULT : write_posix_error_code_));
return;
}
if (use_temp_file_) {
if (!temp_file_.is_valid()) {
// Create the temporary file via open and O_TMPFILE, instead of
// base::CreateTemporaryFile, to simplify clean-up. With the latter,
// there is a garbage collection problem of when to delete no-longer-used
// files (as base::File::DeleteOnClose is Windows only). That problem can
// be tricky if Chrome crashes before we're done with the temporary file.
// With O_TMPFILE, the kernel deletes the file automatically when the
// file descriptor is closed, whether via base::ScopedFD destructor or,
// for crashes, at process exit.
temp_file_.reset(open(profile_path_.c_str(),
O_CLOEXEC | O_EXCL | O_TMPFILE | O_RDWR, 0600));
if (!temp_file_.is_valid()) {
PLOG(WARNING) << "could not create O_TMPFILE file";
is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunWrite2CallbackFailure,
std::move(callback), ENOSPC));
return;
}
created_temp_file_ = true;
if (temp_file_starts_with_copy_) {
auto outer_callback = base::BindOnce(
OnTempFileInitialized, weak_ptr_factory_.GetWeakPtr(),
std::move(buffer), offset, length, std::move(callback));
is_loaning_temp_file_scoped_fd_ = true;
CopyToFileDescriptor(fs_context, fs_url_, std::move(temp_file_),
std::move(outer_callback));
return;
}
}
CallWriteTempFile(weak_ptr_factory_.GetWeakPtr(), std::move(buffer), offset,
length, std::move(callback));
return;
}
// See if we can re-use the previous storage::FileStreamWriter.
//
// If so, go on to CallWriteDirect immediately. Otherwise, go on to
// EOFFlushFsWriterIfNecessary, OnEOFFlushBeforeCallWriteDirect and then
// CallWriteDirect.
if (fs_writer_ && (write_offset_ == offset)) {
CallWriteDirect(std::move(callback), std::move(fs_context),
std::move(fs_writer_), std::move(buffer),
std::exchange(write_offset_, -1), length);
return;
}
// We will need a new storage::FileStreamWriter, so destroy the previous one
// saved to fs_writer_, if it is non-null. However, we might need to Flush it
// (with FlushMode::kEndOfFile) before destroying it.
//
// Calling EOFFlushFsWriterIfNecessary, with std::move(fs_writer_) and with
// OnEOFFlushBeforeCallWriteDirect, will Flush (if needed) and destroy that
// FileStreamWriter (positioned at write_offset_), if it is non-null.
//
// Afterwards, OnEOFFlushBeforeCallWriteDirect creates a new FileStreamWriter
// (positioned at offset) and passes that on to CallWriteDirect.
EOFFlushFsWriterIfNecessary(
std::move(fs_writer_), std::exchange(write_offset_, -1),
std::exchange(fs_writer_needs_eof_flushing_, false),
base::BindOnce(&ReadWriter::OnEOFFlushBeforeCallWriteDirect,
weak_ptr_factory_.GetWeakPtr(), std::move(callback),
std::move(fs_context), std::move(buffer), offset, length));
}
// static
void ReadWriter::OnTempFileInitialized(
base::WeakPtr<ReadWriter> weak_ptr,
scoped_refptr<net::StringIOBuffer> buffer,
int64_t offset,
int length,
Write2Callback callback,
base::expected<base::ScopedFD, int> result) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!result.has_value() || !self) {
if (self) {
self->is_in_flight_ = false;
}
Write2ResponseProto response_proto;
response_proto.set_posix_error_code(result.error_or(EBUSY));
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
self->is_loaning_temp_file_scoped_fd_ = false;
self->temp_file_ = std::move(result.value());
CallWriteTempFile(std::move(weak_ptr), std::move(buffer), offset, length,
std::move(callback));
}
// static
void ReadWriter::CallWriteTempFile(base::WeakPtr<ReadWriter> weak_ptr,
scoped_refptr<net::StringIOBuffer> buffer,
int64_t offset,
int length,
Write2Callback callback) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
Write2ResponseProto response_proto;
response_proto.set_posix_error_code(EBUSY);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
self->is_loaning_temp_file_scoped_fd_ = true;
base::ThreadPool::PostTaskAndReplyWithResult(
FROM_HERE, {base::MayBlock()},
base::BindOnce(&WriteTempFile, std::move(self->temp_file_),
std::move(buffer), offset, length),
base::BindOnce(&OnWriteTempFile, std::move(weak_ptr),
std::move(callback)));
}
// static
void ReadWriter::OnWriteTempFile(base::WeakPtr<ReadWriter> weak_ptr,
Write2Callback callback,
WriteTempFileResult result) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
Write2ResponseProto response_proto;
response_proto.set_posix_error_code(EBUSY);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
DCHECK(self->is_in_flight_);
self->is_in_flight_ = false;
self->is_loaning_temp_file_scoped_fd_ = false;
self->temp_file_ = std::move(result.first);
Write2ResponseProto response_proto;
if (result.second) {
response_proto.set_posix_error_code(result.second);
self->write_posix_error_code_ = result.second;
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
if (self->close2_callback_) {
self->Save();
}
}
// static
void ReadWriter::OnDefaultFlush(
base::WeakPtr<ReadWriter> weak_ptr,
FlushCallback callback,
scoped_refptr<storage::FileSystemContext> fs_context, // See § above.
int flush_posix_error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
flush_posix_error_code = EBUSY;
} else {
self->is_in_flight_ = false;
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunFlushCallback, std::move(callback),
flush_posix_error_code));
}
// static
void ReadWriter::OnEOFFlushBeforeCallWriteDirect(
base::WeakPtr<ReadWriter> weak_ptr,
Write2Callback callback,
scoped_refptr<storage::FileSystemContext> fs_context, // See § above.
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length,
std::unique_ptr<storage::FileStreamWriter> fs_writer,
int flush_posix_error_code) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
flush_posix_error_code = EBUSY;
}
if (flush_posix_error_code) {
if (self) {
self->is_in_flight_ = false;
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&RunWrite2CallbackFailure,
std::move(callback), flush_posix_error_code));
return;
}
fs_writer = fs_context->CreateFileStreamWriter(self->fs_url_, offset);
if (!fs_writer) {
self->is_in_flight_ = false;
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&RunWrite2CallbackFailure, std::move(callback), EINVAL));
return;
}
self->CallWriteDirect(std::move(callback), std::move(fs_context),
std::move(fs_writer), std::move(buffer), offset,
length);
}
void ReadWriter::CallWriteDirect(
Write2Callback callback,
scoped_refptr<storage::FileSystemContext> fs_context, // See § above.
std::unique_ptr<storage::FileStreamWriter> fs_writer,
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
// Save the pointer before we std::move fs_writer into a base::OnceCallback.
// The std::move keeps the underlying storage::FileStreamWriter alive while
// any network I/O is pending. Without the std::move, the underlying
// storage::FileStreamWriter would get destroyed at the end of this function.
auto* saved_fs_writer = fs_writer.get();
auto pair = base::SplitOnceCallback(base::BindOnce(
&ReadWriter::OnWriteDirect, weak_ptr_factory_.GetWeakPtr(),
std::move(callback), fs_context, std::move(fs_writer), buffer, offset));
int result =
saved_fs_writer->Write(buffer.get(), length, std::move(pair.first));
if (result != net::ERR_IO_PENDING) { // The write was synchronous.
std::move(pair.second).Run(result);
}
}
// static
void ReadWriter::OnWriteDirect(
base::WeakPtr<ReadWriter> weak_ptr,
Write2Callback callback,
scoped_refptr<storage::FileSystemContext> fs_context, // See § above.
std::unique_ptr<storage::FileStreamWriter> fs_writer,
scoped_refptr<net::IOBuffer> buffer,
int64_t offset,
int length) {
DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
ReadWriter* self = weak_ptr.get();
if (!self) {
Write2ResponseProto response_proto;
response_proto.set_posix_error_code(EBUSY);
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(std::move(callback), response_proto));
return;
}
DCHECK(self->is_in_flight_);
self->is_in_flight_ = false;
if (length >= 0) {
self->fs_writer_ = std::move(fs_writer);
self->write_offset_ = offset + length;
self->fs_writer_needs_eof_flushing_ =
self->fs_writer_needs_eof_flushing_ ||
(self->fs_url_.mount_option().flush_policy() ==
storage::FlushPolicy::FLUSH_ON_COMPLETION);
} else {
self->fs_writer_.reset();
self->write_offset_ = -1;
self->write_posix_error_code_ = NetErrorToErrno(length);
}
content::GetUIThreadTaskRunner({})->PostTask(
FROM_HERE,
base::BindOnce(&RunWrite2CallbackTypical, std::move(callback), length));
}
} // namespace fusebox
Codebase Browser
chromium