Apply base_bind_rewriters to //net

*** Note: There is no behavior change from this patch. ***

This CL replaces calls to base::{Bind,BindRepeating} with calls to
base::BindOnce, and removes calls to base::AdaptCallbackForRepeating
when the returned base::RepeatingCallback is immediately converted
to a base::OnceCallback.

This CL was uploaded by git cl split.

R=zhongyi@chromium.org

Bug: 714018
Change-Id: I89d91b84381cb4b4598f5df0d0f51dc72be8f312
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1778773
Commit-Queue: Matt Menke <mmenke@chromium.org>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Auto-Submit: Yannic Bonenberger <contact@yannic-bonenberger.com>
Cr-Commit-Position: refs/heads/master@{#693231}

net/http/broken_alternative_services.cc

@@ -325,7 +325,7 @@ void BrokenAlternativeServices ::
   expiration_timer_.Stop();
   expiration_timer_.Start(
       FROM_HERE, delay,
-      base::Bind(
+      base::BindOnce(
           &BrokenAlternativeServices ::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()));
 }

net/http/http_response_body_drainer.cc

@@ -73,10 +73,9 @@ int HttpResponseBodyDrainer::DoDrainResponseBody() {
   next_state_ = STATE_DRAIN_RESPONSE_BODY_COMPLETE;
 
   return stream_->ReadResponseBody(
-      read_buf_.get(),
-      kDrainBodyBufferSize - total_read_,
-      base::Bind(&HttpResponseBodyDrainer::OnIOComplete,
-                 base::Unretained(this)));
+      read_buf_.get(), kDrainBodyBufferSize - total_read_,
+      base::BindOnce(&HttpResponseBodyDrainer::OnIOComplete,
+                     base::Unretained(this)));
 }
 
 int HttpResponseBodyDrainer::DoDrainResponseBodyComplete(int result) {

net/http/http_stream_factory_job.cc

@@ -767,9 +767,8 @@ int HttpStreamFactory::Job::DoInitConnectionImpl() {
       // delay the main job.
       delegate_->MaybeSetWaitTimeForMainJob(
           quic_request_.GetTimeDelayForWaitingJob());
-      expect_on_quic_host_resolution_ =
-          quic_request_.WaitForHostResolution(base::BindRepeating(
-              &Job::OnQuicHostResolution, base::Unretained(this)));
+      expect_on_quic_host_resolution_ = quic_request_.WaitForHostResolution(
+          base::BindOnce(&Job::OnQuicHostResolution, base::Unretained(this)));
     }
     return rv;
   }

net/http/http_stream_factory_job_controller.cc

