Cleanup unreachable cert adding code

net/cert/nss_cert_database.cc

 // Copyright (c) 2012 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 "net/cert/nss_cert_database.h"
 
 #include <cert.h>
 #include <certdb.h>
 #include <keyhi.h>
 #include <pk11pub.h>
@@ skipping 35 matching lines @@
 // the c'tor of NSSCertDatabase, see https://crbug.com/395983 .
 // Helper that observes events from the NSSCertDatabase and forwards them to
 // the given CertDatabase.
 class CertNotificationForwarder : public NSSCertDatabase::Observer {
  public:
   explicit CertNotificationForwarder(CertDatabase* cert_db)
       : cert_db_(cert_db) {}
 
   ~CertNotificationForwarder() override {}
 
-  // NSSCertDatabase::Observer implementation:
-  void OnCertAdded(const X509Certificate* cert) override {
-    cert_db_->NotifyObserversOfCertAdded(cert);
-  }
-
-  void OnCertRemoved(const X509Certificate* cert) override {
-    cert_db_->NotifyObserversOfCertRemoved(cert);
-  }
-
-  void OnCACertChanged(const X509Certificate* cert) override {
-    cert_db_->NotifyObserversOfCACertChanged(cert);
+  void OnCertDBChanged(const X509Certificate* cert) override {
+    cert_db_->NotifyObserversCertDBChanged(cert);
   }
 
  private:
   CertDatabase* cert_db_;
 
   DISALLOW_COPY_AND_ASSIGN(CertNotificationForwarder);
 };
 
 }  // namespace
 
@@ skipping 115 matching lines @@
                                       CertificateList* imported_certs) {
   DVLOG(1) << __func__ << " "
            << PK11_GetModuleID(module->os_module_handle()) << ":"
            << PK11_GetSlotID(module->os_module_handle());
   int result = psm::nsPKCS12Blob_Import(module->os_module_handle(),
                                         data.data(), data.size(),
                                         password,
                                         is_extractable,
                                         imported_certs);
   if (result == OK)
-    NotifyObserversOfCertAdded(NULL);
+    NotifyObserversCertDBChanged(NULL);
 
   return result;
 }
 
 int NSSCertDatabase::ExportToPKCS12(
     const CertificateList& certs,
     const base::string16& password,
     std::string* output) const {
   return psm::nsPKCS12Blob_Export(output, certs, password);
 }
@@ skipping 21 matching lines @@
   return cert0;
 }
 
 int NSSCertDatabase::ImportUserCert(const std::string& data) {
   CertificateList certificates =
       X509Certificate::CreateCertificateListFromBytes(
           data.c_str(), data.size(), net::X509Certificate::FORMAT_AUTO);
   int result = psm::ImportUserCert(certificates);
 
   if (result == OK)
-    NotifyObserversOfCertAdded(NULL);
+    NotifyObserversCertDBChanged(NULL);
 
   return result;
 }
