[Nearby Share] Certificate Storage: Add unit tests for initialization

Add unit tests for a few scenarios around initializing LevelDB in
NearbyShareCertificateStorage, including the deferred callback queueing
mechanism and failure retry.

Change-Id: I005da00cd0ee85c969f10875bd77d3412ad855a5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2339824Reviewed-by: Josh Nohle <nohle@chromium.org>
Commit-Queue: Curt Clemens <cclem@google.com>
Cr-Commit-Position: refs/heads/master@{#795487}

chrome/browser/nearby_sharing/certificates/BUILD.gn

@@ -27,6 +27,7 @@ source_set("certificates") {
   deps = [
     "//base",
     "//base/util/values:values_util",
+    "//chrome/browser/nearby_sharing/common",
     "//chrome/browser/nearby_sharing/logging",
     "//chrome/browser/nearby_sharing/proto",
     "//components/leveldb_proto",
@@ -73,6 +74,7 @@ source_set("unit_tests") {
     "//base",
     "//base/test:test_support",
     "//base/util/values:values_util",
+    "//chrome/browser/nearby_sharing/common",
     "//chrome/browser/nearby_sharing/proto",
     "//components/leveldb_proto:test_support",
     "//components/prefs:test_support",

chrome/browser/nearby_sharing/certificates/constants.cc

@@ -25,3 +25,4 @@ const size_t kNearbyShareMaxNumMetadataEncryptionKeySalts = 32768;
 const size_t kNearbyShareMaxNumMetadataEncryptionKeySaltGenerationRetries = 128;
 const char kNearbyShareSenderVerificationPrefix = 0x01;
 const char kNearbyShareReceiverVerificationPrefix = 0x02;
+const size_t kNearbyShareCertificateStorageMaxNumInitializeAttempts = 3;

chrome/browser/nearby_sharing/certificates/constants.h

@@ -88,4 +88,7 @@ extern const char kNearbyShareSenderVerificationPrefix;
 // signing.
 extern const char kNearbyShareReceiverVerificationPrefix;
 
+// The maximum number of attempts to initialize LevelDB in Certificate Storage.
+extern const size_t kNearbyShareCertificateStorageMaxNumInitializeAttempts;
+
 #endif  // CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_CONSTANTS_H_

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_storage_impl.cc

@@ -17,19 +17,14 @@
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/util/values/values_util.h"
 #include "base/values.h"
+#include "chrome/browser/nearby_sharing/certificates/constants.h"
 #include "chrome/browser/nearby_sharing/certificates/nearby_share_private_certificate.h"
+#include "chrome/browser/nearby_sharing/common/nearby_share_prefs.h"
 #include "chrome/browser/nearby_sharing/proto/rpc_resources.pb.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 
 namespace {
-const size_t kMaxNumInitializeAttempts = 3;
-
-const char kNearbySharePublicCertificateExpirationDictPref[] =
-    "nearbyshare.public_certificate_expiration_dict";
-const char kNearbySharePrivateCertificateListPref[] =
-    "nearbyshare.private_certificate_list";
-
 std::string EncodeString(const std::string& unencoded_string) {
   std::string encoded_string;
   base::Base64UrlEncode(unencoded_string,
@@ -114,20 +109,13 @@ NearbyShareCertificateStorageImpl::NearbyShareCertificateStorageImpl(
 NearbyShareCertificateStorageImpl::~NearbyShareCertificateStorageImpl() =
     default;
 
-// static
-void NearbyShareCertificateStorageImpl::RegisterPrefs(
-    PrefRegistrySimple* registry) {
-  registry->RegisterDictionaryPref(
-      kNearbySharePublicCertificateExpirationDictPref);
-  registry->RegisterListPref(kNearbySharePrivateCertificateListPref);
-}
-
 void NearbyShareCertificateStorageImpl::Initialize() {
   switch (init_status_) {
     case InitStatus::kUninitialized:
     case InitStatus::kFailed:
       num_initialize_attempts_++;
-      if (num_initialize_attempts_ > kMaxNumInitializeAttempts) {
+      if (num_initialize_attempts_ >
+          kNearbyShareCertificateStorageMaxNumInitializeAttempts) {
         FinishInitialization(false);
         break;
       }
@@ -294,8 +282,7 @@ NearbyShareCertificateStorageImpl::GetPublicCertificateIds() const {
 void NearbyShareCertificateStorageImpl::GetPublicCertificates(
     PublicCertificateCallback callback) {
   if (init_status_ == InitStatus::kFailed) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), false, nullptr));
+    std::move(callback).Run(false, nullptr);
     return;
   }
 
@@ -312,7 +299,7 @@ void NearbyShareCertificateStorageImpl::GetPublicCertificates(
 base::Optional<std::vector<NearbySharePrivateCertificate>>
 NearbyShareCertificateStorageImpl::GetPrivateCertificates() const {
   const base::Value* list =
-      pref_service_->Get(kNearbySharePrivateCertificateListPref);
+      pref_service_->Get(prefs::kNearbySharingPrivateCertificateListPrefName);
   std::vector<NearbySharePrivateCertificate> certs;
   for (const base::Value& cert_dict : list->GetList()) {
     base::Optional<NearbySharePrivateCertificate> cert(
@@ -329,7 +316,7 @@ base::Optional<base::Time>
 NearbyShareCertificateStorageImpl::NextPrivateCertificateExpirationTime()
     const {
   const base::Value* list =
-      pref_service_->Get(kNearbySharePrivateCertificateListPref);
+      pref_service_->Get(prefs::kNearbySharingPrivateCertificateListPrefName);
   if (!list || list->GetList().empty())
     return base::nullopt;
 
@@ -359,7 +346,7 @@ void NearbyShareCertificateStorageImpl::ReplacePrivateCertificates(
   for (const NearbySharePrivateCertificate& cert : private_certificates) {
     list.Append(cert.ToDictionary());
   }
-  pref_service_->Set(kNearbySharePrivateCertificateListPref, list);
+  pref_service_->Set(prefs::kNearbySharingPrivateCertificateListPrefName, list);
 }
 
 void NearbyShareCertificateStorageImpl::ReplacePublicCertificates(
@@ -367,8 +354,7 @@ void NearbyShareCertificateStorageImpl::ReplacePublicCertificates(
         public_certificates,
     ResultCallback callback) {
   if (init_status_ == InitStatus::kFailed) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), false));
+    std::move(callback).Run(false);
     return;
   }
 
@@ -401,8 +387,7 @@ void NearbyShareCertificateStorageImpl::AddPublicCertificates(
         public_certificates,
     ResultCallback callback) {
   if (init_status_ == InitStatus::kFailed) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), false));
+    std::move(callback).Run(false);
     return;
   }
 
@@ -436,8 +421,7 @@ void NearbyShareCertificateStorageImpl::RemoveExpiredPublicCertificates(
     base::Time now,
     ResultCallback callback) {
   if (init_status_ == InitStatus::kFailed) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), false));
+    std::move(callback).Run(false);
     return;
   }
 
@@ -475,14 +459,13 @@ void NearbyShareCertificateStorageImpl::RemoveExpiredPublicCertificates(
 }
 
 void NearbyShareCertificateStorageImpl::ClearPrivateCertificates() {
-  pref_service_->ClearPref(kNearbySharePrivateCertificateListPref);
+  pref_service_->ClearPref(prefs::kNearbySharingPrivateCertificateListPrefName);
 }
 
 void NearbyShareCertificateStorageImpl::ClearPublicCertificates(
     ResultCallback callback) {
   if (init_status_ == InitStatus::kFailed) {
-    base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::BindOnce(std::move(callback), false));
+    std::move(callback).Run(false);
     return;
   }
 
@@ -499,8 +482,8 @@ void NearbyShareCertificateStorageImpl::ClearPublicCertificates(
 }
 
 bool NearbyShareCertificateStorageImpl::FetchPublicCertificateExpirations() {
-  const base::Value* dict =
-      pref_service_->Get(kNearbySharePublicCertificateExpirationDictPref);
+  const base::Value* dict = pref_service_->Get(
+      prefs::kNearbySharingPublicCertificateExpirationDictPrefName);
   public_certificate_expirations_.clear();
   if (!dict) {
     return false;
@@ -526,5 +509,6 @@ void NearbyShareCertificateStorageImpl::SavePublicCertificateExpirations() {
     dict.SetKey(EncodeString(pair.first), util::TimeToValue(pair.second));
   }
 
-  pref_service_->Set(kNearbySharePublicCertificateExpirationDictPref, dict);
+  pref_service_->Set(
+      prefs::kNearbySharingPublicCertificateExpirationDictPrefName, dict);
 }

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_storage_impl.h

@@ -11,7 +11,6 @@
 #include "components/leveldb_proto/public/proto_database.h"
 
 class NearbySharePrivateCertificate;
-class PrefRegistrySimple;
 class PrefService;
 
 namespace nearbyshare {
@@ -49,9 +48,6 @@ class NearbyShareCertificateStorageImpl : public NearbyShareCertificateStorage {
 
   using ExpirationList = std::vector<std::pair<std::string, base::Time>>;
 
-  // Registers the prefs used by this class to the given |registry|.
-  static void RegisterPrefs(PrefRegistrySimple* registry);
-
   ~NearbyShareCertificateStorageImpl() override;
   NearbyShareCertificateStorageImpl(NearbyShareCertificateStorageImpl&) =
       delete;

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_storage_impl_unittest.cc

@@ -7,9 +7,13 @@
 
 #include "base/base64url.h"
 #include "base/bind.h"
+#include "base/run_loop.h"
+#include "base/test/task_environment.h"
 #include "base/util/values/values_util.h"
+#include "chrome/browser/nearby_sharing/certificates/constants.h"
 #include "chrome/browser/nearby_sharing/certificates/nearby_share_certificate_storage_impl.h"
 #include "chrome/browser/nearby_sharing/certificates/test_util.h"
+#include "chrome/browser/nearby_sharing/common/nearby_share_prefs.h"
 #include "components/leveldb_proto/testing/fake_db.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
@@ -64,9 +68,6 @@ const char kMetadataEncryptionKey4[] = "metadataencryptionkey4";
 const char kEncryptedMetadataBytes4[] = "encryptedmetadatabytes4";
 const char kMetadataEncryptionKeyTag4[] = "metadataencryptionkeytag4";
 
-const char kNearbySharePublicCertificateExpirationDictPref[] =
-    "nearbyshare.public_certificate_expiration_dict";
-
 std::string EncodeString(const std::string& unencoded_string) {
   std::string encoded_string;
   base::Base64UrlEncode(unencoded_string,
@@ -135,7 +136,10 @@ class NearbyShareCertificateStorageImplTest : public ::testing::Test {
     db_ = db.get();
 
     pref_service_ = std::make_unique<TestingPrefServiceSimple>();
-    NearbyShareCertificateStorageImpl::RegisterPrefs(pref_service_->registry());
+    pref_service_->registry()->RegisterDictionaryPref(
+        prefs::kNearbySharingPublicCertificateExpirationDictPrefName);
+    pref_service_->registry()->RegisterListPref(
+        prefs::kNearbySharingPrivateCertificateListPrefName);
 
     // Add public certificates to database before construction. Needed
     // to ensure test coverage of FetchPublicCertificateExpirations.
@@ -143,8 +147,6 @@ class NearbyShareCertificateStorageImplTest : public ::testing::Test {
 
     cert_store_ = NearbyShareCertificateStorageImpl::Factory::Create(
         pref_service_.get(), std::move(db));
-
-    db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
   }
 
   void PrepopulatePublicCertificates() {
@@ -173,7 +175,8 @@ class NearbyShareCertificateStorageImplTest : public ::testing::Test {
           util::TimeToValue(TimestampToTime(cert.end_time())));
       db_entries_.emplace(cert.secret_id(), std::move(cert));
     }
-    pref_service_->Set(kNearbySharePublicCertificateExpirationDictPref,
+    pref_service_->Set(
+        prefs::kNearbySharingPublicCertificateExpirationDictPrefName,
         expiration_dict);
   }
 
@@ -181,12 +184,14 @@ class NearbyShareCertificateStorageImplTest : public ::testing::Test {
 
   void PublicCertificateCallback(
       std::vector<nearbyshare::proto::PublicCertificate>* public_certificates,
+      base::OnceClosure complete,
       bool success,
       std::unique_ptr<std::vector<nearbyshare::proto::PublicCertificate>>
           result) {
     if (success && result) {
       public_certificates->swap(*result);
     }
+    std::move(complete).Run();
   }
 
  protected:
@@ -197,7 +202,107 @@ class NearbyShareCertificateStorageImplTest : public ::testing::Test {
   std::vector<nearbyshare::proto::PublicCertificate> public_certificates_;
 };
 
+TEST_F(NearbyShareCertificateStorageImplTest, InitializeRetrySucceed) {
+  // This test only makes sense if initialization will be attempted at least
+  // twice.
+  if (kNearbyShareCertificateStorageMaxNumInitializeAttempts < 2)
+    return;
+
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kError);
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
+  bool clear_succeeded = false;
+  cert_store_->ClearPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
+      base::Unretained(this), &clear_succeeded));
+  db_->DestroyCallback(true);
+
+  EXPECT_TRUE(clear_succeeded);
+  EXPECT_TRUE(db_entries_.empty());
+}
+
+TEST_F(NearbyShareCertificateStorageImplTest, InitializeRetryFailed) {
+  for (size_t i = 0; i < kNearbyShareCertificateStorageMaxNumInitializeAttempts;
+       ++i) {
+    db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kError);
+  }
+
+  bool clear_succeeded = true;
+  cert_store_->ClearPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
+      base::Unretained(this), &clear_succeeded));
+
+  EXPECT_FALSE(clear_succeeded);
+  EXPECT_FALSE(db_entries_.empty());
+}
+
+TEST_F(NearbyShareCertificateStorageImplTest,
+       InitializeCorruptDestroySucceeds) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kCorrupt);
+  db_->DestroyCallback(true);
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+  EXPECT_TRUE(db_entries_.empty());
+
+  bool clear_succeeded = false;
+  cert_store_->ClearPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
+      base::Unretained(this), &clear_succeeded));
+  db_->DestroyCallback(true);
+
+  EXPECT_TRUE(clear_succeeded);
+}
+
+TEST_F(NearbyShareCertificateStorageImplTest, InitializeCorruptDestroyFails) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kCorrupt);
+  db_->DestroyCallback(false);
+
+  bool clear_succeeded = true;
+  cert_store_->ClearPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
+      base::Unretained(this), &clear_succeeded));
+
+  EXPECT_FALSE(clear_succeeded);
+}
+
+TEST_F(NearbyShareCertificateStorageImplTest, DeferredCallbackQueue) {
+  base::test::SingleThreadTaskEnvironment task_environment;
+  base::RunLoop run_loop;
+
+  bool clear_succeeded = false;
+  std::vector<nearbyshare::proto::PublicCertificate> public_certificates;
+
+  cert_store_->ClearPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
+      base::Unretained(this), &clear_succeeded));
+  cert_store_->GetPublicCertificates(base::BindOnce(
+      &NearbyShareCertificateStorageImplTest::PublicCertificateCallback,
+      base::Unretained(this), &public_certificates, run_loop.QuitClosure()));
+
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
+  // These callbacks have to be posted to ensure that they run after the
+  // deferred callbacks posted during initialization.
+  base::SequencedTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(
+          &leveldb_proto::test::FakeDB<
+              nearbyshare::proto::PublicCertificate>::DestroyCallback,
+          base::Unretained(db_), true));
+  base::SequencedTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::BindOnce(&leveldb_proto::test::FakeDB<
+                         nearbyshare::proto::PublicCertificate>::LoadCallback,
+                     base::Unretained(db_), true));
+
+  run_loop.Run();
+
+  EXPECT_TRUE(clear_succeeded);
+  EXPECT_TRUE(public_certificates_.empty());
+}
+
 TEST_F(NearbyShareCertificateStorageImplTest, GetPublicCertificateIds) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   auto ids = cert_store_->GetPublicCertificateIds();
   ASSERT_EQ(3u, ids.size());
   EXPECT_EQ(ids[0], kSecretId1);
