Rewrite base::Bind into base::BindOnce on trivial cases in base

base/files/file_proxy.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 "base/files/file_proxy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 19 matching lines @@
       : file_(std::move(file)),
         error_(File::FILE_ERROR_FAILED),
         task_runner_(proxy->task_runner()),
         proxy_(AsWeakPtr(proxy)) {
    }
 
    void PassFile() {
      if (proxy_)
        proxy_->SetFile(std::move(file_));
      else if (file_.IsValid())
-       task_runner_->PostTask(FROM_HERE, Bind(&FileDeleter, Passed(&file_)));
+       task_runner_->PostTask(FROM_HERE,
+                              BindOnce(&FileDeleter, Passed(&file_)));
    }
 
  protected:
   File file_;
   File::Error error_;
 
  private:
   scoped_refptr<TaskRunner> task_runner_;
   WeakPtr<FileProxy> proxy_;
   DISALLOW_COPY_AND_ASSIGN(FileHelper);
@@ skipping 177 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
 }  // namespace
 
 FileProxy::FileProxy(TaskRunner* task_runner) : task_runner_(task_runner) {
 }
 
 FileProxy::~FileProxy() {
   if (file_.IsValid())
-    task_runner_->PostTask(FROM_HERE, Bind(&FileDeleter, Passed(&file_)));
+    task_runner_->PostTask(FROM_HERE, BindOnce(&FileDeleter, Passed(&file_)));
 }
 
 bool FileProxy::CreateOrOpen(const FilePath& file_path,
                              uint32_t file_flags,
                              const StatusCallback& callback) {
   DCHECK(!file_.IsValid());
   CreateOrOpenHelper* helper = new CreateOrOpenHelper(this, File());
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
-      Bind(&CreateOrOpenHelper::RunWork, Unretained(helper), file_path,
-           file_flags),
-      Bind(&CreateOrOpenHelper::Reply, Owned(helper), callback));
+      BindOnce(&CreateOrOpenHelper::RunWork, Unretained(helper), file_path,
+               file_flags),
+      BindOnce(&CreateOrOpenHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::CreateTemporary(uint32_t additional_file_flags,
                                 const CreateTemporaryCallback& callback) {
   DCHECK(!file_.IsValid());
   CreateTemporaryHelper* helper = new CreateTemporaryHelper(this, File());
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
-      Bind(&CreateTemporaryHelper::RunWork, Unretained(helper),
-           additional_file_flags),
-      Bind(&CreateTemporaryHelper::Reply, Owned(helper), callback));
+      BindOnce(&CreateTemporaryHelper::RunWork, Unretained(helper),
+               additional_file_flags),
+      BindOnce(&CreateTemporaryHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::IsValid() const {
   return file_.IsValid();
 }
 
 void FileProxy::SetFile(File file) {
   DCHECK(!file_.IsValid());
   file_ = std::move(file);
 }
 
 File FileProxy::TakeFile() {
   return std::move(file_);
 }
 
 File FileProxy::DuplicateFile() {
   return file_.Duplicate();
 }
 
 PlatformFile FileProxy::GetPlatformFile() const {
   return file_.GetPlatformFile();
 }
 
 bool FileProxy::Close(const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      Bind(&GenericFileHelper::Close, Unretained(helper)),
-      Bind(&GenericFileHelper::Reply, Owned(helper), callback));
+      FROM_HERE, BindOnce(&GenericFileHelper::Close, Unretained(helper)),
+      BindOnce(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::GetInfo(const GetFileInfoCallback& callback) {
   DCHECK(file_.IsValid());
   GetInfoHelper* helper = new GetInfoHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      Bind(&GetInfoHelper::RunWork, Unretained(helper)),
-      Bind(&GetInfoHelper::Reply, Owned(helper), callback));
+      FROM_HERE, BindOnce(&GetInfoHelper::RunWork, Unretained(helper)),
+      BindOnce(&GetInfoHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::Read(int64_t offset,
                      int bytes_to_read,
                      const ReadCallback& callback) {
   DCHECK(file_.IsValid());
   if (bytes_to_read < 0)
     return false;
 
   ReadHelper* helper = new ReadHelper(this, std::move(file_), bytes_to_read);
   return task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      Bind(&ReadHelper::RunWork, Unretained(helper), offset),
-      Bind(&ReadHelper::Reply, Owned(helper), callback));
+      FROM_HERE, BindOnce(&ReadHelper::RunWork, Unretained(helper), offset),
+      BindOnce(&ReadHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::Write(int64_t offset,
                       const char* buffer,
                       int bytes_to_write,
                       const WriteCallback& callback) {
   DCHECK(file_.IsValid());
   if (bytes_to_write <= 0 || buffer == NULL)
     return false;
 
   WriteHelper* helper =
       new WriteHelper(this, std::move(file_), buffer, bytes_to_write);
   return task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      Bind(&WriteHelper::RunWork, Unretained(helper), offset),
-      Bind(&WriteHelper::Reply, Owned(helper), callback));
+      FROM_HERE, BindOnce(&WriteHelper::RunWork, Unretained(helper), offset),
+      BindOnce(&WriteHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::SetTimes(Time last_access_time,
                          Time last_modified_time,
                          const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
-      Bind(&GenericFileHelper::SetTimes, Unretained(helper), last_access_time,
-           last_modified_time),
-      Bind(&GenericFileHelper::Reply, Owned(helper), callback));
+      BindOnce(&GenericFileHelper::SetTimes, Unretained(helper),
+               last_access_time, last_modified_time),
+      BindOnce(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::SetLength(int64_t length, const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
-      Bind(&GenericFileHelper::SetLength, Unretained(helper), length),
-      Bind(&GenericFileHelper::Reply, Owned(helper), callback));
+      BindOnce(&GenericFileHelper::SetLength, Unretained(helper), length),
+      BindOnce(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::Flush(const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
-      FROM_HERE,
-      Bind(&GenericFileHelper::Flush, Unretained(helper)),
-      Bind(&GenericFileHelper::Reply, Owned(helper), callback));
+      FROM_HERE, BindOnce(&GenericFileHelper::Flush, Unretained(helper)),
+      BindOnce(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 }  // namespace base