Remove OnCertDBChanged |cert| parameter.

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 33 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 {}
 
-  void OnCertDBChanged(const X509Certificate* cert) override {
-    cert_db_->NotifyObserversCertDBChanged(cert);
-  }
+  void OnCertDBChanged() override { cert_db_->NotifyObserversCertDBChanged(); }
 
  private:
   CertDatabase* cert_db_;
 
   DISALLOW_COPY_AND_ASSIGN(CertNotificationForwarder);
 };
 
 }  // namespace
 
 NSSCertDatabase::ImportCertFailure::ImportCertFailure(
@@ skipping 110 matching lines @@
                                       CertificateList* imported_certs) {
   DVLOG(1) << __func__ << " "
            << PK11_GetModuleID(slot_info) << ":"
            << PK11_GetSlotID(slot_info);
   int result = psm::nsPKCS12Blob_Import(slot_info,
                                         data.data(), data.size(),
                                         password,
                                         is_extractable,
                                         imported_certs);
   if (result == OK)
-    NotifyObserversCertDBChanged(NULL);
+    NotifyObserversCertDBChanged();
 
   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)
-    NotifyObserversCertDBChanged(NULL);
+    NotifyObserversCertDBChanged();
 
   return result;
 }
 
 int NSSCertDatabase::ImportUserCert(X509Certificate* certificate) {
   CertificateList certificates;
   certificates.emplace_back(certificate);
   int result = psm::ImportUserCert(certificates);
 
   if (result == OK)
-    NotifyObserversCertDBChanged(NULL);
+    NotifyObserversCertDBChanged();
 
   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)
-    NotifyObserversCertDBChanged(NULL);
+    NotifyObserversCertDBChanged();
 
   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)
-    NotifyObserversCertDBChanged(cert);
+    NotifyObserversCertDBChanged();
 
   return success;
 }
 
 bool NSSCertDatabase::DeleteCertAndKey(X509Certificate* cert) {
   if (!DeleteCertAndKeyImpl(cert))
     return false;
-  NotifyObserversCertDBChanged(cert);
+  NotifyObserversCertDBChanged();
   return true;
 }
 
 void NSSCertDatabase::DeleteCertAndKeyAsync(
     const scoped_refptr<X509Certificate>& cert,
     const DeleteCertCallback& callback) {
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits()
                      .WithShutdownBehavior(
                          base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN)
                      .MayBlock(),
       base::Bind(&NSSCertDatabase::DeleteCertAndKeyImpl, cert),
       base::Bind(&NSSCertDatabase::NotifyCertRemovalAndCallBack,
-                 weak_factory_.GetWeakPtr(), cert, callback));
+                 weak_factory_.GetWeakPtr(), callback));
 }
 
 bool NSSCertDatabase::IsReadOnly(const X509Certificate* cert) const {
   PK11SlotInfo* slot = cert->os_cert_handle()->slot;
   return slot && PK11_IsReadOnly(slot);
 }
 
 bool NSSCertDatabase::IsHardwareBacked(const X509Certificate* cert) const {
   PK11SlotInfo* slot = cert->os_cert_handle()->slot;
   return slot && PK11_IsHW(slot);
@@ skipping 21 matching lines @@
   CERTCertListNode* node;
   for (node = CERT_LIST_HEAD(cert_list); !CERT_LIST_END(node, cert_list);
        node = CERT_LIST_NEXT(node)) {
     certs->push_back(X509Certificate::CreateFromHandle(
         node->cert, X509Certificate::OSCertHandles()));
   }
   CERT_DestroyCertList(cert_list);
 }
 
 void NSSCertDatabase::NotifyCertRemovalAndCallBack(
-    scoped_refptr<X509Certificate> cert,
     const DeleteCertCallback& callback,
     bool success) {
   if (success)
-    NotifyObserversCertDBChanged(cert.get());
+    NotifyObserversCertDBChanged();
   callback.Run(success);
 }
 
-void NSSCertDatabase::NotifyObserversCertDBChanged(
-    const X509Certificate* cert) {
-  observer_list_->Notify(FROM_HERE, &Observer::OnCertDBChanged,
-                         base::RetainedRef(cert));
+void NSSCertDatabase::NotifyObserversCertDBChanged() {
+  observer_list_->Notify(FROM_HERE, &Observer::OnCertDBChanged);
 }
 
 // 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