@@ -627,7 +627,7 @@ int HttpStreamFactory::JobController::DoResolveProxy() {
   GURL origin_url = ApplyHostMappingRules(request_info_.url, &destination);
 
   CompletionOnceCallback io_callback =
-      base::Bind(&JobController::OnIOComplete, base::Unretained(this));
+      base::BindOnce(&JobController::OnIOComplete, base::Unretained(this));
   return session_->proxy_resolution_service()->ResolveProxy(
       origin_url, request_info_.method, &proxy_info_, std::move(io_callback),
       &proxy_resolve_request_, net_log_);

net/http/http_transaction_test_util.cc

@@ -195,9 +195,11 @@ TestTransactionConsumer::~TestTransactionConsumer() = default;
 void TestTransactionConsumer::Start(const HttpRequestInfo* request,
                                     const NetLogWithSource& net_log) {
   state_ = STARTING;
-  int result = trans_->Start(
-      request, base::Bind(&TestTransactionConsumer::OnIOComplete,
-                          base::Unretained(this)), net_log);
+  int result =
+      trans_->Start(request,
+                    base::BindOnce(&TestTransactionConsumer::OnIOComplete,
+                                   base::Unretained(this)),
+                    net_log);
   if (result != ERR_IO_PENDING)
     DidStart(result);
 }
@@ -229,10 +231,10 @@ void TestTransactionConsumer::DidFinish(int result) {
 void TestTransactionConsumer::Read() {
   state_ = READING;
   read_buf_ = base::MakeRefCounted<IOBuffer>(1024);
-  int result = trans_->Read(read_buf_.get(),
-                            1024,
-                            base::Bind(&TestTransactionConsumer::OnIOComplete,
-                                       base::Unretained(this)));
+  int result =
+      trans_->Read(read_buf_.get(), 1024,
+                   base::BindOnce(&TestTransactionConsumer::OnIOComplete,
+                                  base::Unretained(this)));
   if (result != ERR_IO_PENDING)
     DidRead(result);
 }

net/server/http_server.cc

@@ -175,8 +175,8 @@ void HttpServer::DoAcceptLoop() {
   int rv;
   do {
     rv = server_socket_->Accept(&accepted_socket_,
-                                base::Bind(&HttpServer::OnAcceptCompleted,
-                                           weak_ptr_factory_.GetWeakPtr()));
+                                base::BindOnce(&HttpServer::OnAcceptCompleted,
+                                               weak_ptr_factory_.GetWeakPtr()));
     if (rv == ERR_IO_PENDING)
       return;
     rv = HandleAcceptResult(rv);
@@ -215,10 +215,9 @@ void HttpServer::DoReadLoop(HttpConnection* connection) {
     }
 
     rv = connection->socket()->Read(
-        read_buf,
-        read_buf->RemainingCapacity(),
-        base::Bind(&HttpServer::OnReadCompleted,
-                   weak_ptr_factory_.GetWeakPtr(), connection->id()));
+        read_buf, read_buf->RemainingCapacity(),
+        base::BindOnce(&HttpServer::OnReadCompleted,
+                       weak_ptr_factory_.GetWeakPtr(), connection->id()));
     if (rv == ERR_IO_PENDING)
       return;
     rv = HandleReadResult(connection, rv);
@@ -325,9 +324,9 @@ void HttpServer::DoWriteLoop(HttpConnection* connection,
   while (rv == OK && write_buf->GetSizeToWrite() > 0) {
     rv = connection->socket()->Write(
         write_buf, write_buf->GetSizeToWrite(),
-        base::Bind(&HttpServer::OnWriteCompleted,
-                   weak_ptr_factory_.GetWeakPtr(), connection->id(),
-                   traffic_annotation),
+        base::BindOnce(&HttpServer::OnWriteCompleted,
+                       weak_ptr_factory_.GetWeakPtr(), connection->id(),
+                       traffic_annotation),
         traffic_annotation);
     if (rv == ERR_IO_PENDING || rv == OK)
       return;

net/server/http_server_unittest.cc

@@ -125,7 +125,7 @@ class TestHttpClient {
   void Write() {
     int result = socket_->Write(
         write_buffer_.get(), write_buffer_->BytesRemaining(),
-        base::Bind(&TestHttpClient::OnWrite, base::Unretained(this)),
+        base::BindOnce(&TestHttpClient::OnWrite, base::Unretained(this)),
         TRAFFIC_ANNOTATION_FOR_TESTS);
     if (result != ERR_IO_PENDING)
       OnWrite(result);

net/socket/sequenced_socket_data_unittest.cc

@@ -479,8 +479,8 @@ TEST_F(SequencedSocketDataTest, SyncReadFromCompletionCallback) {
       ERR_IO_PENDING,
       sock_->Read(
           read_buf_.get(), kLen1,
-          base::Bind(&SequencedSocketDataTest::ReentrantReadCallback,
-                     base::Unretained(this), kMsg1, kLen1, kLen2, kLen2)));
+          base::BindOnce(&SequencedSocketDataTest::ReentrantReadCallback,
+                         base::Unretained(this), kMsg1, kLen1, kLen2, kLen2)));
 
   base::RunLoop().RunUntilIdle();
   AssertReadBufferEquals(kMsg2, kLen2);
@@ -527,12 +527,12 @@ TEST_F(SequencedSocketDataTest, AsyncReadFromCompletionCallback) {
   Initialize(reads, base::span<MockWrite>());
 
   read_buf_ = base::MakeRefCounted<IOBuffer>(kLen1);
-  ASSERT_EQ(
-      ERR_IO_PENDING,
-      sock_->Read(read_buf_.get(), kLen1,
-                  base::Bind(&SequencedSocketDataTest::ReentrantReadCallback,
-                             base::Unretained(this), kMsg1, kLen1, kLen2,
-                             ERR_IO_PENDING)));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(
+                read_buf_.get(), kLen1,
+                base::BindOnce(&SequencedSocketDataTest::ReentrantReadCallback,
+                               base::Unretained(this), kMsg1, kLen1, kLen2,
+                               ERR_IO_PENDING)));
 
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_EQ(kLen2, read_callback_.WaitForResult());
@@ -780,12 +780,13 @@ TEST_F(SequencedSocketDataTest, SyncWriteFromCompletionCallback) {
 
   scoped_refptr<IOBuffer> write_buf = base::MakeRefCounted<IOBuffer>(kLen1);
   memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Write(
-                write_buf.get(), kLen1,
-                base::Bind(&SequencedSocketDataTest::ReentrantWriteCallback,
-                           base::Unretained(this), kLen1, kMsg2, kLen2, kLen2),
-                TRAFFIC_ANNOTATION_FOR_TESTS));
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      sock_->Write(
+          write_buf.get(), kLen1,
+          base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
+                         base::Unretained(this), kLen1, kMsg2, kLen2, kLen2),
+          TRAFFIC_ANNOTATION_FOR_TESTS));
 
   base::RunLoop().RunUntilIdle();
 }
@@ -799,13 +800,13 @@ TEST_F(SequencedSocketDataTest, AsyncWriteFromCompletionCallback) {
 
   scoped_refptr<IOBuffer> write_buf = base::MakeRefCounted<IOBuffer>(kLen1);
   memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(
-      ERR_IO_PENDING,
-      sock_->Write(write_buf.get(), kLen1,
-                   base::Bind(&SequencedSocketDataTest::ReentrantWriteCallback,
-                              base::Unretained(this), kLen1, kMsg2, kLen2,
-                              ERR_IO_PENDING),
-                   TRAFFIC_ANNOTATION_FOR_TESTS));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Write(
+                write_buf.get(), kLen1,
+                base::BindOnce(&SequencedSocketDataTest::ReentrantWriteCallback,
+                               base::Unretained(this), kLen1, kMsg2, kLen2,
+                               ERR_IO_PENDING),
+                TRAFFIC_ANNOTATION_FOR_TESTS));
 
   ASSERT_FALSE(write_callback_.have_result());
   ASSERT_EQ(kLen2, write_callback_.WaitForResult());
@@ -977,12 +978,13 @@ TEST_F(SequencedSocketDataTest, AsyncReadFromWriteCompletionCallback) {
 
   scoped_refptr<IOBuffer> write_buf = base::MakeRefCounted<IOBuffer>(kLen1);
   memcpy(write_buf->data(), kMsg1, kLen1);
-  ASSERT_EQ(ERR_IO_PENDING,
-            sock_->Write(
-                write_buf.get(), kLen1,
-                base::Bind(&SequencedSocketDataTest::ReentrantAsyncReadCallback,
-                           base::Unretained(this), kLen1, kLen2),
-                TRAFFIC_ANNOTATION_FOR_TESTS));
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      sock_->Write(
+          write_buf.get(), kLen1,
+          base::BindOnce(&SequencedSocketDataTest::ReentrantAsyncReadCallback,
+                         base::Unretained(this), kLen1, kLen2),
+          TRAFFIC_ANNOTATION_FOR_TESTS));
 
   ASSERT_FALSE(read_callback_.have_result());
   ASSERT_EQ(kLen2, read_callback_.WaitForResult());

net/socket/socket_posix.cc

@@ -271,9 +271,9 @@ int SocketPosix::Read(IOBuffer* buf,
                       CompletionOnceCallback callback) {
   // Use base::Unretained() is safe here because OnFileCanReadWithoutBlocking()
   // won't be called if |this| is gone.
-  int rv =
-      ReadIfReady(buf, buf_len,
-                  base::Bind(&SocketPosix::RetryRead, base::Unretained(this)));
+  int rv = ReadIfReady(
+      buf, buf_len,
+      base::BindOnce(&SocketPosix::RetryRead, base::Unretained(this)));
   if (rv == ERR_IO_PENDING) {
     read_buf_ = buf;
     read_buf_len_ = buf_len;
@@ -502,7 +502,7 @@ void SocketPosix::RetryRead(int rv) {
   if (rv == OK) {
     rv = ReadIfReady(
         read_buf_.get(), read_buf_len_,
-        base::Bind(&SocketPosix::RetryRead, base::Unretained(this)));
+        base::BindOnce(&SocketPosix::RetryRead, base::Unretained(this)));
     if (rv == ERR_IO_PENDING)
       return;
   }

net/socket/socket_test_util.cc

@@ -982,7 +982,7 @@ int MockTCPClientSocket::Read(IOBuffer* buf,
   // takes a weak ptr of the base class, MockClientSocket.
   int rv = ReadIfReadyImpl(
       buf, buf_len,
-      base::Bind(&MockTCPClientSocket::RetryRead, base::Unretained(this)));
+      base::BindOnce(&MockTCPClientSocket::RetryRead, base::Unretained(this)));
   if (rv == ERR_IO_PENDING) {
     DCHECK(callback);
 
@@ -1224,9 +1224,9 @@ void MockTCPClientSocket::RetryRead(int rv) {
   DCHECK_LT(0, pending_read_buf_len_);
 
   if (rv == OK) {
-    rv = ReadIfReadyImpl(
-        pending_read_buf_.get(), pending_read_buf_len_,
-        base::Bind(&MockTCPClientSocket::RetryRead, base::Unretained(this)));
+    rv = ReadIfReadyImpl(pending_read_buf_.get(), pending_read_buf_len_,
+                         base::BindOnce(&MockTCPClientSocket::RetryRead,
+                                        base::Unretained(this)));
     if (rv == ERR_IO_PENDING)
       return;
   }
@@ -2079,8 +2079,8 @@ MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() = default;
 
 int MockTransportClientSocketPool::MockConnectJob::Connect() {
   socket_->ApplySocketTag(socket_tag_);
-  int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect,
-                                       base::Unretained(this)));
+  int rv = socket_->Connect(
+      base::BindOnce(&MockConnectJob::OnConnect, base::Unretained(this)));
   if (rv != ERR_IO_PENDING) {
     user_callback_.Reset();
     OnConnect(rv);

net/socket/socks_client_socket.cc

@@ -371,7 +371,7 @@ int SOCKSClientSocket::DoHandshakeWrite() {
          handshake_buf_len);
   return transport_socket_->Write(
       handshake_buf_.get(), handshake_buf_len,
-      base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)),
+      base::BindOnce(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)),
       traffic_annotation_);
 }
 
@@ -406,7 +406,7 @@ int SOCKSClientSocket::DoHandshakeRead() {
   handshake_buf_ = base::MakeRefCounted<IOBuffer>(handshake_buf_len);
   return transport_socket_->Read(
       handshake_buf_.get(), handshake_buf_len,
-      base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)));
+      base::BindOnce(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
 int SOCKSClientSocket::DoHandshakeReadComplete(int result) {

net/socket/ssl_client_socket_unittest.cc

@@ -238,8 +238,8 @@ int ReadBufferingStreamSocket::DoRead() {
   state_ = STATE_READ_COMPLETE;
   return transport_->Read(
       read_buffer_.get(), read_buffer_->RemainingCapacity(),
-      base::Bind(&ReadBufferingStreamSocket::OnReadCompleted,
-                 base::Unretained(this)));
+      base::BindOnce(&ReadBufferingStreamSocket::OnReadCompleted,
+                     base::Unretained(this)));
 }
 
 int ReadBufferingStreamSocket::DoReadComplete(int result) {
@@ -466,10 +466,10 @@ int FakeBlockingStreamSocket::Read(IOBuffer* buf,
   DCHECK_EQ(ERR_IO_PENDING, pending_read_result_);
   DCHECK(!callback.is_null());
 
-  int rv =
-      transport_->Read(buf, len,
-                       base::Bind(&FakeBlockingStreamSocket::OnReadCompleted,
-                                  base::Unretained(this)));
+  int rv = transport_->Read(
+      buf, len,
+      base::BindOnce(&FakeBlockingStreamSocket::OnReadCompleted,
+                     base::Unretained(this)));
   if (rv == ERR_IO_PENDING || should_block_read_) {
     // Save the callback to be called later.
     pending_read_buf_ = buf;
@@ -501,8 +501,8 @@ int FakeBlockingStreamSocket::ReadIfReady(IOBuffer* buf,
   }
   scoped_refptr<IOBuffer> buf_copy = base::MakeRefCounted<IOBuffer>(len);
   int rv = Read(buf_copy.get(), len,
-                base::Bind(&FakeBlockingStreamSocket::CompleteReadIfReady,
-                           base::Unretained(this), buf_copy));
+                base::BindOnce(&FakeBlockingStreamSocket::CompleteReadIfReady,
+                               base::Unretained(this), buf_copy));
   if (rv > 0)
     memcpy(buf->data(), buf_copy->data(), rv);
   if (rv == ERR_IO_PENDING)

net/socket/ssl_server_socket_impl.cc

@@ -307,9 +307,8 @@ SSLServerContextImpl::SocketImpl::PrivateKeySignCallback(uint8_t* out,
   signature_result_ = ERR_IO_PENDING;
   context_->private_key_->Sign(
       algorithm, base::make_span(in, in_len),
-      base::BindRepeating(
-          &SSLServerContextImpl::SocketImpl::OnPrivateKeyComplete,
-          weak_factory_.GetWeakPtr()));
+      base::BindOnce(&SSLServerContextImpl::SocketImpl::OnPrivateKeyComplete,
+                     weak_factory_.GetWeakPtr()));
   return ssl_private_key_retry;
 }
 

net/socket/transport_client_socket_unittest.cc

@@ -111,9 +111,10 @@ void TransportClientSocketTest::SetUp() {
   // Get the server's address (including the actual port number).
   ASSERT_THAT(listen_sock_->GetLocalAddress(&local_address), IsOk());
   listen_port_ = local_address.port();
-  listen_sock_->Accept(&connected_sock_,
-                       base::Bind(&TransportClientSocketTest::AcceptCallback,
-                                  base::Unretained(this)));
+  listen_sock_->Accept(
+      &connected_sock_,
+      base::BindOnce(&TransportClientSocketTest::AcceptCallback,
+                     base::Unretained(this)));
 
   AddressList addr = AddressList::CreateFromIPAddress(
       IPAddress::IPv4Localhost(), listen_port_);

net/socket/udp_socket_perftest.cc

@@ -74,12 +74,12 @@ void UDPSocketPerfTest::WritePacketsToSocket(UDPClientSocket* socket,
   memset(io_buffer->data(), 'G', kPacketSize);
 
   while (num_of_packets) {
-    int rv =
-        socket->Write(io_buffer.get(), io_buffer->size(),
-                      base::Bind(&UDPSocketPerfTest::DoneWritePacketsToSocket,
-                                 weak_factory_.GetWeakPtr(), socket,
-                                 num_of_packets - 1, done_callback),
-                      TRAFFIC_ANNOTATION_FOR_TESTS);
+    int rv = socket->Write(
+        io_buffer.get(), io_buffer->size(),
+        base::BindOnce(&UDPSocketPerfTest::DoneWritePacketsToSocket,
+                       weak_factory_.GetWeakPtr(), socket, num_of_packets - 1,
+                       done_callback),
+        TRAFFIC_ANNOTATION_FOR_TESTS);
     if (rv == ERR_IO_PENDING)
       break;
     --num_of_packets;

net/socket/udp_socket_unittest.cc

@@ -199,9 +199,9 @@ void UDPSocketTest::ConnectTest(bool use_nonblocking_io) {
   // Test asynchronous read. Server waits for message.
   base::RunLoop run_loop;
   int read_result = 0;
-  int rv = server->RecvFrom(
-      buffer_.get(), kMaxRead, &recv_from_address_,
-      base::Bind(&ReadCompleteCallback, &read_result, run_loop.QuitClosure()));
+  int rv = server->RecvFrom(buffer_.get(), kMaxRead, &recv_from_address_,
+                            base::BindOnce(&ReadCompleteCallback, &read_result,
+                                           run_loop.QuitClosure()));
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
 
   // Client sends to the server.

net/test/embedded_test_server/default_handlers.cc

@@ -713,10 +713,9 @@ class ExabyteResponse : public net::test_server::BasicHttpResponse {
   // for the purpose of testing.
   static void SendExabyte(const net::test_server::SendBytesCallback& send) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::BindRepeating(
-            send, "echo",
-            base::BindRepeating(&ExabyteResponse::SendExabyte, send)));
+        FROM_HERE, base::BindOnce(send, "echo",
+                                  base::BindRepeating(
+                                      &ExabyteResponse::SendExabyte, send)));
   }
 
   DISALLOW_COPY_AND_ASSIGN(ExabyteResponse);

net/test/embedded_test_server/embedded_test_server.cc

@@ -383,10 +383,10 @@ std::unique_ptr<StreamSocket> EmbeddedTestServer::DoSSLUpgrade(
 }
 
 void EmbeddedTestServer::DoAcceptLoop() {
-  while (
-      listen_socket_->Accept(&accepted_socket_,
-                             base::Bind(&EmbeddedTestServer::OnAcceptCompleted,
-                                        base::Unretained(this))) == OK) {
+  while (listen_socket_->Accept(
+             &accepted_socket_,
+             base::BindOnce(&EmbeddedTestServer::OnAcceptCompleted,
+                            base::Unretained(this))) == OK) {
     HandleAcceptResult(std::move(accepted_socket_));
   }
 }
@@ -434,8 +434,8 @@ void EmbeddedTestServer::HandleAcceptResult(
     SSLServerSocket* ssl_socket =
         static_cast<SSLServerSocket*>(http_connection->socket_.get());
     int rv = ssl_socket->Handshake(
-        base::Bind(&EmbeddedTestServer::OnHandshakeDone, base::Unretained(this),
-                   http_connection));
+        base::BindOnce(&EmbeddedTestServer::OnHandshakeDone,
+                       base::Unretained(this), http_connection));
     if (rv != ERR_IO_PENDING)
       OnHandshakeDone(http_connection, rv);
   } else {
@@ -445,9 +445,9 @@ void EmbeddedTestServer::HandleAcceptResult(
 
 void EmbeddedTestServer::ReadData(HttpConnection* connection) {
   while (true) {
-    int rv =
-        connection->ReadData(base::Bind(&EmbeddedTestServer::OnReadCompleted,
-                                        base::Unretained(this), connection));
+    int rv = connection->ReadData(
+        base::BindOnce(&EmbeddedTestServer::OnReadCompleted,
+                       base::Unretained(this), connection));
     if (rv == ERR_IO_PENDING)
       return;
     if (!HandleReadResult(connection, rv))

net/test/embedded_test_server/http_connection.cc

@@ -54,10 +54,11 @@ bool HttpConnection::ConsumeData(int size) {
 void HttpConnection::SendInternal(const base::Closure& callback,
                                   scoped_refptr<DrainableIOBuffer> buf) {
   while (buf->BytesRemaining() > 0) {
-    int rv = socket_->Write(buf.get(), buf->BytesRemaining(),
-                            base::Bind(&HttpConnection::OnSendInternalDone,
-                                       base::Unretained(this), callback, buf),
-                            TRAFFIC_ANNOTATION_FOR_TESTS);
+    int rv =
+        socket_->Write(buf.get(), buf->BytesRemaining(),
+                       base::BindOnce(&HttpConnection::OnSendInternalDone,
+                                      base::Unretained(this), callback, buf),
+                       TRAFFIC_ANNOTATION_FOR_TESTS);
     if (rv == ERR_IO_PENDING)
       return;
 

net/test/run_all_unittests.cc

@@ -53,6 +53,6 @@ int main(int argc, char** argv) {
   net::TransportClientSocketPool::set_connect_backup_jobs_enabled(false);
 
   return base::LaunchUnitTests(
-      argc, argv, base::Bind(&NetTestSuite::Run,
-                             base::Unretained(&test_suite)));
+      argc, argv,
+      base::BindOnce(&NetTestSuite::Run, base::Unretained(&test_suite)));
 }

net/test/tcp_socket_proxy.cc

@@ -47,9 +47,10 @@ class SocketDataPump {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(!write_buffer_);
 
-    int result = from_socket_->Read(
-        read_buffer_.get(), kBufferSize,
-        base::Bind(&SocketDataPump::HandleReadResult, base::Unretained(this)));
+    int result =
+        from_socket_->Read(read_buffer_.get(), kBufferSize,
+                           base::BindOnce(&SocketDataPump::HandleReadResult,
+                                          base::Unretained(this)));
     if (result != ERR_IO_PENDING)
       HandleReadResult(result);
   }
@@ -71,10 +72,11 @@ class SocketDataPump {
     DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
     DCHECK(write_buffer_);
 
-    int result = to_socket_->Write(
-        write_buffer_.get(), write_buffer_->BytesRemaining(),
-        base::Bind(&SocketDataPump::HandleWriteResult, base::Unretained(this)),
-        TRAFFIC_ANNOTATION_FOR_TESTS);
+    int result =
+        to_socket_->Write(write_buffer_.get(), write_buffer_->BytesRemaining(),
+                          base::BindOnce(&SocketDataPump::HandleWriteResult,
+                                         base::Unretained(this)),
+                          TRAFFIC_ANNOTATION_FOR_TESTS);
     if (result != ERR_IO_PENDING)
       HandleWriteResult(result);
   }
@@ -154,8 +156,8 @@ void ConnectionProxy::Start(const IPEndPoint& remote_endpoint,
   remote_socket_ = std::make_unique<TCPClientSocket>(
       AddressList(remote_endpoint), nullptr, nullptr, NetLogSource());
   int result = remote_socket_->Connect(
-      base::Bind(&ConnectionProxy::HandleConnectResult, base::Unretained(this),
-                 remote_endpoint));
+      base::BindOnce(&ConnectionProxy::HandleConnectResult,
+                     base::Unretained(this), remote_endpoint));
   if (result != ERR_IO_PENDING)
     HandleConnectResult(remote_endpoint, result);
 }
@@ -270,7 +272,7 @@ void TcpSocketProxy::Core::DoAcceptLoop() {
   while (result == OK) {
     result = socket_->Accept(
         &accepted_socket_,
-        base::Bind(&Core::OnAcceptResult, base::Unretained(this)));
+        base::BindOnce(&Core::OnAcceptResult, base::Unretained(this)));
     if (result != ERR_IO_PENDING)
       HandleAcceptResult(result);
   }

net/tools/quic/quic_simple_server.cc

@@ -181,7 +181,8 @@ void QuicSimpleServer::StartReading() {
 
   int result = socket_->RecvFrom(
       read_buffer_.get(), read_buffer_->size(), &client_address_,
-      base::Bind(&QuicSimpleServer::OnReadComplete, base::Unretained(this)));
+      base::BindOnce(&QuicSimpleServer::OnReadComplete,
+                     base::Unretained(this)));
 
   if (result == ERR_IO_PENDING) {
     synchronous_read_count_ = 0;

net/tools/quic/quic_simple_server_packet_writer.cc

@@ -57,8 +57,8 @@ quic::WriteResult QuicSimpleServerPacketWriter::WritePacket(
   if (buf_len <= static_cast<size_t>(std::numeric_limits<int>::max())) {
     rv = socket_->SendTo(
         buf.get(), static_cast<int>(buf_len), ToIPEndPoint(peer_address),
-        base::Bind(&QuicSimpleServerPacketWriter::OnWriteComplete,
-                   weak_factory_.GetWeakPtr()));
+        base::BindOnce(&QuicSimpleServerPacketWriter::OnWriteComplete,
+                       weak_factory_.GetWeakPtr()));
   } else {
     rv = ERR_MSG_TOO_BIG;
   }

net/tools/stress_cache/stress_cache.cc

@@ -169,7 +169,7 @@ void EntryWrapper::DoOpen(int key) {
   state_ = OPEN;
   disk_cache::EntryResult result = g_data->cache->OpenEntry(
       g_data->keys[key], net::HIGHEST,
-      base::Bind(&EntryWrapper::OnOpenDone, base::Unretained(this), key));
+      base::BindOnce(&EntryWrapper::OnOpenDone, base::Unretained(this), key));
   if (result.net_error() != net::ERR_IO_PENDING)
     OnOpenDone(key, std::move(result));
 }
@@ -184,7 +184,7 @@ void EntryWrapper::OnOpenDone(int key, disk_cache::EntryResult result) {
   state_ = CREATE;
   result = g_data->cache->CreateEntry(
       g_data->keys[key], net::HIGHEST,
-      base::Bind(&EntryWrapper::OnOpenDone, base::Unretained(this), key));
+      base::BindOnce(&EntryWrapper::OnOpenDone, base::Unretained(this), key));
   if (result.net_error() != net::ERR_IO_PENDING)
     OnOpenDone(key, std::move(result));
 }
@@ -198,7 +198,7 @@ void EntryWrapper::DoRead() {
   memset(buffer_->data(), 'k', kReadSize);
   int rv = entry_->ReadData(
       0, 0, buffer_.get(), kReadSize,
-      base::Bind(&EntryWrapper::OnReadDone, base::Unretained(this)));
+      base::BindOnce(&EntryWrapper::OnReadDone, base::Unretained(this)));
   if (rv != net::ERR_IO_PENDING)
     OnReadDone(rv);
 }
@@ -219,7 +219,7 @@ void EntryWrapper::DoWrite() {
                  g_data->writes, g_data->iteration, size, truncate ? 1 : 0);
   int rv = entry_->WriteData(
       0, 0, buffer_.get(), size,
-      base::Bind(&EntryWrapper::OnWriteDone, base::Unretained(this), size),
+      base::BindOnce(&EntryWrapper::OnWriteDone, base::Unretained(this), size),
       truncate);
   if (rv != net::ERR_IO_PENDING)
     OnWriteDone(size, rv);
@@ -251,7 +251,7 @@ void EntryWrapper::DoDelete(const std::string& key) {
   state_ = DOOM;
   int rv = g_data->cache->DoomEntry(
       key, net::HIGHEST,
-      base::Bind(&EntryWrapper::OnDeleteDone, base::Unretained(this)));
+      base::BindOnce(&EntryWrapper::OnDeleteDone, base::Unretained(this)));
   if (rv != net::ERR_IO_PENDING)
     OnDeleteDone(rv);
 }

net/url_request/url_fetcher_core.cc

@@ -483,7 +483,7 @@ void URLFetcherCore::OnReadCompleted(URLRequest* request,
     // No more data to write.
     const int result = response_writer_->Finish(
         bytes_read > 0 ? OK : bytes_read,
-        base::Bind(&URLFetcherCore::DidFinishWriting, this));
+        base::BindOnce(&URLFetcherCore::DidFinishWriting, this));
     if (result != ERR_IO_PENDING)
       DidFinishWriting(result);
   }
@@ -527,7 +527,7 @@ void URLFetcherCore::StartOnIOThread() {
     response_writer_.reset(new URLFetcherStringWriter);
 
   const int result = response_writer_->Initialize(
-      base::Bind(&URLFetcherCore::DidInitializeWriter, this));
+      base::BindOnce(&URLFetcherCore::DidInitializeWriter, this));
   if (result != ERR_IO_PENDING)
     DidInitializeWriter(result);
 }
@@ -856,9 +856,8 @@ void URLFetcherCore::CompleteAddingUploadDataChunk(
 int URLFetcherCore::WriteBuffer(scoped_refptr<DrainableIOBuffer> data) {
   while (data->BytesRemaining() > 0) {
     const int result = response_writer_->Write(
-        data.get(),
-        data->BytesRemaining(),
-        base::Bind(&URLFetcherCore::DidWriteBuffer, this, data));
+        data.get(), data->BytesRemaining(),
+        base::BindOnce(&URLFetcherCore::DidWriteBuffer, this, data));
     if (result < 0) {
       if (result != ERR_IO_PENDING)
         DidWriteBuffer(data, result);

net/url_request/url_fetcher_impl_unittest.cc

@@ -600,7 +600,7 @@ TEST_F(URLFetcherTest, SequencedTaskTest) {
                   EXPECT_EQ(kDefaultResponseBody, data);
                   std::move(quit_closure).Run();
                 },
-                base::Passed(&quit_closure), base::Passed(&delegate)));
+                std::move(quit_closure), base::Passed(&delegate)));
 
             raw_delegate->CreateFetcher(response_path, URLFetcher::GET,
                                         context_getter);
@@ -1336,7 +1336,7 @@ TEST_F(URLFetcherTest, CancelSameThread) {
       CreateSameThreadContextGetter());
   bool getter_was_destroyed = false;
   context_getter->set_on_destruction_callback(
-      base::Bind(&SetBoolToTrue, &getter_was_destroyed));
+      base::BindOnce(&SetBoolToTrue, &getter_was_destroyed));
   delegate.CreateFetcher(hanging_url(), URLFetcher::GET, context_getter);
 
   // The getter won't be destroyed if the test holds on to a reference to it.

net/url_request/url_fetcher_response_writer.cc

@@ -81,11 +81,12 @@ int URLFetcherFileWriter::Initialize(CompletionOnceCallback callback) {
                    weak_factory_.GetWeakPtr(),
                    base::Owned(temp_file_path)));
   } else {
-    result = file_stream_->Open(file_path_, base::File::FLAG_WRITE |
-                                                base::File::FLAG_ASYNC |
-                                                base::File::FLAG_CREATE_ALWAYS,
-                                base::Bind(&URLFetcherFileWriter::OnIOCompleted,
-                                           weak_factory_.GetWeakPtr()));
+    result =
+        file_stream_->Open(file_path_,
+                           base::File::FLAG_WRITE | base::File::FLAG_ASYNC |
+                               base::File::FLAG_CREATE_ALWAYS,
+                           base::BindOnce(&URLFetcherFileWriter::OnIOCompleted,
+                                          weak_factory_.GetWeakPtr()));
     DCHECK_NE(OK, result);
   }
 