+
+int NSSCertDatabase::ImportUserCert(X509Certificate* certificate) {
+  CertificateList certificates;
+  certificates.emplace_back(certificate);
+  int result = psm::ImportUserCert(certificates);
+
+  if (result == OK)
+    NotifyObserversCertDBChanged(NULL);
+
+  return result;
+}
 
 bool NSSCertDatabase::ImportCACerts(const CertificateList& certificates,
                                     TrustBits trust_bits,
                                     ImportCertFailureList* not_imported) {
   crypto::ScopedPK11Slot slot(GetPublicSlot());
   X509Certificate* root = FindRootInList(certificates);
   bool success = psm::ImportCACerts(
       slot.get(), certificates, root, trust_bits, not_imported);
   if (success)
-    NotifyObserversOfCACertChanged(NULL);
+    NotifyObserversCertDBChanged(NULL);
 
   return success;
 }
 
 bool NSSCertDatabase::ImportServerCert(const CertificateList& certificates,
                                        TrustBits trust_bits,
                                        ImportCertFailureList* not_imported) {
   crypto::ScopedPK11Slot slot(GetPublicSlot());
   return psm::ImportServerCert(
       slot.get(), certificates, trust_bits, not_imported);
@@ skipping 97 matching lines @@
   }
 
   return false;
 }
 
 bool NSSCertDatabase::SetCertTrust(const X509Certificate* cert,
                                 CertType type,
                                 TrustBits trust_bits) {
   bool success = psm::SetCertTrust(cert, type, trust_bits);
   if (success)
-    NotifyObserversOfCACertChanged(cert);
+    NotifyObserversCertDBChanged(cert);
 
   return success;
 }
 
 bool NSSCertDatabase::DeleteCertAndKey(X509Certificate* cert) {
   if (!DeleteCertAndKeyImpl(cert))
     return false;
-  NotifyObserversOfCertRemoved(cert);
+  NotifyObserversCertDBChanged(cert);
   return true;
 }
 
 void NSSCertDatabase::DeleteCertAndKeyAsync(
     const scoped_refptr<X509Certificate>& cert,
     const DeleteCertCallback& callback) {
   base::PostTaskAndReplyWithResult(
       GetSlowTaskRunner().get(),
       FROM_HERE,
       base::Bind(&NSSCertDatabase::DeleteCertAndKeyImpl, cert),
@@ skipping 50 matching lines @@
   if (slow_task_runner_for_test_.get())
     return slow_task_runner_for_test_;
   return base::WorkerPool::GetTaskRunner(true /*task is slow*/);
 }
 
 void NSSCertDatabase::NotifyCertRemovalAndCallBack(
     scoped_refptr<X509Certificate> cert,
     const DeleteCertCallback& callback,
     bool success) {
   if (success)
-    NotifyObserversOfCertRemoved(cert.get());
+    NotifyObserversCertDBChanged(cert.get());
   callback.Run(success);
 }
 
-void NSSCertDatabase::NotifyObserversOfCertAdded(const X509Certificate* cert) {
-  observer_list_->Notify(FROM_HERE, &Observer::OnCertAdded,
+void NSSCertDatabase::NotifyObserversCertDBChanged(
+    const X509Certificate* cert) {
+  observer_list_->Notify(FROM_HERE, &Observer::OnCertDBChanged,
                          base::RetainedRef(cert));
 }
 
-void NSSCertDatabase::NotifyObserversOfCertRemoved(
-    const X509Certificate* cert) {
-  observer_list_->Notify(FROM_HERE, &Observer::OnCertRemoved,
-                         base::RetainedRef(cert));
-}
-
-void NSSCertDatabase::NotifyObserversOfCACertChanged(
-    const X509Certificate* cert) {
-  observer_list_->Notify(FROM_HERE, &Observer::OnCACertChanged,
-                         base::RetainedRef(cert));
-}
-
 // static
 bool NSSCertDatabase::DeleteCertAndKeyImpl(
     scoped_refptr<X509Certificate> cert) {
   // For some reason, PK11_DeleteTokenCertAndKey only calls
   // SEC_DeletePermCertificate if the private key is found.  So, we check
   // whether a private key exists before deciding which function to call to
   // delete the cert.
   SECKEYPrivateKey* privKey =
       PK11_FindKeyByAnyCert(cert->os_cert_handle(), NULL);
   if (privKey) {
     SECKEY_DestroyPrivateKey(privKey);
     if (PK11_DeleteTokenCertAndKey(cert->os_cert_handle(), NULL)) {
       LOG(ERROR) << "PK11_DeleteTokenCertAndKey failed: " << PORT_GetError();
       return false;
     }
   } else {
     if (SEC_DeletePermCertificate(cert->os_cert_handle())) {
       LOG(ERROR) << "SEC_DeletePermCertificate failed: " << PORT_GetError();
       return false;
     }
   }
   return true;
 }
 
 }  // namespace net