libbrillo: Change MessageLoop to use {Once,Repeating}Closure

base::TaskRunner uses OnceClosure, therefore similar interfaces should
also be updated.

BUG=chromium:993857
TEST=cros_run_unit_tests --board=chell --packages libbrillo

Change-Id: I7942a616d1b655c465b01e8bd23e5c675133b08d
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform2/+/1827107
Reviewed-by: Eric Caruso <ejcaruso@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Tested-by: Anand Mistry <amistry@chromium.org>
Cr-Mirrored-From: https://chromium.googlesource.com/chromiumos/platform2
Cr-Mirrored-Commit: 7eacd33d906574f3a62b5446ce05c2d920afc360

17 files changed, 87 insertions, 86 deletions

diff --git a/brillo/daemons/daemon.cc b/brillo/daemons/daemon.cc
index b706017..fed4705 100644
--- a/brillo/daemons/daemon.cc
+++ b/brillo/daemons/daemon.cc
@@ -27,7 +27,7 @@ int Daemon::Run() {
     return exit_code;
 
   message_loop_.PostTask(
-      base::Bind(&Daemon::OnEventLoopStartedTask, base::Unretained(this)));
+      base::BindOnce(&Daemon::OnEventLoopStartedTask, base::Unretained(this)));
   message_loop_.Run();
 
   OnShutdown(&exit_code_);
diff --git a/brillo/message_loops/base_message_loop.cc b/brillo/message_loops/base_message_loop.cc
index 5cf1730..8c0b4f5 100644
--- a/brillo/message_loops/base_message_loop.cc
+++ b/brillo/message_loops/base_message_loop.cc
@@ -29,8 +29,6 @@
 #include <brillo/location_logging.h>
 #include <brillo/strings/string_utils.h>
 
