Collapse success&failure callbacks into one

Instead of two callbacks:
- void on_success(Result result)
- void on_failure(Status status)
use just one callback:
void on_result(StatusOr<Result> result)

PiperOrigin-RevId: 501912034

internal/platform/credential_storage_impl.cc

@@ -23,7 +23,6 @@ namespace nearby {
 using ::nearby::internal::PrivateCredential;
 using ::nearby::internal::PublicCredential;
 using ::nearby::presence::CredentialSelector;
-using ::nearby::presence::GenerateCredentialsCallback;
 using ::nearby::presence::GetPrivateCredentialsResultCallback;
 using ::nearby::presence::GetPublicCredentialsResultCallback;
 using ::nearby::presence::PublicCredentialType;

internal/platform/credential_storage_impl_test.cc

@@ -36,7 +36,6 @@ using ::nearby::internal::IdentityType;
 using ::nearby::internal::PrivateCredential;
 using ::nearby::internal::PublicCredential;
 using ::nearby::presence::CredentialSelector;
-using ::nearby::presence::GenerateCredentialsCallback;
 using ::nearby::presence::GetPrivateCredentialsResultCallback;
 using ::nearby::presence::GetPublicCredentialsResultCallback;
 using ::nearby::presence::PublicCredentialType;
@@ -91,21 +90,15 @@ absl::StatusOr<std::vector<PrivateCredential>> GetPrivateCredentials(
   CredentialSelector selector = {.manager_app_id = std::string(manager_app_id),
                                  .account_name = std::string(account_name),
                                  .identity_type = identity_type};
-  std::vector<PrivateCredential> private_credentials;
-  absl::Status get_status = absl::OkStatus();
+  absl::StatusOr<std::vector<PrivateCredential>> private_credentials;
   credential_storage.GetPrivateCredentials(
-      selector, GetPrivateCredentialsResultCallback{
-                    .credentials_fetched_cb =
-                        [&](std::vector<PrivateCredential> credentials) {
-                          private_credentials = std::move(credentials);
-                        },
-                    .get_credentials_failed_cb =
-                        [&](absl::Status status) { get_status = status; }});
-  if (get_status.ok()) {
-    return private_credentials;
-  } else {
-    return get_status;
-  }
+      selector,
+      GetPrivateCredentialsResultCallback{
+          .credentials_fetched_cb =
+              [&](absl::StatusOr<std::vector<PrivateCredential>> credentials) {
+                private_credentials = std::move(credentials);
+              }});
+  return private_credentials;
 }
 
 absl::StatusOr<std::vector<PublicCredential>> GetPublicCredentials(
@@ -116,22 +109,15 @@ absl::StatusOr<std::vector<PublicCredential>> GetPublicCredentials(
   CredentialSelector selector = {.manager_app_id = std::string(manager_app_id),
                                  .account_name = std::string(account_name),
                                  .identity_type = identity_type};
-  std::vector<PublicCredential> public_credentials;
-  absl::Status get_status = absl::OkStatus();
+  absl::StatusOr<std::vector<PublicCredential>> public_credentials;
   credential_storage.GetPublicCredentials(
       selector, credential_type,
       GetPublicCredentialsResultCallback{
           .credentials_fetched_cb =
-              [&](std::vector<PublicCredential> credentials) {
+              [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
                 public_credentials = std::move(credentials);
-              },
-          .get_credentials_failed_cb =
-              [&](absl::Status status) { get_status = status; }});
-  if (get_status.ok()) {
-    return public_credentials;
-  } else {
-    return get_status;
-  }
+              }});
+  return public_credentials;
 }
 
 absl::Status SaveCredentials(CredentialStorageImpl& credential_storage,

internal/platform/implementation/credential_callbacks.h

@@ -22,6 +22,7 @@
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 #include "internal/proto/credential.pb.h"
@@ -53,8 +54,9 @@ struct SaveCredentialsResultCallback {
   absl::AnyInvocable<void(absl::Status)> credentials_saved_cb;
 };
 
-struct GenerateCredentialsCallback {
-  absl::AnyInvocable<void(std::vector<nearby::internal::PublicCredential>)>
+struct GenerateCredentialsResultCallback {
+  absl::AnyInvocable<void(
+      absl::StatusOr<std::vector<nearby::internal::PublicCredential>>)>
       credentials_generated_cb;
 };
 
@@ -63,15 +65,15 @@ struct UpdateRemotePublicCredentialsCallback {
 };
 
 struct GetPrivateCredentialsResultCallback {
-  absl::AnyInvocable<void(std::vector<::nearby::internal::PrivateCredential>)>
+  absl::AnyInvocable<void(
+      absl::StatusOr<std::vector<nearby::internal::PrivateCredential>>)>
       credentials_fetched_cb;
-  absl::AnyInvocable<void(absl::Status)> get_credentials_failed_cb;
 };
 
 struct GetPublicCredentialsResultCallback {
-  absl::AnyInvocable<void(std::vector<::nearby::internal::PublicCredential>)>
+  absl::AnyInvocable<void(
+      absl::StatusOr<std::vector<nearby::internal::PublicCredential>>)>
       credentials_fetched_cb;
-  absl::AnyInvocable<void(absl::Status)> get_credentials_failed_cb;
 };
 
 inline std::ostream& operator<<(std::ostream& os,

internal/platform/implementation/g3/credential_storage_impl.cc

@@ -113,7 +113,7 @@ void CredentialStorageImpl::GetPrivateCredentials(
   if (private_credentials_map_.find(key) == private_credentials_map_.end()) {
     NEARBY_LOGS(WARNING) << "There are no Private Credentials stored for key:"
                          << std::get<0>(key) << ", " << std::get<1>(key);
-    std::move(callback.get_credentials_failed_cb)(absl::NotFoundError(
+    std::move(callback.credentials_fetched_cb)(absl::NotFoundError(
         absl::StrFormat("No private credentials for %v", credential_selector)));
     return;
   }
@@ -121,7 +121,7 @@ void CredentialStorageImpl::GetPrivateCredentials(
       private_credentials_map_[key];
   FilterIdentityType(private_credentials, credential_selector.identity_type);
   if (private_credentials.empty()) {
-    std::move(callback.get_credentials_failed_cb)(absl::NotFoundError(
+    std::move(callback.credentials_fetched_cb)(absl::NotFoundError(
         absl::StrFormat("No private credentials for %v", credential_selector)));
     return;
   }
@@ -141,7 +141,7 @@ void CredentialStorageImpl::GetPublicCredentials(
     NEARBY_LOGS(WARNING) << "There are no Public Credentials stored for key:"
                          << std::get<0>(key) << ", " << std::get<1>(key) << ", "
                          << std::get<2>(key);
-    std::move(callback.get_credentials_failed_cb)(absl::NotFoundError(
+    std::move(callback.credentials_fetched_cb)(absl::NotFoundError(
         absl::StrFormat("No public credentials for %v", credential_selector)));
     return;
   }
@@ -149,7 +149,7 @@ void CredentialStorageImpl::GetPublicCredentials(
       public_credentials_map_[key];
   FilterIdentityType(public_credentials, credential_selector.identity_type);
   if (public_credentials.empty()) {
-    std::move(callback.get_credentials_failed_cb)(absl::NotFoundError(
+    std::move(callback.credentials_fetched_cb)(absl::NotFoundError(
         absl::StrFormat("No public credentials for %v", credential_selector)));
     return;
   }