Convert base::Bind and base::Callback in //remoting/base to Once or Repeating

This CL converts base::Bind and base::Callback in //remoting/base to
Once or Repeating

Bug: 1007820
Change-Id: I92c6f555b8b9464beec2f53af00ee45846a52ccd
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2067394Reviewed-by: Joe Downing <joedow@chromium.org>
Commit-Queue: Jun Cai <juncai@chromium.org>
Cr-Commit-Position: refs/heads/master@{#745534}

remoting/base/auto_thread.cc

@@ -173,10 +173,10 @@ void AutoThread::SetComInitType(ComInitType com_init_type) {
 }
 #endif
 
-void AutoThread::QuitThread(const base::Closure& quit_when_idle_closure) {
+void AutoThread::QuitThread(base::OnceClosure quit_when_idle_closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  quit_when_idle_closure.Run();
+  std::move(quit_when_idle_closure).Run();
   was_quit_properly_ = true;
 
   if (joiner_.get()) {
@@ -206,8 +206,8 @@ void AutoThread::ThreadMain() {
   // no more references to it remain.
   startup_data_->task_runner = new AutoThreadTaskRunner(
       single_thread_task_executor.task_runner(),
-      base::Bind(&AutoThread::QuitThread, base::Unretained(this),
-                 run_loop.QuitWhenIdleClosure()));
+      base::BindOnce(&AutoThread::QuitThread, base::Unretained(this),
+                     run_loop.QuitWhenIdleClosure()));
 
   startup_data_->event.Signal();
   // startup_data_ can't be touched anymore since the starting thread is now

remoting/base/auto_thread.h

@@ -82,7 +82,7 @@ class AutoThread : base::PlatformThread::Delegate {
  private:
   AutoThread(const char* name, AutoThreadTaskRunner* joiner);
 
-  void QuitThread(const base::Closure& quit_when_idle_closure);
+  void QuitThread(base::OnceClosure quit_when_idle_closure);
   void JoinAndDeleteThread();
 
   // base::PlatformThread::Delegate methods:

remoting/base/auto_thread_unittest.cc

@@ -72,8 +72,8 @@ class AutoThreadTest : public testing::Test {
   void SetUp() override {
     main_task_runner_ = new AutoThreadTaskRunner(
         task_environment_.GetMainThreadTaskRunner(),
-        base::Bind(&AutoThreadTest::QuitMainMessageLoop,
-                   base::Unretained(this)));
+        base::BindOnce(&AutoThreadTest::QuitMainMessageLoop,
+                       base::Unretained(this)));
   }
 
   void TearDown() override {

remoting/base/buffered_socket_writer.cc

@@ -44,10 +44,11 @@ struct BufferedSocketWriter::PendingPacket {
 // static
 std::unique_ptr<BufferedSocketWriter> BufferedSocketWriter::CreateForSocket(
     net::Socket* socket,
-    const WriteFailedCallback& write_failed_callback) {
+    WriteFailedCallback write_failed_callback) {
   std::unique_ptr<BufferedSocketWriter> result =
       std::make_unique<BufferedSocketWriter>();
-  result->Start(base::Bind(&WriteNetSocket, socket), write_failed_callback);
+  result->Start(base::BindRepeating(&WriteNetSocket, socket),
+                std::move(write_failed_callback));
   return result;
 }
 
@@ -57,11 +58,10 @@ BufferedSocketWriter::~BufferedSocketWriter() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-void BufferedSocketWriter::Start(
-    const WriteCallback& write_callback,
-    const WriteFailedCallback& write_failed_callback) {
+void BufferedSocketWriter::Start(const WriteCallback& write_callback,
+                                 WriteFailedCallback write_failed_callback) {
   write_callback_ = write_callback;
-  write_failed_callback_ = write_failed_callback;
+  write_failed_callback_ = std::move(write_failed_callback);
   DoWrite();
 }
 
@@ -92,8 +92,8 @@ void BufferedSocketWriter::DoWrite() {
          !queue_.empty()) {
     int result = write_callback_.Run(
         queue_.front()->data.get(), queue_.front()->data->BytesRemaining(),
-        base::Bind(&BufferedSocketWriter::OnWritten,
-                   weak_factory_.GetWeakPtr()),
+        base::BindOnce(&BufferedSocketWriter::OnWritten,
+                       weak_factory_.GetWeakPtr()),
         queue_.front()->traffic_annotation);
     HandleWriteResult(result);
   }

remoting/base/buffered_socket_writer.h

@@ -25,17 +25,17 @@ namespace remoting {
 // BufferedSocketWriter implement write data queue for stream sockets.
 class BufferedSocketWriter {
  public:
-  typedef base::Callback<int(
+  typedef base::RepeatingCallback<int(
       const scoped_refptr<net::IOBuffer>& buf,
       int buf_len,
       net::CompletionOnceCallback callback,
       const net::NetworkTrafficAnnotationTag& traffic_annotation)>
       WriteCallback;
-  typedef base::Callback<void(int)> WriteFailedCallback;
+  typedef base::OnceCallback<void(int)> WriteFailedCallback;
 
   static std::unique_ptr<BufferedSocketWriter> CreateForSocket(
       net::Socket* socket,
-      const WriteFailedCallback& write_failed_callback);
+      WriteFailedCallback write_failed_callback);
 
   BufferedSocketWriter();
   virtual ~BufferedSocketWriter();
@@ -44,7 +44,7 @@ class BufferedSocketWriter {
   // socket. |write_failed_callback| is called when write operation fails.
   // Writing stops after the first failed write.
   void Start(const WriteCallback& write_callback,
-             const WriteFailedCallback& write_failed_callback);
+             WriteFailedCallback write_failed_callback);
 
   // Puts a new data chunk in the buffer. If called before Start() then all data
   // is buffered until Start().

remoting/base/buffered_socket_writer_unittest.cc

@@ -117,9 +117,9 @@ class BufferedSocketWriterTest : public testing::Test {
   }
 
   void StartWriter() {
-    writer_->Start(base::Bind(&WriteNetSocket, socket_.get()),
-                   base::Bind(&BufferedSocketWriterTest::OnWriteFailed,
-                              base::Unretained(this)));
+    writer_->Start(base::BindRepeating(&WriteNetSocket, socket_.get()),
+                   base::BindOnce(&BufferedSocketWriterTest::OnWriteFailed,
+                                  base::Unretained(this)));
   }
 
   void OnWriteFailed(int error) {
@@ -140,8 +140,9 @@ class BufferedSocketWriterTest : public testing::Test {
   }
 
   void TestWrite() {
-    writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
-    writer_->Write(test_buffer_2_, base::Closure(),
+    writer_->Write(test_buffer_, base::OnceClosure(),
+                   TRAFFIC_ANNOTATION_FOR_TESTS);
+    writer_->Write(test_buffer_2_, base::OnceClosure(),
                    TRAFFIC_ANNOTATION_FOR_TESTS);
     base::RunLoop().RunUntilIdle();
     VerifyWrittenData();
@@ -152,7 +153,7 @@ class BufferedSocketWriterTest : public testing::Test {
         test_buffer_,
         base::BindOnce(base::IgnoreResult(&BufferedSocketWriter::Write),
                        base::Unretained(writer_.get()), test_buffer_2_,
-                       base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS),
+                       base::OnceClosure(), TRAFFIC_ANNOTATION_FOR_TESTS),
         TRAFFIC_ANNOTATION_FOR_TESTS);
     base::RunLoop().RunUntilIdle();
     VerifyWrittenData();
@@ -207,13 +208,13 @@ TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
   StartWriter();
   socket_data_provider_.set_async_write(true);
   writer_->Write(test_buffer_,
-                 base::Bind(&BufferedSocketWriterTest::DestroyWriter,
-                            base::Unretained(this)),
+                 base::BindOnce(&BufferedSocketWriterTest::DestroyWriter,
+                                base::Unretained(this)),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_2_,
+                 base::BindOnce(&BufferedSocketWriterTest::Unexpected,
+                                base::Unretained(this)),
                  TRAFFIC_ANNOTATION_FOR_TESTS);
-  writer_->Write(
-      test_buffer_2_,
-      base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
-      TRAFFIC_ANNOTATION_FOR_TESTS);
   socket_data_provider_.set_async_write(false);
   base::RunLoop().RunUntilIdle();
   ASSERT_GE(socket_data_provider_.written_data().size(),
@@ -227,13 +228,14 @@ TEST_F(BufferedSocketWriterTest, DestroyFromCallback) {
 TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
   StartWriter();
   socket_data_provider_.set_write_limit(kWriteChunkSize);
-  writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_, base::OnceClosure(),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
   socket_data_provider_.set_async_write(true);
   socket_data_provider_.set_next_write_error(net::ERR_FAILED);
-  writer_->Write(
-      test_buffer_2_,
-      base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
-      TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_2_,
+                 base::BindOnce(&BufferedSocketWriterTest::Unexpected,
+                                base::Unretained(this)),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
   socket_data_provider_.set_async_write(false);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, write_error_);
@@ -245,13 +247,14 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorSync) {
 TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
   StartWriter();
   socket_data_provider_.set_write_limit(kWriteChunkSize);
-  writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_, base::OnceClosure(),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
   socket_data_provider_.set_async_write(true);
   socket_data_provider_.set_next_write_error(net::ERR_FAILED);
-  writer_->Write(
-      test_buffer_2_,
-      base::Bind(&BufferedSocketWriterTest::Unexpected, base::Unretained(this)),
-      TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_2_,
+                 base::BindOnce(&BufferedSocketWriterTest::Unexpected,
+                                base::Unretained(this)),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, write_error_);
   EXPECT_EQ(static_cast<size_t>(test_buffer_->size()),
@@ -259,8 +262,10 @@ TEST_F(BufferedSocketWriterTest, TestWriteErrorAsync) {
 }
 
 TEST_F(BufferedSocketWriterTest, WriteBeforeStart) {
-  writer_->Write(test_buffer_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
-  writer_->Write(test_buffer_2_, base::Closure(), TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_, base::OnceClosure(),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
+  writer_->Write(test_buffer_2_, base::OnceClosure(),
+                 TRAFFIC_ANNOTATION_FOR_TESTS);
 
   StartWriter();
   base::RunLoop().RunUntilIdle();

remoting/base/chromium_url_request.cc

@@ -49,11 +49,11 @@ void ChromiumUrlRequest::SetPostData(const std::string& content_type,
   post_data_ = data;
 }
 
-void ChromiumUrlRequest::Start(const OnResultCallback& on_result_callback) {
+void ChromiumUrlRequest::Start(OnResultCallback on_result_callback) {
   DCHECK(!on_result_callback.is_null());
   DCHECK(on_result_callback_.is_null());
 
-  on_result_callback_ = on_result_callback;
+  on_result_callback_ = std::move(on_result_callback);
 
   std::string method = resource_request_->method;
 

remoting/base/chromium_url_request.h

@@ -34,7 +34,7 @@ class ChromiumUrlRequest : public UrlRequest {
   void AddHeader(const std::string& value) override;
   void SetPostData(const std::string& content_type,
                    const std::string& data) override;
-  void Start(const OnResultCallback& on_result_callback) override;
+  void Start(OnResultCallback on_result_callback) override;
 
  private:
   void OnURLLoadComplete(std::unique_ptr<std::string> response_body);

remoting/base/compound_buffer_unittest.cc

@@ -86,8 +86,9 @@ class CompoundBufferTest : public testing::Test {
 
   // Iterate over chunks of data with sizes specified in |sizes| in the
   // interval [0..kDataSize]. |function| is called for each chunk.
-  void IterateOverPieces(const int sizes[],
-                         const base::Callback<void(int, int)>& function) {
+  void IterateOverPieces(
+      const int sizes[],
+      const base::RepeatingCallback<void(int, int)>& function) {
     DCHECK_GT(sizes[0], 0);
 
     int pos = 0;
@@ -183,81 +184,96 @@ class CompoundBufferTest : public testing::Test {
 
 TEST_F(CompoundBufferTest, Append) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, base::Bind(
-      &CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(
+      kChunkSizes0,
+      base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(
+      kChunkSizes1,
+      base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, AppendCopyOf) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, base::Bind(
-      &CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes0,
+                    base::BindRepeating(&CompoundBufferTest::AppendCopyOf,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::AppendCopyOf, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes1,
+                    base::BindRepeating(&CompoundBufferTest::AppendCopyOf,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, Prepend) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, base::Bind(
-      &CompoundBufferTest::Prepend, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes0,
+                    base::BindRepeating(&CompoundBufferTest::Prepend,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::Prepend, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes1,
+                    base::BindRepeating(&CompoundBufferTest::Prepend,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, PrependCopyOf) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes0, base::Bind(
-      &CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes0,
+                    base::BindRepeating(&CompoundBufferTest::PrependCopyOf,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::PrependCopyOf, base::Unretained(this)));
+  IterateOverPieces(kChunkSizes1,
+                    base::BindRepeating(&CompoundBufferTest::PrependCopyOf,
+                                        base::Unretained(this)));
   EXPECT_TRUE(CompareData(target_, data_->data(), kDataSize));
 }
 
 TEST_F(CompoundBufferTest, CropFront) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::Append, base::Unretained(this)));
-  IterateOverPieces(kCropSizes, base::Bind(
-      &CompoundBufferTest::TestCropFront, base::Unretained(this)));
+  IterateOverPieces(
+      kChunkSizes1,
+      base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(kCropSizes,
+                    base::BindRepeating(&CompoundBufferTest::TestCropFront,
+                                        base::Unretained(this)));
 }
 
 TEST_F(CompoundBufferTest, CropBack) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::Append, base::Unretained(this)));
-  IterateOverPieces(kCropSizes, base::Bind(
-      &CompoundBufferTest::TestCropBack, base::Unretained(this)));
+  IterateOverPieces(
+      kChunkSizes1,
+      base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(kCropSizes,
+                    base::BindRepeating(&CompoundBufferTest::TestCropBack,
+                                        base::Unretained(this)));
 }
 
 TEST_F(CompoundBufferTest, CopyFrom) {
   target_.Clear();
-  IterateOverPieces(kChunkSizes1, base::Bind(
-      &CompoundBufferTest::Append, base::Unretained(this)));
+  IterateOverPieces(
+      kChunkSizes1,
+      base::BindRepeating(&CompoundBufferTest::Append, base::Unretained(this)));
   {
     SCOPED_TRACE("CopyFrom.kCopySizes0");
-    IterateOverPieces(kCopySizes0, base::Bind(
-        &CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
+    IterateOverPieces(kCopySizes0,
+                      base::BindRepeating(&CompoundBufferTest::TestCopyFrom,
+                                          base::Unretained(this)));
   }
   {
     SCOPED_TRACE("CopyFrom.kCopySizes1");
-    IterateOverPieces(kCopySizes1, base::Bind(
-        &CompoundBufferTest::TestCopyFrom, base::Unretained(this)));
+    IterateOverPieces(kCopySizes1,
+                      base::BindRepeating(&CompoundBufferTest::TestCopyFrom,
+                                          base::Unretained(this)));
   }
 }
 

remoting/base/dispatch_win.h.pump

@@ -5,7 +5,7 @@ $$
 $$ https://github.com/google/googletest/blob/master/googletest/docs/PumpManual.md
 
 $$ MAX_ARITY controls the number of arguments that dispatch::Invoke() supports.
-$$ It is choosen to match the number of arguments base::Bind() supports.
+$$ It is choosen to match the number of arguments base::BindOnce() supports.
 $var MAX_ARITY = 7
 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be

remoting/base/gaia_oauth_client.cc

@@ -25,14 +25,14 @@ void GaiaOAuthClient::GetCredentialsFromAuthCode(
     const std::string& auth_code,
     bool need_user_email,
     CompletionCallback on_done) {
-  if (!on_done_.is_null()) {
-    pending_requests_.push(
-        Request(oauth_client_info, auth_code, need_user_email, on_done));
+  if (on_done_) {
+    pending_requests_.push(Request(oauth_client_info, auth_code,
+                                   need_user_email, std::move(on_done)));
     return;
   }
 
   need_user_email_ = need_user_email;
-  on_done_ = on_done;
+  on_done_ = std::move(on_done);
   // Map the authorization code to refresh and access tokens.
   gaia_oauth_client_.GetTokensFromAuthCode(oauth_client_info, auth_code,
                                            kMaxGaiaRetries, this);
@@ -62,11 +62,12 @@ void GaiaOAuthClient::SendResponse(const std::string& user_email,
 
   // Process the next request in the queue.
   if (pending_requests_.size()) {
-    Request request = pending_requests_.front();
+    Request request = std::move(pending_requests_.front());
     pending_requests_.pop();
     // GetCredentialsFromAuthCode is asynchronous, so it's safe to call it here.
     GetCredentialsFromAuthCode(request.oauth_client_info, request.auth_code,
-                               request.need_user_email, request.on_done);
+                               request.need_user_email,
+                               std::move(request.on_done));
   }
 }
 
@@ -90,10 +91,13 @@ GaiaOAuthClient::Request::Request(
   this->oauth_client_info = oauth_client_info;
   this->auth_code = auth_code;
   this->need_user_email = need_user_email;
-  this->on_done = on_done;
+  this->on_done = std::move(on_done);
 }
 
-GaiaOAuthClient::Request::Request(const Request& other) = default;
+GaiaOAuthClient::Request::Request(Request&& other) = default;
+
+GaiaOAuthClient::Request& GaiaOAuthClient::Request::operator=(Request&& other) =
+    default;
 
 GaiaOAuthClient::Request::~Request() = default;
 

remoting/base/gaia_oauth_client.h

@@ -55,7 +55,8 @@ class GaiaOAuthClient : public OAuthClient,
             const std::string& auth_code,
             bool need_user_email,
             CompletionCallback on_done);
-    Request(const Request& other);
+    Request(Request&& other);
+    Request& operator=(Request&& other);
     virtual ~Request();
     gaia::OAuthClientInfo oauth_client_info;
     std::string auth_code;

remoting/base/mock_oauth_client.cc

@@ -17,7 +17,7 @@ void MockOAuthClient::GetCredentialsFromAuthCode(
     const std::string& auth_code,
     bool need_user_email,
     CompletionCallback on_done) {
-  on_done.Run(need_user_email ? user_email_ : "", refresh_token_);
+  std::move(on_done).Run(need_user_email ? user_email_ : "", refresh_token_);
 }
 
 }  // namespace remoting

remoting/base/oauth_client.h

@@ -20,8 +20,8 @@ class OAuthClient {
   // Called when GetCredentialsFromAuthCode is completed, with the |user_email|
   // and |refresh_token| that correspond to the given |auth_code|, or with empty
   // strings on error.
-  typedef base::Callback<void(const std::string& user_email,
-                              const std::string& refresh_token)>
+  typedef base::OnceCallback<void(const std::string& user_email,
+                                  const std::string& refresh_token)>
       CompletionCallback;
 
   virtual ~OAuthClient() {}

remoting/base/run_all_unittests.cc

@@ -23,6 +23,6 @@ int main(int argc, char** argv) {
       mojo::core::ScopedIPCSupport::ShutdownPolicy::CLEAN);
 
   return base::LaunchUnitTests(
-      argc, argv, base::Bind(&base::TestSuite::Run,
-                             base::Unretained(&test_suite)));
+      argc, argv,
+      base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
 }

remoting/base/socket_reader.cc

@@ -29,7 +29,7 @@ void SocketReader::Init(net::Socket* socket,
   DCHECK(!socket_);
 
   socket_ = socket;
-  read_result_callback_ = read_result_callback;
+  read_result_callback_ = std::move(read_result_callback);
   DoRead();
 }
 
@@ -37,9 +37,8 @@ void SocketReader::DoRead() {
   while (true) {
     read_buffer_ = base::MakeRefCounted<net::IOBuffer>(kReadBufferSize);
     int result = socket_->Read(
-        read_buffer_.get(),
-        kReadBufferSize,
-        base::Bind(&SocketReader::OnRead, weak_factory_.GetWeakPtr()));
+        read_buffer_.get(), kReadBufferSize,
+        base::BindOnce(&SocketReader::OnRead, weak_factory_.GetWeakPtr()));
     HandleReadResult(result);
     if (result <= 0)
       break;
@@ -64,7 +63,7 @@ void SocketReader::HandleReadResult(int result) {
 }
 
 void SocketReader::CallCallback(scoped_refptr<net::IOBuffer> data, int result) {
-  read_result_callback_.Run(data, result);
+  std::move(read_result_callback_).Run(data, result);
 }
 
 }  // namespace remoting

remoting/base/socket_reader.h

@@ -25,8 +25,9 @@ class SocketReader {
  public:
   // Callback that is called for each finished read. |data| may be set to NULL
   // in case of an error (result < 0).
-  typedef base::Callback<void(scoped_refptr<net::IOBuffer> data,
-                              int result)> ReadResultCallback;
+  typedef base::OnceCallback<void(scoped_refptr<net::IOBuffer> data,
+                                  int result)>
+      ReadResultCallback;
 
   SocketReader();
   ~SocketReader();

remoting/base/telemetry_log_writer_unittest.cc

@@ -70,11 +70,11 @@ class FakeUrlRequestFactory : public UrlRequestFactory {
   ~FakeUrlRequestFactory() override { EXPECT_TRUE(expected_requests_.empty()); }
 
   // Returns a respond closure. Run this closure to respond to the URL request.
-  base::Closure AddExpectedRequest(const std::string& exp_post,
-                                   const UrlRequest::Result& ret_result) {
+  base::OnceClosure AddExpectedRequest(const std::string& exp_post,
+                                       const UrlRequest::Result& ret_result) {
     FakeUrlRequest* fakeRequest = new FakeUrlRequest(exp_post, ret_result);
-    base::Closure closure =
-        base::Bind(&FakeUrlRequest::Respond, base::Unretained(fakeRequest));
+    base::OnceClosure closure =
+        base::BindOnce(&FakeUrlRequest::Respond, base::Unretained(fakeRequest));
     expected_requests_.push_back(std::unique_ptr<UrlRequest>(fakeRequest));
     return closure;
   }
@@ -148,7 +148,7 @@ TEST_F(TelemetryLogWriterTest, PostOneLogImmediately) {
   auto respond = request_factory_->AddExpectedRequest(
       "{\"event\":[{\"id\":0}]}", success_result_);
   LogFakeEvent();
-  respond.Run();
+  std::move(respond).Run();
 }
 
 TEST_F(TelemetryLogWriterTest, PostOneLogAndHaveTwoPendingLogs) {
@@ -160,8 +160,8 @@ TEST_F(TelemetryLogWriterTest, PostOneLogAndHaveTwoPendingLogs) {
       "{\"event\":[{\"id\":1},{\"id\":2}]}", success_result_);
   LogFakeEvent();
   LogFakeEvent();
-  respond1.Run();
-  respond2.Run();
+  std::move(respond1).Run();
+  std::move(respond2).Run();
 }
 
 TEST_F(TelemetryLogWriterTest, PostLogFailedAndRetry) {
@@ -179,11 +179,11 @@ TEST_F(TelemetryLogWriterTest, PostLogFailedAndRetry) {
 
   LogFakeEvent();
 
-  respond1.Run();
-  respond2.Run();
-  respond3.Run();
-  respond4.Run();
-  respond5.Run();
+  std::move(respond1).Run();
+  std::move(respond2).Run();
+  std::move(respond3).Run();
+  std::move(respond4).Run();
+  std::move(respond5).Run();
 }
 
 TEST_F(TelemetryLogWriterTest, PostOneLogFailedResendWithTwoPendingLogs) {
@@ -196,8 +196,8 @@ TEST_F(TelemetryLogWriterTest, PostOneLogFailedResendWithTwoPendingLogs) {
   LogFakeEvent();
   LogFakeEvent();
 
-  respond1.Run();
-  respond2.Run();
+  std::move(respond1).Run();
+  std::move(respond2).Run();
 }
 
 TEST_F(TelemetryLogWriterTest, PostThreeLogsFailedAndResendWithOnePending) {
@@ -212,15 +212,15 @@ TEST_F(TelemetryLogWriterTest, PostThreeLogsFailedAndResendWithOnePending) {
   LogFakeEvent();
   LogFakeEvent();
 
-  respond1.Run();
+  std::move(respond1).Run();
 
   auto respond3 = request_factory_->AddExpectedRequest(
       "{\"event\":[{\"id\":0},{\"id\":1},{\"id\":2},{\"id\":3}]}",
       success_result_);
   LogFakeEvent();
 
-  respond2.Run();
-  respond3.Run();
+  std::move(respond2).Run();
+  std::move(respond3).Run();
 }
 
 TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedCallClosureAndRetry) {
@@ -230,8 +230,8 @@ TEST_F(TelemetryLogWriterTest, PostOneUnauthorizedCallClosureAndRetry) {
 
   auto respond2 = request_factory_->AddExpectedRequest(
       "{\"event\":[{\"id\":0}]}", success_result_);
-  respond1.Run();
-  respond2.Run();
+  std::move(respond1).Run();
+  std::move(respond2).Run();
 }
 
 }  // namespace remoting

remoting/base/url_request.h

@@ -40,7 +40,7 @@ class UrlRequest {
     std::string response_body;
   };
 
-  typedef base::Callback<void(const Result& result)> OnResultCallback;
+  typedef base::OnceCallback<void(const Result& result)> OnResultCallback;
 
   virtual ~UrlRequest() {}
 
@@ -53,7 +53,7 @@ class UrlRequest {
 
   // Sends a request to the server. |on_response_callback| will be called to
   // return result of the request.
-  virtual void Start(const OnResultCallback& on_result_callback) = 0;
+  virtual void Start(OnResultCallback on_result_callback) = 0;
 };
 
 // Factory for UrlRequest instances.