TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-16 15:36:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'nearby/main'

Browse Source 
# Conflicts:
#	connections/implementation/bwu_manager_test.cc
#	sharing/BUILD
#	sharing/certificates/fake_nearby_share_certificate_manager.cc
#	sharing/certificates/fake_nearby_share_certificate_manager.h
#	sharing/internal/base/utf_string_conversions.h
This commit is contained in:
Lasan Mahaliyana
2026-07-26 22:46:37 +05:30
parent 3d4463d383 a7f6ed3fa7
commit 37e916ecbd
155 changed files with 5257 additions and 2018 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sharing/certificates/BUILD
+4
View File
@@ -63,8 +63,11 @@ cc_library(
"//sharing/proto:enums_cc_proto",
"//sharing/proto:share_cc_proto",
"//sharing/scheduling",
"//third_party/gloop/util/time:protoutil",
"//util/hash:highway_fingerprint",
"@com_google_absl//absl/algorithm",
"@com_google_absl//absl/algorithm:container",
"@com_google_absl//absl/base:core_headers",
"@com_google_absl//absl/base:nullability",
"@com_google_absl//absl/container:btree",
"@com_google_absl//absl/container:flat_hash_map",
@@ -145,6 +148,7 @@ cc_test(
"//sharing/proto:share_cc_proto",
"//sharing/scheduling",
"//sharing/scheduling:test_support",
"//third_party/gloop/util/time:protoutil",
"@com_github_protobuf_matchers//protobuf-matchers",
"@com_google_absl//absl/functional:any_invocable",
"@com_google_absl//absl/status",
sharing/certificates/fake_nearby_share_certificate_manager.cc
+8
View File
@@ -20,9 +20,11 @@
#include <memory>
#include <optional>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "internal/base/file_path.h"
#include "sharing/certificates/nearby_share_certificate_manager.h"
#include "sharing/certificates/nearby_share_encrypted_metadata_key.h"
@@ -102,6 +104,12 @@ void FakeNearbyShareCertificateManager::ClearPublicCertificates(
callback(true);
}
void FakeNearbyShareCertificateManager::AddBindingToPublicCertificate(
absl::string_view certificate_id, absl::string_view binding_id) {
add_binding_to_public_certificate_calls_.push_back(
{std::string(certificate_id), std::string(binding_id)});
}
std::optional<NearbySharePrivateCertificate>
FakeNearbyShareCertificateManager::GetValidPrivateCertificate(
DeviceVisibility visibility) const {
sharing/certificates/fake_nearby_share_certificate_manager.h
+22
View File
@@ -24,6 +24,7 @@
#include <string>
#include <vector>
#include "absl/time/time.h"
#include "internal/base/file_path.h"
#include "sharing/certificates/nearby_share_certificate_manager.h"
#include "sharing/certificates/nearby_share_certificate_manager_impl.h"
@@ -89,6 +90,11 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
CertDecryptedCallback callback;
};
struct AddBindingToPublicCertificateCall {
std::string certificate_id;
std::string binding_id;
};
FakeNearbyShareCertificateManager();
~FakeNearbyShareCertificateManager() override;
@@ -100,6 +106,13 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
void ForceUploadPrivateCertificates() override {};
void ClearPublicCertificates(std::function<void(bool)> callback) override;
void SetVendorId(int32_t vendor_id) override {}
void AddBindingToPublicCertificate(
absl::string_view certificate_id, absl::string_view binding_id) override;
void SetJoinBindingTime(absl::Time join_binding_time,
absl::Duration life_time) override {
join_binding_time_ = join_binding_time;
join_binding_life_time_ = life_time;
}
std::string Dump() const override { return ""; }
// Make protected methods from base class public in this fake class.
@@ -125,6 +138,11 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
return get_decrypted_public_certificate_calls_;
}
const std::vector<AddBindingToPublicCertificateCall>&
add_binding_to_public_certificate_calls() const {
return add_binding_to_public_certificate_calls_;
}
private:
// NearbyShareCertificateManager:
void OnStartScheduledTasks() override {}
@@ -139,7 +157,11 @@ class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
size_t num_clear_public_certificates_calls_ = 0;
std::vector<GetDecryptedPublicCertificateCall>
get_decrypted_public_certificate_calls_;
std::vector<AddBindingToPublicCertificateCall>
add_binding_to_public_certificate_calls_;
std::vector<uint8_t> next_salt_;
absl::Time join_binding_time_;
absl::Duration join_binding_life_time_;
};
} // namespace sharing
sharing/certificates/fake_nearby_share_certificate_storage.cc
+29 -1
View File
@@ -106,7 +106,16 @@ void FakeNearbyShareCertificateStorage::GetPublicCertificate(
std::function<
void(bool, std::unique_ptr<nearby::sharing::proto::PublicCertificate>)>
callback) {
get_public_certificate_callback_ = std::move(callback);
get_public_certificate_callback_ = callback;
if (is_sync_mode_) {
for (const auto& cert : public_certificates_) {
if (cert.secret_id() == id) {
callback(true, std::make_unique<PublicCertificate>(cert));
return;
}
}
callback(false, nullptr);
}
}
std::vector<NearbySharePrivateCertificate>
@@ -135,6 +144,19 @@ void FakeNearbyShareCertificateStorage::AddPublicCertificates(
public_certificates.end()),
callback);
if (is_sync_mode_) {
for (const auto& cert : public_certificates) {
bool found = false;
for (auto& existing_cert : public_certificates_) {
if (existing_cert.secret_id() == cert.secret_id()) {
existing_cert = cert;
found = true;
break;
}
}
if (!found) {
public_certificates_.push_back(cert);
}
}
callback(add_public_certificates_result_);
}
}
@@ -152,6 +174,12 @@ void FakeNearbyShareCertificateStorage::ClearPublicCertificates(
clear_public_certificates_callbacks_.push_back(std::move(callback));
}
void FakeNearbyShareCertificateStorage::SetPublicCertificates(
absl::Span<const PublicCertificate> public_certificates) {
public_certificates_ = std::vector<PublicCertificate>(
public_certificates.begin(), public_certificates.end());
}
void FakeNearbyShareCertificateStorage::SetPublicCertificateIds(
absl::Span<const absl::string_view> ids) {
public_certificate_ids_ = std::vector<std::string>(ids.begin(), ids.end());
sharing/certificates/fake_nearby_share_certificate_storage.h
+4
View File
@@ -123,6 +123,9 @@ class FakeNearbyShareCertificateStorage : public NearbyShareCertificateStorage {
void ClearPublicCertificates(ResultCallback callback) override;
void SetPublicCertificateIds(absl::Span<const absl::string_view> ids);
void SetPublicCertificates(
absl::Span<const nearby::sharing::proto::PublicCertificate>
public_certificates);
void SetNextPublicCertificateExpirationTime(absl::Time time);
std::vector<PublicCertificateCallback>& get_public_certificates_callbacks() {
@@ -156,6 +159,7 @@ class FakeNearbyShareCertificateStorage : public NearbyShareCertificateStorage {
absl::Mutex mutex_;
absl::Time next_public_certificate_expiration_time_ = absl::InfiniteFuture();
std::vector<std::string> public_certificate_ids_;
std::vector<nearby::sharing::proto::PublicCertificate> public_certificates_;
std::vector<NearbySharePrivateCertificate> private_certificates_
ABSL_GUARDED_BY(mutex_);
std::vector<PublicCertificateCallback> get_public_certificates_callbacks_;
sharing/certificates/nearby_share_certificate_manager.cc
+10
View File
@@ -17,6 +17,7 @@
#include <stdint.h>
#include <optional>
#include <string>
#include <vector>
#include "absl/types/span.h"
@@ -73,6 +74,15 @@ NearbyShareCertificateManager::EncryptPrivateCertificateMetadataKey(
return encrypted_key;
}
std::optional<std::string>
NearbyShareCertificateManager::GetPrivateCertificateId(
DeviceVisibility visibility) {
std::optional<NearbySharePrivateCertificate> cert =
GetValidPrivateCertificate(visibility);
if (!cert) return std::nullopt;
return std::string(cert->id().begin(), cert->id().end());
}
std::optional<std::vector<uint8_t>>
NearbyShareCertificateManager::SignWithPrivateCertificate(
DeviceVisibility visibility, absl::Span<const uint8_t> payload) const {
sharing/certificates/nearby_share_certificate_manager.h
+17
View File
@@ -22,6 +22,8 @@
#include <string>
#include <vector>
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "absl/types/span.h"
#include "internal/base/observer_list.h"
#include "sharing/certificates/nearby_share_decrypted_public_certificate.h"
@@ -80,6 +82,12 @@ class NearbyShareCertificateManager {
std::optional<NearbyShareEncryptedMetadataKey>
EncryptPrivateCertificateMetadataKey(proto::DeviceVisibility visibility);
// Returns the id of the currently valid private certificate with
// |visibility|, or absl::nullopt if there is no valid private certificate
// with |visibility|.
std::optional<std::string> GetPrivateCertificateId(
proto::DeviceVisibility visibility);
// Signs the input |payload| using the currently valid private certificate
// with |visibility|. Returns absl::nullopt if there is no valid private
// certificate with |visibility| or if the signing was unsuccessful.
@@ -119,9 +127,18 @@ class NearbyShareCertificateManager {
// Sets the vendor ID to generate certificates for.
virtual void SetVendorId(int32_t vendor_id) = 0;
// Sets the timestamp of the join binding rpc. This is used to ensure that the
// requested public certificates contain the ids of the binding.
// `life_time` determines how long this join_binding_time will be used.
virtual void SetJoinBindingTime(absl::Time join_binding_time,
absl::Duration life_time) = 0;
// Dump certificates ID information for troubleshooting.
virtual std::string Dump() const = 0;
virtual void AddBindingToPublicCertificate(
absl::string_view certificate_id, absl::string_view binding_id) = 0;
protected:
virtual void OnStartScheduledTasks() = 0;
virtual void OnStopScheduledTasks() = 0;
sharing/certificates/nearby_share_certificate_manager_impl.cc
+60 -6
View File
@@ -34,6 +34,7 @@
#include "location/nearby/sharing/lib/account/account_manager.h"
#include "location/nearby/sharing/lib/rpc/sharing_rpc_client.h"
#include "absl/algorithm/algorithm.h"
#include "absl/algorithm/container.h"
#include "absl/base/nullability.h"
#include "absl/container/flat_hash_map.h"
#include "absl/memory/memory.h"
@@ -41,9 +42,11 @@
#include "absl/strings/escaping.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "absl/synchronization/notification.h"
#include "absl/time/time.h"
#include "absl/types/span.h"
#include "third_party/gloop/util/time/protoutil.h"
#include "internal/base/file_path.h"
#include "internal/flags/nearby_flags.h"
#include "internal/platform/mac_address.h"
@@ -383,6 +386,13 @@ void NearbyShareCertificateManagerImpl::CertificateDownloadContext::
page_number_++;
QuerySharedCredentialsWithBindingIdsRequest request;
request.set_name(absl::StrCat("devices/", device_id_));
if (join_time_.has_value()) {
absl::StatusOr<google::protobuf::Timestamp> join_time =
util_time::EncodeGoogleApiProto(*join_time_);
if (join_time.ok()) {
*request.mutable_join_binding_time() = *join_time;
}
}
if (next_page_token_.has_value()) {
request.set_page_token(*next_page_token_);
}
@@ -408,7 +418,8 @@ void NearbyShareCertificateManagerImpl::CertificateDownloadContext::
<< absl::BytesToHexString(credential.data());
continue;
}
VLOG(1) << "Successfully parsed credential: " << credential.id();
VLOG(1) << "Successfully parsed credential: " << credential.id()
<< " with binding id: " << certificate.binding_id();
certificates_.push_back(certificate);
}
@@ -466,10 +477,20 @@ bool NearbyShareCertificateManagerImpl::DownloadPublicCertificatesInExecutor() {
return true;
}
// Clear join_time if it is expired.
std::optional<absl::Time> join_time;
{
absl::MutexLock lock(join_time_mutex_);
if (join_time_.has_value() &&
context_->GetClock()->Now() > join_time_discard_time_) {
join_time_.reset();
}
join_time = join_time_;
}
bool download_succeeded = false;
absl::Notification notification;
auto context = std::make_unique<CertificateDownloadContext>(
nearby_identity_client_, std::move(device_id),
nearby_identity_client_, std::move(device_id), join_time,
[this, &download_succeeded, &notification](
absl::StatusOr<std::vector<PublicCertificate>> certificates_status) {
if (!certificates_status.ok()) {
@@ -489,7 +510,7 @@ bool NearbyShareCertificateManagerImpl::DownloadPublicCertificatesInExecutor() {
notification.Notify();
});
if (NearbyFlags::GetInstance().GetBoolFlag(
config_package_nearby::nearby_sharing_feature::kEnableFileSync)) {
config_package_nearby::nearby_sharing_feature::kEnableBackup)) {
context->QuerySharedCredentialsWithBindingIdsFetchNextPage();
} else {
context->QuerySharedCredentialsFetchNextPage();
@@ -744,6 +765,13 @@ void NearbyShareCertificateManagerImpl::SetVendorId(int32_t vendor_id) {
RegeneratePrivateCertificates();
}
void NearbyShareCertificateManagerImpl::SetJoinBindingTime(
absl::Time join_binding_time, absl::Duration life_time) {
absl::MutexLock lock(join_time_mutex_);
join_time_ = join_binding_time;
join_time_discard_time_ = context_->GetClock()->Now() + life_time;
}
std::string NearbyShareCertificateManagerImpl::Dump() const {
std::stringstream sstream;
sstream << "Public Certificates" << std::endl;
@@ -892,6 +920,32 @@ bool NearbyShareCertificateManagerImpl::RefreshPrivateCertificatesInExecutor(
return true;
}
void NearbyShareCertificateManagerImpl::AddBindingToPublicCertificate(
absl::string_view certificate_id, absl::string_view binding_id) {
LOG(INFO) << "Adding binding to public certificate: "
<< absl::BytesToHexString(certificate_id);
absl::Notification notification;
certificate_storage_->GetPublicCertificate(
certificate_id,
[this, id = std::string(binding_id), &notification](
bool success, std::unique_ptr<PublicCertificate> certificate) {
if (success && certificate != nullptr) {
certificate->set_binding_id(id);
certificate_storage_->AddPublicCertificates(
{*certificate}, [](bool success) {
if (!success) {
LOG(WARNING)
<< "Failed to add binding to public certificate.";
}
});
} else {
LOG(WARNING) << "Failed to add binding to public certificate.";
}
notification.Notify();
});
notification.WaitForNotification();
}
void NearbyShareCertificateManagerImpl::ForceUploadPrivateCertificates() {
executor_->PostTask([this]() {
private_certificate_expiration_scheduler_->HandleResult(
@@ -942,9 +996,9 @@ bool NearbyShareCertificateManagerImpl::UpdateAccountInfoInExecutor() {
get_account_info_succeeded = true;
const auto& capabilities = response->account_info().capabilities();
bool has_titanium_capability =
(std::find(capabilities.begin(), capabilities.end(),
google::nearby::identity::v1::AccountInfo::
CAPABILITY_TITANIUM) != capabilities.end());
(absl::c_find(capabilities,
google::nearby::identity::v1::AccountInfo::
CAPABILITY_TITANIUM) != capabilities.end());
preference_manager_.SetBoolean(PrefNames::kAdvancedProtectionEnabled,
has_titanium_capability);
LOG(INFO) << "GetAccountInfo succeeded, advanced protection enabled: "
sharing/certificates/nearby_share_certificate_manager_impl.h
+18 -1
View File
@@ -26,8 +26,11 @@
#include "location/nearby/sharing/lib/account/account_manager.h"
#include "location/nearby/sharing/lib/rpc/sharing_rpc_client.h"
#include "absl/base/nullability.h"
#include "absl/base/thread_annotations.h"
#include "absl/functional/any_invocable.h"
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "absl/synchronization/mutex.h"
#include "absl/time/time.h"
#include "internal/base/file_path.h"
#include "internal/platform/task_runner.h"
@@ -92,7 +95,12 @@ class NearbyShareCertificateManagerImpl
void ForceUploadPrivateCertificates() override;
void ClearPublicCertificates(std::function<void(bool)> callback) override;
void SetVendorId(int32_t vendor_id) override;
void SetJoinBindingTime(absl::Time join_binding_time,
absl::Duration life_time)
ABSL_LOCKS_EXCLUDED(join_time_mutex_) override;
std::string Dump() const override;
void AddBindingToPublicCertificate(
absl::string_view certificate_id, absl::string_view binding_id) override;
private:
// Class for maintaining a single instance of public certificate download
@@ -104,12 +112,14 @@ class NearbyShareCertificateManagerImpl
nearby::sharing::api::IdentityRpcClient* absl_nonnull
nearby_identity_client,
std::string device_id,
std::optional<absl::Time> join_time,
absl::AnyInvocable<void(absl::StatusOr<std::vector<
nearby::sharing::proto::PublicCertificate>>
certificates_status) &&>
download_callback)
: nearby_identity_client_(nearby_identity_client),
device_id_(std::move(device_id)),
join_time_(join_time),
download_callback_(std::move(download_callback)) {}
// Fetches the next page of certificates by calling Identity API
@@ -123,7 +133,8 @@ class NearbyShareCertificateManagerImpl
private:
nearby::sharing::api::IdentityRpcClient* absl_nonnull const
nearby_identity_client_;
std::string device_id_;
const std::string device_id_;
const std::optional<absl::Time> join_time_;
std::optional<std::string> next_page_token_;
int page_number_ = 1;
std::vector<nearby::sharing::proto::PublicCertificate> certificates_;
@@ -219,6 +230,12 @@ class NearbyShareCertificateManagerImpl
account_info_update_scheduler_;
std::unique_ptr<TaskRunner> executor_;
absl::Mutex join_time_mutex_;
// Set to the transaction timestamp of the last successful pairing if
// available. This is returned from the phone in the BindingResponse message.
std::optional<absl::Time> join_time_ ABSL_GUARDED_BY(join_time_mutex_);
// The time when the join_time_ will be discarded.
absl::Time join_time_discard_time_ ABSL_GUARDED_BY(join_time_mutex_);
};
} // namespace nearby::sharing
sharing/certificates/nearby_share_certificate_manager_impl_test.cc
+85 -2
View File
@@ -39,6 +39,7 @@
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
#include "absl/types/span.h"
#include "third_party/gloop/util/time/protoutil.h"
#include "internal/flags/nearby_flags.h"
#include "internal/platform/mac_address.h"
#include "sharing/certificates/constants.h"
@@ -78,6 +79,7 @@ using ::google::nearby::identity::v1::
QuerySharedCredentialsWithBindingIdsResponse;
using ::nearby::sharing::proto::DeviceVisibility;
using ::nearby::sharing::proto::PublicCertificate;
using ::protobuf_matchers::EqualsProto;
using ::testing::Not;
using ::testing::ReturnRef;
using ::testing::UnorderedElementsAreArray;
@@ -634,6 +636,31 @@ TEST_F(NearbyShareCertificateManagerImplTest,
DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS));
}
TEST_F(NearbyShareCertificateManagerImplTest,
GetPrivateCertificateIdWithNoCertificates) {
Initialize();
cert_store_->ReplacePrivateCertificates({});
EXPECT_FALSE(cert_manager_->GetPrivateCertificateId(
DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS).has_value());
}
TEST_F(NearbyShareCertificateManagerImplTest,
GetPrivateCertificateIdWithValidCertificate) {
Initialize();
NearbySharePrivateCertificate private_certificate =
GetNearbyShareTestPrivateCertificate(
DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS);
cert_store_->ReplacePrivateCertificates({private_certificate});
FastForward(GetNearbyShareTestNotBefore() +
kNearbyShareCertificateValidityPeriod * 0.5 - Now());
ASSERT_TRUE(cert_manager_->GetPrivateCertificateId(
DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS).has_value());
EXPECT_EQ(cert_manager_->GetPrivateCertificateId(
DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS).value(),
std::string(private_certificate.id().begin(),
private_certificate.id().end()));
}
TEST_F(NearbyShareCertificateManagerImplTest, SignWithPrivateCertificate) {
Initialize();
NearbySharePrivateCertificate private_certificate =
@@ -782,7 +809,7 @@ TEST_F(NearbyShareCertificateManagerImplTest,
TEST_F(NearbyShareCertificateManagerImplTest,
QuerySharedCredentialsWithBindingIdsSuccess) {
NearbyFlags::GetInstance().OverrideBoolFlagValue(
config_package_nearby::nearby_sharing_feature::kEnableFileSync, true);
config_package_nearby::nearby_sharing_feature::kEnableBackup, true);
Initialize();
ASSERT_NO_FATAL_FAILURE(QuerySharedCredentialsWithBindingIdsFlow(
/*num_pages=*/2, DownloadPublicCertificatesResult::kSuccess));
@@ -791,12 +818,48 @@ TEST_F(NearbyShareCertificateManagerImplTest,
TEST_F(NearbyShareCertificateManagerImplTest,
QuerySharedCredentialsWithBindingIdsRPCFailure) {
NearbyFlags::GetInstance().OverrideBoolFlagValue(
config_package_nearby::nearby_sharing_feature::kEnableFileSync, true);
config_package_nearby::nearby_sharing_feature::kEnableBackup, true);
Initialize();
ASSERT_NO_FATAL_FAILURE(QuerySharedCredentialsWithBindingIdsFlow(
/*num_pages=*/2, DownloadPublicCertificatesResult::kHttpError));
}
TEST_F(NearbyShareCertificateManagerImplTest,
QuerySharedCredentialsWithBindingIdsWithJoinTime) {
NearbyFlags::GetInstance().OverrideBoolFlagValue(
config_package_nearby::nearby_sharing_feature::kEnableBackup, true);
Initialize();
cert_manager_->SetJoinBindingTime(absl::FromUnixSeconds(123456789),
absl::Seconds(30));
ASSERT_NO_FATAL_FAILURE(QuerySharedCredentialsWithBindingIdsFlow(
/*num_pages=*/2, DownloadPublicCertificatesResult::kSuccess));
std::vector<QuerySharedCredentialsWithBindingIdsRequest> requests =
identity_client_.query_shared_credentials_with_binding_ids_requests();
for (const auto& request : requests) {
ASSERT_OK_AND_ASSIGN(
auto expected_time,
util_time::EncodeGoogleApiProto(absl::FromUnixSeconds(123456789)));
EXPECT_THAT(request.join_binding_time(), EqualsProto(expected_time));
}
}
TEST_F(NearbyShareCertificateManagerImplTest,
QuerySharedCredentialsWithBindingIdsWithJoinTimeExpiration) {
NearbyFlags::GetInstance().OverrideBoolFlagValue(
config_package_nearby::nearby_sharing_feature::kEnableBackup, true);
Initialize();
cert_manager_->SetJoinBindingTime(absl::FromUnixSeconds(123456789),
absl::Seconds(30));
FastForward(absl::Seconds(31));
ASSERT_NO_FATAL_FAILURE(QuerySharedCredentialsWithBindingIdsFlow(
/*num_pages=*/2, DownloadPublicCertificatesResult::kSuccess));
std::vector<QuerySharedCredentialsWithBindingIdsRequest> requests =
identity_client_.query_shared_credentials_with_binding_ids_requests();
for (const auto& request : requests) {
EXPECT_FALSE(request.has_join_binding_time());
}
}
TEST_F(NearbyShareCertificateManagerImplTest, ClearPublicCertificates) {
Initialize();
cert_manager_->ClearPublicCertificates([&](bool result) {});
@@ -1110,4 +1173,24 @@ TEST_F(NearbyShareCertificateManagerImplTest,
PrefNames::kAdvancedProtectionEnabled, /*default_value=*/false));
}
TEST_F(NearbyShareCertificateManagerImplTest, AddBindingToPublicCertificate) {
Initialize();
PublicCertificate cert;
cert.set_secret_id("test_cert_id");
cert.set_binding_id("old_binding_id");
cert_store_->SetPublicCertificates({cert});
cert_store_->SetAddPublicCertificatesResult(true);
cert_manager_->AddBindingToPublicCertificate("test_cert_id",
"new_binding_id");
ASSERT_EQ(cert_store_->add_public_certificates_calls().size(), 1u);
const auto& call = cert_store_->add_public_certificates_calls().back();
ASSERT_EQ(call.public_certificates.size(), 1u);
EXPECT_EQ(call.public_certificates[0].secret_id(), "test_cert_id");
EXPECT_EQ(call.public_certificates[0].binding_id(), "new_binding_id");
}
} // namespace nearby::sharing
sharing/certificates/nearby_share_certificate_storage_impl.cc
+2 -1
View File
@@ -342,7 +342,8 @@ void NearbyShareCertificateStorageImpl::GetPublicCertificate(
});
return;
}
VLOG(1) << __func__ << ": Calling LoadCertificate on database, key: " << id;
VLOG(1) << __func__ << ": Calling LoadCertificate on database, key: "
<< absl::BytesToHexString(id);
public_certificate_database_->LoadCertificate(id, std::move(callback));
}
sharing/certificates/nearby_share_certificate_storage_impl_test.cc
+32 -32
View File
@@ -211,20 +211,20 @@ TEST_F(NearbyShareCertificateStorageImplTest, InitializeRetrySucceed) {
auto db = std::make_unique<StrictMock<MockPublicCertificateDb>>();
MockPublicCertificateDb* mock_db = db.get();
EXPECT_CALL(*mock_db, Initialize(_))
.WillOnce(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
.WillOnce(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kError);
}))
.WillRepeatedly(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
})
.WillRepeatedly(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kOk);
}));
});
EXPECT_CALL(*mock_db, Destroy(_))
.WillOnce(Invoke([](absl::AnyInvocable<void(bool)&&> callback) {
.WillOnce([](absl::AnyInvocable<void(bool) &&> callback) {
std::move(callback)(true);
}));
});
auto cert_store = NearbyShareCertificateStorageImpl::Factory::Create(
preference_manager_, std::move(db));
@@ -243,11 +243,11 @@ TEST_F(NearbyShareCertificateStorageImplTest, InitializeRetryFailed) {
auto db = std::make_unique<StrictMock<MockPublicCertificateDb>>();
MockPublicCertificateDb* mock_db = db.get();
EXPECT_CALL(*mock_db, Initialize(_))
.WillRepeatedly(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
.WillRepeatedly(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kError);
}));
});
auto cert_store = NearbyShareCertificateStorageImpl::Factory::Create(
preference_manager_, std::move(db));
@@ -267,23 +267,23 @@ TEST_F(NearbyShareCertificateStorageImplTest,
auto db = std::make_unique<StrictMock<MockPublicCertificateDb>>();
MockPublicCertificateDb* mock_db = db.get();
EXPECT_CALL(*mock_db, Initialize(_))
.WillOnce(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
.WillOnce(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kCorrupt);
}))
.WillRepeatedly(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
})
.WillRepeatedly(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kOk);
}));
});
// Destroy called once from corrupted initialization and once from cal to
// ClearPublicCertificates.
EXPECT_CALL(*mock_db, Destroy(_))
.Times(2)
.WillRepeatedly(Invoke([](absl::AnyInvocable<void(bool)&&> callback) {
.WillRepeatedly([](absl::AnyInvocable<void(bool) &&> callback) {
std::move(callback)(true);
}));
});
auto cert_store = NearbyShareCertificateStorageImpl::Factory::Create(
preference_manager_, std::move(db));
@@ -301,15 +301,15 @@ TEST_F(NearbyShareCertificateStorageImplTest, InitializeCorruptDestroyFails) {
auto db = std::make_unique<StrictMock<MockPublicCertificateDb>>();
MockPublicCertificateDb* mock_db = db.get();
EXPECT_CALL(*mock_db, Initialize(_))
.WillOnce(Invoke(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
.WillOnce(
[](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) {
std::move(callback)(MockPublicCertificateDb::InitStatus::kCorrupt);
}));
});
EXPECT_CALL(*mock_db, Destroy(_))
.WillOnce(Invoke([](absl::AnyInvocable<void(bool)&&> callback) {
.WillOnce([](absl::AnyInvocable<void(bool) &&> callback) {
std::move(callback)(false);
}));
});
auto cert_store = NearbyShareCertificateStorageImpl::Factory::Create(
preference_manager_, std::move(db));
@@ -333,18 +333,18 @@ TEST_F(NearbyShareCertificateStorageImplTest, DeferredCallbackQueue) {
auto db = std::make_unique<StrictMock<MockPublicCertificateDb>>();
MockPublicCertificateDb* mock_db = db.get();
EXPECT_CALL(*mock_db, Initialize(_))
.WillOnce(Invoke(
[&](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus)&&>
callback) { init_status_callback = std::move(callback); }));
.WillOnce(
[&](absl::AnyInvocable<void(MockPublicCertificateDb::InitStatus) &&>
callback) { init_status_callback = std::move(callback); });
EXPECT_CALL(*mock_db, Destroy(_))
.WillOnce(Invoke([&](absl::AnyInvocable<void(bool)&&> callback) {
.WillOnce([&](absl::AnyInvocable<void(bool) &&> callback) {
destroy_callback = std::move(callback);
}));
});
EXPECT_CALL(*mock_db, LoadEntries(_))
.WillOnce(Invoke(
.WillOnce(
[&](absl::AnyInvocable<void(
bool, std::unique_ptr<std::vector<PublicCertificate>>)&&>
callback) { load_callback = std::move(callback); }));
bool, std::unique_ptr<std::vector<PublicCertificate>>) &&>
callback) { load_callback = std::move(callback); });
auto cert_store = NearbyShareCertificateStorageImpl::Factory::Create(
preference_manager_, std::move(db));