Convert CryptAuth API client to BindOnce/OnceCallback

This changes CryptAuthApiCallFlow and CryptAuthClient to use the newer
callback classes, and updates users of CryptAuthClient's mock as needed.

Bug: 1007662
Change-Id: I1a8acbcbd1ac6294165c2f6ece82571a324487f8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2377766Reviewed-by: Josh Nohle <nohle@chromium.org>
Commit-Queue: Austin Tankiang <austinct@chromium.org>
Cr-Commit-Position: refs/heads/master@{#802070}

chromeos/services/device_sync/cryptauth_api_call_flow.cc

@@ -50,12 +50,12 @@ void CryptAuthApiCallFlow::StartPostRequest(
     const std::string& serialized_request,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     const std::string& access_token,
-    const ResultCallback& result_callback,
-    const ErrorCallback& error_callback) {
+    ResultCallback result_callback,
+    ErrorCallback error_callback) {
   request_url_ = request_url;
   serialized_request_ = serialized_request;
-  result_callback_ = result_callback;
-  error_callback_ = error_callback;
+  result_callback_ = std::move(result_callback);
+  error_callback_ = std::move(error_callback);
   OAuth2ApiCallFlow::Start(std::move(url_loader_factory), access_token);
 }
 
@@ -65,12 +65,12 @@ void CryptAuthApiCallFlow::StartGetRequest(
         request_as_query_parameters,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
     const std::string& access_token,
-    const ResultCallback& result_callback,
-    const ErrorCallback& error_callback) {
+    ResultCallback result_callback,
+    ErrorCallback error_callback) {
   request_url_ = request_url;
   request_as_query_parameters_ = request_as_query_parameters;
-  result_callback_ = result_callback;
-  error_callback_ = error_callback;
+  result_callback_ = std::move(result_callback);
+  error_callback_ = std::move(error_callback);
   OAuth2ApiCallFlow::Start(std::move(url_loader_factory), access_token);
 }
 
@@ -119,10 +119,10 @@ void CryptAuthApiCallFlow::ProcessApiCallSuccess(
     const network::mojom::URLResponseHead* head,
     std::unique_ptr<std::string> body) {
   if (!body) {
-    error_callback_.Run(NetworkRequestError::kResponseMalformed);
+    std::move(error_callback_).Run(NetworkRequestError::kResponseMalformed);
     return;
   }
-  result_callback_.Run(std::move(*body));
+  std::move(result_callback_).Run(std::move(*body));
 }
 
 void CryptAuthApiCallFlow::ProcessApiCallFailure(
@@ -145,7 +145,7 @@ void CryptAuthApiCallFlow::ProcessApiCallFailure(
   if (body)
     PA_LOG(VERBOSE) << "API failure response body:\n" << *body;
 
-  error_callback_.Run(*error);
+  std::move(error_callback_).Run(*error);
 }
 
 net::PartialNetworkTrafficAnnotationTag

chromeos/services/device_sync/cryptauth_api_call_flow.h

@@ -30,9 +30,9 @@ namespace device_sync {
 
 class CryptAuthApiCallFlow : public OAuth2ApiCallFlow {
  public:
-  typedef base::Callback<void(const std::string& serialized_response)>
+  typedef base::OnceCallback<void(const std::string& serialized_response)>
       ResultCallback;
-  typedef base::Callback<void(NetworkRequestError error)> ErrorCallback;
+  typedef base::OnceCallback<void(NetworkRequestError error)> ErrorCallback;
 
   CryptAuthApiCallFlow();
   ~CryptAuthApiCallFlow() override;
@@ -49,8 +49,8 @@ class CryptAuthApiCallFlow : public OAuth2ApiCallFlow {
       const std::string& serialized_request,
       scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       const std::string& access_token,
-      const ResultCallback& result_callback,
-      const ErrorCallback& error_callback);
+      ResultCallback result_callback,
+      ErrorCallback error_callback);
 
   // Starts the API GET request call.
   //   |request_url|: The URL endpoint of the API request.
@@ -67,8 +67,8 @@ class CryptAuthApiCallFlow : public OAuth2ApiCallFlow {
           request_as_query_parameters,
       scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
       const std::string& access_token,
-      const ResultCallback& result_callback,
-      const ErrorCallback& error_callback);
+      ResultCallback result_callback,
+      ErrorCallback error_callback);
 
   void SetPartialNetworkTrafficAnnotation(
       const net::PartialNetworkTrafficAnnotationTag&

chromeos/services/device_sync/cryptauth_api_call_flow_unittest.cc

@@ -94,10 +94,10 @@ class DeviceSyncCryptAuthApiCallFlowTest : public testing::Test {
       const std::string& serialized_request) {
     flow_.StartPostRequest(
         GURL(kRequestUrl), serialized_request, shared_factory_, kAccessToken,
-        base::Bind(&DeviceSyncCryptAuthApiCallFlowTest::OnResult,
-                   base::Unretained(this)),
-        base::Bind(&DeviceSyncCryptAuthApiCallFlowTest::OnError,
-                   base::Unretained(this)));
+        base::BindOnce(&DeviceSyncCryptAuthApiCallFlowTest::OnResult,
+                       base::Unretained(this)),
+        base::BindOnce(&DeviceSyncCryptAuthApiCallFlowTest::OnError,
+                       base::Unretained(this)));
     // A pending fetch for the API request should be created.
     CheckCryptAuthHttpPostRequest(serialized_request);
   }
@@ -113,10 +113,10 @@ class DeviceSyncCryptAuthApiCallFlowTest : public testing::Test {
     flow_.StartGetRequest(
         GURL(kRequestUrl), request_as_query_parameters, shared_factory_,
         kAccessToken,
-        base::Bind(&DeviceSyncCryptAuthApiCallFlowTest::OnResult,
-                   base::Unretained(this)),
-        base::Bind(&DeviceSyncCryptAuthApiCallFlowTest::OnError,
-                   base::Unretained(this)));
+        base::BindOnce(&DeviceSyncCryptAuthApiCallFlowTest::OnResult,
+                       base::Unretained(this)),
+        base::BindOnce(&DeviceSyncCryptAuthApiCallFlowTest::OnError,
+                       base::Unretained(this)));
     // A pending fetch for the API request should be created.
     CheckCryptAuthHttpGetRequest(request_as_query_parameters);
   }

chromeos/services/device_sync/cryptauth_client.h

@@ -63,134 +63,136 @@ namespace device_sync {
 // chromeos/services/device_sync/proto/cryptauth_devicesync.proto.
 class CryptAuthClient {
  public:
-  typedef base::Callback<void(NetworkRequestError)> ErrorCallback;
+  typedef base::OnceCallback<void(NetworkRequestError)> ErrorCallback;
 
   virtual ~CryptAuthClient() {}
 
   // DeviceSync v1: GetMyDevices
-  typedef base::Callback<void(const cryptauth::GetMyDevicesResponse&)>
+  typedef base::OnceCallback<void(const cryptauth::GetMyDevicesResponse&)>
       GetMyDevicesCallback;
   virtual void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
-                            const GetMyDevicesCallback& callback,
-                            const ErrorCallback& error_callback,
+                            GetMyDevicesCallback callback,
+                            ErrorCallback error_callback,
                             const net::PartialNetworkTrafficAnnotationTag&
                                 partial_traffic_annotation) = 0;
 
   // DeviceSync v1: FindEligibleUnlockDevices
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauth::FindEligibleUnlockDevicesResponse&)>
       FindEligibleUnlockDevicesCallback;
   virtual void FindEligibleUnlockDevices(
       const cryptauth::FindEligibleUnlockDevicesRequest& request,
-      const FindEligibleUnlockDevicesCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      FindEligibleUnlockDevicesCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v1: FindEligibleForPromotion
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauth::FindEligibleForPromotionResponse&)>
       FindEligibleForPromotionCallback;
   virtual void FindEligibleForPromotion(
       const cryptauth::FindEligibleForPromotionRequest& request,
-      const FindEligibleForPromotionCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      FindEligibleForPromotionCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v1: SendDeviceSyncTickle
-  typedef base::Callback<void(const cryptauth::SendDeviceSyncTickleResponse&)>
+  typedef base::OnceCallback<void(
+      const cryptauth::SendDeviceSyncTickleResponse&)>
       SendDeviceSyncTickleCallback;
   virtual void SendDeviceSyncTickle(
       const cryptauth::SendDeviceSyncTickleRequest& request,
-      const SendDeviceSyncTickleCallback& callback,
-      const ErrorCallback& error_callback,
+      SendDeviceSyncTickleCallback callback,
+      ErrorCallback error_callback,
       const net::PartialNetworkTrafficAnnotationTag&
           partial_traffic_annotation) = 0;
 
   // DeviceSync v1: ToggleEasyUnlock
-  typedef base::Callback<void(const cryptauth::ToggleEasyUnlockResponse&)>
+  typedef base::OnceCallback<void(const cryptauth::ToggleEasyUnlockResponse&)>
       ToggleEasyUnlockCallback;
   virtual void ToggleEasyUnlock(
       const cryptauth::ToggleEasyUnlockRequest& request,
-      const ToggleEasyUnlockCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      ToggleEasyUnlockCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // Enrollment v1: SetupEnrollment
-  typedef base::Callback<void(const cryptauth::SetupEnrollmentResponse&)>
+  typedef base::OnceCallback<void(const cryptauth::SetupEnrollmentResponse&)>
       SetupEnrollmentCallback;
   virtual void SetupEnrollment(const cryptauth::SetupEnrollmentRequest& request,
-                               const SetupEnrollmentCallback& callback,
-                               const ErrorCallback& error_callback) = 0;
+                               SetupEnrollmentCallback callback,
+                               ErrorCallback error_callback) = 0;
 
   // Enrollment v1: FinishEnrollment
-  typedef base::Callback<void(const cryptauth::FinishEnrollmentResponse&)>
+  typedef base::OnceCallback<void(const cryptauth::FinishEnrollmentResponse&)>
       FinishEnrollmentCallback;
   virtual void FinishEnrollment(
       const cryptauth::FinishEnrollmentRequest& request,
-      const FinishEnrollmentCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      FinishEnrollmentCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // Enrollment v2: SyncKeys
-  typedef base::Callback<void(const cryptauthv2::SyncKeysResponse&)>
+  typedef base::OnceCallback<void(const cryptauthv2::SyncKeysResponse&)>
       SyncKeysCallback;
   virtual void SyncKeys(const cryptauthv2::SyncKeysRequest& request,
-                        const SyncKeysCallback& callback,
-                        const ErrorCallback& error_callback) = 0;
+                        SyncKeysCallback callback,
+                        ErrorCallback error_callback) = 0;
 
   // Enrollment v2: EnrollKeys
-  typedef base::Callback<void(const cryptauthv2::EnrollKeysResponse&)>
+  typedef base::OnceCallback<void(const cryptauthv2::EnrollKeysResponse&)>
       EnrollKeysCallback;
   virtual void EnrollKeys(const cryptauthv2::EnrollKeysRequest& request,
-                          const EnrollKeysCallback& callback,
-                          const ErrorCallback& error_callback) = 0;
+                          EnrollKeysCallback callback,
+                          ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: SyncMetadata
-  typedef base::Callback<void(const cryptauthv2::SyncMetadataResponse&)>
+  typedef base::OnceCallback<void(const cryptauthv2::SyncMetadataResponse&)>
       SyncMetadataCallback;
   virtual void SyncMetadata(const cryptauthv2::SyncMetadataRequest& request,
-                            const SyncMetadataCallback& callback,
-                            const ErrorCallback& error_callback) = 0;
+                            SyncMetadataCallback callback,
+                            ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: ShareGroupPrivateKey
-  typedef base::Callback<void(const cryptauthv2::ShareGroupPrivateKeyResponse&)>
+  typedef base::OnceCallback<void(
+      const cryptauthv2::ShareGroupPrivateKeyResponse&)>
       ShareGroupPrivateKeyCallback;
   virtual void ShareGroupPrivateKey(
       const cryptauthv2::ShareGroupPrivateKeyRequest& request,
-      const ShareGroupPrivateKeyCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      ShareGroupPrivateKeyCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: BatchNotifyGroupDevices
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauthv2::BatchNotifyGroupDevicesResponse&)>
       BatchNotifyGroupDevicesCallback;
   virtual void BatchNotifyGroupDevices(
       const cryptauthv2::BatchNotifyGroupDevicesRequest& request,
-      const BatchNotifyGroupDevicesCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      BatchNotifyGroupDevicesCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: BatchGetFeatureStatuses
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauthv2::BatchGetFeatureStatusesResponse&)>
       BatchGetFeatureStatusesCallback;
   virtual void BatchGetFeatureStatuses(
       const cryptauthv2::BatchGetFeatureStatusesRequest& request,
-      const BatchGetFeatureStatusesCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      BatchGetFeatureStatusesCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: BatchSetFeatureStatuses
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauthv2::BatchSetFeatureStatusesResponse&)>
       BatchSetFeatureStatusesCallback;
   virtual void BatchSetFeatureStatuses(
       const cryptauthv2::BatchSetFeatureStatusesRequest& request,
-      const BatchSetFeatureStatusesCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      BatchSetFeatureStatusesCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // DeviceSync v2: GetDevicesActivityStatus
-  typedef base::Callback<void(
+  typedef base::OnceCallback<void(
       const cryptauthv2::GetDevicesActivityStatusResponse&)>
       GetDevicesActivityStatusCallback;
   virtual void GetDevicesActivityStatus(
       const cryptauthv2::GetDevicesActivityStatusRequest& request,
-      const GetDevicesActivityStatusCallback& callback,
-      const ErrorCallback& error_callback) = 0;
+      GetDevicesActivityStatusCallback callback,
+      ErrorCallback error_callback) = 0;
 
   // Returns the access token used to make the request. If no request has been
   // made yet, this function will return an empty string.

chromeos/services/device_sync/cryptauth_client_impl.h

@@ -52,62 +52,62 @@ class CryptAuthClientImpl : public CryptAuthClient {
 
   // CryptAuthClient:
   void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
-                    const GetMyDevicesCallback& callback,
-                    const ErrorCallback& error_callback,
+                    GetMyDevicesCallback callback,
+                    ErrorCallback error_callback,
                     const net::PartialNetworkTrafficAnnotationTag&
                         partial_traffic_annotation) override;
   void FindEligibleUnlockDevices(
       const cryptauth::FindEligibleUnlockDevicesRequest& request,
-      const FindEligibleUnlockDevicesCallback& callback,
-      const ErrorCallback& error_callback) override;
+      FindEligibleUnlockDevicesCallback callback,
+      ErrorCallback error_callback) override;
   void FindEligibleForPromotion(
       const cryptauth::FindEligibleForPromotionRequest& request,
-      const FindEligibleForPromotionCallback& callback,
-      const ErrorCallback& error_callback) override;
+      FindEligibleForPromotionCallback callback,
+      ErrorCallback error_callback) override;
   void SendDeviceSyncTickle(
       const cryptauth::SendDeviceSyncTickleRequest& request,
-      const SendDeviceSyncTickleCallback& callback,
-      const ErrorCallback& error_callback,
+      SendDeviceSyncTickleCallback callback,
+      ErrorCallback error_callback,
       const net::PartialNetworkTrafficAnnotationTag& partial_traffic_annotation)
       override;
   void ToggleEasyUnlock(const cryptauth::ToggleEasyUnlockRequest& request,
-                        const ToggleEasyUnlockCallback& callback,
-                        const ErrorCallback& error_callback) override;
+                        ToggleEasyUnlockCallback callback,
+                        ErrorCallback error_callback) override;
   void SetupEnrollment(const cryptauth::SetupEnrollmentRequest& request,
-                       const SetupEnrollmentCallback& callback,
-                       const ErrorCallback& error_callback) override;
+                       SetupEnrollmentCallback callback,
+                       ErrorCallback error_callback) override;
   void FinishEnrollment(const cryptauth::FinishEnrollmentRequest& request,
-                        const FinishEnrollmentCallback& callback,
-                        const ErrorCallback& error_callback) override;
+                        FinishEnrollmentCallback callback,
+                        ErrorCallback error_callback) override;
   void SyncKeys(const cryptauthv2::SyncKeysRequest& request,
-                const SyncKeysCallback& callback,
-                const ErrorCallback& error_callback) override;
+                SyncKeysCallback callback,
+                ErrorCallback error_callback) override;
   void EnrollKeys(const cryptauthv2::EnrollKeysRequest& request,
-                  const EnrollKeysCallback& callback,
-                  const ErrorCallback& error_callback) override;
+                  EnrollKeysCallback callback,
+                  ErrorCallback error_callback) override;
   void SyncMetadata(const cryptauthv2::SyncMetadataRequest& request,
-                    const SyncMetadataCallback& callback,
-                    const ErrorCallback& error_callback) override;
+                    SyncMetadataCallback callback,
+                    ErrorCallback error_callback) override;
   void ShareGroupPrivateKey(
       const cryptauthv2::ShareGroupPrivateKeyRequest& request,
-      const ShareGroupPrivateKeyCallback& callback,
-      const ErrorCallback& error_callback) override;
+      ShareGroupPrivateKeyCallback callback,
+      ErrorCallback error_callback) override;
   void BatchNotifyGroupDevices(
       const cryptauthv2::BatchNotifyGroupDevicesRequest& request,
-      const BatchNotifyGroupDevicesCallback& callback,
-      const ErrorCallback& error_callback) override;
+      BatchNotifyGroupDevicesCallback callback,
+      ErrorCallback error_callback) override;
   void BatchGetFeatureStatuses(
       const cryptauthv2::BatchGetFeatureStatusesRequest& request,
-      const BatchGetFeatureStatusesCallback& callback,
-      const ErrorCallback& error_callback) override;
+      BatchGetFeatureStatusesCallback callback,
+      ErrorCallback error_callback) override;
   void BatchSetFeatureStatuses(
       const cryptauthv2::BatchSetFeatureStatusesRequest& request,
-      const BatchSetFeatureStatusesCallback& callback,
-      const ErrorCallback& error_callback) override;
+      BatchSetFeatureStatusesCallback callback,
+      ErrorCallback error_callback) override;
   void GetDevicesActivityStatus(
       const cryptauthv2::GetDevicesActivityStatusRequest& request,
-      const GetDevicesActivityStatusCallback& callback,
-      const ErrorCallback& error_callback) override;
+      GetDevicesActivityStatusCallback callback,
+      ErrorCallback error_callback) override;
   std::string GetAccessTokenUsed() override;
 
  private:
