Clang format slam.

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 23 matching lines @@
 #define CERTDB_TERMINAL_RECORD CERTDB_VALID_PEER
 #endif
 
 // PSM = Mozilla's Personal Security Manager.
 namespace psm = mozilla_security_manager;
 
 namespace net {
 
 namespace {
 
-base::LazyInstance<NSSCertDatabase>::Leaky
-    g_nss_cert_database = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<NSSCertDatabase>::Leaky g_nss_cert_database =
+    LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 NSSCertDatabase::ImportCertFailure::ImportCertFailure(
     const scoped_refptr<X509Certificate>& cert,
     int err)
-    : certificate(cert), net_error(err) {}
+    : certificate(cert), net_error(err) {
+}
 
-NSSCertDatabase::ImportCertFailure::~ImportCertFailure() {}
+NSSCertDatabase::ImportCertFailure::~ImportCertFailure() {
+}
 
 // static
 NSSCertDatabase* NSSCertDatabase::GetInstance() {
-  // TODO(mattm): Remove this ifdef guard once the linux impl of
-  // GetNSSCertDatabaseForResourceContext does not call GetInstance.
+// TODO(mattm): Remove this ifdef guard once the linux impl of
+// GetNSSCertDatabaseForResourceContext does not call GetInstance.
 #if defined(OS_CHROMEOS)
   LOG(ERROR) << "NSSCertDatabase::GetInstance() is deprecated."
              << "See http://crbug.com/329735.";
 #endif
   return &g_nss_cert_database.Get();
 }
 
 NSSCertDatabase::NSSCertDatabase()
     : observer_list_(new ObserverListThreadSafe<Observer>) {
   // This also makes sure that NSS has been initialized.
   CertDatabase::GetInstance()->ObserveNSSCertDatabase(this);
 
   psm::EnsurePKCS12Init();
 }
 
-NSSCertDatabase::~NSSCertDatabase() {}
+NSSCertDatabase::~NSSCertDatabase() {
+}
 
 void NSSCertDatabase::ListCertsSync(CertificateList* certs) {
   ListCertsImpl(certs);
 }
 
 void NSSCertDatabase::ListCerts(
     const base::Callback<void(scoped_ptr<CertificateList> certs)>& callback) {
   scoped_ptr<CertificateList> certs(new CertificateList());
 
   // base::Pased will NULL out |certs|, so cache the underlying pointer here.
   CertificateList* raw_certs = certs.get();
   GetSlowTaskRunner()->PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&NSSCertDatabase::ListCertsImpl,
-                 base::Unretained(raw_certs)),
+      base::Bind(&NSSCertDatabase::ListCertsImpl, base::Unretained(raw_certs)),
       base::Bind(callback, base::Passed(&certs)));
 }
 
 crypto::ScopedPK11Slot NSSCertDatabase::GetPublicSlot() const {
   return crypto::ScopedPK11Slot(crypto::GetPublicNSSKeySlot());
 }
 
 crypto::ScopedPK11Slot NSSCertDatabase::GetPrivateSlot() const {
   return crypto::ScopedPK11Slot(crypto::GetPrivateNSSKeySlot());
 }
@@ skipping 19 matching lines @@
                         PR_TRUE,                       // loadCerts (unused)
                         NULL));                        // wincx
   if (!slot_list) {
     LOG(ERROR) << "PK11_GetAllTokens failed: " << PORT_GetError();
     return;
   }
 
   PK11SlotListElement* slot_element = PK11_GetFirstSafe(slot_list.get());
   while (slot_element) {
     modules->push_back(CryptoModule::CreateFromHandle(slot_element->slot));
-    slot_element = PK11_GetNextSafe(slot_list.get(), slot_element,
+    slot_element = PK11_GetNextSafe(slot_list.get(),
+                                    slot_element,
                                     PR_FALSE);  // restart
   }
 }
 
-int NSSCertDatabase::ImportFromPKCS12(
-    CryptoModule* module,
-    const std::string& data,
-    const base::string16& password,
-    bool is_extractable,
-    net::CertificateList* imported_certs) {
-  DVLOG(1) << __func__ << " "
-           << PK11_GetModuleID(module->os_module_handle()) << ":"
-           << PK11_GetSlotID(module->os_module_handle());
+int NSSCertDatabase::ImportFromPKCS12(CryptoModule* module,
+                                      const std::string& data,
+                                      const base::string16& password,
+                                      bool is_extractable,
+                                      net::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(),
+                                        data.data(),
+                                        data.size(),
                                         password,
                                         is_extractable,
                                         imported_certs);
   if (result == net::OK)
     NotifyObserversOfCertAdded(NULL);
 
   return result;
 }
 
-int NSSCertDatabase::ExportToPKCS12(
-    const CertificateList& certs,
-    const base::string16& password,
-    std::string* output) const {
+int NSSCertDatabase::ExportToPKCS12(const CertificateList& certs,
+                                    const base::string16& password,
+                                    std::string* output) const {
   return psm::nsPKCS12Blob_Export(output, certs, password);
 }
 
 X509Certificate* NSSCertDatabase::FindRootInList(
     const CertificateList& certificates) const {
   DCHECK_GT(certificates.size(), 0U);
 
   if (certificates.size() == 1)
     return certificates[0].get();
 
@@ skipping 128 matching lines @@
                        &cert->os_cert_handle()->subject) == SECEqual) {
     return (nsstrust.sslFlags & kTrusted) == 0 &&
            (nsstrust.emailFlags & kTrusted) == 0 &&
            (nsstrust.objectSigningFlags & kTrusted) == 0;
   }
 
   return false;
 }
 
 bool NSSCertDatabase::SetCertTrust(const X509Certificate* cert,
-                                CertType type,
-                                TrustBits trust_bits) {
+                                   CertType type,
+                                   TrustBits trust_bits) {
   bool success = psm::SetCertTrust(cert, type, trust_bits);
   if (success)
     NotifyObserversOfCACertChanged(cert);
 
   return success;
 }
 
 bool NSSCertDatabase::DeleteCertAndKey(const 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);
+  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;
@@ skipping 27 matching lines @@
     const scoped_refptr<base::TaskRunner>& task_runner) {
   slow_task_runner_for_test_ = task_runner;
 }
 
 // static
 void NSSCertDatabase::ListCertsImpl(CertificateList* certs) {
   certs->clear();
 
   CERTCertList* cert_list = PK11_ListCerts(PK11CertListUnique, NULL);
   CERTCertListNode* node;
-  for (node = CERT_LIST_HEAD(cert_list);
-       !CERT_LIST_END(node, cert_list);
+  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);
 }
 
 scoped_refptr<base::TaskRunner> NSSCertDatabase::GetSlowTaskRunner() const {
   if (slow_task_runner_for_test_)
     return slow_task_runner_for_test_;
   return base::WorkerPool::GetTaskRunner(true /*task is slow*/);
 }
 
 void NSSCertDatabase::NotifyObserversOfCertAdded(const X509Certificate* cert) {
   observer_list_->Notify(&Observer::OnCertAdded, make_scoped_refptr(cert));
 }
 
 void NSSCertDatabase::NotifyObserversOfCertRemoved(
     const X509Certificate* cert) {
   observer_list_->Notify(&Observer::OnCertRemoved, make_scoped_refptr(cert));
 }
 
 void NSSCertDatabase::NotifyObserversOfCACertChanged(
     const X509Certificate* cert) {
-  observer_list_->Notify(
-      &Observer::OnCACertChanged, make_scoped_refptr(cert));
+  observer_list_->Notify(&Observer::OnCACertChanged, make_scoped_refptr(cert));
 }
 
 }  // namespace net