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

base/files/file_descriptor_watcher_posix.cc

 // Copyright 2016 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_descriptor_watcher_posix.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 106 matching lines @@
   }
 }
 
 void FileDescriptorWatcher::Controller::Watcher::OnFileCanReadWithoutBlocking(
     int fd) {
   DCHECK_EQ(fd_, fd);
   DCHECK_EQ(MessageLoopForIO::WATCH_READ, mode_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Run the callback on the sequence on which the watch was initiated.
-  callback_task_runner_->PostTask(FROM_HERE,
-                                  Bind(&Controller::RunCallback, controller_));
+  callback_task_runner_->PostTask(
+      FROM_HERE, BindOnce(&Controller::RunCallback, controller_));
 }
 
 void FileDescriptorWatcher::Controller::Watcher::OnFileCanWriteWithoutBlocking(
     int fd) {
   DCHECK_EQ(fd_, fd);
   DCHECK_EQ(MessageLoopForIO::WATCH_WRITE, mode_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Run the callback on the sequence on which the watch was initiated.
-  callback_task_runner_->PostTask(FROM_HERE,
-                                  Bind(&Controller::RunCallback, controller_));
+  callback_task_runner_->PostTask(
+      FROM_HERE, BindOnce(&Controller::RunCallback, controller_));
 }
 
 void FileDescriptorWatcher::Controller::Watcher::
     WillDestroyCurrentMessageLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // A Watcher is owned by a Controller. When the Controller is deleted, it
   // transfers ownership of the Watcher to a delete task posted to the
   // MessageLoopForIO. If the MessageLoopForIO is deleted before the delete task
   // runs, the following line takes care of deleting the Watcher.
@@ skipping 13 matching lines @@
   StartWatching();
 }
 
 void FileDescriptorWatcher::Controller::StartWatching() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   // It is safe to use Unretained() below because |watcher_| can only be deleted
   // by a delete task posted to |message_loop_for_io_task_runner_| by this
   // Controller's destructor. Since this delete task hasn't been posted yet, it
   // can't run before the task posted below.
   message_loop_for_io_task_runner_->PostTask(
-      FROM_HERE, Bind(&Watcher::StartWatching, Unretained(watcher_.get())));
+      FROM_HERE, BindOnce(&Watcher::StartWatching, Unretained(watcher_.get())));
 }
 
 void FileDescriptorWatcher::Controller::RunCallback() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   WeakPtr<Controller> weak_this = weak_factory_.GetWeakPtr();
 
   callback_.Run();
 
   // If |this| wasn't deleted, re-enable the watch.
@@ skipping 17 matching lines @@
   return WrapUnique(new Controller(MessageLoopForIO::WATCH_READ, fd, callback));
 }
 
 std::unique_ptr<FileDescriptorWatcher::Controller>
 FileDescriptorWatcher::WatchWritable(int fd, const Closure& callback) {
   return WrapUnique(
       new Controller(MessageLoopForIO::WATCH_WRITE, fd, callback));
 }
 
 }  // namespace base