Use base::BindOnce for PostTask callbacks.

TaskRunner::PostTask() takes a OnceCallback. Replace usage of
base::Bind(), which produces a RepeatingCallback, with base::BindOnce()
when the callback is created as a temporary inside of PostTask(). The
following regex was used to find instances that could be replaced:

(Post(?:Delayed)?Task)\((?:\n\s*)?FROM_HERE,(?:\n)?\s*base::Bind\(

Also replace any usage of base::Passed(&var) with std::move(var) for
variables passed to base::BindOnce(). base::Passed() isn't needed for
move-only types with OnceCallbacks.

This CL was uploaded by git cl split.

R=rogerta@chromium.org

Bug: 714018
Change-Id: I6b26b0eb43cb5167e8c115781c956bfe13d6bdfc
Reviewed-on: https://chromium-review.googlesource.com/c/1475637
Auto-Submit: kylechar <kylechar@chromium.org>
Reviewed-by: Roger Tawa <rogerta@chromium.org>
Commit-Queue: Roger Tawa <rogerta@chromium.org>
Cr-Commit-Position: refs/heads/master@{#632809}

google_apis/drive/auth_service.cc

@@ -137,7 +137,7 @@ void AuthService::StartAuthentication(const AuthStatusCallback& callback) {
   if (HasAccessToken()) {
     // We already have access token. Give it back to the caller asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, HTTP_SUCCESS, access_token_));
+        FROM_HERE, base::BindOnce(callback, HTTP_SUCCESS, access_token_));
   } else if (HasRefreshToken()) {
     // We have refresh token, let's get an access token.
     new AuthRequest(identity_manager_, account_id_, url_loader_factory_,
@@ -146,7 +146,7 @@ void AuthService::StartAuthentication(const AuthStatusCallback& callback) {
                     scopes_);
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, DRIVE_NOT_READY, std::string()));
+        FROM_HERE, base::BindOnce(callback, DRIVE_NOT_READY, std::string()));
   }
 }
 

google_apis/drive/base_requests.cc

@@ -303,8 +303,9 @@ void UrlFetchRequestBase::StartAfterPrepare(
     // asynchronously because client code does not assume result callback is
     // called synchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(&UrlFetchRequestBase::CompleteRequestWithError,
-                              weak_ptr_factory_.GetWeakPtr(), error_code));
+        FROM_HERE,
+        base::BindOnce(&UrlFetchRequestBase::CompleteRequestWithError,
+                       weak_ptr_factory_.GetWeakPtr(), error_code));
     return;
   }
 

google_apis/gaia/oauth2_token_service.cc

@@ -446,9 +446,9 @@ OAuth2TokenService::StartRequestForMultilogin(
   // If we can get refresh token from the delegate, inform cosumer right away.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&RequestImpl::InformConsumer, request.get()->AsWeakPtr(),
-                 GoogleServiceAuthError(GoogleServiceAuthError::NONE),
-                 token_response));
+      base::BindOnce(&RequestImpl::InformConsumer, request.get()->AsWeakPtr(),
+                     GoogleServiceAuthError(GoogleServiceAuthError::NONE),
+                     token_response));
   return std::move(request);
 }
 
@@ -515,8 +515,8 @@ OAuth2TokenService::StartRequestForClientWithContext(
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&RequestImpl::InformConsumer, request->AsWeakPtr(), error,
-                   OAuth2AccessTokenConsumer::TokenResponse()));
+        base::BindOnce(&RequestImpl::InformConsumer, request->AsWeakPtr(),
+                       error, OAuth2AccessTokenConsumer::TokenResponse()));
     return std::move(request);
   }
 
