Convert google_apis::AuthStatusCallback to OnceCallback

Bug: 1007788
Change-Id: I52a2b0a15d8962f312f41a9fb1e227c911d5f410
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1997425Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Ryo Hashimoto <hashimoto@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#731808}

chrome/browser/chromeos/extensions/file_manager/private_api_drive.cc

@@ -1050,7 +1050,7 @@ void FileManagerPrivateInternalGetDownloadUrlFunction::OnGotDownloadUrl(
           ->GetURLLoaderFactoryForBrowserProcess();
   auth_service_ = std::make_unique<google_apis::AuthService>(
       identity_manager, account_id, url_loader_factory, scopes);
-  auth_service_->StartAuthentication(base::Bind(
+  auth_service_->StartAuthentication(base::BindOnce(
       &FileManagerPrivateInternalGetDownloadUrlFunction::OnTokenFetched, this));
 }
 

chrome/browser/chromeos/extensions/file_manager/private_api_misc.cc

@@ -381,10 +381,10 @@ FileManagerPrivateRequestWebStoreAccessTokenFunction::Run() {
       g_browser_process->system_network_context_manager()
           ->GetSharedURLLoaderFactory(),
       scopes);
-  auth_service_->StartAuthentication(base::Bind(
-      &FileManagerPrivateRequestWebStoreAccessTokenFunction::
-          OnAccessTokenFetched,
-      this));
+  auth_service_->StartAuthentication(
+      base::BindOnce(&FileManagerPrivateRequestWebStoreAccessTokenFunction::
+                         OnAccessTokenFetched,
+                     this));
 
   return RespondLater();
 }

chrome/browser/sync_file_system/drive_backend/drive_service_on_worker.cc

@@ -287,7 +287,7 @@ bool DriveServiceOnWorker::HasAccessToken() const {
 }
 
 void DriveServiceOnWorker::RequestAccessToken(
-    const google_apis::AuthStatusCallback& callback) {
+    google_apis::AuthStatusCallback callback) {
   NOTREACHED();
 }
 

chrome/browser/sync_file_system/drive_backend/drive_service_on_worker.h

@@ -112,8 +112,7 @@ class DriveServiceOnWorker : public drive::DriveServiceInterface {
   void RemoveObserver(drive::DriveServiceObserver* observer) override;
   bool CanSendRequest() const override;
   bool HasAccessToken() const override;
-  void RequestAccessToken(
-      const google_apis::AuthStatusCallback& callback) override;
+  void RequestAccessToken(google_apis::AuthStatusCallback callback) override;
   void ClearAccessToken() override;
   void ClearRefreshToken() override;
   google_apis::CancelCallback GetAllTeamDriveList(

components/drive/service/drive_api_service.cc

@@ -793,18 +793,18 @@ bool DriveAPIService::HasAccessToken() const {
   return sender_->auth_service()->HasAccessToken();
 }
 
-void DriveAPIService::RequestAccessToken(const AuthStatusCallback& callback) {
+void DriveAPIService::RequestAccessToken(AuthStatusCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!callback.is_null());
+  DCHECK(callback);
 
   const std::string access_token = sender_->auth_service()->access_token();
   if (!access_token.empty()) {
-    callback.Run(google_apis::HTTP_NOT_MODIFIED, access_token);
+    std::move(callback).Run(google_apis::HTTP_NOT_MODIFIED, access_token);
     return;
   }
 
   // Retrieve the new auth token.
-  sender_->auth_service()->StartAuthentication(callback);
+  sender_->auth_service()->StartAuthentication(std::move(callback));
 }
 
 bool DriveAPIService::HasRefreshToken() const {

components/drive/service/drive_api_service.h

@@ -124,8 +124,7 @@ class DriveAPIService : public DriveServiceInterface,
   void RemoveObserver(DriveServiceObserver* observer) override;
   bool CanSendRequest() const override;
   bool HasAccessToken() const override;
-  void RequestAccessToken(
-      const google_apis::AuthStatusCallback& callback) override;
+  void RequestAccessToken(google_apis::AuthStatusCallback callback) override;
   bool HasRefreshToken() const override;
   void ClearAccessToken() override;
   void ClearRefreshToken() override;

components/drive/service/drive_api_service_unittest.cc

@@ -22,16 +22,15 @@ const char kTestUserAgent[] = "test-user-agent";
 
 class TestAuthService : public google_apis::DummyAuthService {
  public:
-  void StartAuthentication(
-      const google_apis::AuthStatusCallback& callback) override {
-    callback_ = callback;
+  void StartAuthentication(google_apis::AuthStatusCallback callback) override {
+    callback_ = std::move(callback);
   }
 
   bool HasAccessToken() const override { return false; }
 
   void SendHttpError() {
     ASSERT_FALSE(callback_.is_null());
-    callback_.Run(google_apis::HTTP_UNAUTHORIZED, "");
+    std::move(callback_).Run(google_apis::HTTP_UNAUTHORIZED, "");
   }
 
  private:

components/drive/service/drive_service_interface.h

@@ -181,8 +181,7 @@ class DriveServiceInterface : public DriveServiceBatchOperationsInterface {
   virtual bool HasAccessToken() const = 0;
 
   // Gets the cached OAuth2 access token or if empty, then fetches a new one.
-  virtual void RequestAccessToken(
-      const google_apis::AuthStatusCallback& callback) = 0;
+  virtual void RequestAccessToken(google_apis::AuthStatusCallback callback) = 0;
 
   // True if OAuth2 refresh token is present.
   virtual bool HasRefreshToken() const = 0;

components/drive/service/dummy_drive_service.cc

@@ -38,8 +38,8 @@ bool DummyDriveService::CanSendRequest() const { return true; }
 
 bool DummyDriveService::HasAccessToken() const { return true; }
 
-void DummyDriveService::RequestAccessToken(const AuthStatusCallback& callback) {
-  callback.Run(google_apis::HTTP_NOT_MODIFIED, "fake_access_token");
+void DummyDriveService::RequestAccessToken(AuthStatusCallback callback) {
+  std::move(callback).Run(google_apis::HTTP_NOT_MODIFIED, "fake_access_token");
 }
 
 bool DummyDriveService::HasRefreshToken() const { return true; }

components/drive/service/dummy_drive_service.h

@@ -28,8 +28,7 @@ class DummyDriveService : public DriveServiceInterface {
   void RemoveObserver(DriveServiceObserver* observer) override;
   bool CanSendRequest() const override;
   bool HasAccessToken() const override;
-  void RequestAccessToken(
-      const google_apis::AuthStatusCallback& callback) override;
+  void RequestAccessToken(google_apis::AuthStatusCallback callback) override;
   bool HasRefreshToken() const override;
   void ClearAccessToken() override;
   void ClearRefreshToken() override;

components/drive/service/fake_drive_service.cc

@@ -326,10 +326,10 @@ bool FakeDriveService::HasAccessToken() const {
   return true;
 }
 
-void FakeDriveService::RequestAccessToken(const AuthStatusCallback& callback) {
+void FakeDriveService::RequestAccessToken(AuthStatusCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(callback);
-  callback.Run(google_apis::HTTP_NOT_MODIFIED, "fake_access_token");
+  std::move(callback).Run(google_apis::HTTP_NOT_MODIFIED, "fake_access_token");
 }
 
 bool FakeDriveService::HasRefreshToken() const {

components/drive/service/fake_drive_service.h

@@ -129,8 +129,7 @@ class FakeDriveService : public DriveServiceInterface {
   bool CanSendRequest() const override;
   std::string GetRootResourceId() const override;
   bool HasAccessToken() const override;
-  void RequestAccessToken(
-      const google_apis::AuthStatusCallback& callback) override;
+  void RequestAccessToken(google_apis::AuthStatusCallback callback) override;
   bool HasRefreshToken() const override;
   void ClearAccessToken() override;
   void ClearRefreshToken() override;

google_apis/drive/auth_service.cc

@@ -42,7 +42,7 @@ class AuthRequest {
   AuthRequest(signin::IdentityManager* identity_manager,
               const CoreAccountId& account_id,
               scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-              const AuthStatusCallback& callback,
+              AuthStatusCallback callback,
               const std::vector<std::string>& scopes);
   ~AuthRequest();
 
@@ -61,11 +61,11 @@ AuthRequest::AuthRequest(
     signin::IdentityManager* identity_manager,
     const CoreAccountId& account_id,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
-    const AuthStatusCallback& callback,
+    AuthStatusCallback callback,
     const std::vector<std::string>& scopes)
-    : callback_(callback) {
+    : callback_(std::move(callback)) {
   DCHECK(identity_manager);
-  DCHECK(!callback_.is_null());
+  DCHECK(callback_);
 
   access_token_fetcher_ = identity_manager->CreateAccessTokenFetcherForAccount(
       account_id, "auth_service", url_loader_factory,
@@ -84,7 +84,7 @@ void AuthRequest::OnAccessTokenFetchComplete(
 
   if (error.state() == GoogleServiceAuthError::NONE) {
     RecordAuthResultHistogram(kSuccessRatioHistogramSuccess);
-    callback_.Run(HTTP_SUCCESS, token_info.token);
+    std::move(callback_).Run(HTTP_SUCCESS, token_info.token);
   } else {
     LOG(WARNING) << "AuthRequest: token request using refresh token failed: "
                  << error.ToString();
@@ -94,14 +94,14 @@ void AuthRequest::OnAccessTokenFetchComplete(
     // so that the file manager works while off-line.
     if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED) {
       RecordAuthResultHistogram(kSuccessRatioHistogramNoConnection);
-      callback_.Run(DRIVE_NO_CONNECTION, std::string());
+      std::move(callback_).Run(DRIVE_NO_CONNECTION, std::string());
     } else if (error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
       RecordAuthResultHistogram(kSuccessRatioHistogramTemporaryFailure);
-      callback_.Run(HTTP_FORBIDDEN, std::string());
+      std::move(callback_).Run(HTTP_FORBIDDEN, std::string());
     } else {
       // Permanent auth error.
       RecordAuthResultHistogram(kSuccessRatioHistogramFailure);
-      callback_.Run(HTTP_UNAUTHORIZED, std::string());
+      std::move(callback_).Run(HTTP_UNAUTHORIZED, std::string());
     }
   }
 
@@ -130,22 +130,25 @@ AuthService::~AuthService() {
   identity_manager_->RemoveObserver(this);
 }
 
-void AuthService::StartAuthentication(const AuthStatusCallback& callback) {
+void AuthService::StartAuthentication(AuthStatusCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (HasAccessToken()) {
     // We already have access token. Give it back to the caller asynchronously.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(callback, HTTP_SUCCESS, access_token_));
+        FROM_HERE,
+        base::BindOnce(std::move(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_,
-                    base::Bind(&AuthService::OnAuthCompleted,
-                               weak_ptr_factory_.GetWeakPtr(), callback),
-                    scopes_);
+    new AuthRequest(
+        identity_manager_, account_id_, url_loader_factory_,
+        base::BindOnce(&AuthService::OnAuthCompleted,
+                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)),
+        scopes_);
   } else {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(callback, DRIVE_NOT_READY, std::string()));
+        FROM_HERE,
+        base::BindOnce(std::move(callback), DRIVE_NOT_READY, std::string()));
   }
 }
 
@@ -169,11 +172,11 @@ void AuthService::ClearRefreshToken() {
   OnHandleRefreshToken(false);
 }
 
-void AuthService::OnAuthCompleted(const AuthStatusCallback& callback,
+void AuthService::OnAuthCompleted(AuthStatusCallback callback,
                                   DriveApiErrorCode error,
                                   const std::string& access_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!callback.is_null());
+  DCHECK(callback);
 
   if (error == HTTP_SUCCESS) {
     access_token_ = access_token;
@@ -188,7 +191,7 @@ void AuthService::OnAuthCompleted(const AuthStatusCallback& callback,
     ClearRefreshToken();
   }
 
-  callback.Run(error, access_token);
+  std::move(callback).Run(error, access_token);
 }
 
 void AuthService::AddObserver(AuthServiceObserver* observer) {

google_apis/drive/auth_service.h

@@ -44,7 +44,7 @@ class AuthService : public AuthServiceInterface,
   // Overriden from AuthServiceInterface:
   void AddObserver(AuthServiceObserver* observer) override;
   void RemoveObserver(AuthServiceObserver* observer) override;
-  void StartAuthentication(const AuthStatusCallback& callback) override;
+  void StartAuthentication(AuthStatusCallback callback) override;
   bool HasAccessToken() const override;
   bool HasRefreshToken() const override;
   const std::string& access_token() const override;
@@ -63,7 +63,7 @@ class AuthService : public AuthServiceInterface,
 
   // Called when authentication request from StartAuthentication() is
   // completed.
-  void OnAuthCompleted(const AuthStatusCallback& callback,
+  void OnAuthCompleted(AuthStatusCallback callback,
                        DriveApiErrorCode error,
                        const std::string& access_token);
 

google_apis/drive/auth_service_interface.h

@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include "base/callback_forward.h"
+#include "base/callback.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 
 namespace google_apis {
@@ -15,8 +15,8 @@ namespace google_apis {
 class AuthServiceObserver;
 
 // Called when fetching of access token is complete.
-typedef base::Callback<void(DriveApiErrorCode error,
-                            const std::string& access_token)>
+typedef base::OnceCallback<void(DriveApiErrorCode error,
+                                const std::string& access_token)>
     AuthStatusCallback;
 
 // This defines an interface for the authentication service which is required
@@ -32,7 +32,7 @@ class AuthServiceInterface {
 
   // Starts fetching OAuth2 access token from the refresh token.
   // |callback| must not be null.
-  virtual void StartAuthentication(const AuthStatusCallback& callback) = 0;
+  virtual void StartAuthentication(AuthStatusCallback callback) = 0;
 
   // True if an OAuth2 access token is retrieved and believed to be fresh.
   // The access token is used to access the Drive server.

google_apis/drive/dummy_auth_service.cc

@@ -17,8 +17,7 @@ void DummyAuthService::AddObserver(AuthServiceObserver* observer) {
 void DummyAuthService::RemoveObserver(AuthServiceObserver* observer) {
 }
 
-void DummyAuthService::StartAuthentication(const AuthStatusCallback& callback) {
-}
+void DummyAuthService::StartAuthentication(AuthStatusCallback callback) {}
 
 bool DummyAuthService::HasAccessToken() const {
   return !access_token_.empty();

google_apis/drive/dummy_auth_service.h

@@ -26,7 +26,7 @@ class DummyAuthService : public AuthServiceInterface {
   // AuthServiceInterface overrides.
   void AddObserver(AuthServiceObserver* observer) override;
   void RemoveObserver(AuthServiceObserver* observer) override;
-  void StartAuthentication(const AuthStatusCallback& callback) override;
+  void StartAuthentication(AuthStatusCallback callback) override;
   bool HasAccessToken() const override;
   bool HasRefreshToken() const override;
   const std::string& access_token() const override;

google_apis/drive/request_sender.cc

@@ -50,8 +50,8 @@ base::Closure RequestSender::StartRequestWithAuthRetryInternal(
   if (!auth_service_->HasAccessToken()) {
     // Fetch OAuth2 access token from the refresh token first.
     auth_service_->StartAuthentication(
-        base::Bind(&RequestSender::OnAccessTokenFetched,
-                   weak_ptr_factory_.GetWeakPtr(), request->GetWeakPtr()));
+        base::BindOnce(&RequestSender::OnAccessTokenFetched,
+                       weak_ptr_factory_.GetWeakPtr(), request->GetWeakPtr()));
   } else {
     request->Start(auth_service_->access_token(), custom_user_agent_,
                    base::BindRepeating(&RequestSender::RetryRequest,

google_apis/drive/request_sender_unittest.cc

@@ -34,7 +34,7 @@ class TestAuthService : public DummyAuthService {
  public:
   TestAuthService() : auth_try_count_(0) {}
 
-  void StartAuthentication(const AuthStatusCallback& callback) override {
+  void StartAuthentication(AuthStatusCallback callback) override {
     // RequestSender should clear the rejected access token before starting
     // to request another one.
     EXPECT_FALSE(HasAccessToken());
@@ -45,10 +45,10 @@ class TestAuthService : public DummyAuthService {
       const std::string token =
           kTestAccessToken + base::NumberToString(auth_try_count_);
       set_access_token(token);
-      callback.Run(HTTP_SUCCESS, token);
+      std::move(callback).Run(HTTP_SUCCESS, token);
     } else {
       set_access_token("");
-      callback.Run(HTTP_UNAUTHORIZED, "");
+      std::move(callback).Run(HTTP_UNAUTHORIZED, "");
     }
   }