This applies GUIDs to certificate and key nicknames when

net/base/cert_database_nss.cc

 // Copyright (c) 2011 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/base/cert_database.h"
 
 #include <cert.h>
 #include <certdb.h>
 #include <keyhi.h>
 #include <pk11pub.h>
@@ skipping 48 matching lines @@
   PK11_FreeSlot(slot);
 
   return OK;
 }
 
 int CertDatabase::AddUserCert(X509Certificate* cert_obj) {
   CERTCertificate* cert = cert_obj->os_cert_handle();
   PK11SlotInfo* slot = NULL;
   std::string nickname;
 
-  // Create a nickname for this certificate.
-  // We use the scheme used by Firefox:
-  // --> <subject's common name>'s <issuer's common name> ID.
-
-  std::string username, ca_name;
-  char* temp_username = CERT_GetCommonName(&cert->subject);
-  char* temp_ca_name = CERT_GetCommonName(&cert->issuer);
-  if (temp_username) {
-    username = temp_username;
-    PORT_Free(temp_username);
-  }
-  if (temp_ca_name) {
-    ca_name = temp_ca_name;
-    PORT_Free(temp_ca_name);
-  }
-  nickname = username + "'s " + ca_name + " ID";
-
   {
     crypto::AutoNSSWriteLock lock;
     slot = PK11_ImportCertForKey(cert,
-                                 const_cast<char*>(nickname.c_str()),
+                                 cert_obj->GetLabel().c_str(),
                                  NULL);
   }
 
   if (!slot) {
     LOG(ERROR) << "Couldn't import user certificate.";
     return ERR_ADD_USER_CERT_FAILED;
   }
   PK11_FreeSlot(slot);
   CertDatabase::NotifyObserversOfUserCertAdded(cert_obj);
   return OK;
 }
 
 void CertDatabase::ListCerts(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);
        node = CERT_LIST_NEXT(node)) {
     certs->push_back(X509Certificate::CreateFromHandle(
         node->cert, X509Certificate::OSCertHandles()));
   }
   CERT_DestroyCertList(cert_list);
 }
 
+void CertDatabase::ListCertsWithLabel(const std::string& label,
+                                      CertificateList* certs) {
+  ListCerts(certs);
+  CertificateList new_list;
+  for (CertificateList::iterator iter = certs->begin();
+       iter != certs->end(); ++iter) {
+    if (iter->get()->GetLabel().find(label) != std::string::npos)
+      new_list.push_back(*iter);
+  }
+  certs->swap(new_list);
+}
+
 CryptoModule* CertDatabase::GetPublicModule() const {
   CryptoModule* module =
       CryptoModule::CreateFromHandle(crypto::GetPublicNSSKeySlot());
   // The module is already referenced when returned from
   // GetPublicNSSKeySlot, so we need to deref it once.
   PK11_FreeSlot(module->os_module_handle());
 
   return module;
 }
 
@@ skipping 28 matching lines @@
                                     PR_FALSE);  // restart
   }
 
   PK11_FreeSlotList(slot_list);
 }
 
 int CertDatabase::ImportFromPKCS12(
     CryptoModule* module,
     const std::string& data,
     const string16& password,
-    bool is_extractable) {
+    bool is_extractable,
+    net::CertificateList* imported_certs) {
   int result = psm::nsPKCS12Blob_Import(module->os_module_handle(),
                                         data.data(), data.size(),
                                         password,
-                                        is_extractable);
+                                        is_extractable,
+                                        imported_certs);
   if (result == net::OK)
     CertDatabase::NotifyObserversOfUserCertAdded(NULL);
 
   return result;
 }
 
 int CertDatabase::ExportToPKCS12(
     const CertificateList& certs,
     const string16& password,
     std::string* output) const {
@@ skipping 155 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 bool CertDatabase::IsReadOnly(const X509Certificate* cert) const {
   PK11SlotInfo* slot = cert->os_cert_handle()->slot;
   return slot && PK11_IsReadOnly(slot);
 }
 
 }  // namespace net