Implement SHA-256 fingerprint support

net/base/x509_certificate.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/base/x509_certificate.h"
 
 #include <stdlib.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 73 matching lines @@
     Entry() : cert_handle(NULL), ref_count(0) {}
 
     X509Certificate::OSCertHandle cert_handle;
 
     // Increased by each call to InsertOrUpdate(), and balanced by each call
     // to Remove(). When it equals 0, all references created by
     // InsertOrUpdate() have been released, so the cache entry will be removed
     // the cached OS certificate handle will be freed.
     int ref_count;
   };
-  typedef std::map<SHA1Fingerprint, Entry, SHA1FingerprintLessThan> CertMap;
+  typedef std::map<SHA1HashValue, Entry, SHA1HashValueLessThan> CertMap;
 
   // Obtain an instance of X509CertificateCache via a LazyInstance.
   X509CertificateCache() {}
   ~X509CertificateCache() {}
   friend struct base::DefaultLazyInstanceTraits<X509CertificateCache>;
 
   // You must acquire this lock before using any private data of this object
   // You must not block while holding this lock.
   base::Lock lock_;
 
   // The certificate cache.  You must acquire |lock_| before using |cache_|.
   CertMap cache_;
 
   DISALLOW_COPY_AND_ASSIGN(X509CertificateCache);
 };
 
 base::LazyInstance<X509CertificateCache>::Leaky
     g_x509_certificate_cache = LAZY_INSTANCE_INITIALIZER;
 
 void X509CertificateCache::InsertOrUpdate(
     X509Certificate::OSCertHandle* cert_handle) {
   DCHECK(cert_handle);
-  SHA1Fingerprint fingerprint =
+  SHA1HashValue fingerprint =
       X509Certificate::CalculateFingerprint(*cert_handle);
 
   X509Certificate::OSCertHandle old_handle = NULL;
   {
     base::AutoLock lock(lock_);
     CertMap::iterator pos = cache_.find(fingerprint);
     if (pos == cache_.end()) {
       // A cached entry was not found, so initialize a new entry. The entry
       // assumes ownership of the current |*cert_handle|.
       Entry cache_entry;
@@ skipping 25 matching lines @@
   // |old_handle| may be the only handle for this particular certificate, so
   // freeing it may be complex or resource-intensive and does not need to
   // be guarded by the lock.
   if (old_handle) {
     X509Certificate::FreeOSCertHandle(old_handle);
     DHISTOGRAM_COUNTS("X509CertificateReuseCount", 1);
   }
 }
 
 void X509CertificateCache::Remove(X509Certificate::OSCertHandle cert_handle) {
-  SHA1Fingerprint fingerprint =
+  SHA1HashValue fingerprint =
       X509Certificate::CalculateFingerprint(cert_handle);
   base::AutoLock lock(lock_);
 
   CertMap::iterator pos = cache_.find(fingerprint);
   if (pos == cache_.end())
     return;  // A hash collision where the winning cert was already freed.
 
   bool is_same_cert = X509Certificate::IsSameOSCert(cert_handle,
                                                     pos->second.cert_handle);
   if (!is_same_cert)
@@ skipping 518 matching lines @@
     RemoveFromCache(cert_handle_);
     FreeOSCertHandle(cert_handle_);
   }
   for (size_t i = 0; i < intermediate_ca_certs_.size(); ++i) {
     RemoveFromCache(intermediate_ca_certs_[i]);
     FreeOSCertHandle(intermediate_ca_certs_[i]);
   }
 }
 
 }  // namespace net