Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/sync_file_system

chrome/browser/sync_file_system/local/canned_syncable_file_system.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
@@ skipping 50 matching lines @@
 
 template <typename R>
 R RunOnThread(
     base::SingleThreadTaskRunner* task_runner,
     const tracked_objects::Location& location,
     const base::Callback<void(const base::Callback<void(R)>& callback)>& task) {
   R result;
   base::RunLoop run_loop;
   task_runner->PostTask(
       location,
-      base::Bind(task, base::Bind(&AssignAndQuit<R>,
-                                  base::RetainedRef(
-                                      base::ThreadTaskRunnerHandle::Get()),
-                                  run_loop.QuitClosure(), &result)));
+      base::BindOnce(task, base::Bind(&AssignAndQuit<R>,
+                                      base::RetainedRef(
+                                          base::ThreadTaskRunnerHandle::Get()),
+                                      run_loop.QuitClosure(), &result)));
   run_loop.Run();
   return result;
 }
 
 void RunOnThread(base::SingleThreadTaskRunner* task_runner,
                  const tracked_objects::Location& location,
                  const base::Closure& task) {
   base::RunLoop run_loop;
-  task_runner->PostTaskAndReply(
-      location, task,
-      base::Bind(base::IgnoreResult(
-          base::Bind(&base::SingleThreadTaskRunner::PostTask,
-                     base::ThreadTaskRunnerHandle::Get(),
-                     FROM_HERE, run_loop.QuitClosure()))));
+  task_runner->PostTaskAndReply(location, task,
+                                base::BindOnce(base::IgnoreResult(base::Bind(
+                                    &base::SingleThreadTaskRunner::PostTask,
+                                    base::ThreadTaskRunnerHandle::Get(),
+                                    FROM_HERE, run_loop.QuitClosure()))));
   run_loop.Run();
 }
 
 void EnsureRunningOn(base::SingleThreadTaskRunner* runner) {
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 }
 
 void VerifySameTaskRunner(
     base::SingleThreadTaskRunner* runner1,
     base::SingleThreadTaskRunner* runner2) {
   ASSERT_TRUE(runner1 != nullptr);
   ASSERT_TRUE(runner2 != nullptr);
-  runner1->PostTask(FROM_HERE,
-                    base::Bind(&EnsureRunningOn, base::RetainedRef(runner2)));
+  runner1->PostTask(
+      FROM_HERE, base::BindOnce(&EnsureRunningOn, base::RetainedRef(runner2)));
 }
 
 void OnCreateSnapshotFileAndVerifyData(
     const std::string& expected_data,
     const CannedSyncableFileSystem::StatusCallback& callback,
     base::File::Error result,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<storage::ShareableFileReference>& /* file_ref */) {
   if (result != base::File::FILE_OK) {
@@ skipping 86 matching lines @@
                          storage::QuotaStatusCode status,
                          int64_t usage,
                          int64_t quota) {
   *usage_out = usage;
   *quota_out = quota;
   callback.Run(status);
 }
 
 void EnsureLastTaskRuns(base::SingleThreadTaskRunner* runner) {
   base::RunLoop run_loop;
-  runner->PostTaskAndReply(
-      FROM_HERE, base::Bind(&base::DoNothing), run_loop.QuitClosure());
+  runner->PostTaskAndReply(FROM_HERE, base::BindOnce(&base::DoNothing),
+                           run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace
 
 CannedSyncableFileSystem::CannedSyncableFileSystem(
     const GURL& origin,
     leveldb::Env* env_override,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
@@ skipping 63 matching lines @@
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
 File::Error CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
 
   base::RunLoop run_loop;
   io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(
+      base::BindOnce(
           &CannedSyncableFileSystem::DoOpenFileSystem, base::Unretained(this),
           base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
                      base::Unretained(this),
                      base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
                      run_loop.QuitClosure())));
   run_loop.Run();
 
   if (backend()->sync_context()) {
     // Register 'this' as a sync status observer.
     RunOnThread(
@@ skipping 425 matching lines @@
     const GURL& root,
     const std::string& name,
     File::Error result) {
   if (io_task_runner_->RunsTasksOnCurrentThread()) {
     EXPECT_FALSE(is_filesystem_opened_);
     is_filesystem_opened_ = true;
   }
   if (!original_task_runner->RunsTasksOnCurrentThread()) {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     original_task_runner->PostTask(
-        FROM_HERE, base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
-                              base::Unretained(this),
-                              base::RetainedRef(original_task_runner),
-                              quit_closure, root, name, result));
+        FROM_HERE, base::BindOnce(&CannedSyncableFileSystem::DidOpenFileSystem,
+                                  base::Unretained(this),
+                                  base::RetainedRef(original_task_runner),
+                                  quit_closure, root, name, result));
     return;
   }
   result_ = result;
   root_url_ = root;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::DidInitializeFileSystemContext(
     const base::Closure& quit_closure,
     SyncStatusCode status) {
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system