Rename PublicCredential to SharedCredential and PrivateCredential to LocalCredential

PiperOrigin-RevId: 503221477

internal/platform/credential_storage_impl.cc

@@ -20,8 +20,8 @@
 
 namespace nearby {
 
-using ::nearby::internal::PrivateCredential;
-using ::nearby::internal::PublicCredential;
+using ::nearby::internal::LocalCredential;
+using ::nearby::internal::SharedCredential;
 using ::nearby::presence::CredentialSelector;
 using ::nearby::presence::GetPrivateCredentialsResultCallback;
 using ::nearby::presence::GetPublicCredentialsResultCallback;
@@ -29,8 +29,8 @@ using ::nearby::presence::PublicCredentialType;
 
 void CredentialStorageImpl::SaveCredentials(
     absl::string_view manager_app_id, absl::string_view account_name,
-    const std::vector<PrivateCredential>& private_credentials,
-    const std::vector<PublicCredential>& public_credentials,
+    const std::vector<LocalCredential>& private_credentials,
+    const std::vector<SharedCredential>& public_credentials,
     PublicCredentialType public_credential_type,
     SaveCredentialsResultCallback callback) {
   return impl_->SaveCredentials(manager_app_id, account_name,

internal/platform/credential_storage_impl.h

@@ -42,8 +42,8 @@ class CredentialStorageImpl : public api::CredentialStorage {
 
   void SaveCredentials(
       absl::string_view manager_app_id, absl::string_view account_name,
-      const std::vector<PrivateCredential>& private_credentials,
-      const std::vector<PublicCredential>& public_credentials,
+      const std::vector<LocalCredential>& private_credentials,
+      const std::vector<SharedCredential>& public_credentials,
       PublicCredentialType public_credential_type,
       SaveCredentialsResultCallback callback) override;
 

internal/platform/credential_storage_impl_test.cc

@@ -33,8 +33,8 @@ namespace nearby {
 namespace {
 
 using ::nearby::internal::IdentityType;
-using ::nearby::internal::PrivateCredential;
-using ::nearby::internal::PublicCredential;
+using ::nearby::internal::LocalCredential;
+using ::nearby::internal::SharedCredential;
 using ::nearby::presence::CredentialSelector;
 using ::nearby::presence::GetPrivateCredentialsResultCallback;
 using ::nearby::presence::GetPublicCredentialsResultCallback;
@@ -49,24 +49,24 @@ constexpr absl::string_view kManagerAppId = "manager app id";
 constexpr absl::string_view kAccountName = "test_account";
 
 // `secret_id` is used to create credentials with different content.
-PrivateCredential CreatePrivateCredential(absl::string_view secret_id,
+LocalCredential CreatePrivateCredential(absl::string_view secret_id,
                                           IdentityType identity_type) {
-  PrivateCredential private_credential;
+  LocalCredential private_credential;
   private_credential.set_secret_id(secret_id);
   private_credential.set_identity_type(identity_type);
   return private_credential;
 }
 
-PublicCredential CreatePublicCredential(absl::string_view secret_id,
+SharedCredential CreatePublicCredential(absl::string_view secret_id,
                                         IdentityType identity_type) {
-  PublicCredential public_credential;
+  SharedCredential public_credential;
   public_credential.set_secret_id(secret_id);
   public_credential.set_identity_type(identity_type);
   return public_credential;
 }
 
-std::vector<PrivateCredential> BuildPrivateCreds(absl::string_view secret_id) {
-  std::vector<PrivateCredential> private_credentials = {
+std::vector<LocalCredential> BuildPrivateCreds(absl::string_view secret_id) {
+  std::vector<LocalCredential> private_credentials = {
       CreatePrivateCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE),
       CreatePrivateCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED),
       CreatePrivateCredential(secret_id,
@@ -74,8 +74,8 @@ std::vector<PrivateCredential> BuildPrivateCreds(absl::string_view secret_id) {
   return private_credentials;
 }
 
-std::vector<PublicCredential> BuildPublicCreds(absl::string_view secret_id) {
-  std::vector<PublicCredential> public_credentials = {
+std::vector<SharedCredential> BuildPublicCreds(absl::string_view secret_id) {
+  std::vector<SharedCredential> public_credentials = {
       CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE),
       CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED),
       CreatePublicCredential(secret_id,
@@ -83,25 +83,25 @@ std::vector<PublicCredential> BuildPublicCreds(absl::string_view secret_id) {
   return public_credentials;
 }
 
-absl::StatusOr<std::vector<PrivateCredential>> GetPrivateCredentials(
+absl::StatusOr<std::vector<LocalCredential>> GetPrivateCredentials(
     CredentialStorageImpl& credential_storage, IdentityType identity_type,
     absl::string_view manager_app_id = kManagerAppId,
     absl::string_view account_name = kAccountName) {
   CredentialSelector selector = {.manager_app_id = std::string(manager_app_id),
                                  .account_name = std::string(account_name),
                                  .identity_type = identity_type};
-  absl::StatusOr<std::vector<PrivateCredential>> private_credentials;
+  absl::StatusOr<std::vector<LocalCredential>> private_credentials;
   credential_storage.GetPrivateCredentials(
       selector,
       GetPrivateCredentialsResultCallback{
           .credentials_fetched_cb =
-              [&](absl::StatusOr<std::vector<PrivateCredential>> credentials) {
+              [&](absl::StatusOr<std::vector<LocalCredential>> credentials) {
                 private_credentials = std::move(credentials);
               }});
   return private_credentials;
 }
 
-absl::StatusOr<std::vector<PublicCredential>> GetPublicCredentials(
+absl::StatusOr<std::vector<SharedCredential>> GetPublicCredentials(
     CredentialStorageImpl& credential_storage, IdentityType identity_type,
     PublicCredentialType credential_type,
     absl::string_view manager_app_id = kManagerAppId,
@@ -109,12 +109,12 @@ 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};
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials;
   credential_storage.GetPublicCredentials(
       selector, credential_type,
       GetPublicCredentialsResultCallback{
           .credentials_fetched_cb =
-              [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+              [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
                 public_credentials = std::move(credentials);
               }});
   return public_credentials;
@@ -123,8 +123,8 @@ absl::StatusOr<std::vector<PublicCredential>> GetPublicCredentials(
 absl::Status SaveCredentials(CredentialStorageImpl& credential_storage,
                              absl::string_view manager_app_id,
                              absl::string_view account_name,
-                             std::vector<PrivateCredential> private_credentials,
-                             std::vector<PublicCredential> public_credentials,
+                             std::vector<LocalCredential> private_credentials,
+                             std::vector<SharedCredential> public_credentials,
                              PublicCredentialType public_credential_type) {
   absl::Status save_status = absl::UnknownError("");
 
@@ -139,8 +139,8 @@ absl::Status SaveCredentials(CredentialStorageImpl& credential_storage,
 }
 
 absl::Status SaveCredentials(CredentialStorageImpl& credential_storage,
-                             std::vector<PrivateCredential> private_credentials,
-                             std::vector<PublicCredential> public_credentials) {
+                             std::vector<LocalCredential> private_credentials,
+                             std::vector<SharedCredential> public_credentials) {
   return SaveCredentials(credential_storage, kManagerAppId, kAccountName,
                          private_credentials, public_credentials,
                          PublicCredentialType::kLocalPublicCredential);
@@ -150,7 +150,7 @@ absl::Status SavePrivateCredentials(CredentialStorageImpl& credential_storage,
                                     absl::string_view secret_id) {
   return SaveCredentials(credential_storage, kManagerAppId, kAccountName,
                          BuildPrivateCreds(secret_id),
-                         std::vector<PublicCredential>(),
+                         std::vector<SharedCredential>(),
                          PublicCredentialType::kLocalPublicCredential);
 }
 
@@ -158,14 +158,14 @@ absl::Status SavePublicCredentials(CredentialStorageImpl& credential_storage,
                                    PublicCredentialType credential_type,
                                    absl::string_view secret_id) {
   return SaveCredentials(credential_storage, kManagerAppId, kAccountName,
-                         std::vector<PrivateCredential>(),
+                         std::vector<LocalCredential>(),
                          BuildPublicCreds(secret_id), credential_type);
 }
 
 TEST(CredentialStorageImplTest, SaveAndGetPrivateCredentials) {
-  std::vector<PrivateCredential> default_private_creds =
+  std::vector<LocalCredential> default_private_creds =
       BuildPrivateCreds(kSecretId);
-  std::vector<PublicCredential> empty_public_creds;
+  std::vector<SharedCredential> empty_public_creds;
   CredentialStorageImpl credential_storage;
   absl::Status save_status = absl::UnknownError("");
 
@@ -201,8 +201,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetPrivateCredentials) {
 }
 
 TEST(CredentialStorageImplTest, SaveAndGetLocalPublicCredentials) {
-  std::vector<PrivateCredential> empty_private_creds;
-  std::vector<PublicCredential> public_creds = BuildPublicCreds(kSecretId);
+  std::vector<LocalCredential> empty_private_creds;
+  std::vector<SharedCredential> public_creds = BuildPublicCreds(kSecretId);
   CredentialStorageImpl credential_storage;
   absl::Status save_status = absl::UnknownError("");
 
@@ -244,8 +244,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetLocalPublicCredentials) {
 }
 
 TEST(CredentialStorageImplTest, SaveAndGetRemotePublicCredentials) {
-  std::vector<PrivateCredential> empty_private_creds;
-  std::vector<PublicCredential> public_creds = BuildPublicCreds(kSecretId);
+  std::vector<LocalCredential> empty_private_creds;
+  std::vector<SharedCredential> public_creds = BuildPublicCreds(kSecretId);
   CredentialStorageImpl credential_storage;
   absl::Status save_status = absl::UnknownError("");
 
@@ -287,8 +287,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetRemotePublicCredentials) {
 }
 
 TEST(CredentialStorageImplTest, SavePrivateAndLocalPublicCredentials) {
-  std::vector<PrivateCredential> private_creds = BuildPrivateCreds(kSecretId);
-  std::vector<PublicCredential> public_creds = BuildPublicCreds(kSecretId);
+  std::vector<LocalCredential> private_creds = BuildPrivateCreds(kSecretId);
+  std::vector<SharedCredential> public_creds = BuildPublicCreds(kSecretId);
   CredentialStorageImpl credential_storage;
 
   absl::Status status =
@@ -309,8 +309,8 @@ TEST(CredentialStorageImplTest, SavePrivateAndLocalPublicCredentials) {
 }
 
 TEST(CredentialStorageImplTest, SaveCredentialsFailsWhenNoCredentials) {
-  std::vector<PrivateCredential> empty_private_creds;
-  std::vector<PublicCredential> empty_public_creds;
+  std::vector<LocalCredential> empty_private_creds;
+  std::vector<SharedCredential> empty_public_creds;
   CredentialStorageImpl credential_storage;
   absl::Status save_status = absl::UnknownError("");
 
@@ -415,7 +415,7 @@ TEST_P(IdentityFilterTest, FilterPrivateCredentialsByIdentityType) {
   EXPECT_THAT(
       *private_credentials,
       UnorderedPointwise(EqualsProto(),
-                         std::vector<PrivateCredential>{CreatePrivateCredential(
+                         std::vector<LocalCredential>{CreatePrivateCredential(
                              kSecretId, identity_type)}));
 }
 
@@ -426,7 +426,7 @@ TEST_P(IdentityFilterTest,
   IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE
                                 ? IdentityType::IDENTITY_TYPE_TRUSTED
                                 : IdentityType::IDENTITY_TYPE_PRIVATE;
-  std::vector<PrivateCredential> private_creds = {
+  std::vector<LocalCredential> private_creds = {
       CreatePrivateCredential(kSecretId, other_type)};
   CredentialStorageImpl credential_storage;
   EXPECT_OK(SaveCredentials(credential_storage, private_creds,
@@ -452,7 +452,7 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsByIdentityType) {
   EXPECT_THAT(
       *public_credentials,
       UnorderedPointwise(EqualsProto(),
-                         std::vector<PublicCredential>{CreatePublicCredential(
+                         std::vector<SharedCredential>{CreatePublicCredential(
                              kSecretId, identity_type)}));
 }
 
@@ -462,7 +462,7 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsFailsWhenNoCredentialsMatch) {
   IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE
                                 ? IdentityType::IDENTITY_TYPE_TRUSTED
                                 : IdentityType::IDENTITY_TYPE_PRIVATE;
-  std::vector<PublicCredential> public_creds = {
+  std::vector<SharedCredential> public_creds = {
       CreatePublicCredential(kSecretId, other_type)};
   CredentialStorageImpl credential_storage;
   EXPECT_OK(SaveCredentials(credential_storage, BuildPrivateCreds(kSecretId),

internal/platform/implementation/credential_callbacks.h

@@ -66,7 +66,7 @@ struct SaveCredentialsResultCallback {
 
 struct GenerateCredentialsResultCallback {
   absl::AnyInvocable<void(
-      absl::StatusOr<std::vector<nearby::internal::PublicCredential>>)>
+      absl::StatusOr<std::vector<nearby::internal::SharedCredential>>)>
       credentials_generated_cb;
 };
 
@@ -76,13 +76,13 @@ struct UpdateRemotePublicCredentialsCallback {
 
 struct GetPrivateCredentialsResultCallback {
   absl::AnyInvocable<void(
-      absl::StatusOr<std::vector<nearby::internal::PrivateCredential>>)>
+      absl::StatusOr<std::vector<nearby::internal::LocalCredential>>)>
       credentials_fetched_cb;
 };
 
 struct GetPublicCredentialsResultCallback {
   absl::AnyInvocable<void(
-      absl::StatusOr<std::vector<nearby::internal::PublicCredential>>)>
+      absl::StatusOr<std::vector<nearby::internal::SharedCredential>>)>
       credentials_fetched_cb;
 };
 

internal/platform/implementation/credential_storage.h

@@ -28,8 +28,8 @@ namespace api {
 // Credential Storage interface
 class CredentialStorage {
  public:
-  using PrivateCredential = ::nearby::internal::PrivateCredential;
-  using PublicCredential = ::nearby::internal::PublicCredential;
+  using LocalCredential = ::nearby::internal::LocalCredential;
+  using SharedCredential = ::nearby::internal::SharedCredential;
   using PublicCredentialType = ::nearby::presence::PublicCredentialType;
   using SaveCredentialsResultCallback =
       ::nearby::presence::SaveCredentialsResultCallback;
@@ -55,8 +55,8 @@ class CredentialStorage {
   // which is used for querying credentials.
   virtual void SaveCredentials(
       absl::string_view manager_app_id, absl::string_view account_name,
-      const std::vector<PrivateCredential>& private_credentials,
-      const std::vector<PublicCredential>& public_credentials,
+      const std::vector<LocalCredential>& Local_credentials,
+      const std::vector<SharedCredential>& Shared_credentials,
       PublicCredentialType public_credential_type,
       SaveCredentialsResultCallback callback) = 0;
 

internal/platform/implementation/g3/credential_storage_impl.cc

@@ -52,8 +52,8 @@ void FilterIdentityType(std::vector<Credential>& credentials,
 
 void CredentialStorageImpl::SaveCredentials(
     absl::string_view manager_app_id, absl::string_view account_name,
-    const std::vector<PrivateCredential>& private_credentials,
-    const std::vector<PublicCredential>& public_credentials,
+    const std::vector<LocalCredential>& private_credentials,
+    const std::vector<SharedCredential>& public_credentials,
     PublicCredentialType public_credential_type,
     SaveCredentialsResultCallback callback) {
   if (private_credentials.empty() && public_credentials.empty()) {
@@ -117,7 +117,7 @@ void CredentialStorageImpl::GetPrivateCredentials(
         absl::StrFormat("No private credentials for %v", credential_selector)));
     return;
   }
-  std::vector<PrivateCredential> private_credentials =
+  std::vector<LocalCredential> private_credentials =
       private_credentials_map_[key];
   FilterIdentityType(private_credentials, credential_selector.identity_type);
   if (private_credentials.empty()) {
@@ -145,7 +145,7 @@ void CredentialStorageImpl::GetPublicCredentials(
         absl::StrFormat("No public credentials for %v", credential_selector)));
     return;
   }
-  std::vector<PublicCredential> public_credentials =
+  std::vector<SharedCredential> public_credentials =
       public_credentials_map_[key];
   FilterIdentityType(public_credentials, credential_selector.identity_type);
   if (public_credentials.empty()) {

internal/platform/implementation/g3/credential_storage_impl.h

@@ -38,8 +38,8 @@ namespace g3 {
  */
 class CredentialStorageImpl : public api::CredentialStorage {
  public:
-  using PrivateCredential = ::nearby::internal::PrivateCredential;
-  using PublicCredential = ::nearby::internal::PublicCredential;
+  using LocalCredential = ::nearby::internal::LocalCredential;
+  using SharedCredential = ::nearby::internal::SharedCredential;
   using PublicCredentialType = ::nearby::presence::PublicCredentialType;
   using PrivateCredentialKey = std::pair<std::string, std::string>;
   using PublicCredentialKey =
@@ -51,8 +51,8 @@ class CredentialStorageImpl : public api::CredentialStorage {
   // Used to save private and public credentials.
   void SaveCredentials(
       absl::string_view manager_app_id, absl::string_view account_name,
-      const std::vector<PrivateCredential>& private_credentials,
-      const std::vector<PublicCredential>& public_credentials,
+      const std::vector<LocalCredential>& private_credentials,
+      const std::vector<SharedCredential>& public_credentials,
       PublicCredentialType public_credential_type,
       SaveCredentialsResultCallback callback) override;
 
@@ -79,9 +79,9 @@ class CredentialStorageImpl : public api::CredentialStorage {
     return std::make_tuple(std::string(manager_app_id),
                            std::string(account_name), credential_type);
   }
-  absl::flat_hash_map<PrivateCredentialKey, std::vector<PrivateCredential>>
+  absl::flat_hash_map<PrivateCredentialKey, std::vector<LocalCredential>>
       private_credentials_map_;
-  absl::flat_hash_map<PublicCredentialKey, std::vector<PublicCredential>>
+  absl::flat_hash_map<PublicCredentialKey, std::vector<SharedCredential>>
       public_credentials_map_;
   absl::Mutex private_mutex_;
   absl::Mutex public_mutex_;

internal/proto/credential.proto

@@ -15,12 +15,12 @@ enum IdentityType {
 }
 
 // A proto to store the local device's private credential.
-message PrivateCredential {
+message LocalCredential {
   optional IdentityType identity_type = 1;
 
   // The unique id of (and hashed based on) a pair of secret
-  // key (PrivateCredential.verification_key) and X509Certificate's public
-  // key (PublicCredential.verification_key).
+  // key (LocalCredential.verification_key) and X509Certificate's public
+  // key (SharedCredential.verification_key).
   optional bytes secret_id = 2;
 
   // The aes key to encrypt personal fields in public certificates.
@@ -48,7 +48,7 @@ message PrivateCredential {
   optional DeviceMetadata device_metadata = 9;
 }
 
-message PublicCredential {
+message SharedCredential {
   optional IdentityType identity_type = 1;
 
   // The unique id of (and hashed based on) a pair of secret

presence/credential_test.cc

@@ -25,21 +25,21 @@ namespace nearby {
 namespace presence {
 namespace {
 using ::nearby::internal::DeviceMetadata;
-using ::nearby::internal::PrivateCredential;
-using ::nearby::internal::PublicCredential;
+using ::nearby::internal::LocalCredential;
+using ::nearby::internal::SharedCredential;
 using ::nearby::internal::IdentityType::IDENTITY_TYPE_PROVISIONED;
 using ::nearby::internal::IdentityType::IDENTITY_TYPE_PUBLIC;
 
 using ::protobuf_matchers::EqualsProto;
 
 TEST(CredentialsTest, NoDefaultConstructor) {
-  EXPECT_FALSE(std::is_trivially_constructible<PrivateCredential>::value);
-  EXPECT_FALSE(std::is_trivially_constructible<PublicCredential>::value);
+  EXPECT_FALSE(std::is_trivially_constructible<LocalCredential>::value);
+  EXPECT_FALSE(std::is_trivially_constructible<SharedCredential>::value);
 }
 
-TEST(CredentialsTest, InitPublicCredential) {
-  PublicCredential pc1 = {};
-  PublicCredential pc2 = {};
+TEST(CredentialsTest, InitSharedCredential) {
+  SharedCredential pc1 = {};
+  SharedCredential pc2 = {};
   EXPECT_THAT(pc1, EqualsProto(pc2));
   pc1.set_identity_type(IDENTITY_TYPE_PUBLIC);
   EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2)));
@@ -47,9 +47,9 @@ TEST(CredentialsTest, InitPublicCredential) {
   EXPECT_THAT(pc1, EqualsProto(pc2));
 }
 
-TEST(CredentialsTest, InitPrivateCredential) {
-  PrivateCredential pc1 = {};
-  PrivateCredential pc2 = {};
+TEST(CredentialsTest, InitLocalCredential) {
+  LocalCredential pc1 = {};
+  LocalCredential pc2 = {};
   EXPECT_THAT(pc1, EqualsProto(pc2));
   pc1.set_identity_type(IDENTITY_TYPE_PUBLIC);
   EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2)));
@@ -57,24 +57,24 @@ TEST(CredentialsTest, InitPrivateCredential) {
   EXPECT_THAT(pc1, EqualsProto(pc2));
 }
 
-TEST(CredentialsTest, CopyPrivateCredential) {
-  PrivateCredential pc1 = {};
+TEST(CredentialsTest, CopyLocalCredential) {
+  LocalCredential pc1 = {};
   pc1.set_identity_type(IDENTITY_TYPE_PROVISIONED);
   auto salts = pc1.mutable_consumed_salts();
   salts->insert(std::pair<int32, bool>(15, true));
   pc1.mutable_device_metadata()->set_device_name("Android Phone");
   pc1.mutable_device_metadata()->set_device_type(DeviceMetadata::PHONE);
-  PrivateCredential pc1_copy = {pc1};
+  LocalCredential pc1_copy = {pc1};
   EXPECT_THAT(pc1, EqualsProto(pc1_copy));
 }
 
-TEST(CredentialsTest, CopyPublicCredential) {
-  PublicCredential pc1 = {};
+TEST(CredentialsTest, CopySharedCredential) {
+  SharedCredential pc1 = {};
   pc1.set_identity_type(IDENTITY_TYPE_PROVISIONED);
   for (const uint8_t byte : nearby::Uuid().data()) {
     pc1.mutable_secret_id()->push_back(byte);
   }
-  PublicCredential pc1_copy = {pc1};
+  SharedCredential pc1_copy = {pc1};
   EXPECT_THAT(pc1, EqualsProto(pc1_copy));
 }
 }  // namespace

presence/implementation/advertisement_decoder.cc

@@ -212,7 +212,7 @@ void AdvertisementDecoder::DecodeBaseTxAndAction(
 }
 
 absl::StatusOr<std::string> AdvertisementDecoder::DecryptLdt(
-    const std::vector<internal::PublicCredential>& credentials,
+    const std::vector<internal::SharedCredential>& credentials,
     absl::string_view salt, absl::string_view data_elements) {
   if (credentials.empty()) {
     return absl::UnavailableError("No credentials");
@@ -278,7 +278,7 @@ absl::StatusOr<std::string> AdvertisementDecoder::Decrypt(
     if (!absl::holds_alternative<LegacyPresenceScanFilter>(scan_filter)) {
       continue;
     }
-    const std::vector<nearby::internal::PublicCredential>& credentials =
+    const std::vector<nearby::internal::SharedCredential>& credentials =
         absl::get<LegacyPresenceScanFilter>(scan_filter)
             .remote_public_credentials;
     if (credentials.empty()) {

presence/implementation/advertisement_decoder.h

@@ -33,7 +33,7 @@ namespace presence {
 struct Advertisement {
   uint8_t version = 0;
   std::vector<DataElement> data_elements;
-  absl::StatusOr<internal::PublicCredential> public_credential =
+  absl::StatusOr<internal::SharedCredential> public_credential =
       absl::NotFoundError("");
   internal::IdentityType identity_type = internal::IDENTITY_TYPE_UNSPECIFIED;
   std::string metadata_key;
@@ -45,7 +45,7 @@ class AdvertisementDecoder {
   AdvertisementDecoder(
       ScanRequest scan_request,
       absl::flat_hash_map<internal::IdentityType,
-                          std::vector<internal::PublicCredential>>* credentials)
+                          std::vector<internal::SharedCredential>>* credentials)
       : scan_request_(scan_request), credentials_(credentials) {
     AddBannedDataTypes();
   }
@@ -76,7 +76,7 @@ class AdvertisementDecoder {
                                       absl::string_view encrypted);
   void DecodeBaseTxAndAction(absl::string_view serialized_action);
   absl::StatusOr<std::string> DecryptLdt(
-      const std::vector<internal::PublicCredential>& credentials,
+      const std::vector<internal::SharedCredential>& credentials,
       absl::string_view salt, absl::string_view data_elements);
   void AddBannedDataTypes();
   bool MatchesScanFilter(const std::vector<DataElement>& data_elements,
@@ -86,7 +86,7 @@ class AdvertisementDecoder {
 
   ScanRequest scan_request_;
   absl::flat_hash_map<internal::IdentityType,
-                      std::vector<internal::PublicCredential>>* credentials_ =
+                      std::vector<internal::SharedCredential>>* credentials_ =
       nullptr;
   absl::flat_hash_set<int> banned_data_types_;
   Advertisement decoded_advertisement_;

presence/implementation/advertisement_decoder_test.cc

@@ -35,7 +35,7 @@ namespace presence {
 
 namespace {
 using ::nearby::ByteArray;                   // NOLINT
-using ::nearby::internal::PublicCredential;  // NOLINT
+using ::nearby::internal::SharedCredential;  // NOLINT
 using ::testing::ElementsAre;
 using ::protobuf_matchers::EqualsProto;
 using ::testing::Matcher;
@@ -55,7 +55,7 @@ ScanRequest GetScanRequest() {
 }
 
 #if USE_RUST_LDT == 1
-ScanRequest GetScanRequest(std::vector<PublicCredential> credentials) {
+ScanRequest GetScanRequest(std::vector<SharedCredential> credentials) {
   LegacyPresenceScanFilter scan_filter = {.remote_public_credentials =
                                               credentials};
   return ScanRequestBuilder()
@@ -68,7 +68,7 @@ ScanRequest GetScanRequest(std::vector<PublicCredential> credentials) {
       .Build();
 }
 
-PublicCredential GetPublicCredential() {
+SharedCredential GetPublicCredential() {
   // Values copied from LDT tests
   ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72,
                   184, 148, 30, 209, 154, 29,  54,  14, 117, 224, 152,
@@ -76,7 +76,7 @@ PublicCredential GetPublicCredential() {
   ByteArray known_mac({223, 185, 10,  31,  155, 31, 226, 141, 24,  187, 204,
                        165, 34,  64,  181, 204, 44, 203, 95,  141, 82,  137,
                        163, 203, 100, 235, 53,  65, 202, 97,  75,  180});
-  PublicCredential public_credential;
+  SharedCredential public_credential;
   public_credential.set_authenticity_key(seed.AsStringView());
   public_credential.set_metadata_encryption_key_tag(known_mac.AsStringView());
   return public_credential;
@@ -87,7 +87,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpPrivateAdvertisement) {
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
   absl::flat_hash_map<internal::IdentityType,
-                      std::vector<internal::PublicCredential>>
+                      std::vector<internal::SharedCredential>>
       credentials;
   credentials[internal::IDENTITY_TYPE_PRIVATE].push_back(GetPublicCredential());
   AdvertisementDecoder decoder(GetScanRequest(), &credentials);
@@ -111,7 +111,7 @@ TEST(AdvertisementDecoder,
   const std::string salt = "AB";
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
-  std::vector<PublicCredential> credentials = {GetPublicCredential()};
+  std::vector<SharedCredential> credentials = {GetPublicCredential()};
 
   AdvertisementDecoder decoder(GetScanRequest(credentials));
 
@@ -134,7 +134,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpTrustedAdvertisement) {
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
   absl::flat_hash_map<internal::IdentityType,
-                      std::vector<internal::PublicCredential>>
+                      std::vector<internal::SharedCredential>>
       credentials;
   credentials[internal::IDENTITY_TYPE_TRUSTED].push_back(GetPublicCredential());
   AdvertisementDecoder decoder(GetScanRequest(), &credentials);
@@ -161,7 +161,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpProvisionedAdvertisement) {
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
   absl::flat_hash_map<internal::IdentityType,
-                      std::vector<internal::PublicCredential>>
+                      std::vector<internal::SharedCredential>>
       credentials;
   credentials[internal::IDENTITY_TYPE_PROVISIONED].push_back(
       GetPublicCredential());
@@ -189,7 +189,7 @@ TEST(AdvertisementDecoder, InvalidEncryptedContent) {
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
   absl::flat_hash_map<internal::IdentityType,
-                      std::vector<internal::PublicCredential>>
+                      std::vector<internal::SharedCredential>>
       credentials;
   credentials[internal::IDENTITY_TYPE_PRIVATE].push_back(GetPublicCredential());
   AdvertisementDecoder decoder(GetScanRequest(), &credentials);

presence/implementation/advertisement_factory.cc

@@ -96,7 +96,7 @@ std::string SerializeAction(const Action& action) {
 
 absl::StatusOr<AdvertisementData> AdvertisementFactory::CreateAdvertisement(
     const BaseBroadcastRequest& request,
-    std::vector<PrivateCredential>& credentials) const {
+    std::vector<LocalCredential>& credentials) const {
   AdvertisementData advert = {};
   if (absl::holds_alternative<BaseBroadcastRequest::BasePresence>(
           request.variant)) {
@@ -108,7 +108,7 @@ absl::StatusOr<AdvertisementData> AdvertisementFactory::CreateAdvertisement(
 absl::StatusOr<AdvertisementData>
 AdvertisementFactory::CreateBaseNpAdvertisement(
     const BaseBroadcastRequest& request,
-    std::vector<PrivateCredential>& credentials) const {
+    std::vector<LocalCredential>& credentials) const {
   const auto& presence =
       absl::get<BaseBroadcastRequest::BasePresence>(request.variant);
   std::string payload;
@@ -181,9 +181,9 @@ AdvertisementFactory::CreateBaseNpAdvertisement(
                            .content = payload};
 }
 absl::StatusOr<std::string> AdvertisementFactory::EncryptDataElements(
-    std::vector<PrivateCredential>& credentials, absl::string_view salt,
+    std::vector<LocalCredential>& credentials, absl::string_view salt,
     absl::string_view data_elements) const {
-  PrivateCredential& credential = credentials.front();
+  LocalCredential& credential = credentials.front();
   if (credential.metadata_encryption_key().size() != kBaseMetadataSize) {
     return absl::FailedPreconditionError(absl::StrFormat(
         "Metadata key size %d, expected %d",

presence/implementation/advertisement_factory.h

@@ -29,7 +29,7 @@ namespace presence {
 // Builds BLE advertisements from broadcast requests.
 class AdvertisementFactory {
  public:
-  using PrivateCredential = internal::PrivateCredential;
+  using LocalCredential = internal::LocalCredential;
 
   // Returns a `CredentialSelector` if credentials are required to create an
   // advertisement from the `request`.
@@ -39,20 +39,20 @@ class AdvertisementFactory {
   // Returns a BLE advertisement for given `request.
   absl::StatusOr<AdvertisementData> CreateAdvertisement(
       const BaseBroadcastRequest& request,
-      std::vector<PrivateCredential>& credentials) const;
+      std::vector<LocalCredential>& credentials) const;
 
   absl::StatusOr<AdvertisementData> CreateAdvertisement(
       const BaseBroadcastRequest& request) const {
-    std::vector<PrivateCredential> empty;
+    std::vector<LocalCredential> empty;
     return CreateAdvertisement(request, empty);
   }
 
  private:
   absl::StatusOr<AdvertisementData> CreateBaseNpAdvertisement(
       const BaseBroadcastRequest& request,
-      std::vector<PrivateCredential>& credentials) const;
+      std::vector<LocalCredential>& credentials) const;
   absl::StatusOr<std::string> EncryptDataElements(
-      std::vector<PrivateCredential>& credentials, absl::string_view salt,
+      std::vector<LocalCredential>& credentials, absl::string_view salt,
       absl::string_view data_elements) const;
 };
 

presence/implementation/advertisement_factory_test.cc

@@ -35,13 +35,13 @@ namespace {
 
 using ::nearby::ByteArray;  // NOLINT
 using ::nearby::internal::IdentityType;
-using ::nearby::internal::PrivateCredential;  // NOLINT
+using ::nearby::internal::LocalCredential;  // NOLINT
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::status::StatusIs;
 
 #if USE_RUST_LDT == 1
-PrivateCredential CreatePrivateCredential(IdentityType identity_type) {
+LocalCredential CreatePrivateCredential(IdentityType identity_type) {
   // Values copied from LDT tests
   ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72,
                   184, 148, 30, 209, 154, 29,  54,  14, 117, 224, 152,
@@ -49,7 +49,7 @@ PrivateCredential CreatePrivateCredential(IdentityType identity_type) {
   ByteArray metadata_key(
       {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174});
 
-  PrivateCredential private_credential;
+  LocalCredential private_credential;
   private_credential.set_identity_type(identity_type);
   private_credential.set_authenticity_key(seed.AsStringView());
   private_credential.set_metadata_encryption_key(metadata_key.AsStringView());
@@ -60,7 +60,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromPrivateIdentity) {
   std::string account_name = "Test account";
   std::string salt = "AB";
   constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE;
-  std::vector<PrivateCredential> credentials = {
+  std::vector<LocalCredential> credentials = {
       CreatePrivateCredential(kIdentity)};
   std::vector<DataElement> data_elements;
   data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction));
@@ -85,7 +85,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromTrustedIdentity) {
   std::string account_name = "Test account";
   std::string salt = "AB";
   constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_TRUSTED;
-  std::vector<PrivateCredential> credentials = {
+  std::vector<LocalCredential> credentials = {
       CreatePrivateCredential(kIdentity)};
   std::vector<DataElement> data_elements;
   data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction));
@@ -111,7 +111,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromProvisionedIdentity) {
   std::string account_name = "Test account";
   std::string salt = "AB";
   constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PROVISIONED;
-  std::vector<PrivateCredential> credentials = {
+  std::vector<LocalCredential> credentials = {
       CreatePrivateCredential(kIdentity)};
   std::vector<DataElement> data_elements;
   data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction));

presence/implementation/broadcast_manager.cc

@@ -69,7 +69,7 @@ void BroadcastManager::FetchCredentials(
           .credentials_fetched_cb =
               [this, id, broadcast_request = std::move(broadcast_request)](
                   absl::StatusOr<
-                      std::vector<::nearby::internal::PrivateCredential>>
+                      std::vector<::nearby::internal::LocalCredential>>
                       credentials) {
                 if (!credentials.ok()) {
                   NEARBY_LOGS(WARNING)
@@ -90,7 +90,7 @@ void BroadcastManager::FetchCredentials(
 
 void BroadcastManager::Advertise(BroadcastSessionId id,
                                  BaseBroadcastRequest broadcast_request,
-                                 std::vector<PrivateCredential> credentials) {
+                                 std::vector<LocalCredential> credentials) {
   auto it = sessions_.find(id);
   if (it == sessions_.end()) {
     NEARBY_LOGS(INFO) << "Broadcast session terminated, id: " << id;

presence/implementation/broadcast_manager.h

@@ -42,7 +42,7 @@ class BroadcastManager {
   using AdvertisingSession =
       ::nearby::api::ble_v2::BleMedium::AdvertisingSession;
   using Runnable = ::nearby::Runnable;
-  using PrivateCredential = internal::PrivateCredential;
+  using LocalCredential = internal::LocalCredential;
   BroadcastManager(Mediums& mediums, CredentialManager& credential_manager,
                    SingleThreadExecutor& executor) {
     mediums_ = &mediums, credential_manager_ = &credential_manager,
@@ -85,7 +85,7 @@ class BroadcastManager {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
 
   void Advertise(BroadcastSessionId id, BaseBroadcastRequest broadcast_request,
-                 std::vector<PrivateCredential> credentials)
+                 std::vector<LocalCredential> credentials)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
   absl::flat_hash_map<BroadcastSessionId, BroadcastSessionState> sessions_
       ABSL_GUARDED_BY(*executor_);

presence/implementation/credential_manager.h

@@ -55,7 +55,7 @@ class CredentialManager {
   // Update remote public credentials.
   virtual void UpdateRemotePublicCredentials(
       absl::string_view manager_app_id, absl::string_view account_name,
-      const std::vector<nearby::internal::PublicCredential>&
+      const std::vector<nearby::internal::SharedCredential>&
           remote_public_creds,
       UpdateRemotePublicCredentialsCallback credentials_updated_cb) = 0;
 

presence/implementation/credential_manager_impl.cc

@@ -33,6 +33,7 @@
 #include "internal/platform/implementation/crypto.h"
 #include "internal/platform/logging.h"
 #include "internal/proto/credential.pb.h"
+#include "internal/proto/credential.proto.h"
 #include "presence/implementation/encryption.h"
 #include "presence/implementation/ldt.h"
 
@@ -46,8 +47,8 @@ using ::nearby::ExceptionOr;
 using ::nearby::Future;
 using ::nearby::internal::DeviceMetadata;
 using ::nearby::internal::IdentityType;
-using ::nearby::internal::PrivateCredential;
-using ::nearby::internal::PublicCredential;
+using ::nearby::internal::LocalCredential;
+using ::nearby::internal::SharedCredential;
 
 // Key to retrieve local device's Private/Public Key Credentials from key store.
 constexpr char kPairedKeyAliasPrefix[] = "nearby_presence_paired_key_alias_";
@@ -61,8 +62,8 @@ void CredentialManagerImpl::GenerateCredentials(
     const std::vector<IdentityType>& identity_types,
     int credential_life_cycle_days, int contiguous_copy_of_credentials,
     GenerateCredentialsResultCallback credentials_generated_cb) {
-  std::vector<PublicCredential> public_credentials;
-  std::vector<PrivateCredential> private_credentials;
+  std::vector<SharedCredential> public_credentials;
+  std::vector<LocalCredential> private_credentials;
 
   for (auto identity_type : identity_types) {
     // TODO(b/241587906): Get linux time from the platform (like Android)
@@ -115,7 +116,7 @@ void CredentialManagerImpl::GenerateCredentials(
 
 void CredentialManagerImpl::UpdateRemotePublicCredentials(
     absl::string_view manager_app_id, absl::string_view account_name,
-    const std::vector<nearby::internal::PublicCredential>& remote_public_creds,
+    const std::vector<SharedCredential>& remote_public_creds,
     UpdateRemotePublicCredentialsCallback credentials_updated_cb) {
   credential_storage_ptr_->SaveCredentials(
       manager_app_id, account_name, /* private_credentials */ {},
@@ -144,11 +145,11 @@ void CredentialManagerImpl::UpdateRemotePublicCredentials(
               }});
 }
 
-std::pair<PrivateCredential, PublicCredential>
+std::pair<LocalCredential, SharedCredential>
 CredentialManagerImpl::CreatePrivateCredential(
     const DeviceMetadata& device_metadata, IdentityType identity_type,
     uint64_t start_time_ms, uint64_t end_time_ms) {
-  PrivateCredential private_credential;
+  LocalCredential private_credential;
   private_credential.set_start_time_millis(start_time_ms);
   private_credential.set_end_time_millis(end_time_ms);
   private_credential.set_identity_type(identity_type);
@@ -189,15 +190,15 @@ CredentialManagerImpl::CreatePrivateCredential(
   std::vector<uint8_t> public_key;
   key_pair->ExportPublicKey(&public_key);
 
-  return std::pair<PrivateCredential, PublicCredential>(
+  return std::pair<LocalCredential, SharedCredential>(
       private_credential,
       CreatePublicCredential(private_credential, public_key));
 }
 
-PublicCredential CredentialManagerImpl::CreatePublicCredential(
-    const PrivateCredential& private_credential,
+SharedCredential CredentialManagerImpl::CreatePublicCredential(
+    const LocalCredential& private_credential,
     const std::vector<uint8_t>& public_key) {
-  PublicCredential public_credential;
+  SharedCredential public_credential;
   public_credential.set_identity_type(private_credential.identity_type());
   public_credential.set_secret_id(private_credential.secret_id());
   public_credential.set_authenticity_key(private_credential.authenticity_key());
@@ -304,14 +305,14 @@ void CredentialManagerImpl::GetPublicCredentials(
       credential_selector, public_credential_type, std::move(callback));
 }
 
-ExceptionOr<std::vector<PrivateCredential>>
+ExceptionOr<std::vector<LocalCredential>>
 CredentialManagerImpl::GetPrivateCredentialsSync(
     const CredentialSelector& credential_selector, absl::Duration timeout) {
-  Future<std::vector<PrivateCredential>> result;
+  Future<std::vector<LocalCredential>> result;
   GetPrivateCredentials(
       credential_selector,
       {.credentials_fetched_cb =
-           [result](absl::StatusOr<std::vector<PrivateCredential>>
+           [result](absl::StatusOr<std::vector<LocalCredential>>
                         credentials) mutable {
              if (!credentials.ok()) {
                result.SetException({Exception::kFailed});
@@ -322,15 +323,15 @@ CredentialManagerImpl::GetPrivateCredentialsSync(
   return result.Get(timeout);
 }
 
-ExceptionOr<std::vector<PublicCredential>>
+ExceptionOr<std::vector<SharedCredential>>
 CredentialManagerImpl::GetPublicCredentialsSync(
     const CredentialSelector& credential_selector,
     PublicCredentialType public_credential_type, absl::Duration timeout) {
-  Future<std::vector<PublicCredential>> result;
+  Future<std::vector<SharedCredential>> result;
   GetPublicCredentials(
       credential_selector, public_credential_type,
       {.credentials_fetched_cb =
-           [result](absl::StatusOr<std::vector<PublicCredential>>
+           [result](absl::StatusOr<std::vector<SharedCredential>>
                         credentials) mutable {
              if (!credentials.ok()) {
                result.SetException({Exception::kFailed});
@@ -424,7 +425,7 @@ CredentialManagerImpl::CreateNotifySubscribersCallback(SubscriberKey key) {
   return GetPublicCredentialsResultCallback{
       .credentials_fetched_cb =
           [this, key](
-              absl::StatusOr<std::vector<::nearby::internal::PublicCredential>>
+              absl::StatusOr<std::vector<SharedCredential>>
                   credentials) {
             if (!credentials.ok()) {
               NEARBY_LOGS(WARNING)
@@ -443,7 +444,7 @@ CredentialManagerImpl::CreateNotifySubscribersCallback(SubscriberKey key) {
 
 void CredentialManagerImpl::NotifySubscribers(
     const SubscriberKey& key,
-    std::vector<::nearby::internal::PublicCredential> credentials) {
+    std::vector<SharedCredential> credentials) {
   // We are on `executor_` thread, so we can iterate over `subscribers_`
   // without locking.
   auto it = subscribers_.find(key);
@@ -463,7 +464,7 @@ void CredentialManagerImpl::NotifySubscribers(
 }
 
 void CredentialManagerImpl::Subscriber::NotifyCredentialsFetched(
-    std::vector<::nearby::internal::PublicCredential>& credentials) {
+    std::vector<SharedCredential>& credentials) {
   callback_.credentials_fetched_cb(credentials);
 }
 

presence/implementation/credential_manager_impl.h

@@ -71,7 +71,7 @@ class CredentialManagerImpl : public CredentialManager {
 
   void UpdateRemotePublicCredentials(
       absl::string_view manager_app_id, absl::string_view account_name,
-      const std::vector<nearby::internal::PublicCredential>&
+      const std::vector<nearby::internal::SharedCredential>&
           remote_public_creds,
       UpdateRemotePublicCredentialsCallback credentials_updated_cb) override;
 
@@ -80,7 +80,7 @@ class CredentialManagerImpl : public CredentialManager {
       GetPrivateCredentialsResultCallback callback) override;
 
   // Blocking version of `GetPrivateCredentials`
-  nearby::ExceptionOr<std::vector<nearby::internal::PrivateCredential>>
+  nearby::ExceptionOr<std::vector<nearby::internal::LocalCredential>>
   GetPrivateCredentialsSync(const CredentialSelector& credential_selector,
                             absl::Duration timeout);
 
@@ -91,7 +91,7 @@ class CredentialManagerImpl : public CredentialManager {
       GetPublicCredentialsResultCallback callback) override;
 
   // Blocking version of `GetPublicCredentials`.
-  ::nearby::ExceptionOr<std::vector<::nearby::internal::PublicCredential>>
+  ::nearby::ExceptionOr<std::vector<::nearby::internal::SharedCredential>>
   GetPublicCredentialsSync(const CredentialSelector& credential_selector,
                            PublicCredentialType public_credential_type,
                            absl::Duration timeout);
@@ -108,14 +108,14 @@ class CredentialManagerImpl : public CredentialManager {
       absl::string_view authenticity_key,
       absl::string_view device_metadata_string) override;
 
-  std::pair<nearby::internal::PrivateCredential,
-            nearby::internal::PublicCredential>
+  std::pair<nearby::internal::LocalCredential,
+            nearby::internal::SharedCredential>
   CreatePrivateCredential(
       const nearby::internal::DeviceMetadata& device_metadata,
       IdentityType identity_type, uint64_t start_time_ms, uint64_t end_time_ms);
 
-  nearby::internal::PublicCredential CreatePublicCredential(
-      const nearby::internal::PrivateCredential& private_credential,
+  nearby::internal::SharedCredential CreatePublicCredential(
+      const nearby::internal::LocalCredential& private_credential,
       const std::vector<uint8_t>& public_key);
 
   virtual std::string EncryptDeviceMetadata(
@@ -150,7 +150,7 @@ class CredentialManagerImpl : public CredentialManager {
 
     // Notifies the subscriber about fetched credentials.
     void NotifyCredentialsFetched(
-        std::vector<::nearby::internal::PublicCredential>& credentials);
+        std::vector<::nearby::internal::SharedCredential>& credentials);
 
    private:
     GetPublicCredentialsResultCallback callback_;
@@ -167,7 +167,7 @@ class CredentialManagerImpl : public CredentialManager {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
   void NotifySubscribers(
       const SubscriberKey& key,
-      std::vector<::nearby::internal::PublicCredential> credentials)
+      std::vector<::nearby::internal::SharedCredential> credentials)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
   void AddSubscriber(SubscriberKey key, SubscriberId id,
                      GetPublicCredentialsResultCallback callback)

presence/implementation/credential_manager_impl_test.cc

@@ -40,8 +40,8 @@ using ::nearby::Crypto;
 using ::nearby::MediumEnvironment;
 using ::nearby::internal::DeviceMetadata;
 using ::nearby::internal::IdentityType;
-using ::nearby::internal::PrivateCredential;
-using ::nearby::internal::PublicCredential;
+using ::nearby::internal::LocalCredential;
+using ::nearby::internal::SharedCredential;
 using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE;
 using ::proto2::contrib::parse_proto::ParseTestProto;
 using ::protobuf_matchers::EqualsProto;
@@ -77,9 +77,9 @@ class CredentialManagerImplTest : public ::testing::Test {
     MOCK_METHOD(void, SaveCredentials,
                 (absl::string_view manager_app_id,
                  absl::string_view account_name,
-                 const std::vector<::nearby::internal::PrivateCredential>&
+                 const std::vector<LocalCredential>&
                      private_credentials,
-                 const std::vector<::nearby::internal::PublicCredential>&
+                 const std::vector<SharedCredential>&
                      public_credentials,
                  PublicCredentialType public_credential_type,
                  SaveCredentialsResultCallback callback),
@@ -127,7 +127,7 @@ class CredentialManagerImplTest : public ::testing::Test {
         device_metadata, manager_app_id, {identity_type},
         /*credential_life_cycle_days=*/1,
         /*contigous_copy_of_credentials=*/1,
-        {[](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+        {[](absl::StatusOr<std::vector<SharedCredential>> credentials) {
           EXPECT_OK(credentials);
         }});
   }
@@ -145,7 +145,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
       device_metadata, IDENTITY_TYPE_PRIVATE, /* start_time_ms= */ 0,
       /* end_time_ms= */ 1000);
 
-  PrivateCredential private_credential = credentials.first;
+  LocalCredential private_credential = credentials.first;
 
   // Verify the private credential.
   EXPECT_THAT(private_credential.device_metadata(),
@@ -160,7 +160,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
   EXPECT_EQ(private_credential.metadata_encryption_key().size(),
             CredentialManagerImpl::kAuthenticityKeyByteSize);
 
-  PublicCredential public_credential = credentials.second;
+  SharedCredential public_credential = credentials.second;
   // Verify the public credential.
   EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE);
   EXPECT_FALSE(public_credential.secret_id().empty());
@@ -187,14 +187,14 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
 
 TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) {
   DeviceMetadata device_metadata = CreateTestDeviceMetadata();
-  absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+  absl::StatusOr<std::vector<SharedCredential>>
       public_credentials;
   std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
 
   credential_manager_.GenerateCredentials(
       device_metadata, kManagerAppId, identityTypes, 1, 2,
       {.credentials_generated_cb =
-           [&](absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+           [&](absl::StatusOr<std::vector<SharedCredential>>
                    credentials) {
              public_credentials = std::move(credentials);
            }});
@@ -213,8 +213,8 @@ TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) {
 
 TEST_F(CredentialManagerImplTest,
        SubscribeCallsCallbackWithExistingCredentials) {
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials1;
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials2;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials1;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials2;
   AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE);
 
   SubscriberId id1 = credential_manager_.SubscribeForPublicCredentials(
@@ -223,7 +223,7 @@ TEST_F(CredentialManagerImplTest,
                          .identity_type = IDENTITY_TYPE_PRIVATE},
       PublicCredentialType::kLocalPublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              public_credentials1 = std::move(credentials);
            }});
   SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials(
@@ -232,7 +232,7 @@ TEST_F(CredentialManagerImplTest,
                          .identity_type = IDENTITY_TYPE_PRIVATE},
       PublicCredentialType::kLocalPublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              public_credentials2 = std::move(credentials);
            }});
 
@@ -249,7 +249,7 @@ TEST_F(CredentialManagerImplTest,
 
 TEST_F(CredentialManagerImplTest,
        SubscribeCallsCallbackWithUpdatedCredentials) {
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials;
 
   SubscriberId id = credential_manager_.SubscribeForPublicCredentials(
       CredentialSelector{.manager_app_id = std::string(kManagerAppId),
@@ -257,7 +257,7 @@ TEST_F(CredentialManagerImplTest,
                          .identity_type = IDENTITY_TYPE_PRIVATE},
       PublicCredentialType::kLocalPublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              public_credentials = std::move(credentials);
            }});
   Fence();
@@ -274,14 +274,14 @@ TEST_F(CredentialManagerImplTest,
 }
 
 TEST_F(CredentialManagerImplTest, NoCallbacksAfterUnsubscribe) {
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials;
   SubscriberId id = credential_manager_.SubscribeForPublicCredentials(
       CredentialSelector{.manager_app_id = std::string(kManagerAppId),
                          .account_name = std::string(kAccountName),
                          .identity_type = IDENTITY_TYPE_PRIVATE},
       PublicCredentialType::kLocalPublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              public_credentials = std::move(credentials);
            }});
 
@@ -300,8 +300,8 @@ TEST_F(CredentialManagerImplTest,
   EXPECT_CALL(*credential_storage_ptr, SaveCredentials)
       .WillOnce(::testing::Invoke(
           [](absl::string_view manager_app_id, absl::string_view account_name,
-             const std::vector<PrivateCredential>& private_credentials,
-             const std::vector<PublicCredential>& public_credentials,
+             const std::vector<LocalCredential>& private_credentials,
+             const std::vector<SharedCredential>& public_credentials,
              PublicCredentialType public_credential_type,
              SaveCredentialsResultCallback callback) {
             callback.credentials_saved_cb(
@@ -309,14 +309,14 @@ TEST_F(CredentialManagerImplTest,
           }));
   credential_manager_ =
       CredentialManagerImpl(&executor_, std::move(credential_storage_ptr));
-  absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+  absl::StatusOr<std::vector<SharedCredential>>
       public_credentials;
   std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
 
   credential_manager_.GenerateCredentials(
       device_metadata, kManagerAppId, identityTypes, 1, 2,
       {.credentials_generated_cb =
-           [&](absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+           [&](absl::StatusOr<std::vector<SharedCredential>>
                    credentials) {
              public_credentials = std::move(credentials);
            }});
@@ -325,10 +325,10 @@ TEST_F(CredentialManagerImplTest,
 }
 
 TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsSuccessfully) {
-  nearby::internal::PublicCredential public_credential_for_test;
+  SharedCredential public_credential_for_test;
   public_credential_for_test.set_identity_type(
-      nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED);
-  std::vector<nearby::internal::PublicCredential> public_credentials{
+      IdentityType::IDENTITY_TYPE_TRUSTED);
+  std::vector<SharedCredential> public_credentials{
       {public_credential_for_test}};
 
   nearby::CountDownLatch updated_latch(1);
@@ -350,11 +350,11 @@ TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsSuccessfully) {
 
 TEST_F(CredentialManagerImplTest,
        UpdateRemotePublicCredentialsNotifiesSubscribers) {
-  absl::StatusOr<std::vector<PublicCredential>> subscribed_credentials;
-  nearby::internal::PublicCredential public_credential_for_test;
+  absl::StatusOr<std::vector<SharedCredential>> subscribed_credentials;
+  SharedCredential public_credential_for_test;
   public_credential_for_test.set_identity_type(
-      nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE);
-  std::vector<nearby::internal::PublicCredential> public_credentials{
+      IdentityType::IDENTITY_TYPE_PRIVATE);
+  std::vector<SharedCredential> public_credentials{
       {public_credential_for_test}};
   nearby::CountDownLatch updated_latch(1);
   UpdateRemotePublicCredentialsCallback update_credentials_cb{
@@ -371,7 +371,7 @@ TEST_F(CredentialManagerImplTest,
                          .identity_type = internal::IDENTITY_TYPE_PRIVATE},
       PublicCredentialType::kRemotePublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              subscribed_credentials = std::move(credentials);
            }});
   SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials(
@@ -380,7 +380,7 @@ TEST_F(CredentialManagerImplTest,
                          .identity_type = internal::IDENTITY_TYPE_TRUSTED},
       PublicCredentialType::kRemotePublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              // This callback should not be called because there are no Trusted
              // credentials in this test.
              GTEST_FAIL();
@@ -398,14 +398,14 @@ TEST_F(CredentialManagerImplTest,
   credential_manager_.UnsubscribeFromPublicCredentials(id2);
 }
 
-TEST_F(CredentialManagerImplTest, GetPrivateCredentialsFailed) {
-  absl::StatusOr<std::vector<PrivateCredential>> private_credentials;
+TEST_F(CredentialManagerImplTest, GetLocalCredentialsFailed) {
+  absl::StatusOr<std::vector<LocalCredential>> private_credentials;
   CredentialSelector credential_selector = BuildDefaultCredentialSelector();
 
   credential_manager_.GetPrivateCredentials(
       credential_selector,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PrivateCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<LocalCredential>> credentials) {
              private_credentials = std::move(credentials);
            }});
 
@@ -413,13 +413,13 @@ TEST_F(CredentialManagerImplTest, GetPrivateCredentialsFailed) {
 }
 
 TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) {
-  absl::StatusOr<std::vector<PublicCredential>> public_credentials;
+  absl::StatusOr<std::vector<SharedCredential>> public_credentials;
   CredentialSelector credential_selector = BuildDefaultCredentialSelector();
 
   credential_manager_.GetPublicCredentials(
       credential_selector, PublicCredentialType::kLocalPublicCredential,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PublicCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
              public_credentials = std::move(credentials);
            }});
 
@@ -428,23 +428,23 @@ TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) {
 
 TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) {
   DeviceMetadata device_metadata = CreateTestDeviceMetadata();
-  absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+  absl::StatusOr<std::vector<SharedCredential>>
       public_credentials;
   std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
-  absl::StatusOr<std::vector<PrivateCredential>> private_credentials;
+  absl::StatusOr<std::vector<LocalCredential>> private_credentials;
   CredentialSelector credential_selector = BuildDefaultCredentialSelector();
 
   credential_manager_.GenerateCredentials(
       device_metadata, kManagerAppId, identity_types, 1, 1,
       {.credentials_generated_cb =
-           [&](absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+           [&](absl::StatusOr<std::vector<SharedCredential>>
                    credentials) {
              public_credentials = std::move(credentials);
            }});
   credential_manager_.GetPrivateCredentials(
       credential_selector,
       {.credentials_fetched_cb =
-           [&](absl::StatusOr<std::vector<PrivateCredential>> credentials) {
+           [&](absl::StatusOr<std::vector<LocalCredential>> credentials) {
              private_credentials = std::move(credentials);
            }});
 
@@ -456,7 +456,7 @@ TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) {
 
 TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) {
   DeviceMetadata device_metadata = CreateTestDeviceMetadata();
-  absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+  absl::StatusOr<std::vector<SharedCredential>>
       public_credentials;
   auto credential_manager_ptr =
       std::make_unique<CredentialManagerImplTest::MockCredentialManager>(
@@ -471,7 +471,7 @@ TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) {
   credential_manager_ptr->GenerateCredentials(
       device_metadata, kManagerAppId, identity_types, 1, 1,
       {.credentials_generated_cb =
-           [&](absl::StatusOr<std::vector<nearby::internal::PublicCredential>>
+           [&](absl::StatusOr<std::vector<SharedCredential>>
                    credentials) {
              public_credentials = std::move(credentials);
            }});

presence/implementation/scan_manager.cc

@@ -131,7 +131,7 @@ void ScanManager::FetchCredentials(ScanSessionId id,
         {.credentials_fetched_cb =
              [this, id, identity_type = selector.identity_type](
                  absl::StatusOr<
-                     std::vector<::nearby::internal::PublicCredential>>
+                     std::vector<::nearby::internal::SharedCredential>>
                      credentials) {
                if (!credentials.ok()) {
                  NEARBY_LOGS(WARNING)
@@ -152,7 +152,7 @@ void ScanManager::FetchCredentials(ScanSessionId id,
 
 void ScanManager::UpdateCredentials(ScanSessionId id,
                                     IdentityType identity_type,
-                                    std::vector<PublicCredential> credentials) {
+                                    std::vector<SharedCredential> credentials) {
   auto it = scan_sessions_.find(id);
   if (it == scan_sessions_.end()) {
     return;

presence/implementation/scan_manager.h

@@ -19,6 +19,7 @@
 #include <memory>
 #include <string>
 #include <utility>
+#include <vector>
 
 #include "absl/container/flat_hash_map.h"
 #include "internal/platform/single_thread_executor.h"
@@ -42,7 +43,7 @@ class ScanManager {
   using ScanningSession = ::nearby::api::ble_v2::BleMedium::ScanningSession;
   using Runnable = ::nearby::Runnable;
   using BleAdvertisementData = ::nearby::api::ble_v2::BleAdvertisementData;
-  using PublicCredential = ::nearby::internal::PublicCredential;
+  using SharedCredential = ::nearby::internal::SharedCredential;
   using IdentityType = ::nearby::internal::IdentityType;
 
   ScanManager(Mediums& mediums, CredentialManager& credential_manager,
@@ -62,7 +63,7 @@ class ScanManager {
   struct ScanSessionState {
     ScanRequest request;
     ScanCallback callback;
-    absl::flat_hash_map<IdentityType, std::vector<PublicCredential>>
+    absl::flat_hash_map<IdentityType, std::vector<SharedCredential>>
         credentials;
     AdvertisementDecoder decoder;
     std::unique_ptr<ScanningSession> scanning_session;
@@ -73,7 +74,7 @@ class ScanManager {
   void FetchCredentials(ScanSessionId id, const ScanRequest& scan_request)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
   void UpdateCredentials(ScanSessionId id, IdentityType identity_type,
-                         std::vector<PublicCredential> credentials)
+                         std::vector<SharedCredential> credentials)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_);
   void RunOnServiceControllerThread(absl::string_view name, Runnable runnable) {
     executor_->Execute(std::string(name), std::move(runnable));

presence/scan_request.h

@@ -56,7 +56,7 @@ struct LegacyPresenceScanFilter {
 
   // Android T needs clients to provide remote public credentials in scan
   // requests.
-  std::vector<nearby::internal::PublicCredential> remote_public_credentials;
+  std::vector<nearby::internal::SharedCredential> remote_public_credentials;
 
   // A list of presence actions for matching. Matching condition is met as
   // long as there’s one or more equal actions between Scan actions and