[Nearby] Add certificate manager implementation skeleton and fake

Add a certificate manager implementation class, where the overridden
methods are currently marked as NOTIMPLEMENTED(). We also include a fake
implementation and factory for use in unit tests.

The full implementation will happen in a follow-up CL. For now, these
classes unblock consumers of the certificate manager.

Bug: b/154863644
Change-Id: Ib81bd4e09b7fed0d98e7e18792de78664ff9d20c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2311078Reviewed-by: James Vecore <vecore@google.com>
Commit-Queue: Josh Nohle <nohle@chromium.org>
Cr-Commit-Position: refs/heads/master@{#791021}

chrome/browser/nearby_sharing/certificates/BUILD.gn

@@ -10,6 +10,8 @@ source_set("certificates") {
     "constants.h",
     "nearby_share_certificate_manager.cc",
     "nearby_share_certificate_manager.h",
+    "nearby_share_certificate_manager_impl.cc",
+    "nearby_share_certificate_manager_impl.h",
     "nearby_share_decrypted_public_certificate.cc",
     "nearby_share_decrypted_public_certificate.h",
     "nearby_share_encrypted_metadata_key.cc",
@@ -32,6 +34,8 @@ source_set("test_support") {
   testonly = true
 
   sources = [
+    "fake_nearby_share_certificate_manager.cc",
+    "fake_nearby_share_certificate_manager.h",
     "test_util.cc",
     "test_util.h",
   ]

chrome/browser/nearby_sharing/certificates/fake_nearby_share_certificate_manager.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <utility>
+
+#include "chrome/browser/nearby_sharing/certificates/fake_nearby_share_certificate_manager.h"
+#include "chrome/browser/nearby_sharing/certificates/test_util.h"
+
+FakeNearbyShareCertificateManager::Factory::Factory() = default;
+
+FakeNearbyShareCertificateManager::Factory::~Factory() = default;
+
+std::unique_ptr<NearbyShareCertificateManager>
+FakeNearbyShareCertificateManager::Factory::CreateInstance() {
+  auto instance = std::make_unique<FakeNearbyShareCertificateManager>();
+  instances_.push_back(instance.get());
+
+  return instance;
+}
+
+FakeNearbyShareCertificateManager::GetDecryptedPublicCertificateCall::
+    GetDecryptedPublicCertificateCall(
+        base::span<const uint8_t> encrypted_metadata_key,
+        base::span<const uint8_t> salt,
+        CertDecryptedCallback callback)
+    : encrypted_metadata_key(encrypted_metadata_key.begin(),
+                             encrypted_metadata_key.end()),
+      salt(salt.begin(), salt.end()),
+      callback(std::move(callback)) {}
+
+FakeNearbyShareCertificateManager::GetDecryptedPublicCertificateCall::
+    GetDecryptedPublicCertificateCall(
+        GetDecryptedPublicCertificateCall&& other) = default;
+
+FakeNearbyShareCertificateManager::GetDecryptedPublicCertificateCall&
+FakeNearbyShareCertificateManager::GetDecryptedPublicCertificateCall::operator=(
+    GetDecryptedPublicCertificateCall&& other) = default;
+
+FakeNearbyShareCertificateManager::GetDecryptedPublicCertificateCall::
+    ~GetDecryptedPublicCertificateCall() = default;
+
+FakeNearbyShareCertificateManager::FakeNearbyShareCertificateManager() =
+    default;
+
+FakeNearbyShareCertificateManager::~FakeNearbyShareCertificateManager() =
+    default;
+
+NearbySharePrivateCertificate
+FakeNearbyShareCertificateManager::GetValidPrivateCertificate(
+    NearbyShareVisibility visibility) {
+  ++num_get_valid_private_certificate_calls_;
+  return GetNearbyShareTestPrivateCertificate(visibility);
+}
+
+void FakeNearbyShareCertificateManager::GetDecryptedPublicCertificate(
+    base::span<const uint8_t> encrypted_metadata_key,
+    base::span<const uint8_t> salt,
+    CertDecryptedCallback callback) {
+  get_decrypted_public_certificate_calls_.emplace_back(
+      encrypted_metadata_key, salt, std::move(callback));
+}
+
+void FakeNearbyShareCertificateManager::DownloadPublicCertificates() {
+  ++num_download_public_certificates_calls_;
+}
+
+void FakeNearbyShareCertificateManager::OnStart() {}
+
+void FakeNearbyShareCertificateManager::OnStop() {}

chrome/browser/nearby_sharing/certificates/fake_nearby_share_certificate_manager.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_FAKE_NEARBY_SHARE_CERTIFICATE_MANAGER_H_
+#define CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_FAKE_NEARBY_SHARE_CERTIFICATE_MANAGER_H_
+
+#include <memory>
+#include <vector>
+
+#include "base/containers/span.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager_impl.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_decrypted_public_certificate.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_private_certificate.h"
+
+// A fake implementation of NearbyShareCertificateManager, along with a fake
+// factory, to be used in tests.
+class FakeNearbyShareCertificateManager : public NearbyShareCertificateManager {
+ public:
+  // Factory that creates FakeNearbyShareCertificateManager instances. Use in
+  // NearbyShareCertificateManagerImpl::Factor::SetFactoryForTesting() in unit
+  // tests.
+  class Factory : NearbyShareCertificateManagerImpl::Factory {
+    Factory();
+    ~Factory() override;
+
+    // Returns all FakeNearbyShareCertificateManager instances created by
+    // CreateInstance().
+    std::vector<FakeNearbyShareCertificateManager*>& instances() {
+      return instances_;
+    }
+
+   private:
+    // NearbyShareCertificateManagerImpl::Factory:
+    std::unique_ptr<NearbyShareCertificateManager> CreateInstance() override;
+
+    std::vector<FakeNearbyShareCertificateManager*> instances_;
+  };
+
+  class GetDecryptedPublicCertificateCall {
+   public:
+    GetDecryptedPublicCertificateCall(
+        base::span<const uint8_t> encrypted_metadata_key,
+        base::span<const uint8_t> salt,
+        CertDecryptedCallback callback);
+    GetDecryptedPublicCertificateCall(
+        GetDecryptedPublicCertificateCall&& other);
+    GetDecryptedPublicCertificateCall& operator=(
+        GetDecryptedPublicCertificateCall&& other);
+    GetDecryptedPublicCertificateCall(
+        const GetDecryptedPublicCertificateCall&) = delete;
+    GetDecryptedPublicCertificateCall& operator=(
+        const GetDecryptedPublicCertificateCall&) = delete;
+    ~GetDecryptedPublicCertificateCall();
+
+    std::vector<uint8_t> encrypted_metadata_key;
+    std::vector<uint8_t> salt;
+    CertDecryptedCallback callback;
+  };
+
+  FakeNearbyShareCertificateManager();
+  ~FakeNearbyShareCertificateManager() override;
+
+  // NearbyShareCertificateManager:
+  NearbySharePrivateCertificate GetValidPrivateCertificate(
+      NearbyShareVisibility visibility) override;
+  void GetDecryptedPublicCertificate(
+      base::span<const uint8_t> encrypted_metadata_key,
+      base::span<const uint8_t> salt,
+      CertDecryptedCallback callback) override;
+  void DownloadPublicCertificates() override;
+
+  // Make protected methods from base class public in this fake class.
+  using NearbyShareCertificateManager::NotifyPrivateCertificatesChanged;
+  using NearbyShareCertificateManager::NotifyPublicCertificatesDownloaded;
+
+  std::vector<GetDecryptedPublicCertificateCall>&
+  get_decrypted_public_certificate_calls() {
+    return get_decrypted_public_certificate_calls_;
+  }
+
+ private:
+  // NearbyShareCertificateManager:
+  void OnStart() override;
+  void OnStop() override;
+
+  size_t num_get_valid_private_certificate_calls_ = 0;
+  size_t num_download_public_certificates_calls_ = 0;
+  std::vector<GetDecryptedPublicCertificateCall>
+      get_decrypted_public_certificate_calls_;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_FAKE_NEARBY_SHARE_CERTIFICATE_MANAGER_H_

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager.h

@@ -45,13 +45,10 @@ class NearbyShareCertificateManager {
   void Stop();
   bool is_running() { return is_running_; }
 
-  // Clears all certificate-related data.
-  virtual void ClearAllData() = 0;
-
   // Returns the currently valid private certificate with |visibility|.
   // TODO(crbug.com/1106369): Use common visibility enum.
   virtual NearbySharePrivateCertificate GetValidPrivateCertificate(
-      NearbyShareVisibility visibility) const = 0;
+      NearbyShareVisibility visibility) = 0;
 
   // Returns in |callback| the public certificate that is able to be decrypted
   // using |encrypted_metadata_key| and |salt|, and returns base::nullopt if no
@@ -59,7 +56,7 @@ class NearbyShareCertificateManager {
   virtual void GetDecryptedPublicCertificate(
       base::span<const uint8_t> encrypted_metadata_key,
       base::span<const uint8_t> salt,
-      CertDecryptedCallback callback) const = 0;
+      CertDecryptedCallback callback) = 0;
 
   // Makes an RPC call to the Nearby server to retrieve all public certificates
   // available to the local device. These are also downloaded periodically.

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager_impl.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager_impl.h"
+
+#include "base/memory/ptr_util.h"
+#include "base/notreached.h"
+#include "base/time/time.h"
+#include "chrome/browser/nearby_sharing/proto/encrypted_metadata.pb.h"
+
+// static
+NearbyShareCertificateManagerImpl::Factory*
+    NearbyShareCertificateManagerImpl::Factory::test_factory_ = nullptr;
+
+// static
+std::unique_ptr<NearbyShareCertificateManager>
+NearbyShareCertificateManagerImpl::Factory::Create() {
+  if (test_factory_) {
+    return test_factory_->CreateInstance();
+  }
+
+  return base::WrapUnique(new NearbyShareCertificateManagerImpl());
+}
+
+// static
+void NearbyShareCertificateManagerImpl::Factory::SetFactoryForTesting(
+    Factory* test_factory) {
+  test_factory_ = test_factory;
+}
+
+NearbyShareCertificateManagerImpl::Factory::~Factory() = default;
+
+NearbyShareCertificateManagerImpl::NearbyShareCertificateManagerImpl() =
+    default;
+
+NearbyShareCertificateManagerImpl::~NearbyShareCertificateManagerImpl() =
+    default;
+
+NearbySharePrivateCertificate
+NearbyShareCertificateManagerImpl::GetValidPrivateCertificate(
+    NearbyShareVisibility visibility) {
+  NOTIMPLEMENTED();
+  return NearbySharePrivateCertificate(NearbyShareVisibility::kNoOne,
+                                       /* not_before=*/base::Time(),
+                                       nearbyshare::proto::EncryptedMetadata());
+}
+
+void NearbyShareCertificateManagerImpl::GetDecryptedPublicCertificate(
+    base::span<const uint8_t> encrypted_metadata_key,
+    base::span<const uint8_t> salt,
+    CertDecryptedCallback callback) {
+  NOTIMPLEMENTED();
+}
+
+void NearbyShareCertificateManagerImpl::DownloadPublicCertificates() {
+  NOTIMPLEMENTED();
+}
+
+void NearbyShareCertificateManagerImpl::OnStart() {
+  NOTIMPLEMENTED();
+}
+
+void NearbyShareCertificateManagerImpl::OnStop() {
+  NOTIMPLEMENTED();
+}

chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager_impl.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_NEARBY_SHARE_CERTIFICATE_MANAGER_IMPL_H_
+#define CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_NEARBY_SHARE_CERTIFICATE_MANAGER_IMPL_H_
+
+#include <memory>
+
+#include "base/containers/span.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_certificate_manager.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_private_certificate.h"
+#include "chrome/browser/nearby_sharing/certificates/nearby_share_visibility.h"
+
+// TODO(nohle): Add description after class is fully implemented.
+class NearbyShareCertificateManagerImpl : public NearbyShareCertificateManager {
+ public:
+  class Factory {
+   public:
+    static std::unique_ptr<NearbyShareCertificateManager> Create();
+    static void SetFactoryForTesting(Factory* test_factory);
+
+   protected:
+    virtual ~Factory();
+    virtual std::unique_ptr<NearbyShareCertificateManager> CreateInstance() = 0;
+
+   private:
+    static Factory* test_factory_;
+  };
+
+  ~NearbyShareCertificateManagerImpl() override;
+
+ private:
+  NearbyShareCertificateManagerImpl();
+
+  // NearbyShareCertificateManager:
+  NearbySharePrivateCertificate GetValidPrivateCertificate(
+      NearbyShareVisibility visibility) override;
+  void GetDecryptedPublicCertificate(
+      base::span<const uint8_t> encrypted_metadata_key,
+      base::span<const uint8_t> salt,
+      CertDecryptedCallback callback) override;
+  void DownloadPublicCertificates() override;
+  void OnStart() override;
+  void OnStop() override;
+};
+
+#endif  // CHROME_BROWSER_NEARBY_SHARING_CERTIFICATES_NEARBY_SHARE_CERTIFICATE_MANAGER_IMPL_H_