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

chrome/browser/sync_file_system/drive_backend/sync_task_manager_unittest.cc

 // Copyright 2014 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/drive_backend/sync_task_manager.h"
 
 #include <stdint.h>
 #include <deque>
 #include <string>
 #include <utility>
@@ skipping 16 matching lines @@
   base::FilePath(storage::VirtualPath::GetNormalizedFilePath( \
       base::FilePath(FILE_PATH_LITERAL(path))))
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 void DumbTask(SyncStatusCode status,
               const SyncStatusCallback& callback) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(callback, status));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(callback, status));
 }
 
 void IncrementAndAssign(int expected_before_counter,
                         int* counter,
                         SyncStatusCode* status_out,
                         SyncStatusCode status) {
   EXPECT_EQ(expected_before_counter, *counter);
   ++(*counter);
   *status_out = status;
 }
@@ skipping 54 matching lines @@
   }
 
  private:
   void DoTask(SyncStatusCode status_to_return,
               bool is_idle_task,
               const SyncStatusCallback& callback) {
     ++task_scheduled_count_;
     if (is_idle_task)
       ++idle_task_scheduled_count_;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, status_to_return));
+        FROM_HERE, base::BindOnce(callback, status_to_return));
   }
 
   std::unique_ptr<SyncTaskManager> task_manager_;
 
   int maybe_schedule_next_task_count_;
   int task_scheduled_count_;
   int idle_task_scheduled_count_;
 
   SyncStatusCode last_operation_status_;
 
@@ skipping 10 matching lines @@
     DCHECK(task_started_);
     DCHECK(task_completed_);
   }
 
   ~MultihopSyncTask() override {}
 
   void RunExclusive(const SyncStatusCallback& callback) override {
     DCHECK(!*task_started_);
     *task_started_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&MultihopSyncTask::CompleteTask,
-                              weak_ptr_factory_.GetWeakPtr(), callback));
+        FROM_HERE, base::BindOnce(&MultihopSyncTask::CompleteTask,
+                                  weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
  private:
   void CompleteTask(const SyncStatusCallback& callback) {
     DCHECK(*task_started_);
     DCHECK(!*task_completed_);
     *task_completed_ = true;
     callback.Run(SYNC_STATUS_OK);
   }
 
@@ skipping 40 matching lines @@
   }
 
  private:
   void RunAsBackgroundTask(std::unique_ptr<SyncTaskToken> token) {
     ++(stats_->running_background_task);
     if (stats_->max_parallel_task < stats_->running_background_task)
       stats_->max_parallel_task = stats_->running_background_task;
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&BackgroundTask::CompleteTask,
-                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
+        base::BindOnce(&BackgroundTask::CompleteTask,
+                       weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
   void CompleteTask(std::unique_ptr<SyncTaskToken> token) {
     ++(stats_->finished_task);
     --(stats_->running_background_task);
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
   }
 
   std::string app_id_;
   base::FilePath path_;
@@ skipping 48 matching lines @@
         std::move(token), std::move(task_blocker),
         base::Bind(&BlockerUpdateTestHelper::UpdateBlockerSoon,
                    weak_ptr_factory_.GetWeakPtr(), updating_to));
   }
 
   void UpdateBlockerSoon(const std::string& updated_to,
                          std::unique_ptr<SyncTaskToken> token) {
     log_->push_back(name_ + ": updated to " + updated_to);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&BlockerUpdateTestHelper::UpdateBlocker,
-                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
+        base::BindOnce(&BlockerUpdateTestHelper::UpdateBlocker,
+                       weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
   }
 
   std::string name_;
   std::string app_id_;
   std::deque<std::string> paths_;
   Log* log_;
 
   base::WeakPtrFactory<BlockerUpdateTestHelper> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockerUpdateTestHelper);
@@ skipping 343 matching lines @@
 
   EXPECT_EQ("task1: finished", log[i++]);
 
   EXPECT_EQ("task2: updating to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: updated to /hoge/fuga/piyo", log[i++]);
   EXPECT_EQ("task2: finished", log[i++]);
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system