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

base/threading/post_task_and_reply_impl.cc

 // Copyright (c) 2011 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/threading/post_task_and_reply_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 26 matching lines @@
         reply_(std::move(reply)),
         task_(std::move(task)) {}
 
   ~PostTaskAndReplyRelay() {
     DCHECK(sequence_checker_.CalledOnValidSequence());
   }
 
   void RunTaskAndPostReply() {
     std::move(task_).Run();
     origin_task_runner_->PostTask(
-        from_here_, Bind(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct,
-                         base::Unretained(this)));
+        from_here_, BindOnce(&PostTaskAndReplyRelay::RunReplyAndSelfDestruct,
+                             base::Unretained(this)));
   }
 
  private:
   void RunReplyAndSelfDestruct() {
     DCHECK(sequence_checker_.CalledOnValidSequence());
 
     // Ensure |task_| has already been released before |reply_| to ensure that
     // no one accidentally depends on |task_| keeping one of its arguments alive
     // while |reply_| is executing.
     DCHECK(!task_);
@@ skipping 22 matching lines @@
   DCHECK(!task.is_null()) << from_here.ToString();
   DCHECK(!reply.is_null()) << from_here.ToString();
   PostTaskAndReplyRelay* relay =
       new PostTaskAndReplyRelay(from_here, std::move(task), std::move(reply));
   // PostTaskAndReplyRelay self-destructs after executing |reply|. On the flip
   // side though, it is intentionally leaked if the |task| doesn't complete
   // before the origin sequence stops executing tasks. Annotate |relay| as leaky
   // to avoid having to suppress every callsite which happens to flakily trigger
   // this race.
   ANNOTATE_LEAKING_OBJECT_PTR(relay);
-  if (!PostTask(from_here, Bind(&PostTaskAndReplyRelay::RunTaskAndPostReply,
-                                Unretained(relay)))) {
+  if (!PostTask(from_here, BindOnce(&PostTaskAndReplyRelay::RunTaskAndPostReply,
+                                    Unretained(relay)))) {
     delete relay;
     return false;
   }
 
   return true;
 }
 
 }  // namespace internal
 
 }  // namespace base