@@ -135,8 +135,8 @@ class CryptAuthClientImpl : public CryptAuthClient {
       const base::Optional<std::string>& serialized_request,
       const base::Optional<std::vector<std::pair<std::string, std::string>>>&
           request_as_query_parameters,
-      const base::Callback<void(const ResponseProto&)>& response_callback,
-      const ErrorCallback& error_callback,
+      base::OnceCallback<void(const ResponseProto&)> response_callback,
+      ErrorCallback error_callback,
       const net::PartialNetworkTrafficAnnotationTag&
           partial_traffic_annotation);
 
@@ -147,7 +147,7 @@ class CryptAuthClientImpl : public CryptAuthClient {
       const base::Optional<std::string>& serialized_request,
       const base::Optional<std::vector<std::pair<std::string, std::string>>>&
           request_as_query_parameters,
-      const base::Callback<void(const ResponseProto&)>& response_callback,
+      base::OnceCallback<void(const ResponseProto&)> response_callback,
       GoogleServiceAuthError error,
       signin::AccessTokenInfo access_token_info);
 
@@ -155,7 +155,7 @@ class CryptAuthClientImpl : public CryptAuthClient {
   // return the result.
   template <class ResponseProto>
   void OnFlowSuccess(
-      const base::Callback<void(const ResponseProto&)>& result_callback,
+      base::OnceCallback<void(const ResponseProto&)> result_callback,
       const std::string& serialized_response);
 
   // Called when the current API call fails at any step.

chromeos/services/device_sync/cryptauth_device_activity_getter_impl_unittest.cc

@@ -163,15 +163,15 @@ class DeviceSyncCryptAuthDeviceActivityGetterImplTest
  private:
   void OnGetDevicesActivityStatus(
       const cryptauthv2::GetDevicesActivityStatusRequest& request,
-      const CryptAuthClient::GetDevicesActivityStatusCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::GetDevicesActivityStatusCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     EXPECT_FALSE(get_device_activity_status_request_);
     EXPECT_FALSE(get_device_activity_status_success_callback_);
     EXPECT_FALSE(get_device_activity_status_failure_callback_);
 
     get_device_activity_status_request_ = request;
-    get_device_activity_status_success_callback_ = callback;
-    get_device_activity_status_failure_callback_ = error_callback;
+    get_device_activity_status_success_callback_ = std::move(callback);
+    get_device_activity_status_failure_callback_ = std::move(error_callback);
   }
 
   void OnGetDevicesActivityStatusFinished(

chromeos/services/device_sync/cryptauth_device_manager_impl_unittest.cc

@@ -15,6 +15,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "base/test/gmock_move_support.h"
 #include "base/test/metrics/histogram_tester.h"
 #include "base/test/simple_test_clock.h"
 #include "chromeos/components/multidevice/software_feature_state.h"
@@ -587,10 +588,10 @@ class DeviceSyncCryptAuthDeviceManagerImplTest
 
   // MockCryptAuthClientFactory::Observer:
   void OnCryptAuthClientCreated(MockCryptAuthClient* client) override {
-    EXPECT_CALL(*client, GetMyDevices(_, _, _, _))
+    EXPECT_CALL(*client, GetMyDevices_(_, _, _, _))
         .WillOnce(DoAll(SaveArg<0>(&get_my_devices_request_),
-                        SaveArg<1>(&success_callback_),
-                        SaveArg<2>(&error_callback_)));
+                        MoveArg<1>(&success_callback_),
+                        MoveArg<2>(&error_callback_)));
   }
 
   MockSyncScheduler* sync_scheduler() {
@@ -761,7 +762,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncSucceedsForFirstTime) {
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
 
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
   EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -780,7 +781,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, ForceSync) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
   EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -802,7 +803,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, ForceSyncFailsThenSucceeds) {
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::FAILURE,
                   CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED));