@@ -580,9 +580,9 @@ void OAuth2TokenService::InformConsumerWithCachedTokenResponse(
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(&RequestImpl::InformConsumer, request->AsWeakPtr(),
-                 GoogleServiceAuthError(GoogleServiceAuthError::NONE),
-                 *cache_token_response));
+      base::BindOnce(&RequestImpl::InformConsumer, request->AsWeakPtr(),
+                     GoogleServiceAuthError(GoogleServiceAuthError::NONE),
+                     *cache_token_response));
 }
 
 std::vector<std::string> OAuth2TokenService::GetAccounts() const {

google_apis/gaia/oauth2_token_service_request.cc

@@ -111,8 +111,8 @@ void OAuth2TokenServiceRequest::Core::Start() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   token_service_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&OAuth2TokenServiceRequest::Core::StartOnTokenServiceThread,
-                 this));
+      base::BindOnce(
+          &OAuth2TokenServiceRequest::Core::StartOnTokenServiceThread, this));
 }
 
 void OAuth2TokenServiceRequest::Core::Stop() {
@@ -127,8 +127,8 @@ void OAuth2TokenServiceRequest::Core::Stop() {
   // will be destroyed on the owner thread.
   token_service_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&OAuth2TokenServiceRequest::Core::StopOnTokenServiceThread,
-                 this));
+      base::BindOnce(&OAuth2TokenServiceRequest::Core::StopOnTokenServiceThread,
+                     this));
 }
 
 bool OAuth2TokenServiceRequest::Core::IsStopped() const {
@@ -227,8 +227,8 @@ void RequestCore::OnGetTokenSuccess(
   DCHECK(token_service_task_runner()->RunsTasksInCurrentSequence());
   DCHECK_EQ(request_.get(), request);
   owning_task_runner()->PostTask(
-      FROM_HERE, base::Bind(&RequestCore::InformOwnerOnGetTokenSuccess, this,
-                            token_response));
+      FROM_HERE, base::BindOnce(&RequestCore::InformOwnerOnGetTokenSuccess,
+                                this, token_response));
   request_.reset();
 }
 
@@ -238,7 +238,7 @@ void RequestCore::OnGetTokenFailure(const OAuth2TokenService::Request* request,
   DCHECK_EQ(request_.get(), request);
   owning_task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&RequestCore::InformOwnerOnGetTokenFailure, this, error));
+      base::BindOnce(&RequestCore::InformOwnerOnGetTokenFailure, this, error));
   request_.reset();
 }
 

google_apis/gcm/engine/checkin_request.cc

@@ -207,7 +207,7 @@ void CheckinRequest::RetryWithBackoff() {
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&CheckinRequest::Start, weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&CheckinRequest::Start, weak_ptr_factory_.GetWeakPtr()),
       backoff_entry_.GetTimeUntilRelease());
 }
 

google_apis/gcm/engine/connection_factory_impl.cc

@@ -144,8 +144,8 @@ void ConnectionFactoryImpl::ConnectWithBackoff() {
         backoff_entry_->GetTimeUntilRelease().InMilliseconds());
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
-        base::Bind(&ConnectionFactoryImpl::ConnectWithBackoff,
-                   weak_ptr_factory_.GetWeakPtr()),
+        base::BindOnce(&ConnectionFactoryImpl::ConnectWithBackoff,
+                       weak_ptr_factory_.GetWeakPtr()),
         backoff_entry_->GetTimeUntilRelease());
     return;
   }

google_apis/gcm/engine/connection_handler_impl.cc

@@ -133,9 +133,8 @@ void ConnectionHandlerImpl::Login(
           base::Bind(&ConnectionHandlerImpl::OnMessageSent,
                      weak_ptr_factory_.GetWeakPtr())) != net::ERR_IO_PENDING) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&ConnectionHandlerImpl::OnMessageSent,
-                   weak_ptr_factory_.GetWeakPtr()));
+        FROM_HERE, base::BindOnce(&ConnectionHandlerImpl::OnMessageSent,
+                                  weak_ptr_factory_.GetWeakPtr()));
   }
 
   read_timeout_timer_.Start(FROM_HERE,
@@ -262,9 +261,8 @@ void ConnectionHandlerImpl::WaitForData(ProcessingState state) {
              << " more bytes.";
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
-        base::Bind(&ConnectionHandlerImpl::WaitForData,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   MCS_PROTO_BYTES));
+        base::BindOnce(&ConnectionHandlerImpl::WaitForData,
+                       weak_ptr_factory_.GetWeakPtr(), MCS_PROTO_BYTES));
     return;
   }
 
@@ -383,9 +381,8 @@ void ConnectionHandlerImpl::OnGotMessageBytes() {
   // that tag.
   if (protobuf.get() && message_size_ == 0) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE,
-        base::Bind(&ConnectionHandlerImpl::GetNextMessage,
-                   weak_ptr_factory_.GetWeakPtr()));
+        FROM_HERE, base::BindOnce(&ConnectionHandlerImpl::GetNextMessage,
+                                  weak_ptr_factory_.GetWeakPtr()));
     read_callback_.Run(std::move(protobuf));
     return;
   }