@@ -206,10 +311,12 @@ TEST_F(NearbyShareCertificateStorageImplTest, GetPublicCertificateIds) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, GetPublicCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   std::vector<nearbyshare::proto::PublicCertificate> public_certificates;
   cert_store_->GetPublicCertificates(base::BindOnce(
       &NearbyShareCertificateStorageImplTest::PublicCertificateCallback,
-      base::Unretained(this), &public_certificates));
+      base::Unretained(this), &public_certificates, base::BindOnce([] {})));
   db_->LoadCallback(true);
 
   ASSERT_EQ(3u, public_certificates.size());
@@ -223,6 +330,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, GetPublicCertificates) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, ReplacePublicCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   std::vector<nearbyshare::proto::PublicCertificate> new_certs = {
       CreatePublicCertificate(kSecretId4, kSecretKey4, kPublicKey4,
                               kStartSeconds4, kStartNanos4, kEndSeconds4,
@@ -257,6 +366,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, ReplacePublicCertificates) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, AddPublicCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   std::vector<nearbyshare::proto::PublicCertificate> new_certs = {
       CreatePublicCertificate(kSecretId3, kSecretKey2, kPublicKey2,
                               kStartSeconds2, kStartNanos2, kEndSeconds2,
@@ -307,6 +418,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, AddPublicCertificates) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, ClearPublicCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   bool succeeded = false;
   cert_store_->ClearPublicCertificates(base::BindOnce(
       &NearbyShareCertificateStorageImplTest::CaptureBoolCallback,
@@ -318,6 +431,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, ClearPublicCertificates) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, RemoveExpiredPublicCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   std::vector<base::Time> expiration_times;
   for (const auto& pair : db_entries_) {
     expiration_times.emplace_back(TimestampToTime(pair.second.end_time()));
@@ -340,6 +455,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, RemoveExpiredPublicCertificates) {
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, ReplaceGetPrivateCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   auto certs_before = CreatePrivateCertificates(3);
   cert_store_->ReplacePrivateCertificates(certs_before);
   auto certs_after = cert_store_->GetPrivateCertificates();
@@ -363,6 +480,8 @@ TEST_F(NearbyShareCertificateStorageImplTest, ReplaceGetPrivateCertificates) {
 
 TEST_F(NearbyShareCertificateStorageImplTest,
        NextPrivateCertificateExpirationTime) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   auto certs = CreatePrivateCertificates(3);
   cert_store_->ReplacePrivateCertificates(certs);
   base::Optional<base::Time> next_expiration =
@@ -380,6 +499,8 @@ TEST_F(NearbyShareCertificateStorageImplTest,
 
 TEST_F(NearbyShareCertificateStorageImplTest,
        NextPublicCertificateExpirationTime) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   base::Optional<base::Time> next_expiration =
       cert_store_->NextPublicCertificateExpirationTime();
 
@@ -395,6 +516,8 @@ TEST_F(NearbyShareCertificateStorageImplTest,
 }
 
 TEST_F(NearbyShareCertificateStorageImplTest, ClearPrivateCertificates) {
+  db_->InitStatusCallback(leveldb_proto::Enums::InitStatus::kOK);
+
   std::vector<NearbySharePrivateCertificate> certs_before =
       CreatePrivateCertificates(3);
   cert_store_->ReplacePrivateCertificates(certs_before);

chrome/browser/nearby_sharing/common/nearby_share_prefs.cc

@@ -32,6 +32,10 @@ const char kNearbySharingSchedulerDownloadDeviceDataPrefName[] =
     "nearby_sharing.scheduler.download_device_data";
 const char kNearbySharingSchedulerUploadDeviceNamePrefName[] =
     "nearby_sharing.scheduler.upload_device_name";
+const char kNearbySharingPublicCertificateExpirationDictPrefName[] =
+    "nearbyshare.public_certificate_expiration_dict";
+const char kNearbySharingPrivateCertificateListPrefName[] =
+    "nearbyshare.private_certificate_list";
 
 }  // namespace prefs
 
@@ -64,6 +68,10 @@ void RegisterNearbySharingPrefs(PrefRegistrySimple* registry) {
   registry->RegisterTimePref(
       prefs::kNearbySharingOnboardingDismissedTimePrefName,
       /*default_value=*/base::Time());
+  registry->RegisterDictionaryPref(
+      prefs::kNearbySharingPublicCertificateExpirationDictPrefName);
+  registry->RegisterListPref(
+      prefs::kNearbySharingPrivateCertificateListPrefName);
 }
 
 void RegisterNearbySharingLocalPrefs(PrefRegistrySimple* local_state) {

chrome/browser/nearby_sharing/common/nearby_share_prefs.h

@@ -21,6 +21,8 @@ extern const char kNearbySharingIconUrlPrefName[];
 extern const char kNearbySharingOnboardingDismissedTimePrefName[];
 extern const char kNearbySharingSchedulerDownloadDeviceDataPrefName[];
 extern const char kNearbySharingSchedulerUploadDeviceNamePrefName[];
+extern const char kNearbySharingPublicCertificateExpirationDictPrefName[];
+extern const char kNearbySharingPrivateCertificateListPrefName[];
 
 }  // namespace prefs