-using base::Closure;
-
 namespace {
 
 const char kMiscMinorPath[] = "/proc/misc";
@@ -75,21 +73,21 @@ BaseMessageLoop::~BaseMessageLoop() {
 
 MessageLoop::TaskId BaseMessageLoop::PostDelayedTask(
     const base::Location& from_here,
-    const Closure &task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
   TaskId task_id =  NextTaskId();
   bool base_scheduled = base_loop_->task_runner()->PostDelayedTask(
       from_here,
-      base::Bind(&BaseMessageLoop::OnRanPostedTask,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 task_id),
+      base::BindOnce(&BaseMessageLoop::OnRanPostedTask,
+                     weak_ptr_factory_.GetWeakPtr(), task_id),
       delay);
   DVLOG_LOC(from_here, 1) << "Scheduling delayed task_id " << task_id
                           << " to run in " << delay << ".";
   if (!base_scheduled)
     return MessageLoop::kTaskIdNull;
 
-  delayed_tasks_.emplace(task_id, DelayedTask{from_here, task_id, task});
+  delayed_tasks_.emplace(task_id,
+                         DelayedTask{from_here, task_id, std::move(task)});
   return task_id;
 }
 
@@ -109,10 +107,10 @@ bool BaseMessageLoop::CancelTask(TaskId task_id) {
 
   DVLOG_LOC(delayed_task_it->second.location, 1)
       << "Removing task_id " << task_id << " scheduled from this location.";
-  // We reset to closure to a null Closure to release all the resources
+  // We reset to closure to a null OnceClosure to release all the resources
   // used by this closure at this point, but we don't remove the task_id from
   // delayed_tasks_ since we can't tell base::MessageLoopForIO to not run it.
-  delayed_task_it->second.closure = Closure();
+  delayed_task_it->second.closure.Reset();
 
   return true;
 }
@@ -149,10 +147,10 @@ void BaseMessageLoop::BreakLoop() {
   base_run_loop_->Quit();
 }
 
-Closure BaseMessageLoop::QuitClosure() const {
+base::RepeatingClosure BaseMessageLoop::QuitClosure() const {
   if (base_run_loop_ == nullptr)
     // TODO(crbug.com/909719): Replace by base::DoNothing.
-    return base::Bind([]() {});
+    return base::BindRepeating([]() {});
   return base_run_loop_->QuitClosure();
 }
 
@@ -175,9 +173,7 @@ void BaseMessageLoop::OnRanPostedTask(MessageLoop::TaskId task_id) {
         << " scheduled from this location.";
     // Mark the task as canceled while we are running it so CancelTask returns
     // false.
-    Closure closure = std::move(task_it->second.closure);
-    task_it->second.closure = Closure();
-    closure.Run();
+    std::move(task_it->second.closure).Run();
 
     // If the |run_once_| flag is set, it is because we are instructed to run
     // only once callback.
diff --git a/brillo/message_loops/base_message_loop.h b/brillo/message_loops/base_message_loop.h
index 835908f..ae85539 100644
--- a/brillo/message_loops/base_message_loop.h
+++ b/brillo/message_loops/base_message_loop.h
@@ -41,7 +41,7 @@ class BRILLO_EXPORT BaseMessageLoop : public MessageLoop {
 
   // MessageLoop overrides.
   TaskId PostDelayedTask(const base::Location& from_here,
-                         const base::Closure& task,
+                         base::OnceClosure task,
                          base::TimeDelta delay) override;
   using MessageLoop::PostDelayedTask;
   bool CancelTask(TaskId task_id) override;
@@ -51,7 +51,7 @@ class BRILLO_EXPORT BaseMessageLoop : public MessageLoop {
 
   // Returns a callback that will quit the current message loop. If the message
   // loop is not running, an empty (null) callback is returned.
-  base::Closure QuitClosure() const;
+  base::RepeatingClosure QuitClosure() const;
 
  private:
   FRIEND_TEST(BaseMessageLoopTest, ParseBinderMinor);
@@ -78,7 +78,7 @@ class BRILLO_EXPORT BaseMessageLoop : public MessageLoop {
     base::Location location;
 
     MessageLoop::TaskId task_id;
-    base::Closure closure;
+    base::OnceClosure closure;
   };
 
   // The base::MessageLoopForIO instance owned by this class, if any. This
diff --git a/brillo/message_loops/fake_message_loop.cc b/brillo/message_loops/fake_message_loop.cc
index 9ab2aa9..185b20c 100644
--- a/brillo/message_loops/fake_message_loop.cc
+++ b/brillo/message_loops/fake_message_loop.cc
@@ -15,7 +15,7 @@ FakeMessageLoop::FakeMessageLoop(base::SimpleTestClock* clock)
 
 MessageLoop::TaskId FakeMessageLoop::PostDelayedTask(
     const base::Location& from_here,
-    const base::Closure& task,
+    base::OnceClosure task,
     base::TimeDelta delay) {
   // If no SimpleTestClock was provided, we use the last time we fired a
   // callback. In this way, tasks scheduled from a Closure will have the right
@@ -25,7 +25,7 @@ MessageLoop::TaskId FakeMessageLoop::PostDelayedTask(
   MessageLoop::TaskId current_id = ++last_id_;
   // FakeMessageLoop is limited to only 2^64 tasks. That should be enough.
   CHECK(current_id);
-  tasks_.emplace(current_id, ScheduledTask{from_here, false, task});
+  tasks_.emplace(current_id, ScheduledTask{from_here, std::move(task)});
   fire_order_.push(std::make_pair(current_time_ + delay, current_id));
   VLOG_LOC(from_here, 1) << "Scheduling delayed task_id " << current_id
                          << " to run at " << current_time_ + delay
@@ -64,13 +64,13 @@ bool FakeMessageLoop::RunOnce(bool may_block) {
     // Move the Closure out of the map before delete it. We need to delete the
     // entry from the map before we call the callback, since calling CancelTask
     // for the task you are running now should fail and return false.
-    base::Closure callback = std::move(scheduled_task_ref->second.callback);
+    base::OnceClosure callback = std::move(scheduled_task_ref->second.callback);
     VLOG_LOC(scheduled_task_ref->second.location, 1)
         << "Running task_id " << task_ref.second
         << " at time " << current_time_ << " from this location.";
     tasks_.erase(scheduled_task_ref);
 
-    callback.Run();
+    std::move(callback).Run();
     return true;
   }
   return false;
@@ -79,8 +79,7 @@ bool FakeMessageLoop::RunOnce(bool may_block) {
 bool FakeMessageLoop::PendingTasks() {
   for (const auto& task : tasks_) {
     VLOG_LOC(task.second.location, 1)
-        << "Pending " << (task.second.persistent ? "persistent " : "")
-        << "task_id " << task.first << " scheduled from here.";
+        << "Pending task_id " << task.first << " scheduled from here.";
   }
   return !tasks_.empty();
 }
diff --git a/brillo/message_loops/fake_message_loop.h b/brillo/message_loops/fake_message_loop.h
index 45bab81..783af1b 100644
--- a/brillo/message_loops/fake_message_loop.h
+++ b/brillo/message_loops/fake_message_loop.h
@@ -37,7 +37,7 @@ class BRILLO_EXPORT FakeMessageLoop : public MessageLoop {
   ~FakeMessageLoop() override = default;
 
   TaskId PostDelayedTask(const base::Location& from_here,
-                         const base::Closure& task,
+                         base::OnceClosure task,
                          base::TimeDelta delay) override;
   using MessageLoop::PostDelayedTask;
   bool CancelTask(TaskId task_id) override;
@@ -52,8 +52,7 @@ class BRILLO_EXPORT FakeMessageLoop : public MessageLoop {
  private:
   struct ScheduledTask {
     base::Location location;
-    bool persistent;
-    base::Closure callback;
+    base::OnceClosure callback;
   };
 
   // The sparse list of scheduled pending callbacks.
diff --git a/brillo/message_loops/fake_message_loop_test.cc b/brillo/message_loops/fake_message_loop_test.cc
index ae4b301..14f70bd 100644
--- a/brillo/message_loops/fake_message_loop_test.cc
+++ b/brillo/message_loops/fake_message_loop_test.cc
@@ -14,7 +14,7 @@
 
 #include <brillo/message_loops/message_loop.h>
 
-using base::Bind;
+using base::BindOnce;
 using base::Time;
 using base::TimeDelta;
 using std::vector;
@@ -44,18 +44,18 @@ TEST_F(FakeMessageLoopTest, CancelTaskInvalidValuesTest) {
 
 TEST_F(FakeMessageLoopTest, PostDelayedTaskRunsInOrder) {
   vector<int> order;
-  loop_->PostDelayedTask(Bind([](vector<int>* order) { order->push_back(1); },
-                              &order),
-                         TimeDelta::FromSeconds(1));
-  loop_->PostDelayedTask(Bind([](vector<int>* order) { order->push_back(4); },
-                              &order),
-                         TimeDelta::FromSeconds(4));
-  loop_->PostDelayedTask(Bind([](vector<int>* order) { order->push_back(3); },
-                              &order),
-                         TimeDelta::FromSeconds(3));
-  loop_->PostDelayedTask(Bind([](vector<int>* order) { order->push_back(2); },
-                              &order),
-                         TimeDelta::FromSeconds(2));
+  loop_->PostDelayedTask(
+      BindOnce([](vector<int>* order) { order->push_back(1); }, &order),
+      TimeDelta::FromSeconds(1));
+  loop_->PostDelayedTask(
+      BindOnce([](vector<int>* order) { order->push_back(4); }, &order),
+      TimeDelta::FromSeconds(4));
+  loop_->PostDelayedTask(
+      BindOnce([](vector<int>* order) { order->push_back(3); }, &order),
+      TimeDelta::FromSeconds(3));
+  loop_->PostDelayedTask(
+      BindOnce([](vector<int>* order) { order->push_back(2); }, &order),
+      TimeDelta::FromSeconds(2));
   // Run until all the tasks are run.
   loop_->Run();
   EXPECT_EQ((vector<int>{1, 2, 3, 4}), order);
@@ -66,8 +66,8 @@ TEST_F(FakeMessageLoopTest, PostDelayedTaskAdvancesTheTime) {
   clock_.SetNow(start);
   loop_.reset(new FakeMessageLoop(&clock_));
   // TODO(crbug.com/909719): Replace by base::DoNothing.
-  loop_->PostDelayedTask(Bind([]() {}), TimeDelta::FromSeconds(1));
-  loop_->PostDelayedTask(Bind([]() {}), TimeDelta::FromSeconds(2));
+  loop_->PostDelayedTask(BindOnce([]() {}), TimeDelta::FromSeconds(1));
+  loop_->PostDelayedTask(BindOnce([]() {}), TimeDelta::FromSeconds(2));
   EXPECT_FALSE(loop_->RunOnce(false));
   // If the callback didn't run, the time shouldn't change.
   EXPECT_EQ(start, clock_.Now());
@@ -87,7 +87,7 @@ TEST_F(FakeMessageLoopTest, PostDelayedTaskAdvancesTheTime) {
 
 TEST_F(FakeMessageLoopTest, PendingTasksTest) {
   // TODO(crbug.com/909719): Replace by base::DoNothing.
-  loop_->PostDelayedTask(Bind([]() {}), TimeDelta::FromSeconds(1));
+  loop_->PostDelayedTask(BindOnce([]() {}), TimeDelta::FromSeconds(1));
   EXPECT_TRUE(loop_->PendingTasks());
   loop_->Run();
 }
diff --git a/brillo/message_loops/message_loop.h b/brillo/message_loops/message_loop.h
index 0f9740d..13c4dc2 100644
--- a/brillo/message_loops/message_loop.h
+++ b/brillo/message_loops/message_loop.h
@@ -6,6 +6,7 @@
 #define LIBBRILLO_BRILLO_MESSAGE_LOOPS_MESSAGE_LOOP_H_
 
 #include <string>
+#include <utility>
 
 #include <base/callback.h>
 #include <base/location.h>
@@ -50,21 +51,20 @@ class BRILLO_EXPORT MessageLoop {
   // at a later point.
   // This methond can only be called from the same thread running the main loop.
   virtual TaskId PostDelayedTask(const base::Location& from_here,
-                                 const base::Closure& task,
+                                 base::OnceClosure task,
                                  base::TimeDelta delay) = 0;
   // Variant without the Location for easier usage.
-  TaskId PostDelayedTask(const base::Closure& task, base::TimeDelta delay) {
-    return PostDelayedTask(base::Location(), task, delay);
+  TaskId PostDelayedTask(base::OnceClosure task, base::TimeDelta delay) {
+    return PostDelayedTask(base::Location(), std::move(task), delay);
   }
 
   // A convenience method to schedule a call with no delay.
   // This methond can only be called from the same thread running the main loop.
-  TaskId PostTask(const base::Closure& task) {
-    return PostDelayedTask(task, base::TimeDelta());
+  TaskId PostTask(base::OnceClosure task) {
+    return PostDelayedTask(std::move(task), base::TimeDelta());
   }
-  TaskId PostTask(const base::Location& from_here,
-                  const base::Closure& task) {
-    return PostDelayedTask(from_here, task, base::TimeDelta());
+  TaskId PostTask(const base::Location& from_here, base::OnceClosure task) {
+    return PostDelayedTask(from_here, std::move(task), base::TimeDelta());
   }
 
   // Cancel a scheduled task. Returns whether the task was canceled. For
diff --git a/brillo/message_loops/message_loop_test.cc b/brillo/message_loops/message_loop_test.cc
index 475f929..e3d5f0c 100644
--- a/brillo/message_loops/message_loop_test.cc
+++ b/brillo/message_loops/message_loop_test.cc
@@ -21,12 +21,13 @@
 #include <brillo/message_loops/message_loop_utils.h>
 #include <brillo/unittest_utils.h>
 
-using base::Bind;
+using base::BindOnce;
+using base::BindRepeating;
 using base::TimeDelta;
 
 namespace {
 
-// Convenience functions for passing to base::Bind.
+// Convenience functions for passing to base::Bind{Once,Repeating}.
 void SetToTrue(bool* b) {
   *b = true;
 }
@@ -79,7 +80,8 @@ TYPED_TEST(MessageLoopTest, CancelTaskInvalidValuesTest) {
 
 TYPED_TEST(MessageLoopTest, PostTaskTest) {
   bool called = false;
-  TaskId task_id = this->loop_->PostTask(FROM_HERE, Bind(&SetToTrue, &called));
+  TaskId task_id =
+      this->loop_->PostTask(FROM_HERE, BindOnce(&SetToTrue, &called));
   EXPECT_NE(MessageLoop::kTaskIdNull, task_id);
   MessageLoopRunMaxIterations(this->loop_.get(), 100);
   EXPECT_TRUE(called);
@@ -88,7 +90,8 @@ TYPED_TEST(MessageLoopTest, PostTaskTest) {
 // Tests that we can cancel tasks right after we schedule them.
 TYPED_TEST(MessageLoopTest, PostTaskCancelledTest) {
   bool called = false;
-  TaskId task_id = this->loop_->PostTask(FROM_HERE, Bind(&SetToTrue, &called));
+  TaskId task_id =
+      this->loop_->PostTask(FROM_HERE, BindOnce(&SetToTrue, &called));
   EXPECT_TRUE(this->loop_->CancelTask(task_id));
   MessageLoopRunMaxIterations(this->loop_.get(), 100);
   EXPECT_FALSE(called);
@@ -98,12 +101,12 @@ TYPED_TEST(MessageLoopTest, PostTaskCancelledTest) {
 
 TYPED_TEST(MessageLoopTest, PostDelayedTaskRunsEventuallyTest) {
   bool called = false;
-  TaskId task_id = this->loop_->PostDelayedTask(
-      FROM_HERE, Bind(&SetToTrue, &called), TimeDelta::FromMilliseconds(50));
+  TaskId task_id =
+      this->loop_->PostDelayedTask(FROM_HERE, BindOnce(&SetToTrue, &called),
+                                   TimeDelta::FromMilliseconds(50));
   EXPECT_NE(MessageLoop::kTaskIdNull, task_id);
-  MessageLoopRunUntil(this->loop_.get(),
-                      TimeDelta::FromSeconds(10),
-                      Bind(&ReturnBool, &called));
+  MessageLoopRunUntil(this->loop_.get(), TimeDelta::FromSeconds(10),
+                      BindRepeating(&ReturnBool, &called));
   // Check that the main loop finished before the 10 seconds timeout, so it
   // finished due to the callback being called and not due to the timeout.
   EXPECT_TRUE(called);
@@ -114,7 +117,7 @@ TYPED_TEST(MessageLoopTest, PostDelayedTaskRunsEventuallyTest) {
 // virtual, so you need to unhide the other when overriding the virtual one.
 TYPED_TEST(MessageLoopTest, PostDelayedTaskWithoutLocation) {
   // TODO(crbug.com/909719): Replace by base::DoNothing.
-  this->loop_->PostDelayedTask(Bind([]() {}), TimeDelta());
+  this->loop_->PostDelayedTask(BindOnce([]() {}), TimeDelta());
   EXPECT_EQ(1, MessageLoopRunMaxIterations(this->loop_.get(), 100));
 }
 
@@ -124,9 +127,11 @@ TYPED_TEST(MessageLoopTest, DeleteTaskFromSelf) {
   TaskId task_id;
   task_id = this->loop_->PostTask(
       FROM_HERE,
-      Bind([](bool* cancel_result, MessageLoop* loop, TaskId* task_id) {
-        *cancel_result = loop->CancelTask(*task_id);
-      }, &cancel_result, this->loop_.get(), &task_id));
+      BindOnce(
+          [](bool* cancel_result, MessageLoop* loop, TaskId* task_id) {
+            *cancel_result = loop->CancelTask(*task_id);
+          },
+          &cancel_result, this->loop_.get(), &task_id));
   EXPECT_EQ(1, MessageLoopRunMaxIterations(this->loop_.get(), 100));
   EXPECT_FALSE(cancel_result);
 }
diff --git a/brillo/message_loops/message_loop_utils.cc b/brillo/message_loops/message_loop_utils.cc
index 54c588c..0f3214b 100644
--- a/brillo/message_loops/message_loop_utils.cc
+++ b/brillo/message_loops/message_loop_utils.cc
@@ -9,15 +9,14 @@
 
 namespace brillo {
 
-void MessageLoopRunUntil(
-    MessageLoop* loop,
-    base::TimeDelta timeout,
-    base::Callback<bool()> terminate) {
+void MessageLoopRunUntil(MessageLoop* loop,
+                         base::TimeDelta timeout,
+                         base::RepeatingCallback<bool()> terminate) {
   bool timeout_called = false;
   MessageLoop::TaskId task_id = loop->PostDelayedTask(
       FROM_HERE,
-      base::Bind([](bool* timeout_called) { *timeout_called = true; },
-                 &timeout_called),
+      base::BindOnce([](bool* timeout_called) { *timeout_called = true; },
+                     &timeout_called),
       timeout);
   while (!timeout_called && (terminate.is_null() || !terminate.Run()))
     loop->RunOnce(true);
diff --git a/brillo/message_loops/message_loop_utils.h b/brillo/message_loops/message_loop_utils.h
index d49ebdf..7384ddb 100644
--- a/brillo/message_loops/message_loop_utils.h
+++ b/brillo/message_loops/message_loop_utils.h
@@ -18,7 +18,7 @@ namespace brillo {
 BRILLO_EXPORT void MessageLoopRunUntil(
     MessageLoop* loop,
     base::TimeDelta timeout,
-    base::Callback<bool()> terminate);
+    base::RepeatingCallback<bool()> terminate);
 
 // Run the MessageLoop |loop| for up to |iterations| times without blocking.
 // Return the number of tasks run.
diff --git a/brillo/message_loops/mock_message_loop.h b/brillo/message_loops/mock_message_loop.h
index 30a19b8..357ec24 100644
--- a/brillo/message_loops/mock_message_loop.h
+++ b/brillo/message_loops/mock_message_loop.h
@@ -37,7 +37,7 @@ class BRILLO_EXPORT MockMessageLoop : public MessageLoop {
           &fake_loop_,
           static_cast<TaskId(FakeMessageLoop::*)(
                       const base::Location&,
-                      const base::Closure&,
+                      base::OnceClosure,
                       base::TimeDelta)>(
               &FakeMessageLoop::PostDelayedTask)));
     ON_CALL(*this, CancelTask(::testing::_))
@@ -51,7 +51,7 @@ class BRILLO_EXPORT MockMessageLoop : public MessageLoop {
 
   MOCK_METHOD(TaskId,
               PostDelayedTask,
-              (const base::Location&, const base::Closure&, base::TimeDelta),
+              (const base::Location&, base::OnceClosure, base::TimeDelta),
               (override));
   using MessageLoop::PostDelayedTask;
   MOCK_METHOD(bool, CancelTask, (TaskId), (override));
diff --git a/brillo/streams/input_stream_set.cc b/brillo/streams/input_stream_set.cc
index 0ceb5b4..847bf05 100644
--- a/brillo/streams/input_stream_set.cc
+++ b/brillo/streams/input_stream_set.cc
@@ -172,7 +172,7 @@ bool InputStreamSet::WaitForData(
     return stream->WaitForData(mode, callback, error);
   }
 
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, mode));
+  MessageLoop::current()->PostTask(FROM_HERE, base::BindOnce(callback, mode));
   return true;
 }
 
diff --git a/brillo/streams/memory_stream.cc b/brillo/streams/memory_stream.cc
index 54f127a..f4f9cca 100644
--- a/brillo/streams/memory_stream.cc
+++ b/brillo/streams/memory_stream.cc
@@ -185,7 +185,7 @@ bool MemoryStream::CheckContainer(ErrorPtr* error) const {
 bool MemoryStream::WaitForData(AccessMode mode,
                                const base::Callback<void(AccessMode)>& callback,
                                ErrorPtr* /* error */) {
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, mode));
+  MessageLoop::current()->PostTask(FROM_HERE, base::BindOnce(callback, mode));
   return true;
 }
 
diff --git a/brillo/streams/stream.cc b/brillo/streams/stream.cc
index 6a40c00..80f2df4 100644
--- a/brillo/streams/stream.cc
+++ b/brillo/streams/stream.cc
@@ -213,8 +213,9 @@ bool Stream::ReadAsyncImpl(
     if (force_async_callback) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&Stream::OnReadAsyncDone, weak_ptr_factory_.GetWeakPtr(),
-                     success_callback, read, eos));
+          base::BindOnce(&Stream::OnReadAsyncDone,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         success_callback, read, eos));
     } else {
       is_async_read_pending_ = false;
       success_callback.Run(read, eos);
@@ -277,8 +278,9 @@ bool Stream::WriteAsyncImpl(
     if (force_async_callback) {
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&Stream::OnWriteAsyncDone, weak_ptr_factory_.GetWeakPtr(),
-                     success_callback, written));
+          base::BindOnce(&Stream::OnWriteAsyncDone,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         success_callback, written));
     } else {
       is_async_write_pending_ = false;
       success_callback.Run(written);
diff --git a/brillo/streams/stream_utils.cc b/brillo/streams/stream_utils.cc
index 6f8a1d0..5029e3a 100644
--- a/brillo/streams/stream_utils.cc
+++ b/brillo/streams/stream_utils.cc
@@ -213,7 +213,7 @@ void CopyData(StreamPtr in_stream,
   state->success_callback = success_callback;
   state->error_callback = error_callback;
   brillo::MessageLoop::current()->PostTask(FROM_HERE,
-                                             base::Bind(&PerformRead, state));
+                                           base::BindOnce(&PerformRead, state));
 }
 
 }  // namespace stream_utils
diff --git a/brillo/streams/stream_utils_test.cc b/brillo/streams/stream_utils_test.cc
index e0b327d..50fb67e 100644
--- a/brillo/streams/stream_utils_test.cc
+++ b/brillo/streams/stream_utils_test.cc
@@ -25,7 +25,7 @@ ACTION_TEMPLATE(InvokeAsyncCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(size)) {
   brillo::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(std::get<k>(args), size));
+      FROM_HERE, base::BindOnce(std::get<k>(args), size));
   return true;
 }
 
@@ -42,7 +42,8 @@ ACTION_TEMPLATE(InvokeAsyncErrorCallback,
   brillo::ErrorPtr error;
   brillo::Error::AddTo(&error, FROM_HERE, "test", code, "message");
   brillo::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(std::get<k>(args), base::Owned(error.release())));
+      FROM_HERE, base::BindOnce(std::get<k>(args),
+                                base::Owned(error.release())));
   return true;
 }
 
diff --git a/brillo/streams/tls_stream.cc b/brillo/streams/tls_stream.cc
index cc63258..4b8a227 100644
--- a/brillo/streams/tls_stream.cc
+++ b/brillo/streams/tls_stream.cc
@@ -393,10 +393,10 @@ bool TlsStream::TlsStreamImpl::Init(StreamPtr socket,
   if (MessageLoop::ThreadHasCurrent()) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(&TlsStreamImpl::DoHandshake,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   success_callback,
-                   error_callback));
+        base::BindOnce(&TlsStreamImpl::DoHandshake,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       success_callback,
+                       error_callback));
   } else {
     DoHandshake(success_callback, error_callback);
   }