-  error_callback_.Run(NetworkRequestError::kEndpointNotFound);
+  std::move(error_callback_).Run(NetworkRequestError::kEndpointNotFound);
   EXPECT_EQ(old_sync_time, device_manager_->GetLastSyncTime());
   EXPECT_TRUE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
@@ -817,7 +818,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, ForceSyncFailsThenSucceeds) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
   EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -844,7 +845,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
               OnSyncFinishedProxy(
                   CryptAuthDeviceManager::SyncResult::FAILURE,
                   CryptAuthDeviceManager::DeviceChangeResult::UNCHANGED));
-  error_callback_.Run(NetworkRequestError::kAuthenticationError);
+  std::move(error_callback_).Run(NetworkRequestError::kAuthenticationError);
   EXPECT_EQ(old_sync_time, device_manager_->GetLastSyncTime());
   EXPECT_TRUE(pref_service_.GetBoolean(
       prefs::kCryptAuthDeviceSyncIsRecoveringFromFailure));
@@ -857,7 +858,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
   EXPECT_EQ(clock_.Now(), device_manager_->GetLastSyncTime());
 
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -890,7 +891,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncSameDevice) {
   synced_device.set_unlockable(kStoredUnlockable);
   cryptauth::GetMyDevicesResponse get_my_devices_response;
   get_my_devices_response.add_devices()->CopyFrom(synced_device);
-  success_callback_.Run(get_my_devices_response);
+  std::move(success_callback_).Run(get_my_devices_response);
 
   // Check that devices are still the same after sync.
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -908,7 +909,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncEmptyDeviceList) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(empty_response);
+  std::move(success_callback_).Run(empty_response);
 
   ExpectSyncedDevicesAndPrefAreEqual(
       std::vector<cryptauth::ExternalDeviceInfo>(),
@@ -944,7 +945,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncThreeDevices) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(response);
+  std::move(success_callback_).Run(response);
 
   ExpectSyncedDevicesAndPrefAreEqual(
       expected_devices, device_manager_->GetSyncedDevices(), pref_service_);