@@ -456,9 +453,8 @@ void ConnectionHandlerImpl::OnGotMessageBytes() {
 
   input_stream_->RebuildBuffer();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&ConnectionHandlerImpl::GetNextMessage,
-                 weak_ptr_factory_.GetWeakPtr()));
+      FROM_HERE, base::BindOnce(&ConnectionHandlerImpl::GetNextMessage,
+                                weak_ptr_factory_.GetWeakPtr()));
   if (message_tag_ == kLoginResponseTag) {
     if (handshake_complete_) {
       LOG(ERROR) << "Unexpected login response.";

google_apis/gcm/engine/heartbeat_manager.cc

@@ -194,8 +194,8 @@ void HeartbeatManager::RestartTimer() {
   // Linux so we need to poll to check for missed heartbeats.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&HeartbeatManager::CheckForMissedHeartbeat,
-                 weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&HeartbeatManager::CheckForMissedHeartbeat,
+                     weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kHeartbeatMissedCheckMs));
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 }
@@ -217,8 +217,8 @@ void HeartbeatManager::CheckForMissedHeartbeat() {
   // Otherwise check again later.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&HeartbeatManager::CheckForMissedHeartbeat,
-                 weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&HeartbeatManager::CheckForMissedHeartbeat,
+                     weak_ptr_factory_.GetWeakPtr()),
       base::TimeDelta::FromMilliseconds(kHeartbeatMissedCheckMs));
 #endif  // defined(OS_LINUX) && !defined(OS_CHROMEOS)
 }

google_apis/gcm/engine/mcs_client.cc

@@ -550,9 +550,8 @@ void MCSClient::MaybeSendMessage() {
         base::Bind(&MCSClient::OnGCMUpdateFinished,
                    weak_ptr_factory_.GetWeakPtr()));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE,
-            base::Bind(&MCSClient::MaybeSendMessage,
-                       weak_ptr_factory_.GetWeakPtr()));
+        FROM_HERE, base::BindOnce(&MCSClient::MaybeSendMessage,
+                                  weak_ptr_factory_.GetWeakPtr()));
     return;
   }
   DVLOG(1) << "Pending output message found, sending.";
@@ -724,15 +723,14 @@ void MCSClient::HandlePacketFromWire(
 
       // Pass the login response on up.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(message_received_callback_,
-                                MCSMessage(tag, std::move(protobuf))));
+          FROM_HERE, base::BindOnce(message_received_callback_,
+                                    MCSMessage(tag, std::move(protobuf))));
 
       // If there are pending messages, attempt to send one.
       if (!to_send_.empty()) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE,
-            base::Bind(&MCSClient::MaybeSendMessage,
-                       weak_ptr_factory_.GetWeakPtr()));
+            FROM_HERE, base::BindOnce(&MCSClient::MaybeSendMessage,
+                                      weak_ptr_factory_.GetWeakPtr()));
       }
 
       heartbeat_manager_.Start(
@@ -794,8 +792,8 @@ void MCSClient::HandlePacketFromWire(
 
       DCHECK(protobuf.get());
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(message_received_callback_,
-                                MCSMessage(tag, std::move(protobuf))));
+          FROM_HERE, base::BindOnce(message_received_callback_,
+                                    MCSMessage(tag, std::move(protobuf))));
       return;
     }
     default:
@@ -901,9 +899,8 @@ void MCSClient::HandleSelectiveAck(const PersistentIdList& id_list) {
     to_resend_.pop_back();
   }
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&MCSClient::MaybeSendMessage,
-                 weak_ptr_factory_.GetWeakPtr()));
+      FROM_HERE, base::BindOnce(&MCSClient::MaybeSendMessage,
+                                weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MCSClient::HandleServerConfirmedReceipt(StreamId device_stream_id) {

google_apis/gcm/engine/registration_request.cc

@@ -232,7 +232,8 @@ void RegistrationRequest::RetryWithBackoff() {
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&RegistrationRequest::Start, weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&RegistrationRequest::Start,
+                     weak_ptr_factory_.GetWeakPtr()),
       backoff_entry_.GetTimeUntilRelease());
 }
 

google_apis/gcm/engine/unregistration_request.cc

@@ -259,7 +259,8 @@ void UnregistrationRequest::RetryWithBackoff() {
   DCHECK(!weak_ptr_factory_.HasWeakPtrs());
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&UnregistrationRequest::Start, weak_ptr_factory_.GetWeakPtr()),
+      base::BindOnce(&UnregistrationRequest::Start,
+                     weak_ptr_factory_.GetWeakPtr()),
       backoff_entry_.GetTimeUntilRelease());
 }