Refactor event creation in cert provider service

Extract the code related to API event creation in the
chrome.certificateProvider API into separate functions.

This is preparation CL for the introduction of the new version of the
chrome.certificateProvider API.

No functional changes expected - this is a pure refactoring CL.

Bug: 1078761
Change-Id: I2324a07b6db6fae0d8e1cc634ea0bfd865168b2e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2247781
Commit-Queue: Maksim Ivanov <emaxx@chromium.org>
Reviewed-by: Fabian Sommer <fabiansommer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#783099}

chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.cc

@@ -9,6 +9,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/containers/flat_set.h"
 #include "base/containers/span.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
@@ -70,56 +71,32 @@ class DefaultDelegate : public CertificateProviderService::Delegate,
                            extensions::UnloadedExtensionReason reason) override;
 
  private:
+  // Returns extension IDs that currently have event listeners for the given
+  // event,
+  base::flat_set<std::string> GetSubscribedExtensions(
+      const std::string& event_name);
+
   CertificateProviderService* const service_;
   extensions::ExtensionRegistry* const registry_;
   extensions::EventRouter* const event_router_;
 };
 
-DefaultDelegate::DefaultDelegate(CertificateProviderService* service,
-                                 extensions::ExtensionRegistry* registry,
-                                 extensions::EventRouter* event_router)
-    : service_(service), registry_(registry), event_router_(event_router) {
-  DCHECK(service_);
-  registry_->AddObserver(this);
-  event_router_->RegisterObserver(this,
-                                  api_cp::OnCertificatesRequested::kEventName);
-}
-
-DefaultDelegate::~DefaultDelegate() {
-  event_router_->UnregisterObserver(this);
-  registry_->RemoveObserver(this);
-}
-
-std::vector<std::string> DefaultDelegate::CertificateProviderExtensions() {
-  const std::string event_name(api_cp::OnCertificatesRequested::kEventName);
-  std::vector<std::string> ids;
-  for (const auto& listener :
-       event_router_->listeners().GetEventListenersByName(event_name)) {
-    ids.push_back(listener->extension_id());
-  }
-  return ids;
-}
-
-void DefaultDelegate::BroadcastCertificateRequest(int request_id) {
-  const std::string event_name(api_cp::OnCertificatesRequested::kEventName);
-  std::unique_ptr<base::ListValue> internal_args(new base::ListValue);
-  internal_args->AppendInteger(request_id);
-  std::unique_ptr<extensions::Event> event(new extensions::Event(
+// Constructs the "onCertificatesRequested" event.
+std::unique_ptr<extensions::Event> BuildOnCertificatesRequestedEvent(
+    int request_id) {
+  auto event_args = std::make_unique<base::ListValue>();
+  event_args->Append(request_id);
+  return std::make_unique<extensions::Event>(
       extensions::events::CERTIFICATEPROVIDER_ON_CERTIFICATES_REQUESTED,
-      event_name, std::move(internal_args)));
-  event_router_->BroadcastEvent(std::move(event));
+      api_cp::OnCertificatesRequested::kEventName, std::move(event_args));
 }
 
-bool DefaultDelegate::DispatchSignRequestToExtension(
-    const std::string& extension_id,
+// Constructs the "onSignDigestRequested" event.
+std::unique_ptr<extensions::Event> BuildOnSignDigestRequestedEvent(
     int request_id,
     uint16_t algorithm,
     const scoped_refptr<net::X509Certificate>& certificate,
     base::span<const uint8_t> input) {
-  const std::string event_name(api_cp::OnSignDigestRequested::kEventName);
-  if (!event_router_->ExtensionHasEventListener(extension_id, event_name))
-    return false;
-
   api_cp::SignRequest request;
 
   request.sign_request_id = request_id;
@@ -141,7 +118,7 @@ bool DefaultDelegate::DispatchSignRequestToExtension(
       break;
     default:
       LOG(ERROR) << "Unknown signature algorithm";
-      return false;
+      return nullptr;
   }
   base::StringPiece cert_der =
       net::x509_util::CryptoBufferAsStringPiece(certificate->cert_buffer());
@@ -153,19 +130,62 @@ bool DefaultDelegate::DispatchSignRequestToExtension(
   unsigned digest_len;
   if (!md || !EVP_Digest(input.data(), input.size(), request.digest.data(),
                          &digest_len, md, /*ENGINE *impl=*/nullptr)) {
-    return false;
+    return nullptr;
   }
   request.digest.resize(digest_len);
 
-  std::unique_ptr<base::ListValue> internal_args(new base::ListValue);
-  internal_args->AppendInteger(request_id);
-  internal_args->Append(request.ToValue());
+  std::unique_ptr<base::ListValue> event_args(new base::ListValue);
+  event_args->AppendInteger(request_id);
+  event_args->Append(request.ToValue());
+
+  return std::make_unique<extensions::Event>(
+      extensions::events::CERTIFICATEPROVIDER_ON_SIGN_DIGEST_REQUESTED,
+      api_cp::OnSignDigestRequested::kEventName, std::move(event_args));
+}
+
+DefaultDelegate::DefaultDelegate(CertificateProviderService* service,
+                                 extensions::ExtensionRegistry* registry,
+                                 extensions::EventRouter* event_router)
+    : service_(service), registry_(registry), event_router_(event_router) {
+  DCHECK(service_);
+  registry_->AddObserver(this);
+  event_router_->RegisterObserver(this,
+                                  api_cp::OnCertificatesRequested::kEventName);
+}
+
+DefaultDelegate::~DefaultDelegate() {
+  event_router_->UnregisterObserver(this);
+  registry_->RemoveObserver(this);
+}
+
+std::vector<std::string> DefaultDelegate::CertificateProviderExtensions() {
+  const base::flat_set<std::string> ids =
+      GetSubscribedExtensions(api_cp::OnCertificatesRequested::kEventName);
+  return std::vector<std::string>(ids.begin(), ids.end());
+}
+
+void DefaultDelegate::BroadcastCertificateRequest(int request_id) {
+  for (const std::string& extension_id :
+       GetSubscribedExtensions(api_cp::OnCertificatesRequested::kEventName)) {
+    event_router_->DispatchEventToExtension(
+        extension_id, BuildOnCertificatesRequestedEvent(request_id));
+  }
+}
 
-  event_router_->DispatchEventToExtension(
-      extension_id,
-      std::make_unique<extensions::Event>(
-          extensions::events::CERTIFICATEPROVIDER_ON_SIGN_DIGEST_REQUESTED,
-          event_name, std::move(internal_args)));
+bool DefaultDelegate::DispatchSignRequestToExtension(
+    const std::string& extension_id,
+    int request_id,
+    uint16_t algorithm,
+    const scoped_refptr<net::X509Certificate>& certificate,
+    base::span<const uint8_t> input) {
+  if (!event_router_->ExtensionHasEventListener(
+          extension_id, api_cp::OnSignDigestRequested::kEventName))
+    return false;
+  std::unique_ptr<extensions::Event> event = BuildOnSignDigestRequestedEvent(
+      request_id, algorithm, certificate, input);
+  if (!event)
+    return false;
+  event_router_->DispatchEventToExtension(extension_id, std::move(event));
   return true;
 }
 
@@ -183,6 +203,16 @@ void DefaultDelegate::OnExtensionUnloaded(
   service_->OnExtensionUnloaded(extension->id());
 }
 
+base::flat_set<std::string> DefaultDelegate::GetSubscribedExtensions(
+    const std::string& event_name) {
+  std::vector<std::string> ids;
+  for (const std::unique_ptr<extensions::EventListener>& listener :
+       event_router_->listeners().GetEventListenersByName(event_name)) {
+    ids.push_back(listener->extension_id());
+  }
+  return base::flat_set<std::string>(ids.begin(), ids.end());
+}
+
 }  // namespace
 
 // static