@@ -105,9 +106,10 @@ int URLFetcherFileWriter::Write(IOBuffer* buffer,
   DCHECK(owns_file_);
   DCHECK(!callback_);
 
-  int result = file_stream_->Write(
-      buffer, num_bytes, base::Bind(&URLFetcherFileWriter::OnIOCompleted,
-                                    weak_factory_.GetWeakPtr()));
+  int result =
+      file_stream_->Write(buffer, num_bytes,
+                          base::BindOnce(&URLFetcherFileWriter::OnIOCompleted,
+                                         weak_factory_.GetWeakPtr()));
   if (result == ERR_IO_PENDING) {
     callback_ = std::move(callback);
     return result;
@@ -134,7 +136,7 @@ int URLFetcherFileWriter::Finish(int net_error,
   DCHECK(!callback_);
   // If the file_stream_ still exists at this point, close it.
   if (file_stream_) {
-    int result = file_stream_->Close(base::Bind(
+    int result = file_stream_->Close(base::BindOnce(
         &URLFetcherFileWriter::CloseComplete, weak_factory_.GetWeakPtr()));
     if (result == ERR_IO_PENDING) {
       callback_ = std::move(callback);
@@ -179,8 +181,8 @@ void URLFetcherFileWriter::DidCreateTempFile(base::FilePath* temp_file_path,
   const int result = file_stream_->Open(
       file_path_,
       base::File::FLAG_WRITE | base::File::FLAG_ASYNC | base::File::FLAG_OPEN,
-      base::Bind(&URLFetcherFileWriter::OnIOCompleted,
-                 weak_factory_.GetWeakPtr()));
+      base::BindOnce(&URLFetcherFileWriter::OnIOCompleted,
+                     weak_factory_.GetWeakPtr()));
   if (result != ERR_IO_PENDING)
     OnIOCompleted(result);
 }

net/url_request/url_request_file_job.cc

@@ -70,11 +70,10 @@ void URLRequestFileJob::Start() {
   FileMetaInfo* meta_info = new FileMetaInfo();
   file_task_runner_->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&URLRequestFileJob::FetchMetaInfo, file_path_,
-                 base::Unretained(meta_info)),
-      base::Bind(&URLRequestFileJob::DidFetchMetaInfo,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(meta_info)));
+      base::BindOnce(&URLRequestFileJob::FetchMetaInfo, file_path_,
+                     base::Unretained(meta_info)),
+      base::BindOnce(&URLRequestFileJob::DidFetchMetaInfo,
+                     weak_ptr_factory_.GetWeakPtr(), base::Owned(meta_info)));
 }
 
 void URLRequestFileJob::Kill() {
@@ -96,10 +95,10 @@ int URLRequestFileJob::ReadRawData(IOBuffer* dest, int dest_size) {
   if (!dest_size)
     return 0;
 
-  int rv = stream_->Read(
-      dest, dest_size,
-      base::Bind(&URLRequestFileJob::DidRead, weak_ptr_factory_.GetWeakPtr(),
-                 base::WrapRefCounted(dest)));
+  int rv = stream_->Read(dest, dest_size,
+                         base::BindOnce(&URLRequestFileJob::DidRead,
+                                        weak_ptr_factory_.GetWeakPtr(),
+                                        base::WrapRefCounted(dest)));
   if (rv >= 0) {
     remaining_bytes_ -= rv;
     DCHECK_GE(remaining_bytes_, 0);
@@ -258,8 +257,8 @@ void URLRequestFileJob::DidFetchMetaInfo(const FileMetaInfo* meta_info) {
               base::File::FLAG_READ |
               base::File::FLAG_ASYNC;
   int rv = stream_->Open(file_path_, flags,
-                         base::Bind(&URLRequestFileJob::DidOpen,
-                                    weak_ptr_factory_.GetWeakPtr()));
+                         base::BindOnce(&URLRequestFileJob::DidOpen,
+                                        weak_ptr_factory_.GetWeakPtr()));
   if (rv != ERR_IO_PENDING)
     DidOpen(rv);
 }
@@ -283,8 +282,8 @@ void URLRequestFileJob::DidOpen(int result) {
 
   if (remaining_bytes_ > 0 && byte_range_.first_byte_position() != 0) {
     int rv = stream_->Seek(byte_range_.first_byte_position(),
-                           base::Bind(&URLRequestFileJob::DidSeek,
-                                      weak_ptr_factory_.GetWeakPtr()));
+                           base::BindOnce(&URLRequestFileJob::DidSeek,
+                                          weak_ptr_factory_.GetWeakPtr()));
     if (rv != ERR_IO_PENDING)
       DidSeek(ERR_REQUEST_RANGE_NOT_SATISFIABLE);
   } else {

net/url_request/url_request_ftp_job.cc

@@ -102,8 +102,8 @@ void URLRequestFtpJob::Start() {
               proxy_resolution_service_);
     rv = proxy_resolution_service_->ResolveProxy(
         request_->url(), "GET", &proxy_info_,
-        base::Bind(&URLRequestFtpJob::OnResolveProxyComplete,
-                   base::Unretained(this)),
+        base::BindOnce(&URLRequestFtpJob::OnResolveProxyComplete,
+                       base::Unretained(this)),
         &proxy_resolve_request_, request_->net_log());
 
     if (rv == ERR_IO_PENDING)
@@ -162,7 +162,8 @@ void URLRequestFtpJob::StartFtpTransaction() {
   if (ftp_transaction_) {
     rv = ftp_transaction_->Start(
         &ftp_request_info_,
-        base::Bind(&URLRequestFtpJob::OnStartCompleted, base::Unretained(this)),
+        base::BindOnce(&URLRequestFtpJob::OnStartCompleted,
+                       base::Unretained(this)),
         request_->net_log(), request_->traffic_annotation());
     if (rv == ERR_IO_PENDING)
       return;

net/url_request/url_request_http_job.cc

@@ -519,8 +519,8 @@ void URLRequestHttpJob::StartTransactionInternal() {
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(
-        auth_credentials_, base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                                      base::Unretained(this)));
+        auth_credentials_, base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+                                          base::Unretained(this)));
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context()->http_transaction_factory());
@@ -549,8 +549,9 @@ void URLRequestHttpJob::StartTransactionInternal() {
       if (!throttling_entry_.get() ||
           !throttling_entry_->ShouldRejectRequest(*request_)) {
         rv = transaction_->Start(
-            &request_info_, base::Bind(&URLRequestHttpJob::OnStartCompleted,
-                                       base::Unretained(this)),
+            &request_info_,
+            base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+                           base::Unretained(this)),
             request_->net_log());
         start_time_ = base::TimeTicks::Now();
       } else {
@@ -628,8 +629,8 @@ void URLRequestHttpJob::AddCookieHeaderAndStart() {
             request_->initiator(), request_->attach_same_site_cookies()));
     cookie_store->GetCookieListWithOptionsAsync(
         request_->url(), options,
-        base::Bind(&URLRequestHttpJob::SetCookieHeaderAndStart,
-                   weak_factory_.GetWeakPtr(), options));
+        base::BindOnce(&URLRequestHttpJob::SetCookieHeaderAndStart,
+                       weak_factory_.GetWeakPtr(), options));
   } else {
     StartTransaction();
   }
@@ -1238,7 +1239,8 @@ void URLRequestHttpJob::ContinueWithCertificate(
 
   int rv = transaction_->RestartWithCertificate(
       std::move(client_cert), std::move(client_private_key),
-      base::Bind(&URLRequestHttpJob::OnStartCompleted, base::Unretained(this)));
+      base::BindOnce(&URLRequestHttpJob::OnStartCompleted,
+                     base::Unretained(this)));
   if (rv == ERR_IO_PENDING)
     return;
 
@@ -1260,8 +1262,8 @@ void URLRequestHttpJob::ContinueDespiteLastError() {
 
   ResetTimer();
 
-  int rv = transaction_->RestartIgnoringLastError(
-      base::Bind(&URLRequestHttpJob::OnStartCompleted, base::Unretained(this)));
+  int rv = transaction_->RestartIgnoringLastError(base::BindOnce(
+      &URLRequestHttpJob::OnStartCompleted, base::Unretained(this)));
   if (rv == ERR_IO_PENDING)
     return;
 
@@ -1299,9 +1301,10 @@ int URLRequestHttpJob::ReadRawData(IOBuffer* buf, int buf_size) {
   DCHECK_NE(buf_size, 0);
   DCHECK(!read_in_progress_);
 
-  int rv = transaction_->Read(
-      buf, buf_size,
-      base::Bind(&URLRequestHttpJob::OnReadCompleted, base::Unretained(this)));
+  int rv =
+      transaction_->Read(buf, buf_size,
+                         base::BindOnce(&URLRequestHttpJob::OnReadCompleted,
+                                        base::Unretained(this)));
 
   if (ShouldFixMismatchedContentLength(rv))
     rv = OK;

net/url_request/url_request_job.cc

@@ -119,8 +119,9 @@ int URLRequestJob::Read(IOBuffer* buf, int buf_size) {
 
   pending_read_buffer_ = buf;
   int result = source_stream_->Read(
-      buf, buf_size, base::Bind(&URLRequestJob::SourceStreamReadComplete,
-                                weak_factory_.GetWeakPtr(), false));
+      buf, buf_size,
+      base::BindOnce(&URLRequestJob::SourceStreamReadComplete,
+                     weak_factory_.GetWeakPtr(), false));
   if (result == ERR_IO_PENDING)
     return ERR_IO_PENDING;
 

net/url_request/url_request_quic_perftest.cc

@@ -274,7 +274,8 @@ TEST_F(URLRequestQuicPerfTest, TestGetRequest) {
 
       };
   base::trace_event::MemoryDumpManager::GetInstance()->CreateProcessDump(
-      args, base::Bind(on_memory_dump_done, run_loop.QuitClosure(), context()));
+      args,
+      base::BindOnce(on_memory_dump_done, run_loop.QuitClosure(), context()));
   run_loop.Run();
   base::trace_event::MemoryDumpManager::GetInstance()->TeardownForTracing();
 }

net/url_request/url_request_simple_job.cc

@@ -73,10 +73,10 @@ int URLRequestSimpleJob::ReadRawData(IOBuffer* buf, int buf_size) {
   base::PostTaskAndReply(
       FROM_HERE,
       {base::ThreadPool(), base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
-      base::Bind(&CopyData, base::WrapRefCounted(buf), buf_size, data_,
-                 next_data_offset_),
-      base::Bind(&URLRequestSimpleJob::ReadRawDataComplete,
-                 weak_factory_.GetWeakPtr(), buf_size));
+      base::BindOnce(&CopyData, base::WrapRefCounted(buf), buf_size, data_,
+                     next_data_offset_),
+      base::BindOnce(&URLRequestSimpleJob::ReadRawDataComplete,
+                     weak_factory_.GetWeakPtr(), buf_size));
   next_data_offset_ += buf_size;
   return ERR_IO_PENDING;
 }
@@ -116,8 +116,8 @@ void URLRequestSimpleJob::StartAsync() {
 
   const int result =
       GetRefCountedData(&mime_type_, &charset_, &data_,
-                        base::Bind(&URLRequestSimpleJob::OnGetDataCompleted,
-                                   weak_factory_.GetWeakPtr()));
+                        base::BindOnce(&URLRequestSimpleJob::OnGetDataCompleted,
+                                       weak_factory_.GetWeakPtr()));
 
   if (result != ERR_IO_PENDING)
     OnGetDataCompleted(result);

net/url_request/url_request_unittest.cc

@@ -5756,11 +5756,9 @@ class AsyncLoggingUrlRequestDelegate : public TestDelegate {
                           bool* defer_redirect) override {
     *defer_redirect = true;
     AsyncDelegateLogger::Run(
-        request,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        base::Bind(
+        request, LOAD_STATE_WAITING_FOR_DELEGATE,
+        LOAD_STATE_WAITING_FOR_DELEGATE, LOAD_STATE_WAITING_FOR_DELEGATE,
+        base::BindOnce(
             &AsyncLoggingUrlRequestDelegate::OnReceivedRedirectLoggingComplete,
             base::Unretained(this), request, redirect_info));
   }
@@ -5769,18 +5767,15 @@ class AsyncLoggingUrlRequestDelegate : public TestDelegate {
     AsyncDelegateLogger::Run(
         request, LOAD_STATE_WAITING_FOR_DELEGATE,
         LOAD_STATE_WAITING_FOR_DELEGATE, LOAD_STATE_WAITING_FOR_DELEGATE,
-        base::Bind(
+        base::BindOnce(
             &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
             base::Unretained(this), request, net_error));
   }
 
   void OnReadCompleted(URLRequest* request, int bytes_read) override {
     AsyncDelegateLogger::Run(
-        request,
-        LOAD_STATE_IDLE,
-        LOAD_STATE_IDLE,
-        LOAD_STATE_IDLE,
-        base::Bind(
+        request, LOAD_STATE_IDLE, LOAD_STATE_IDLE, LOAD_STATE_IDLE,
+        base::BindOnce(
             &AsyncLoggingUrlRequestDelegate::AfterReadCompletedLoggingComplete,
             base::Unretained(this), request, bytes_read));
   }
@@ -5833,11 +5828,9 @@ TEST_F(URLRequestTestHTTP, DelegateInfoBeforeStart) {
     EXPECT_EQ(base::string16(), load_state.param);
 
     AsyncDelegateLogger::Run(
-        r.get(),
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_WAITING_FOR_DELEGATE,
-        LOAD_STATE_IDLE,
-        base::Bind(&URLRequest::Start, base::Unretained(r.get())));
+        r.get(), LOAD_STATE_WAITING_FOR_DELEGATE,
+        LOAD_STATE_WAITING_FOR_DELEGATE, LOAD_STATE_IDLE,
+        base::BindOnce(&URLRequest::Start, base::Unretained(r.get())));
 
     request_delegate.RunUntilComplete();