@@ -962,7 +963,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncOnGCMPushMessage) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   ExpectSyncedDevicesAndPrefAreEqual(
       devices_in_response_, device_manager_->GetSyncedDevices(), pref_service_);
@@ -980,7 +981,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SyncDeviceWithNoContents) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   ExpectSyncedDevicesAndPrefAreEqual(
       devices_in_response_, device_manager_->GetSyncedDevices(), pref_service_);
@@ -1051,7 +1052,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   cryptauth::GetMyDevicesResponse response;
   response.add_devices()->CopyFrom(device_with_only_public_key);
   response.add_devices()->CopyFrom(device_with_all_fields);
-  success_callback_.Run(response);
+  std::move(success_callback_).Run(response);
 
   ExpectSyncedDevicesAndPrefAreEqual(
       expected_devices, device_manager_->GetSyncedDevices(), pref_service_);
@@ -1065,7 +1066,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest, SubsetsOfSyncedDevices) {
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   // All synced devices.
   ExpectSyncedDevicesAndPrefAreEqual(
@@ -1100,7 +1101,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   cryptauth::ExternalDeviceInfo synced_device =
       device_manager_->GetSyncedDevices()[2];
@@ -1151,7 +1152,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   cryptauth::ExternalDeviceInfo synced_device =
       device_manager_->GetSyncedDevices()[2];
@@ -1202,7 +1203,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(get_my_devices_response_);
+  std::move(success_callback_).Run(get_my_devices_response_);
 
   cryptauth::ExternalDeviceInfo synced_device =
       device_manager_->GetSyncedDevices()[2];
@@ -1267,7 +1268,7 @@ TEST_F(DeviceSyncCryptAuthDeviceManagerImplTest,
   EXPECT_CALL(*this, OnSyncFinishedProxy(
                          CryptAuthDeviceManager::SyncResult::SUCCESS,
                          CryptAuthDeviceManager::DeviceChangeResult::CHANGED));
-  success_callback_.Run(response);
+  std::move(success_callback_).Run(response);
 
   histogram_tester.ExpectTotalCount(
       "CryptAuth.DeviceSyncSoftwareFeaturesResult", 4);

chromeos/services/device_sync/cryptauth_device_notifier_impl_unittest.cc

@@ -186,8 +186,8 @@ class DeviceSyncCryptAuthDeviceNotifierImplTest
  private:
   void OnBatchNotifyGroupDevices(
       const cryptauthv2::BatchNotifyGroupDevicesRequest& request,
-      const CryptAuthClient::BatchNotifyGroupDevicesCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::BatchNotifyGroupDevicesCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     batch_notify_group_devices_requests_.push(request);
     batch_notify_group_devices_success_callbacks_.push(std::move(callback));
     batch_notify_group_devices_failure_callbacks_.push(

chromeos/services/device_sync/cryptauth_enroller_impl_unittest.cc

@@ -211,10 +211,9 @@ class DeviceSyncCryptAuthEnrollerTest
     enroller_result_.reset(new bool(success));
   }
 
-  void OnSetupEnrollment(
-      const cryptauth::SetupEnrollmentRequest& request,
-      const CryptAuthClient::SetupEnrollmentCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+  void OnSetupEnrollment(const cryptauth::SetupEnrollmentRequest& request,
+                         CryptAuthClient::SetupEnrollmentCallback callback,
+                         CryptAuthClient::ErrorCallback error_callback) {
     // Check that SetupEnrollment is called before FinishEnrollment.
     EXPECT_FALSE(setup_request_.get());
     EXPECT_FALSE(finish_request_.get());
@@ -222,22 +221,21 @@ class DeviceSyncCryptAuthEnrollerTest
     EXPECT_TRUE(error_callback_.is_null());
 
     setup_request_.reset(new cryptauth::SetupEnrollmentRequest(request));
-    setup_callback_ = callback;
-    error_callback_ = error_callback;
+    setup_callback_ = std::move(callback);
+    error_callback_ = std::move(error_callback);
   }
 
-  void OnFinishEnrollment(
-      const cryptauth::FinishEnrollmentRequest& request,
-      const CryptAuthClient::FinishEnrollmentCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+  void OnFinishEnrollment(const cryptauth::FinishEnrollmentRequest& request,
+                          CryptAuthClient::FinishEnrollmentCallback callback,
+                          CryptAuthClient::ErrorCallback error_callback) {
     // Check that FinishEnrollment is called after SetupEnrollment.
     EXPECT_TRUE(setup_request_.get());
     EXPECT_FALSE(finish_request_.get());
     EXPECT_TRUE(finish_callback_.is_null());
 
     finish_request_.reset(new cryptauth::FinishEnrollmentRequest(request));
-    finish_callback_ = callback;
-    error_callback_ = error_callback;
+    finish_callback_ = std::move(callback);
+    error_callback_ = std::move(error_callback);
   }
 
   // The persistent user key-pair.
@@ -273,7 +271,7 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, EnrollmentSucceeds) {
   ASSERT_EQ(1, setup_request_->types_size());
   EXPECT_EQ(kSupportedEnrollmentTypeGcmV1, setup_request_->types(0));
   ASSERT_FALSE(setup_callback_.is_null());
-  setup_callback_.Run(GetSetupEnrollmentResponse(true));
+  std::move(setup_callback_).Run(GetSetupEnrollmentResponse(true));
 
   // Handle FinishEnrollment request.
   EXPECT_TRUE(finish_request_.get());
@@ -283,7 +281,7 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, EnrollmentSucceeds) {
   EXPECT_EQ(kInvocationReason, finish_request_->invocation_reason());
 
   ASSERT_FALSE(finish_callback_.is_null());
-  finish_callback_.Run(GetFinishEnrollmentResponse(true));
+  std::move(finish_callback_).Run(GetFinishEnrollmentResponse(true));
 
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_TRUE(*enroller_result_);
@@ -294,7 +292,7 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, SetupEnrollmentApiCallError) {
 
   EXPECT_TRUE(setup_request_.get());
   ASSERT_FALSE(error_callback_.is_null());
-  error_callback_.Run(NetworkRequestError::kBadRequest);
+  std::move(error_callback_).Run(NetworkRequestError::kBadRequest);
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
@@ -305,7 +303,7 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, SetupEnrollmentBadStatus) {
   StartEnroller(GetDeviceInfo());
 
   EXPECT_TRUE(setup_request_.get());
-  setup_callback_.Run(GetSetupEnrollmentResponse(false));
+  std::move(setup_callback_).Run(GetSetupEnrollmentResponse(false));
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
@@ -317,7 +315,7 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, SetupEnrollmentNoInfosReturned) {
   EXPECT_TRUE(setup_request_.get());
   cryptauth::SetupEnrollmentResponse response;
   response.set_status(kResponseStatusOk);
-  setup_callback_.Run(response);
+  std::move(setup_callback_).Run(response);
 
   EXPECT_TRUE(finish_callback_.is_null());
   ASSERT_TRUE(enroller_result_.get());
@@ -326,26 +324,26 @@ TEST_F(DeviceSyncCryptAuthEnrollerTest, SetupEnrollmentNoInfosReturned) {
 
 TEST_F(DeviceSyncCryptAuthEnrollerTest, FinishEnrollmentApiCallError) {
   StartEnroller(GetDeviceInfo());
-  setup_callback_.Run(GetSetupEnrollmentResponse(true));
+  std::move(setup_callback_).Run(GetSetupEnrollmentResponse(true));
   ASSERT_FALSE(error_callback_.is_null());
-  error_callback_.Run(NetworkRequestError::kAuthenticationError);
+  std::move(error_callback_).Run(NetworkRequestError::kAuthenticationError);
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
 TEST_F(DeviceSyncCryptAuthEnrollerTest, FinishEnrollmentBadStatus) {
   StartEnroller(GetDeviceInfo());
-  setup_callback_.Run(GetSetupEnrollmentResponse(true));
+  std::move(setup_callback_).Run(GetSetupEnrollmentResponse(true));
   ASSERT_FALSE(finish_callback_.is_null());
-  finish_callback_.Run(GetFinishEnrollmentResponse(false));
+  std::move(finish_callback_).Run(GetFinishEnrollmentResponse(false));
   ASSERT_TRUE(enroller_result_.get());
   EXPECT_FALSE(*enroller_result_);
 }
 
 TEST_F(DeviceSyncCryptAuthEnrollerTest, ReuseEnroller) {
   StartEnroller(GetDeviceInfo());
-  setup_callback_.Run(GetSetupEnrollmentResponse(true));
-  finish_callback_.Run(GetFinishEnrollmentResponse(true));
+  std::move(setup_callback_).Run(GetSetupEnrollmentResponse(true));
+  std::move(finish_callback_).Run(GetFinishEnrollmentResponse(true));
   EXPECT_TRUE(*enroller_result_);
 
   StartEnroller(GetDeviceInfo());

chromeos/services/device_sync/cryptauth_feature_status_getter_impl_unittest.cc

@@ -217,15 +217,15 @@ class DeviceSyncCryptAuthFeatureStatusGetterImplTest
  private:
   void OnBatchGetFeatureStatuses(
       const cryptauthv2::BatchGetFeatureStatusesRequest& request,
-      const CryptAuthClient::BatchGetFeatureStatusesCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::BatchGetFeatureStatusesCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     EXPECT_FALSE(batch_get_feature_statuses_request_);
     EXPECT_FALSE(batch_get_feature_statuses_success_callback_);
     EXPECT_FALSE(batch_get_feature_statuses_failure_callback_);
 
     batch_get_feature_statuses_request_ = request;
-    batch_get_feature_statuses_success_callback_ = callback;
-    batch_get_feature_statuses_failure_callback_ = error_callback;
+    batch_get_feature_statuses_success_callback_ = std::move(callback);
+    batch_get_feature_statuses_failure_callback_ = std::move(error_callback);
   }
 
   void OnGetFeatureStatusesComplete(

chromeos/services/device_sync/cryptauth_feature_status_setter_impl_unittest.cc

@@ -212,8 +212,8 @@ class DeviceSyncCryptAuthFeatureStatusSetterImplTest
  private:
   void OnBatchSetFeatureStatuses(
       const cryptauthv2::BatchSetFeatureStatusesRequest& request,
-      const CryptAuthClient::BatchSetFeatureStatusesCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::BatchSetFeatureStatusesCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     batch_set_feature_statuses_requests_.push(request);
     batch_set_feature_statuses_success_callbacks_.push(std::move(callback));
     batch_set_feature_statuses_failure_callbacks_.push(

chromeos/services/device_sync/cryptauth_group_private_key_sharer_impl_unittest.cc

@@ -245,15 +245,15 @@ class DeviceSyncCryptAuthGroupPrivateKeySharerImplTest
 
   void OnShareGroupPrivateKey(
       const cryptauthv2::ShareGroupPrivateKeyRequest& request,
-      const CryptAuthClient::ShareGroupPrivateKeyCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::ShareGroupPrivateKeyCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     EXPECT_FALSE(share_group_private_key_request_);
     EXPECT_FALSE(share_group_private_key_success_callback_);
     EXPECT_FALSE(share_group_private_key_failure_callback_);
 
     share_group_private_key_request_ = request;
-    share_group_private_key_success_callback_ = callback;
-    share_group_private_key_failure_callback_ = error_callback;
+    share_group_private_key_success_callback_ = std::move(callback);
+    share_group_private_key_failure_callback_ = std::move(error_callback);
   }
 
   void OnShareGroupPrivateKeyComplete(

chromeos/services/device_sync/cryptauth_metadata_syncer_impl_unittest.cc

@@ -292,10 +292,9 @@ class DeviceSyncCryptAuthMetadataSyncerImplTest
   base::MockOneShotTimer* timer() { return timer_; }
 
  private:
-  void OnSyncMetadataResponse(
-      const cryptauthv2::SyncMetadataRequest& request,
-      const CryptAuthClient::SyncMetadataCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+  void OnSyncMetadataResponse(const cryptauthv2::SyncMetadataRequest& request,
+                              CryptAuthClient::SyncMetadataCallback callback,
+                              CryptAuthClient::ErrorCallback error_callback) {
     ++num_sync_metadata_calls_;
     EXPECT_LE(num_sync_metadata_calls_, 2u);
 
@@ -309,16 +308,16 @@ class DeviceSyncCryptAuthMetadataSyncerImplTest
       EXPECT_FALSE(first_sync_metadata_failure_callback_);
 
       first_sync_metadata_request_ = request;
-      first_sync_metadata_success_callback_ = callback;
-      first_sync_metadata_failure_callback_ = error_callback;
+      first_sync_metadata_success_callback_ = std::move(callback);
+      first_sync_metadata_failure_callback_ = std::move(error_callback);
     } else if (num_sync_metadata_calls_ == 2) {
       EXPECT_TRUE(first_sync_metadata_request_);
       EXPECT_FALSE(first_sync_metadata_success_callback_);
       EXPECT_TRUE(first_sync_metadata_failure_callback_);
 
       second_sync_metadata_request_ = request;
-      second_sync_metadata_success_callback_ = callback;
-      second_sync_metadata_failure_callback_ = error_callback;
+      second_sync_metadata_success_callback_ = std::move(callback);
+      second_sync_metadata_failure_callback_ = std::move(error_callback);
     }
   }
 

chromeos/services/device_sync/cryptauth_v2_enroller_impl_unittest.cc

@@ -347,8 +347,8 @@ class DeviceSyncCryptAuthV2EnrollerImplTest
   }
 
   void OnSyncKeys(const SyncKeysRequest& request,
-                  const CryptAuthClient::SyncKeysCallback& callback,
-                  const CryptAuthClient::ErrorCallback& error_callback) {
+                  CryptAuthClient::SyncKeysCallback callback,
+                  CryptAuthClient::ErrorCallback error_callback) {
     // Check that SyncKeys is called before EnrollKeys.
     EXPECT_FALSE(sync_keys_request_);
     EXPECT_FALSE(enroll_keys_request_);
@@ -358,8 +358,8 @@ class DeviceSyncCryptAuthV2EnrollerImplTest
     EXPECT_TRUE(enroll_keys_failure_callback_.is_null());
 
     sync_keys_request_ = request;
-    sync_keys_success_callback_ = callback;
-    sync_keys_failure_callback_ = error_callback;
+    sync_keys_success_callback_ = std::move(callback);
+    sync_keys_failure_callback_ = std::move(error_callback);
   }
 
   void SendSyncKeysResponse(const SyncKeysResponse& sync_keys_response) {
@@ -387,8 +387,8 @@ class DeviceSyncCryptAuthV2EnrollerImplTest
   }
 
   void OnEnrollKeys(const EnrollKeysRequest& request,
-                    const CryptAuthClient::EnrollKeysCallback& callback,
-                    const CryptAuthClient::ErrorCallback& error_callback) {
+                    CryptAuthClient::EnrollKeysCallback callback,
+                    CryptAuthClient::ErrorCallback error_callback) {
     // Check that EnrollKeys is called after a successful SyncKeys call.
     EXPECT_TRUE(sync_keys_request_);
     EXPECT_FALSE(enroll_keys_request_);
@@ -398,8 +398,8 @@ class DeviceSyncCryptAuthV2EnrollerImplTest
     EXPECT_TRUE(enroll_keys_failure_callback_.is_null());
 
     enroll_keys_request_ = request;
-    enroll_keys_success_callback_ = callback;
-    enroll_keys_failure_callback_ = error_callback;
+    enroll_keys_success_callback_ = std::move(callback);
+    enroll_keys_failure_callback_ = std::move(error_callback);
   }
 
   void VerifyKeyCreatorInputs(

chromeos/services/device_sync/mock_cryptauth_client.h

@@ -5,6 +5,7 @@
 #ifndef CHROMEOS_SERVICES_DEVICE_SYNC_MOCK_CRYPTAUTH_CLIENT_H_
 #define CHROMEOS_SERVICES_DEVICE_SYNC_MOCK_CRYPTAUTH_CLIENT_H_
 
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "chromeos/services/device_sync/cryptauth_client.h"
@@ -24,70 +25,78 @@ class MockCryptAuthClient : public CryptAuthClient {
 
   // TODO(https://crbug.com/997268): Update these to use MOCK_METHOD.
   // CryptAuthClient:
-  MOCK_METHOD4(GetMyDevices,
+  void GetMyDevices(const cryptauth::GetMyDevicesRequest& request,
+                    GetMyDevicesCallback callback,
+                    ErrorCallback error_callback,
+                    const net::PartialNetworkTrafficAnnotationTag&
+                        partial_traffic_annotation) override {
+    GetMyDevices_(request, callback, error_callback,
+                  partial_traffic_annotation);
+  }
+  MOCK_METHOD4(GetMyDevices_,
                void(const cryptauth::GetMyDevicesRequest& request,
-                    const GetMyDevicesCallback& callback,
-                    const ErrorCallback& error_callback,
+                    GetMyDevicesCallback& callback,
+                    ErrorCallback& error_callback,
                     const net::PartialNetworkTrafficAnnotationTag&
                         partial_traffic_annotation));
   MOCK_METHOD3(FindEligibleUnlockDevices,
                void(const cryptauth::FindEligibleUnlockDevicesRequest& request,
-                    const FindEligibleUnlockDevicesCallback& callback,
-                    const ErrorCallback& error_callback));
+                    FindEligibleUnlockDevicesCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(FindEligibleForPromotion,
                void(const cryptauth::FindEligibleForPromotionRequest& request,
-                    const FindEligibleForPromotionCallback& callback,
-                    const ErrorCallback& error_callback));
+                    FindEligibleForPromotionCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD4(SendDeviceSyncTickle,
                void(const cryptauth::SendDeviceSyncTickleRequest& request,
-                    const SendDeviceSyncTickleCallback& callback,
-                    const ErrorCallback& error_callback,
+                    SendDeviceSyncTickleCallback callback,
+                    ErrorCallback error_callback,
                     const net::PartialNetworkTrafficAnnotationTag&
                         partial_traffic_annotation));
   MOCK_METHOD3(ToggleEasyUnlock,
                void(const cryptauth::ToggleEasyUnlockRequest& request,
-                    const ToggleEasyUnlockCallback& callback,
-                    const ErrorCallback& error_callback));
+                    ToggleEasyUnlockCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(SetupEnrollment,
                void(const cryptauth::SetupEnrollmentRequest& request,
-                    const SetupEnrollmentCallback& callback,
-                    const ErrorCallback& error_callback));
+                    SetupEnrollmentCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(FinishEnrollment,
                void(const cryptauth::FinishEnrollmentRequest& request,
-                    const FinishEnrollmentCallback& callback,
-                    const ErrorCallback& error_callback));
+                    FinishEnrollmentCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(SyncKeys,
                void(const cryptauthv2::SyncKeysRequest& request,
-                    const SyncKeysCallback& callback,
-                    const ErrorCallback& error_callback));
+                    SyncKeysCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(EnrollKeys,
                void(const cryptauthv2::EnrollKeysRequest& request,
-                    const EnrollKeysCallback& callback,
-                    const ErrorCallback& error_callback));
+                    EnrollKeysCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(SyncMetadata,
                void(const cryptauthv2::SyncMetadataRequest& request,
-                    const SyncMetadataCallback& callback,
-                    const ErrorCallback& error_callback));
+                    SyncMetadataCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(ShareGroupPrivateKey,
                void(const cryptauthv2::ShareGroupPrivateKeyRequest& request,
-                    const ShareGroupPrivateKeyCallback& callback,
-                    const ErrorCallback& error_callback));
+                    ShareGroupPrivateKeyCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(BatchNotifyGroupDevices,
                void(const cryptauthv2::BatchNotifyGroupDevicesRequest& request,
-                    const BatchNotifyGroupDevicesCallback& callback,
-                    const ErrorCallback& error_callback));
+                    BatchNotifyGroupDevicesCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(BatchGetFeatureStatuses,
                void(const cryptauthv2::BatchGetFeatureStatusesRequest& request,
-                    const BatchGetFeatureStatusesCallback& callback,
-                    const ErrorCallback& error_callback));
+                    BatchGetFeatureStatusesCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(BatchSetFeatureStatuses,
                void(const cryptauthv2::BatchSetFeatureStatusesRequest& request,
-                    const BatchSetFeatureStatusesCallback& callback,
-                    const ErrorCallback& error_callback));
+                    BatchSetFeatureStatusesCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD3(GetDevicesActivityStatus,
                void(const cryptauthv2::GetDevicesActivityStatusRequest& request,
-                    const GetDevicesActivityStatusCallback& callback,
-                    const ErrorCallback& error_callback));
+                    GetDevicesActivityStatusCallback callback,
+                    ErrorCallback error_callback));
   MOCK_METHOD0(GetAccessTokenUsed, std::string());
 
  private:

chromeos/services/device_sync/software_feature_manager_impl_unittest.cc

@@ -113,24 +113,23 @@ class DeviceSyncSoftwareFeatureManagerImplTest
   }
 
   // Mock CryptAuthClient::ToggleEasyUnlock() implementation.
-  void MockToggleEasyUnlock(
-      const cryptauth::ToggleEasyUnlockRequest& request,
-      const CryptAuthClient::ToggleEasyUnlockCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+  void MockToggleEasyUnlock(const cryptauth::ToggleEasyUnlockRequest& request,
+                            CryptAuthClient::ToggleEasyUnlockCallback callback,
+                            CryptAuthClient::ErrorCallback error_callback) {
     last_toggle_request_ = request;
-    toggle_easy_unlock_callback_ = callback;
-    error_callback_ = error_callback;
+    toggle_easy_unlock_callback_ = std::move(callback);
+    error_callback_ = std::move(error_callback);
     error_code_ = kErrorSettingSoftwareFeatureNetworkRequestError;
   }
 
   // Mock CryptAuthClient::FindEligibleUnlockDevices() implementation.
   void MockFindEligibleUnlockDevices(
       const cryptauth::FindEligibleUnlockDevicesRequest& request,
-      const CryptAuthClient::FindEligibleUnlockDevicesCallback& callback,
-      const CryptAuthClient::ErrorCallback& error_callback) {
+      CryptAuthClient::FindEligibleUnlockDevicesCallback callback,
+      CryptAuthClient::ErrorCallback error_callback) {
     last_find_request_ = request;
-    find_eligible_unlock_devices_callback_ = callback;
-    error_callback_ = error_callback;
+    find_eligible_unlock_devices_callback_ = std::move(callback);
+    error_callback_ = std::move(error_callback);
     error_code_ = kErrorFindingEligibleNetworkRequestError;
   }
 
@@ -259,10 +258,9 @@ class DeviceSyncSoftwareFeatureManagerImplTest
 
   void InvokeSetSoftwareFeatureCallback() {
     CryptAuthClient::ToggleEasyUnlockCallback success_callback =
-        toggle_easy_unlock_callback_;
+        std::move(toggle_easy_unlock_callback_);
     ASSERT_TRUE(!success_callback.is_null());
-    toggle_easy_unlock_callback_.Reset();
-    success_callback.Run(cryptauth::ToggleEasyUnlockResponse());
+    std::move(success_callback).Run(cryptauth::ToggleEasyUnlockResponse());
   }
 
   void InvokeSetFeatureStatusCallback() {
@@ -282,17 +280,15 @@ class DeviceSyncSoftwareFeatureManagerImplTest
       const cryptauth::FindEligibleUnlockDevicesResponse&
           retrieved_devices_response) {
     CryptAuthClient::FindEligibleUnlockDevicesCallback success_callback =
-        find_eligible_unlock_devices_callback_;
+        std::move(find_eligible_unlock_devices_callback_);
     ASSERT_TRUE(!success_callback.is_null());
-    find_eligible_unlock_devices_callback_.Reset();
-    success_callback.Run(retrieved_devices_response);
+    std::move(success_callback).Run(retrieved_devices_response);
   }
 
   void InvokeErrorCallback() {
-    CryptAuthClient::ErrorCallback error_callback = error_callback_;
+    CryptAuthClient::ErrorCallback error_callback = std::move(error_callback_);
     ASSERT_TRUE(!error_callback.is_null());
-    error_callback_.Reset();
-    error_callback.Run(*error_code_);
+    std::move(error_callback).Run(*error_code_);
   }
 
   void InvokeSetFeatureStatusErrorCallback() {