From 3bdb686ce0d696b447d6956125f56f26ab66c9b8 Mon Sep 17 00:00:00 2001 From: Victor Costan Date: Mon, 22 Oct 2018 20:00:02 +0000 Subject: [PATCH] File API: Upgrade base::Bind to modern alternatives. Change-Id: I7eba57be3c04b8c8d7963e2043bc3992e7193484 Reviewed-on: https://chromium-review.googlesource.com/c/1293031 Reviewed-by: Bill Budge Reviewed-by: Marijn Kruisselbrink Commit-Queue: Victor Costan Cr-Commit-Position: refs/heads/master@{#601697} --- .../pepper/quota_reservation_unittest.cc | 9 +++--- .../copy_or_move_operation_delegate.cc | 22 +++++++------- .../fileapi/copy_or_move_operation_delegate.h | 3 +- ...opy_or_move_operation_delegate_unittest.cc | 24 ++++++++------- storage/browser/fileapi/file_system_backend.h | 2 +- .../browser/fileapi/file_system_context.cc | 4 +-- .../file_system_dir_url_request_job.cc | 9 +++--- ...ile_system_dir_url_request_job_unittest.cc | 4 +-- ...file_system_file_stream_reader_unittest.cc | 2 +- .../browser/fileapi/file_system_file_util.h | 4 +-- .../fileapi/file_system_operation_impl.cc | 4 +-- .../file_system_operation_impl_unittest.cc | 12 +++----- ...le_system_operation_impl_write_unittest.cc | 12 ++++---- .../fileapi/file_system_operation_runner.cc | 4 +-- .../fileapi/file_system_url_request_job.cc | 13 ++++---- .../fileapi/file_system_usage_cache.cc | 4 +-- .../browser/fileapi/file_writer_delegate.cc | 26 ++++++++-------- .../browser/fileapi/file_writer_delegate.h | 10 +++---- .../local_file_stream_reader_unittest.cc | 2 +- .../local_file_stream_writer_unittest.cc | 6 ++-- .../browser/fileapi/obfuscated_file_util.cc | 12 ++++---- .../browser/fileapi/obfuscated_file_util.h | 4 +-- .../plugin_private_file_system_backend.cc | 8 ++--- .../fileapi/quota/quota_backend_impl.cc | 13 ++++---- .../fileapi/quota/quota_backend_impl.h | 4 +-- .../quota/quota_backend_impl_unittest.cc | 26 +++++++++------- .../fileapi/quota/quota_reservation.cc | 20 ++++++------- .../browser/fileapi/quota/quota_reservation.h | 8 ++--- .../fileapi/quota/quota_reservation_buffer.cc | 4 +-- .../quota/quota_reservation_manager.cc | 12 ++++---- .../fileapi/quota/quota_reservation_manager.h | 10 +++---- .../quota_reservation_manager_unittest.cc | 6 ++-- .../fileapi/recursive_operation_delegate.cc | 23 +++++++------- .../recursive_operation_delegate_unittest.cc | 30 +++++++++---------- .../sandbox_file_system_backend_delegate.cc | 7 +++-- .../browser/fileapi/sandbox_quota_observer.cc | 4 +-- .../browser/test/async_file_test_helper.cc | 10 +++---- 37 files changed, 192 insertions(+), 185 deletions(-) diff --git a/content/browser/renderer_host/pepper/quota_reservation_unittest.cc b/content/browser/renderer_host/pepper/quota_reservation_unittest.cc index cc2f82f564af90..e75c196331ae86 100644 --- a/content/browser/renderer_host/pepper/quota_reservation_unittest.cc +++ b/content/browser/renderer_host/pepper/quota_reservation_unittest.cc @@ -48,9 +48,9 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend { const url::Origin& origin, storage::FileSystemType type, int64_t delta, - const QuotaReservationManager::ReserveQuotaCallback& callback) override { + QuotaReservationManager::ReserveQuotaCallback callback) override { base::ThreadTaskRunnerHandle::Get()->PostTask( - FROM_HERE, base::BindOnce(base::IgnoreResult(callback), + FROM_HERE, base::BindOnce(base::IgnoreResult(std::move(callback)), base::File::FILE_OK, delta)); } @@ -81,9 +81,8 @@ class QuotaReservationTest : public testing::Test { void SetUp() override { ASSERT_TRUE(work_dir_.CreateUniqueTempDir()); - reservation_manager_.reset(new QuotaReservationManager( - std::unique_ptr( - new FakeBackend))); + reservation_manager_ = std::make_unique( + std::make_unique()); } void TearDown() override { diff --git a/storage/browser/fileapi/copy_or_move_operation_delegate.cc b/storage/browser/fileapi/copy_or_move_operation_delegate.cc index fbcb102e7f2565..54a4b4177ca0f6 100644 --- a/storage/browser/fileapi/copy_or_move_operation_delegate.cc +++ b/storage/browser/fileapi/copy_or_move_operation_delegate.cc @@ -55,14 +55,13 @@ class CopyOrMoveOnSameFileSystemImpl const FileSystemURL& src_url, const FileSystemURL& dest_url, CopyOrMoveOperationDelegate::CopyOrMoveOption option, - const FileSystemOperation::CopyFileProgressCallback& - file_progress_callback) + FileSystemOperation::CopyFileProgressCallback file_progress_callback) : operation_runner_(operation_runner), operation_type_(operation_type), src_url_(src_url), dest_url_(dest_url), option_(option), - file_progress_callback_(file_progress_callback) {} + file_progress_callback_(std::move(file_progress_callback)) {} void Run(CopyOrMoveOperationDelegate::StatusCallback callback) override { if (operation_type_ == CopyOrMoveOperationDelegate::OPERATION_MOVE) { @@ -596,12 +595,12 @@ CopyOrMoveOperationDelegate::StreamCopyHelper::StreamCopyHelper( std::unique_ptr writer, storage::FlushPolicy flush_policy, int buffer_size, - const FileSystemOperation::CopyFileProgressCallback& file_progress_callback, + FileSystemOperation::CopyFileProgressCallback file_progress_callback, const base::TimeDelta& min_progress_callback_invocation_span) : reader_(std::move(reader)), writer_(std::move(writer)), flush_policy_(flush_policy), - file_progress_callback_(file_progress_callback), + file_progress_callback_(std::move(file_progress_callback)), io_buffer_(base::MakeRefCounted(buffer_size)), num_copied_bytes_(0), previous_flush_offset_(0), @@ -814,8 +813,8 @@ void CopyOrMoveOperationDelegate::ProcessFile(const FileSystemURL& src_url, operation_type_ == OPERATION_MOVE)) { impl = std::make_unique( operation_runner(), operation_type_, src_url, dest_url, option_, - base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress, - weak_factory_.GetWeakPtr(), src_url)); + base::BindRepeating(&CopyOrMoveOperationDelegate::OnCopyFileProgress, + weak_factory_.GetWeakPtr(), src_url)); } else { // Cross filesystem case. base::File::Error error = base::File::FILE_ERROR_FAILED; @@ -841,8 +840,9 @@ void CopyOrMoveOperationDelegate::ProcessFile(const FileSystemURL& src_url, impl = std::make_unique( operation_runner(), file_system_context(), operation_type_, src_url, dest_url, option_, std::move(reader), std::move(writer), - base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress, - weak_factory_.GetWeakPtr(), src_url)); + base::BindRepeating( + &CopyOrMoveOperationDelegate::OnCopyFileProgress, + weak_factory_.GetWeakPtr(), src_url)); } } @@ -850,8 +850,8 @@ void CopyOrMoveOperationDelegate::ProcessFile(const FileSystemURL& src_url, impl = std::make_unique( operation_runner(), operation_type_, src_url, dest_url, option_, validator_factory, - base::Bind(&CopyOrMoveOperationDelegate::OnCopyFileProgress, - weak_factory_.GetWeakPtr(), src_url)); + base::BindRepeating(&CopyOrMoveOperationDelegate::OnCopyFileProgress, + weak_factory_.GetWeakPtr(), src_url)); } } diff --git a/storage/browser/fileapi/copy_or_move_operation_delegate.h b/storage/browser/fileapi/copy_or_move_operation_delegate.h index 529ce4b387df9d..a256bc98efaf17 100644 --- a/storage/browser/fileapi/copy_or_move_operation_delegate.h +++ b/storage/browser/fileapi/copy_or_move_operation_delegate.h @@ -52,8 +52,7 @@ class CopyOrMoveOperationDelegate std::unique_ptr writer, FlushPolicy flush_policy, int buffer_size, - const FileSystemOperation::CopyFileProgressCallback& - file_progress_callback, + FileSystemOperation::CopyFileProgressCallback file_progress_callback, const base::TimeDelta& min_progress_callback_invocation_span); ~StreamCopyHelper(); diff --git a/storage/browser/fileapi/copy_or_move_operation_delegate_unittest.cc b/storage/browser/fileapi/copy_or_move_operation_delegate_unittest.cc index 7b43d21b763124..f5b4ebe0d327ac 100644 --- a/storage/browser/fileapi/copy_or_move_operation_delegate_unittest.cc +++ b/storage/browser/fileapi/copy_or_move_operation_delegate_unittest.cc @@ -674,10 +674,11 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, ProgressCallback) { kRegularFileSystemTestCaseSize)); std::vector records; - ASSERT_EQ(base::File::FILE_OK, - helper.CopyWithProgress(src, dest, - base::Bind(&RecordProgressCallback, - base::Unretained(&records)))); + ASSERT_EQ( + base::File::FILE_OK, + helper.CopyWithProgress(src, dest, + base::BindRepeating(&RecordProgressCallback, + base::Unretained(&records)))); // Verify progress callback. for (size_t i = 0; i < kRegularFileSystemTestCaseSize; ++i) { @@ -758,12 +759,13 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper) { std::move(reader), std::move(writer), storage::FlushPolicy::NO_FLUSH_ON_COMPLETION, 10, // buffer size - base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)), + base::BindRepeating(&RecordFileProgressCallback, + base::Unretained(&progress)), base::TimeDelta()); // For testing, we need all the progress. base::File::Error error = base::File::FILE_ERROR_FAILED; base::RunLoop run_loop; - helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error)); + helper.Run(base::BindOnce(&AssignAndQuit, &run_loop, &error)); run_loop.Run(); EXPECT_EQ(base::File::FILE_OK, error); @@ -814,12 +816,13 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelperWithFlush) { std::move(reader), std::move(writer), storage::FlushPolicy::NO_FLUSH_ON_COMPLETION, 10, // buffer size - base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)), + base::BindRepeating(&RecordFileProgressCallback, + base::Unretained(&progress)), base::TimeDelta()); // For testing, we need all the progress. base::File::Error error = base::File::FILE_ERROR_FAILED; base::RunLoop run_loop; - helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error)); + helper.Run(base::BindOnce(&AssignAndQuit, &run_loop, &error)); run_loop.Run(); EXPECT_EQ(base::File::FILE_OK, error); @@ -865,7 +868,8 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper_Cancel) { std::move(reader), std::move(writer), storage::FlushPolicy::NO_FLUSH_ON_COMPLETION, 10, // buffer size - base::Bind(&RecordFileProgressCallback, base::Unretained(&progress)), + base::BindRepeating(&RecordFileProgressCallback, + base::Unretained(&progress)), base::TimeDelta()); // For testing, we need all the progress. // Call Cancel() later. @@ -876,7 +880,7 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper_Cancel) { base::File::Error error = base::File::FILE_ERROR_FAILED; base::RunLoop run_loop; - helper.Run(base::Bind(&AssignAndQuit, &run_loop, &error)); + helper.Run(base::BindOnce(&AssignAndQuit, &run_loop, &error)); run_loop.Run(); EXPECT_EQ(base::File::FILE_ERROR_ABORT, error); diff --git a/storage/browser/fileapi/file_system_backend.h b/storage/browser/fileapi/file_system_backend.h index 31afaaffa5ffb3..79825434360b55 100644 --- a/storage/browser/fileapi/file_system_backend.h +++ b/storage/browser/fileapi/file_system_backend.h @@ -55,7 +55,7 @@ class STORAGE_EXPORT FileSystemBackend { base::OnceCallback; - virtual ~FileSystemBackend() {} + virtual ~FileSystemBackend() = default; // Returns true if this filesystem backend can handle |type|. // One filesystem backend may be able to handle multiple filesystem types. diff --git a/storage/browser/fileapi/file_system_context.cc b/storage/browser/fileapi/file_system_context.cc index e670bacf4b27a9..35595d42b6b4ec 100644 --- a/storage/browser/fileapi/file_system_context.cc +++ b/storage/browser/fileapi/file_system_context.cc @@ -633,8 +633,8 @@ void FileSystemContext::DidOpenFileSystemForResolveURL( FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | FileSystemOperation::GET_METADATA_FIELD_SIZE | FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED, - base::Bind(&DidGetMetadataForResolveURL, path, base::Passed(&callback), - info)); + base::BindOnce(&DidGetMetadataForResolveURL, path, std::move(callback), + info)); } } // namespace storage diff --git a/storage/browser/fileapi/file_system_dir_url_request_job.cc b/storage/browser/fileapi/file_system_dir_url_request_job.cc index 7ac3cbcd56355e..7acfdaa756e318 100644 --- a/storage/browser/fileapi/file_system_dir_url_request_job.cc +++ b/storage/browser/fileapi/file_system_dir_url_request_job.cc @@ -159,10 +159,11 @@ void FileSystemDirURLRequestJob::GetMetadata(size_t index) { url_.path().Append(base::FilePath(entry.name))); DCHECK(url.is_valid()); file_system_context_->operation_runner()->GetMetadata( - url, FileSystemOperation::GET_METADATA_FIELD_SIZE | - FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED, - base::Bind(&FileSystemDirURLRequestJob::DidGetMetadata, - weak_factory_.GetWeakPtr(), index)); + url, + FileSystemOperation::GET_METADATA_FIELD_SIZE | + FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED, + base::BindOnce(&FileSystemDirURLRequestJob::DidGetMetadata, + weak_factory_.GetWeakPtr(), index)); } void FileSystemDirURLRequestJob::DidGetMetadata( diff --git a/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc b/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc index c7dac7e19089ca..73ea68271168f8 100644 --- a/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc +++ b/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc @@ -155,11 +155,11 @@ class FileSystemDirURLRequestJobTest : public testing::Test { std::vector> additional_providers; - additional_providers.push_back(std::make_unique( + additional_providers.emplace_back(std::make_unique( base::ThreadTaskRunnerHandle::Get().get(), *mnt_point)); std::vector handlers; - handlers.push_back(base::Bind(&TestAutoMountForURLRequest)); + handlers.emplace_back(base::BindRepeating(&TestAutoMountForURLRequest)); file_system_context_ = CreateFileSystemContextWithAutoMountersForTesting( nullptr, std::move(additional_providers), handlers, diff --git a/storage/browser/fileapi/file_system_file_stream_reader_unittest.cc b/storage/browser/fileapi/file_system_file_stream_reader_unittest.cc index 0f9584a1401914..e1f4e924484f9b 100644 --- a/storage/browser/fileapi/file_system_file_stream_reader_unittest.cc +++ b/storage/browser/fileapi/file_system_file_stream_reader_unittest.cc @@ -263,7 +263,7 @@ TEST_F(FileSystemFileStreamReaderTest, DeleteWithUnfinishedRead) { net::TestCompletionCallback callback; scoped_refptr buf = base::MakeRefCounted(kTestDataSize); - int rv = reader->Read(buf.get(), buf->size(), base::Bind(&NeverCalled)); + int rv = reader->Read(buf.get(), buf->size(), base::BindOnce(&NeverCalled)); ASSERT_TRUE(rv == net::ERR_IO_PENDING || rv >= 0); // Delete immediately. diff --git a/storage/browser/fileapi/file_system_file_util.h b/storage/browser/fileapi/file_system_file_util.h index bd0d0a9c0cb9cd..af6bef634088d7 100644 --- a/storage/browser/fileapi/file_system_file_util.h +++ b/storage/browser/fileapi/file_system_file_util.h @@ -37,7 +37,7 @@ class STORAGE_EXPORT FileSystemFileUtil { // It will be implemented by each subclass such as FileSystemFileEnumerator. class STORAGE_EXPORT AbstractFileEnumerator { public: - virtual ~AbstractFileEnumerator() {} + virtual ~AbstractFileEnumerator() = default; // Returns an empty string if there are no more results. virtual base::FilePath Next() = 0; @@ -59,7 +59,7 @@ class STORAGE_EXPORT FileSystemFileUtil { bool IsDirectory() override; }; - virtual ~FileSystemFileUtil() {} + virtual ~FileSystemFileUtil() = default; // Creates or opens a file with the given flags. // See header comments for AsyncFileUtil::CreateOrOpen() for more details. diff --git a/storage/browser/fileapi/file_system_operation_impl.cc b/storage/browser/fileapi/file_system_operation_impl.cc index cde61558fed1f0..b9a92bece62ee9 100644 --- a/storage/browser/fileapi/file_system_operation_impl.cc +++ b/storage/browser/fileapi/file_system_operation_impl.cc @@ -202,8 +202,8 @@ void FileSystemOperationImpl::WriteBlob( file_writer_delegate_ = std::move(writer_delegate); file_writer_delegate_->Start( std::move(blob_reader), - base::Bind(&FileSystemOperationImpl::DidWrite, weak_factory_.GetWeakPtr(), - url, callback)); + base::BindRepeating(&FileSystemOperationImpl::DidWrite, + weak_factory_.GetWeakPtr(), url, callback)); } void FileSystemOperationImpl::Write( diff --git a/storage/browser/fileapi/file_system_operation_impl_unittest.cc b/storage/browser/fileapi/file_system_operation_impl_unittest.cc index 8636aa75c2a682..ca9490086a16ea 100644 --- a/storage/browser/fileapi/file_system_operation_impl_unittest.cc +++ b/storage/browser/fileapi/file_system_operation_impl_unittest.cc @@ -177,10 +177,8 @@ class FileSystemOperationImplTest FileSystemOperation::StatusCallback RecordStatusCallback( const base::Closure& closure, base::File::Error* status) { - return base::Bind(&FileSystemOperationImplTest::DidFinish, - weak_factory_.GetWeakPtr(), - closure, - status); + return base::BindOnce(&FileSystemOperationImplTest::DidFinish, + weak_factory_.GetWeakPtr(), closure, status); } FileSystemOperation::ReadDirectoryCallback RecordReadDirectoryCallback( @@ -194,10 +192,8 @@ class FileSystemOperationImplTest FileSystemOperation::GetMetadataCallback RecordMetadataCallback( const base::Closure& closure, base::File::Error* status) { - return base::Bind(&FileSystemOperationImplTest::DidGetMetadata, - weak_factory_.GetWeakPtr(), - closure, - status); + return base::BindOnce(&FileSystemOperationImplTest::DidGetMetadata, + weak_factory_.GetWeakPtr(), closure, status); } FileSystemOperation::SnapshotFileCallback RecordSnapshotFileCallback( diff --git a/storage/browser/fileapi/file_system_operation_impl_write_unittest.cc b/storage/browser/fileapi/file_system_operation_impl_write_unittest.cc index 59ac2a95abf2d3..34c52ec31aa493 100644 --- a/storage/browser/fileapi/file_system_operation_impl_write_unittest.cc +++ b/storage/browser/fileapi/file_system_operation_impl_write_unittest.cc @@ -82,7 +82,7 @@ class FileSystemOperationImplWriteTest : public testing::Test { file_system_context_->operation_runner()->CreateFile( URLForPath(virtual_path_), true /* exclusive */, - base::Bind(&AssertStatusEq, base::File::FILE_OK)); + base::BindOnce(&AssertStatusEq, base::File::FILE_OK)); static_cast( file_system_context_->GetFileSystemBackend(kFileSystemType)) @@ -121,13 +121,13 @@ class FileSystemOperationImplWriteTest : public testing::Test { // Callback function for recording test results. FileSystemOperation::WriteCallback RecordWriteCallback() { - return base::Bind(&FileSystemOperationImplWriteTest::DidWrite, - weak_factory_.GetWeakPtr()); + return base::BindRepeating(&FileSystemOperationImplWriteTest::DidWrite, + weak_factory_.GetWeakPtr()); } FileSystemOperation::StatusCallback RecordCancelCallback() { - return base::Bind(&FileSystemOperationImplWriteTest::DidCancel, - weak_factory_.GetWeakPtr()); + return base::BindOnce(&FileSystemOperationImplWriteTest::DidCancel, + weak_factory_.GetWeakPtr()); } void DidWrite(base::File::Error status, int64_t bytes, bool complete) { @@ -237,7 +237,7 @@ TEST_F(FileSystemOperationImplWriteTest, TestWriteDir) { base::FilePath virtual_dir_path(FILE_PATH_LITERAL("d")); file_system_context_->operation_runner()->CreateDirectory( URLForPath(virtual_dir_path), true /* exclusive */, false /* recursive */, - base::Bind(&AssertStatusEq, base::File::FILE_OK)); + base::BindOnce(&AssertStatusEq, base::File::FILE_OK)); ScopedTextBlob blob(url_request_context(), "blob:writedir", "It\'ll not be written, too."); diff --git a/storage/browser/fileapi/file_system_operation_runner.cc b/storage/browser/fileapi/file_system_operation_runner.cc index 9b40c853ba77ae..804dc9105eec59 100644 --- a/storage/browser/fileapi/file_system_operation_runner.cc +++ b/storage/browser/fileapi/file_system_operation_runner.cc @@ -103,8 +103,8 @@ OperationID FileSystemOperationRunner::Copy( src_url, dest_url, option, error_behavior, progress_callback.is_null() ? CopyProgressCallback() - : base::Bind(&FileSystemOperationRunner::OnCopyProgress, weak_ptr_, - id, progress_callback), + : base::BindRepeating(&FileSystemOperationRunner::OnCopyProgress, + weak_ptr_, id, progress_callback), base::BindOnce(&FileSystemOperationRunner::DidFinish, weak_ptr_, id, std::move(callback))); return id; diff --git a/storage/browser/fileapi/file_system_url_request_job.cc b/storage/browser/fileapi/file_system_url_request_job.cc index 152d67f43e2d60..b5f148198b4e87 100644 --- a/storage/browser/fileapi/file_system_url_request_job.cc +++ b/storage/browser/fileapi/file_system_url_request_job.cc @@ -96,8 +96,8 @@ int FileSystemURLRequestJob::ReadRawData(net::IOBuffer* dest, int dest_size) { return 0; const int rv = reader_->Read(dest, dest_size, - base::Bind(&FileSystemURLRequestJob::DidRead, - weak_factory_.GetWeakPtr())); + base::BindOnce(&FileSystemURLRequestJob::DidRead, + weak_factory_.GetWeakPtr())); if (rv >= 0) { remaining_bytes_ -= rv; DCHECK_GE(remaining_bytes_, 0); @@ -162,10 +162,11 @@ void FileSystemURLRequestJob::StartAsync() { return; } file_system_context_->operation_runner()->GetMetadata( - url_, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | - FileSystemOperation::GET_METADATA_FIELD_SIZE, - base::Bind(&FileSystemURLRequestJob::DidGetMetadata, - weak_factory_.GetWeakPtr())); + url_, + FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | + FileSystemOperation::GET_METADATA_FIELD_SIZE, + base::BindOnce(&FileSystemURLRequestJob::DidGetMetadata, + weak_factory_.GetWeakPtr())); } void FileSystemURLRequestJob::DidAttemptAutoMount(base::File::Error result) { diff --git a/storage/browser/fileapi/file_system_usage_cache.cc b/storage/browser/fileapi/file_system_usage_cache.cc index 8d02a1045e24ab..d089d6416fff10 100644 --- a/storage/browser/fileapi/file_system_usage_cache.cc +++ b/storage/browser/fileapi/file_system_usage_cache.cc @@ -282,8 +282,8 @@ void FileSystemUsageCache::ScheduleCloseTimer() { } timer_.Start(FROM_HERE, kCloseDelay, - base::Bind(&FileSystemUsageCache::CloseCacheFiles, - weak_factory_.GetWeakPtr())); + base::BindOnce(&FileSystemUsageCache::CloseCacheFiles, + weak_factory_.GetWeakPtr())); } bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) { diff --git a/storage/browser/fileapi/file_writer_delegate.cc b/storage/browser/fileapi/file_writer_delegate.cc index 1813bc2802aae7..084d406f2d7404 100644 --- a/storage/browser/fileapi/file_writer_delegate.cc +++ b/storage/browser/fileapi/file_writer_delegate.cc @@ -42,8 +42,8 @@ FileWriterDelegate::FileWriterDelegate( FileWriterDelegate::~FileWriterDelegate() = default; void FileWriterDelegate::Start(std::unique_ptr blob_reader, - const DelegateWriteCallback& write_callback) { - write_callback_ = write_callback; + DelegateWriteCallback write_callback) { + write_callback_ = std::move(write_callback); if (!blob_reader) { OnReadError(base::File::FILE_ERROR_FAILED); @@ -68,8 +68,8 @@ void FileWriterDelegate::Start(std::unique_ptr blob_reader, } void FileWriterDelegate::Start(mojo::ScopedDataPipeConsumerHandle data_pipe, - const DelegateWriteCallback& write_callback) { - write_callback_ = write_callback; + DelegateWriteCallback write_callback) { + write_callback_ = std::move(write_callback); if (!data_pipe) { OnReadError(base::File::FILE_ERROR_FAILED); @@ -93,9 +93,8 @@ void FileWriterDelegate::Cancel() { data_pipe_.reset(); weak_factory_.InvalidateWeakPtrs(); - const int status = file_stream_writer_->Cancel( - base::Bind(&FileWriterDelegate::OnWriteCancelled, - weak_factory_.GetWeakPtr())); + const int status = file_stream_writer_->Cancel(base::BindOnce( + &FileWriterDelegate::OnWriteCancelled, weak_factory_.GetWeakPtr())); // Return true to finish immediately if we have no pending writes. // Otherwise we'll do the final cleanup in the Cancel callback. if (status != net::ERR_IO_PENDING) { @@ -188,11 +187,10 @@ void FileWriterDelegate::OnDataReceived(int bytes_read) { void FileWriterDelegate::Write() { writing_started_ = true; int64_t bytes_to_write = bytes_read_ - bytes_written_; - int write_response = - file_stream_writer_->Write(cursor_.get(), - static_cast(bytes_to_write), - base::Bind(&FileWriterDelegate::OnDataWritten, - weak_factory_.GetWeakPtr())); + int write_response = file_stream_writer_->Write( + cursor_.get(), static_cast(bytes_to_write), + base::BindOnce(&FileWriterDelegate::OnDataWritten, + weak_factory_.GetWeakPtr())); if (write_response > 0) { base::ThreadTaskRunnerHandle::Get()->PostTask( FROM_HERE, base::BindOnce(&FileWriterDelegate::OnDataWritten, @@ -302,8 +300,8 @@ void FileWriterDelegate::MaybeFlushForCompletion( DCHECK(flush_policy_ == FlushPolicy::FLUSH_ON_COMPLETION); int flush_error = file_stream_writer_->Flush( - base::Bind(&FileWriterDelegate::OnFlushed, weak_factory_.GetWeakPtr(), - error, bytes_written, progress_status)); + base::BindOnce(&FileWriterDelegate::OnFlushed, weak_factory_.GetWeakPtr(), + error, bytes_written, progress_status)); if (flush_error != net::ERR_IO_PENDING) OnFlushed(error, bytes_written, progress_status, flush_error); } diff --git a/storage/browser/fileapi/file_writer_delegate.h b/storage/browser/fileapi/file_writer_delegate.h index 0782fb9efadfbf..77dc1e9d20c6c4 100644 --- a/storage/browser/fileapi/file_writer_delegate.h +++ b/storage/browser/fileapi/file_writer_delegate.h @@ -36,18 +36,18 @@ class STORAGE_EXPORT FileWriterDelegate { }; using DelegateWriteCallback = - base::Callback; + base::RepeatingCallback; FileWriterDelegate(std::unique_ptr file_writer, FlushPolicy flush_policy); virtual ~FileWriterDelegate(); void Start(std::unique_ptr blob_reader, - const DelegateWriteCallback& write_callback); + DelegateWriteCallback write_callback); void Start(mojo::ScopedDataPipeConsumerHandle data_pipe, - const DelegateWriteCallback& write_callback); + DelegateWriteCallback write_callback); // Cancels the current write operation. This will synchronously or // asynchronously call the given write callback (which may result in diff --git a/storage/browser/fileapi/local_file_stream_reader_unittest.cc b/storage/browser/fileapi/local_file_stream_reader_unittest.cc index ecacaa7bdd4b64..35d6aa09d3340e 100644 --- a/storage/browser/fileapi/local_file_stream_reader_unittest.cc +++ b/storage/browser/fileapi/local_file_stream_reader_unittest.cc @@ -271,7 +271,7 @@ TEST_F(LocalFileStreamReaderTest, DeleteWithUnfinishedRead) { net::TestCompletionCallback callback; scoped_refptr buf = base::MakeRefCounted(kTestDataSize); - int rv = reader->Read(buf.get(), buf->size(), base::Bind(&NeverCalled)); + int rv = reader->Read(buf.get(), buf->size(), base::BindOnce(&NeverCalled)); ASSERT_TRUE(rv == net::ERR_IO_PENDING || rv >= 0); // Delete immediately. diff --git a/storage/browser/fileapi/local_file_stream_writer_unittest.cc b/storage/browser/fileapi/local_file_stream_writer_unittest.cc index bc9c50f6672612..6147365ce4ac38 100644 --- a/storage/browser/fileapi/local_file_stream_writer_unittest.cc +++ b/storage/browser/fileapi/local_file_stream_writer_unittest.cc @@ -146,7 +146,7 @@ TEST_F(LocalFileStreamWriterTest, CancelBeforeOperation) { base::FilePath path = Path("file_a"); std::unique_ptr writer(CreateWriter(path, 0)); // Cancel immediately fails when there's no in-flight operation. - int cancel_result = writer->Cancel(base::Bind(&NeverCalled)); + int cancel_result = writer->Cancel(base::BindOnce(&NeverCalled)); EXPECT_EQ(net::ERR_UNEXPECTED, cancel_result); } @@ -156,7 +156,7 @@ TEST_F(LocalFileStreamWriterTest, CancelAfterFinishedOperation) { EXPECT_EQ(net::OK, WriteStringToWriter(writer.get(), "foo")); // Cancel immediately fails when there's no in-flight operation. - int cancel_result = writer->Cancel(base::Bind(&NeverCalled)); + int cancel_result = writer->Cancel(base::BindOnce(&NeverCalled)); EXPECT_EQ(net::ERR_UNEXPECTED, cancel_result); writer.reset(); @@ -173,7 +173,7 @@ TEST_F(LocalFileStreamWriterTest, CancelWrite) { scoped_refptr buffer( base::MakeRefCounted("xxx")); int result = - writer->Write(buffer.get(), buffer->size(), base::Bind(&NeverCalled)); + writer->Write(buffer.get(), buffer->size(), base::BindOnce(&NeverCalled)); ASSERT_EQ(net::ERR_IO_PENDING, result); net::TestCompletionCallback callback; diff --git a/storage/browser/fileapi/obfuscated_file_util.cc b/storage/browser/fileapi/obfuscated_file_util.cc index 49f5f3cb844f53..36af9ac0131e9a 100644 --- a/storage/browser/fileapi/obfuscated_file_util.cc +++ b/storage/browser/fileapi/obfuscated_file_util.cc @@ -253,16 +253,17 @@ ObfuscatedFileUtil::ObfuscatedFileUtil( storage::SpecialStoragePolicy* special_storage_policy, const base::FilePath& file_system_directory, leveldb::Env* env_override, - const GetTypeStringForURLCallback& get_type_string_for_url, + GetTypeStringForURLCallback get_type_string_for_url, const std::set& known_type_strings, SandboxFileSystemBackendDelegate* sandbox_delegate) : special_storage_policy_(special_storage_policy), file_system_directory_(file_system_directory), env_override_(env_override), db_flush_delay_seconds_(10 * 60), // 10 mins. - get_type_string_for_url_(get_type_string_for_url), + get_type_string_for_url_(std::move(get_type_string_for_url)), known_type_strings_(known_type_strings), sandbox_delegate_(sandbox_delegate) { + DCHECK(!get_type_string_for_url_.is_null()); DETACH_FROM_SEQUENCE(sequence_checker_); } @@ -1286,9 +1287,10 @@ void ObfuscatedFileUtil::MarkUsed() { if (timer_.IsRunning()) { timer_.Reset(); } else { - timer_.Start( - FROM_HERE, base::TimeDelta::FromSeconds(db_flush_delay_seconds_), - base::Bind(&ObfuscatedFileUtil::DropDatabases, base::Unretained(this))); + timer_.Start(FROM_HERE, + base::TimeDelta::FromSeconds(db_flush_delay_seconds_), + base::BindOnce(&ObfuscatedFileUtil::DropDatabases, + base::Unretained(this))); } } diff --git a/storage/browser/fileapi/obfuscated_file_util.h b/storage/browser/fileapi/obfuscated_file_util.h index ce12c819f14b3b..f68671e8783116 100644 --- a/storage/browser/fileapi/obfuscated_file_util.h +++ b/storage/browser/fileapi/obfuscated_file_util.h @@ -83,7 +83,7 @@ class STORAGE_EXPORT ObfuscatedFileUtil : public FileSystemFileUtil { }; using GetTypeStringForURLCallback = - base::Callback; + base::RepeatingCallback; // |get_type_string_for_url| is user-defined callback that should return // a type string for the given FileSystemURL. The type string is used @@ -99,7 +99,7 @@ class STORAGE_EXPORT ObfuscatedFileUtil : public FileSystemFileUtil { ObfuscatedFileUtil(storage::SpecialStoragePolicy* special_storage_policy, const base::FilePath& file_system_directory, leveldb::Env* env_override, - const GetTypeStringForURLCallback& get_type_string_for_url, + GetTypeStringForURLCallback get_type_string_for_url, const std::set& known_type_strings, SandboxFileSystemBackendDelegate* sandbox_delegate); ~ObfuscatedFileUtil() override; diff --git a/storage/browser/fileapi/plugin_private_file_system_backend.cc b/storage/browser/fileapi/plugin_private_file_system_backend.cc index dbb95864130af1..8ac9d009bd3d7d 100644 --- a/storage/browser/fileapi/plugin_private_file_system_backend.cc +++ b/storage/browser/fileapi/plugin_private_file_system_backend.cc @@ -102,11 +102,11 @@ PluginPrivateFileSystemBackend::PluginPrivateFileSystemBackend( .Append(kPluginPrivateDirectory)), plugin_map_(new FileSystemIDToPluginMap(file_task_runner)), weak_factory_(this) { - file_util_.reset(new AsyncFileUtilAdapter(new ObfuscatedFileUtil( + file_util_ = std::make_unique(new ObfuscatedFileUtil( special_storage_policy, base_path_, env_override, - base::Bind(&FileSystemIDToPluginMap::GetPluginIDForURL, - base::Owned(plugin_map_)), - std::set(), nullptr))); + base::BindRepeating(&FileSystemIDToPluginMap::GetPluginIDForURL, + base::Owned(plugin_map_)), + std::set(), nullptr)); } PluginPrivateFileSystemBackend::~PluginPrivateFileSystemBackend() { diff --git a/storage/browser/fileapi/quota/quota_backend_impl.cc b/storage/browser/fileapi/quota/quota_backend_impl.cc index 19236d1d1ea872..a15dc773bdd72f 100644 --- a/storage/browser/fileapi/quota/quota_backend_impl.cc +++ b/storage/browser/fileapi/quota/quota_backend_impl.cc @@ -38,11 +38,11 @@ QuotaBackendImpl::~QuotaBackendImpl() = default; void QuotaBackendImpl::ReserveQuota(const url::Origin& origin, FileSystemType type, int64_t delta, - const ReserveQuotaCallback& callback) { + ReserveQuotaCallback callback) { DCHECK(file_task_runner_->RunsTasksInCurrentSequence()); DCHECK(!origin.opaque()); if (!delta) { - callback.Run(base::File::FILE_OK, 0); + std::move(callback).Run(base::File::FILE_OK, 0); return; } DCHECK(quota_manager_proxy_.get()); @@ -50,7 +50,8 @@ void QuotaBackendImpl::ReserveQuota(const url::Origin& origin, file_task_runner_.get(), origin, FileSystemTypeToQuotaStorageType(type), base::BindOnce(&QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota, weak_ptr_factory_.GetWeakPtr(), - QuotaReservationInfo(origin, type, delta), callback)); + QuotaReservationInfo(origin, type, delta), + std::move(callback))); } void QuotaBackendImpl::ReleaseReservedQuota(const url::Origin& origin, @@ -103,7 +104,7 @@ void QuotaBackendImpl::DecrementDirtyCount(const url::Origin& origin, void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota( const QuotaReservationInfo& info, - const ReserveQuotaCallback& callback, + ReserveQuotaCallback callback, blink::mojom::QuotaStatusCode status, int64_t usage, int64_t quota) { @@ -112,7 +113,7 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota( DCHECK_LE(0, usage); DCHECK_LE(0, quota); if (status != blink::mojom::QuotaStatusCode::kOk) { - callback.Run(base::File::FILE_ERROR_FAILED, 0); + std::move(callback).Run(base::File::FILE_ERROR_FAILED, 0); return; } @@ -127,7 +128,7 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota( } ReserveQuotaInternal(normalized_info); - if (callback.Run(base::File::FILE_OK, normalized_info.delta)) + if (std::move(callback).Run(base::File::FILE_OK, normalized_info.delta)) return; // The requester could not accept the reserved quota. Revert it. ReserveQuotaInternal( diff --git a/storage/browser/fileapi/quota/quota_backend_impl.h b/storage/browser/fileapi/quota/quota_backend_impl.h index 347522b1768c4d..2a8e915dcc46e8 100644 --- a/storage/browser/fileapi/quota/quota_backend_impl.h +++ b/storage/browser/fileapi/quota/quota_backend_impl.h @@ -46,7 +46,7 @@ class STORAGE_EXPORT QuotaBackendImpl void ReserveQuota(const url::Origin& origin, FileSystemType type, int64_t delta, - const ReserveQuotaCallback& callback) override; + ReserveQuotaCallback callback) override; void ReleaseReservedQuota(const url::Origin& origin, FileSystemType type, int64_t size) override; @@ -73,7 +73,7 @@ class STORAGE_EXPORT QuotaBackendImpl }; void DidGetUsageAndQuotaForReserveQuota(const QuotaReservationInfo& info, - const ReserveQuotaCallback& callback, + ReserveQuotaCallback callback, blink::mojom::QuotaStatusCode status, int64_t usage, int64_t quota); diff --git a/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc b/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc index 9367fe87fa3d68..d04b7ca80e0d7b 100644 --- a/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc +++ b/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc @@ -102,9 +102,9 @@ class QuotaBackendImplTest : public testing::Test { in_memory_env_ = leveldb_chrome::NewMemEnv("quota"); file_util_.reset(ObfuscatedFileUtil::CreateForTesting( nullptr, data_dir_.GetPath(), in_memory_env_.get())); - backend_.reset(new QuotaBackendImpl(file_task_runner(), file_util_.get(), - &file_system_usage_cache_, - quota_manager_proxy_.get())); + backend_ = std::make_unique( + file_task_runner(), file_util_.get(), &file_system_usage_cache_, + quota_manager_proxy_.get()); } void TearDown() override { @@ -166,16 +166,18 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) { const int64_t kDelta1 = 1000; base::File::Error error = base::File::FILE_ERROR_FAILED; - backend_->ReserveQuota(kOrigin, type, kDelta1, - base::Bind(&DidReserveQuota, true, &error, &delta)); + backend_->ReserveQuota( + kOrigin, type, kDelta1, + base::BindOnce(&DidReserveQuota, true, &error, &delta)); EXPECT_EQ(base::File::FILE_OK, error); EXPECT_EQ(kDelta1, delta); EXPECT_EQ(kDelta1, quota_manager_proxy_->usage()); const int64_t kDelta2 = -300; error = base::File::FILE_ERROR_FAILED; - backend_->ReserveQuota(kOrigin, type, kDelta2, - base::Bind(&DidReserveQuota, true, &error, &delta)); + backend_->ReserveQuota( + kOrigin, type, kDelta2, + base::BindOnce(&DidReserveQuota, true, &error, &delta)); EXPECT_EQ(base::File::FILE_OK, error); EXPECT_EQ(kDelta2, delta); EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage()); @@ -192,8 +194,9 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) { const int64_t kDelta = 1000; base::File::Error error = base::File::FILE_ERROR_FAILED; - backend_->ReserveQuota(kOrigin, type, kDelta, - base::Bind(&DidReserveQuota, true, &error, &delta)); + backend_->ReserveQuota( + kOrigin, type, kDelta, + base::BindOnce(&DidReserveQuota, true, &error, &delta)); EXPECT_EQ(base::File::FILE_OK, error); EXPECT_EQ(100, delta); EXPECT_EQ(100, quota_manager_proxy_->usage()); @@ -210,8 +213,9 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) { const int64_t kDelta = 1000; base::File::Error error = base::File::FILE_ERROR_FAILED; - backend_->ReserveQuota(kOrigin, type, kDelta, - base::Bind(&DidReserveQuota, false, &error, &delta)); + backend_->ReserveQuota( + kOrigin, type, kDelta, + base::BindOnce(&DidReserveQuota, false, &error, &delta)); EXPECT_EQ(base::File::FILE_OK, error); EXPECT_EQ(kDelta, delta); EXPECT_EQ(0, quota_manager_proxy_->usage()); diff --git a/storage/browser/fileapi/quota/quota_reservation.cc b/storage/browser/fileapi/quota/quota_reservation.cc index ac3ca9f777ff75..56dfa60a5a4049 100644 --- a/storage/browser/fileapi/quota/quota_reservation.cc +++ b/storage/browser/fileapi/quota/quota_reservation.cc @@ -16,7 +16,7 @@ namespace storage { void QuotaReservation::RefreshReservation(int64_t size, - const StatusCallback& callback) { + StatusCallback callback) { DCHECK(sequence_checker_.CalledOnValidSequence()); DCHECK(!running_refresh_request_); DCHECK(!client_crashed_); @@ -27,9 +27,9 @@ void QuotaReservation::RefreshReservation(int64_t size, reservation_manager()->ReserveQuota( origin(), type(), size - remaining_quota_, - base::Bind(&QuotaReservation::AdaptDidUpdateReservedQuota, - weak_ptr_factory_.GetWeakPtr(), - remaining_quota_, callback)); + base::BindOnce(&QuotaReservation::AdaptDidUpdateReservedQuota, + weak_ptr_factory_.GetWeakPtr(), remaining_quota_, + std::move(callback))); if (running_refresh_request_) remaining_quota_ = 0; @@ -98,18 +98,18 @@ QuotaReservation::~QuotaReservation() { bool QuotaReservation::AdaptDidUpdateReservedQuota( const base::WeakPtr& reservation, int64_t previous_size, - const StatusCallback& callback, + StatusCallback callback, base::File::Error error, int64_t delta) { if (!reservation) return false; - return reservation->DidUpdateReservedQuota( - previous_size, callback, error, delta); + return reservation->DidUpdateReservedQuota(previous_size, std::move(callback), + error, delta); } bool QuotaReservation::DidUpdateReservedQuota(int64_t previous_size, - const StatusCallback& callback, + StatusCallback callback, base::File::Error error, int64_t delta) { DCHECK(sequence_checker_.CalledOnValidSequence()); @@ -117,13 +117,13 @@ bool QuotaReservation::DidUpdateReservedQuota(int64_t previous_size, running_refresh_request_ = false; if (client_crashed_) { - callback.Run(base::File::FILE_ERROR_ABORT); + std::move(callback).Run(base::File::FILE_ERROR_ABORT); return false; } if (error == base::File::FILE_OK) remaining_quota_ = previous_size + delta; - callback.Run(error); + std::move(callback).Run(error); return true; } diff --git a/storage/browser/fileapi/quota/quota_reservation.h b/storage/browser/fileapi/quota/quota_reservation.h index 527caaee7c9e69..9f7fb7bb7b8805 100644 --- a/storage/browser/fileapi/quota/quota_reservation.h +++ b/storage/browser/fileapi/quota/quota_reservation.h @@ -31,14 +31,14 @@ class OpenFileHandle; class STORAGE_EXPORT QuotaReservation : public base::RefCounted { public: - using StatusCallback = base::Callback; + using StatusCallback = base::OnceCallback; // Reclaims unused quota and reserves another |size| of quota. So that the // resulting new |remaining_quota_| will be same as |size| as far as available // space is enough. |remaining_quota_| may be less than |size| if there is // not enough space available. // Invokes |callback| upon completion. - void RefreshReservation(int64_t size, const StatusCallback& callback); + void RefreshReservation(int64_t size, StatusCallback callback); // Associates |platform_path| to the QuotaReservation instance. // Returns an OpenFileHandle instance that represents a quota managed file. @@ -76,11 +76,11 @@ class STORAGE_EXPORT QuotaReservation static bool AdaptDidUpdateReservedQuota( const base::WeakPtr& reservation, int64_t previous_size, - const StatusCallback& callback, + StatusCallback callback, base::File::Error error, int64_t delta); bool DidUpdateReservedQuota(int64_t previous_size, - const StatusCallback& callback, + StatusCallback callback, base::File::Error error, int64_t delta); diff --git a/storage/browser/fileapi/quota/quota_reservation_buffer.cc b/storage/browser/fileapi/quota/quota_reservation_buffer.cc index 802f0548eb258d..697c6141306e6e 100644 --- a/storage/browser/fileapi/quota/quota_reservation_buffer.cc +++ b/storage/browser/fileapi/quota/quota_reservation_buffer.cc @@ -88,8 +88,8 @@ QuotaReservationBuffer::~QuotaReservationBuffer() { if (reserved_quota_ && reservation_manager_) { reservation_manager_->ReserveQuota( origin_, type_, -reserved_quota_, - base::Bind(&QuotaReservationBuffer::DecrementDirtyCount, - reservation_manager_, origin_, type_)); + base::BindOnce(&QuotaReservationBuffer::DecrementDirtyCount, + reservation_manager_, origin_, type_)); } reservation_manager_->ReleaseReservationBuffer(this); } diff --git a/storage/browser/fileapi/quota/quota_reservation_manager.cc b/storage/browser/fileapi/quota/quota_reservation_manager.cc index d8702ca2ffb46b..f948659e87a6a9 100644 --- a/storage/browser/fileapi/quota/quota_reservation_manager.cc +++ b/storage/browser/fileapi/quota/quota_reservation_manager.cc @@ -9,6 +9,7 @@ #include #include +#include "base/callback.h" #include "storage/browser/fileapi/quota/quota_reservation.h" #include "storage/browser/fileapi/quota/quota_reservation_buffer.h" @@ -24,13 +25,12 @@ QuotaReservationManager::~QuotaReservationManager() { DCHECK(sequence_checker_.CalledOnValidSequence()); } -void QuotaReservationManager::ReserveQuota( - const url::Origin& origin, - FileSystemType type, - int64_t size, - const ReserveQuotaCallback& callback) { +void QuotaReservationManager::ReserveQuota(const url::Origin& origin, + FileSystemType type, + int64_t size, + ReserveQuotaCallback callback) { DCHECK(!origin.opaque()); - backend_->ReserveQuota(origin, type, size, callback); + backend_->ReserveQuota(origin, type, size, std::move(callback)); } void QuotaReservationManager::ReleaseReservedQuota(const url::Origin& origin, diff --git a/storage/browser/fileapi/quota/quota_reservation_manager.h b/storage/browser/fileapi/quota/quota_reservation_manager.h index a567e4a9b76672..603ed839d6a5d8 100644 --- a/storage/browser/fileapi/quota/quota_reservation_manager.h +++ b/storage/browser/fileapi/quota/quota_reservation_manager.h @@ -37,13 +37,13 @@ class STORAGE_EXPORT QuotaReservationManager { // Callback for ReserveQuota. When this callback returns false, ReserveQuota // operation should be reverted. using ReserveQuotaCallback = - base::Callback; + base::OnceCallback; // An abstraction of backing quota system. class STORAGE_EXPORT QuotaBackend { public: - QuotaBackend() {} - virtual ~QuotaBackend() {} + QuotaBackend() = default; + virtual ~QuotaBackend() = default; // Reserves or reclaims |delta| of quota for |origin| and |type| pair. // Reserved quota should be counted as usage, but it should be on-memory @@ -54,7 +54,7 @@ class STORAGE_EXPORT QuotaReservationManager { virtual void ReserveQuota(const url::Origin& origin, FileSystemType type, int64_t delta, - const ReserveQuotaCallback& callback) = 0; + ReserveQuotaCallback callback) = 0; // Reclaims |size| of quota for |origin| and |type|. virtual void ReleaseReservedQuota(const url::Origin& origin, @@ -95,7 +95,7 @@ class STORAGE_EXPORT QuotaReservationManager { void ReserveQuota(const url::Origin& origin, FileSystemType type, int64_t delta, - const ReserveQuotaCallback& callback); + ReserveQuotaCallback callback); void ReleaseReservedQuota(const url::Origin& origin, FileSystemType type, diff --git a/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc b/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc index 1e73a3a42a51db..4a5dd3a523e2a4 100644 --- a/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc +++ b/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc @@ -61,12 +61,12 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend { void ReserveQuota(const url::Origin& origin, storage::FileSystemType type, int64_t delta, - const ReserveQuotaCallback& callback) override { + ReserveQuotaCallback callback) override { EXPECT_EQ(kOrigin, origin); EXPECT_EQ(kType, type); on_memory_usage_ += delta; base::ThreadTaskRunnerHandle::Get()->PostTask( - FROM_HERE, base::BindOnce(base::IgnoreResult(callback), + FROM_HERE, base::BindOnce(base::IgnoreResult(std::move(callback)), base::File::FILE_OK, delta)); } @@ -176,7 +176,7 @@ void RefreshReservation(QuotaReservation* reservation, int64_t size) { DCHECK(reservation); bool done = false; - reservation->RefreshReservation(size, base::Bind(&ExpectSuccess, &done)); + reservation->RefreshReservation(size, base::BindOnce(&ExpectSuccess, &done)); base::RunLoop().RunUntilIdle(); EXPECT_TRUE(done); } diff --git a/storage/browser/fileapi/recursive_operation_delegate.cc b/storage/browser/fileapi/recursive_operation_delegate.cc index 1e8d6f9ac85264..9cdc1078844ec3 100644 --- a/storage/browser/fileapi/recursive_operation_delegate.cc +++ b/storage/browser/fileapi/recursive_operation_delegate.cc @@ -44,8 +44,9 @@ void RecursiveOperationDelegate::StartRecursiveOperation( } void RecursiveOperationDelegate::TryProcessFile(const FileSystemURL& root) { - ProcessFile(root, base::Bind(&RecursiveOperationDelegate::DidTryProcessFile, - AsWeakPtr(), root)); + ProcessFile(root, + base::BindOnce(&RecursiveOperationDelegate::DidTryProcessFile, + AsWeakPtr(), root)); } FileSystemOperationRunner* RecursiveOperationDelegate::operation_runner() { @@ -79,9 +80,8 @@ void RecursiveOperationDelegate::ProcessNextDirectory() { const FileSystemURL& url = pending_directory_stack_.top().front(); ProcessDirectory( - url, - base::Bind( - &RecursiveOperationDelegate::DidProcessDirectory, AsWeakPtr())); + url, base::BindOnce(&RecursiveOperationDelegate::DidProcessDirectory, + AsWeakPtr())); } void RecursiveOperationDelegate::DidProcessDirectory( @@ -149,10 +149,11 @@ void RecursiveOperationDelegate::ProcessPendingFiles() { if (!pending_files_.empty()) { current_task_runner->PostTask( FROM_HERE, - base::BindOnce(&RecursiveOperationDelegate::ProcessFile, AsWeakPtr(), - pending_files_.front(), - base::Bind(&RecursiveOperationDelegate::DidProcessFile, - AsWeakPtr(), pending_files_.front()))); + base::BindOnce( + &RecursiveOperationDelegate::ProcessFile, AsWeakPtr(), + pending_files_.front(), + base::BindOnce(&RecursiveOperationDelegate::DidProcessFile, + AsWeakPtr(), pending_files_.front()))); pending_files_.pop(); } } @@ -200,8 +201,8 @@ void RecursiveOperationDelegate::ProcessSubDirectory() { DCHECK(!pending_directory_stack_.top().empty()); PostProcessDirectory( pending_directory_stack_.top().front(), - base::Bind(&RecursiveOperationDelegate::DidPostProcessDirectory, - AsWeakPtr())); + base::BindOnce(&RecursiveOperationDelegate::DidPostProcessDirectory, + AsWeakPtr())); } void RecursiveOperationDelegate::DidPostProcessDirectory( diff --git a/storage/browser/fileapi/recursive_operation_delegate_unittest.cc b/storage/browser/fileapi/recursive_operation_delegate_unittest.cc index 33aeaed0921257..4c0f63e19043bc 100644 --- a/storage/browser/fileapi/recursive_operation_delegate_unittest.cc +++ b/storage/browser/fileapi/recursive_operation_delegate_unittest.cc @@ -204,9 +204,9 @@ TEST_F(RecursiveOperationDelegateTest, RootIsFile) { base::File::Error error = base::File::FILE_ERROR_FAILED; std::unique_ptr context = NewContext(); - std::unique_ptr operation( - new LoggingRecursiveOperation(context->file_system_context(), src_file, - base::Bind(&ReportStatus, &error))); + auto operation = std::make_unique( + context->file_system_context(), src_file, + base::BindOnce(&ReportStatus, &error)); operation->RunRecursively(); base::RunLoop().RunUntilIdle(); ASSERT_EQ(base::File::FILE_OK, error); @@ -228,9 +228,9 @@ TEST_F(RecursiveOperationDelegateTest, RootIsDirectory) { base::File::Error error = base::File::FILE_ERROR_FAILED; std::unique_ptr context = NewContext(); - std::unique_ptr operation( - new LoggingRecursiveOperation(context->file_system_context(), src_root, - base::Bind(&ReportStatus, &error))); + auto operation = std::make_unique( + context->file_system_context(), src_root, + base::BindOnce(&ReportStatus, &error)); operation->RunRecursively(); base::RunLoop().RunUntilIdle(); ASSERT_EQ(base::File::FILE_OK, error); @@ -283,9 +283,9 @@ TEST_F(RecursiveOperationDelegateTest, Cancel) { base::File::Error error = base::File::FILE_ERROR_FAILED; std::unique_ptr context = NewContext(); - std::unique_ptr operation( - new LoggingRecursiveOperation(context->file_system_context(), src_root, - base::Bind(&ReportStatus, &error))); + auto operation = std::make_unique( + context->file_system_context(), src_root, + base::BindOnce(&ReportStatus, &error)); operation->RunRecursively(); // Invoke Cancel(), after 5 times message posting. @@ -303,9 +303,9 @@ TEST_F(RecursiveOperationDelegateTest, AbortWithError) { base::File::Error error = base::File::FILE_ERROR_FAILED; std::unique_ptr context = NewContext(); - std::unique_ptr operation( - new LoggingRecursiveOperation(context->file_system_context(), src_root, - base::Bind(&ReportStatus, &error))); + auto operation = std::make_unique( + context->file_system_context(), src_root, + base::BindOnce(&ReportStatus, &error)); operation->SetEntryToFail(src_file1); operation->RunRecursively(); base::RunLoop().RunUntilIdle(); @@ -339,9 +339,9 @@ TEST_F(RecursiveOperationDelegateTest, ContinueWithError) { base::File::Error error = base::File::FILE_ERROR_FAILED; std::unique_ptr context = NewContext(); - std::unique_ptr operation( - new LoggingRecursiveOperation(context->file_system_context(), src_root, - base::Bind(&ReportStatus, &error))); + auto operation = std::make_unique( + context->file_system_context(), src_root, + base::BindOnce(&ReportStatus, &error)); operation->SetEntryToFail(src_file1); operation->RunRecursivelyWithIgnoringError(); base::RunLoop().RunUntilIdle(); diff --git a/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc b/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc index e2c9ac942e3c90..eb4239d25a8645 100644 --- a/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc +++ b/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc @@ -182,11 +182,11 @@ SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate( leveldb::Env* env_override) : file_task_runner_(file_task_runner), quota_manager_proxy_(quota_manager_proxy), - sandbox_file_util_(new AsyncFileUtilAdapter( + sandbox_file_util_(std::make_unique( new ObfuscatedFileUtil(special_storage_policy, profile_path.Append(kFileSystemDirectory), env_override, - base::Bind(&GetTypeStringForURL), + base::BindRepeating(&GetTypeStringForURL), GetKnownTypeStrings(), this))), file_system_usage_cache_(std::make_unique()), @@ -702,7 +702,8 @@ ObfuscatedFileUtil* ObfuscatedFileUtil::CreateForTesting( const base::FilePath& file_system_directory, leveldb::Env* env_override) { return new ObfuscatedFileUtil(special_storage_policy, file_system_directory, - env_override, base::Bind(&GetTypeStringForURL), + env_override, + base::BindRepeating(&GetTypeStringForURL), GetKnownTypeStrings(), nullptr); } diff --git a/storage/browser/fileapi/sandbox_quota_observer.cc b/storage/browser/fileapi/sandbox_quota_observer.cc index 8e6fb93075c8db..e326267ac6b2db 100644 --- a/storage/browser/fileapi/sandbox_quota_observer.cc +++ b/storage/browser/fileapi/sandbox_quota_observer.cc @@ -54,8 +54,8 @@ void SandboxQuotaObserver::OnUpdate(const FileSystemURL& url, int64_t delta) { delayed_cache_update_helper_.Start( FROM_HERE, base::TimeDelta(), // No delay. - base::Bind(&SandboxQuotaObserver::ApplyPendingUsageUpdate, - base::Unretained(this))); + base::BindOnce(&SandboxQuotaObserver::ApplyPendingUsageUpdate, + base::Unretained(this))); } } diff --git a/storage/browser/test/async_file_test_helper.cc b/storage/browser/test/async_file_test_helper.cc index d28d9a0e3a8ce7..1e31dade73eaac 100644 --- a/storage/browser/test/async_file_test_helper.cc +++ b/storage/browser/test/async_file_test_helper.cc @@ -29,10 +29,10 @@ void AssignAndQuit(base::RunLoop* run_loop, run_loop->Quit(); } -base::Callback AssignAndQuitCallback( +base::OnceCallback AssignAndQuitCallback( base::RunLoop* run_loop, base::File::Error* result) { - return base::Bind(&AssignAndQuit, run_loop, base::Unretained(result)); + return base::BindOnce(&AssignAndQuit, run_loop, base::Unretained(result)); } void GetMetadataCallback(base::RunLoop* run_loop, @@ -221,7 +221,7 @@ base::File::Error AsyncFileTestHelper::GetMetadata( storage::FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY | storage::FileSystemOperation::GET_METADATA_FIELD_SIZE | storage::FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED, - base::Bind(&GetMetadataCallback, &run_loop, &result, file_info)); + base::BindOnce(&GetMetadataCallback, &run_loop, &result, file_info)); run_loop.Run(); return result; } @@ -233,8 +233,8 @@ base::File::Error AsyncFileTestHelper::GetPlatformPath( base::File::Error result = base::File::FILE_ERROR_FAILED; base::RunLoop run_loop; context->operation_runner()->CreateSnapshotFile( - url, base::Bind(&CreateSnapshotFileCallback, &run_loop, &result, - platform_path)); + url, base::BindOnce(&CreateSnapshotFileCallback, &run_loop, &result, + platform_path)); run_loop.Run(); return result; }