Reland 66791 (change was innocent)...

net/base/x509_certificate_mac.cc

 // Copyright (c) 2006-2008 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 <CommonCrypto/CommonDigest.h>
 #include <Security/Security.h>
 #include <time.h>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/sys_string_conversions.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/cert_verify_result.h"
 #include "net/base/net_errors.h"
 
 using base::mac::ScopedCFTypeRef;
 using base::Time;
 
 namespace net {
 
+namespace {
+
 class MacTrustedCertificates {
  public:
   // Sets the trusted root certificate used by tests. Call with |cert| set
   // to NULL to clear the test certificate.
   void SetTestCertificate(X509Certificate* cert) {
     AutoLock lock(lock_);
     test_certificate_ = cert;
   }
 
   // Returns an array containing the trusted certificates for use with
@@ skipping 16 matching lines @@
     ScopedCFTypeRef<CFArrayRef> scoped_anchor_array(anchor_array);
     CFMutableArrayRef merged_array = CFArrayCreateMutableCopy(
         kCFAllocatorDefault, 0, anchor_array);
     if (!merged_array)
       return NULL;
     CFArrayAppendValue(merged_array, test_certificate_->os_cert_handle());
 
     return merged_array;
   }
  private:
-  friend struct DefaultSingletonTraits<MacTrustedCertificates>;
+  friend struct base::DefaultLazyInstanceTraits<MacTrustedCertificates>;
 
   // Obtain an instance of MacTrustedCertificates via the singleton
   // interface.
   MacTrustedCertificates() : test_certificate_(NULL) { }
 
   // An X509Certificate object that may be appended to the list of
   // system trusted anchors.
   scoped_refptr<X509Certificate> test_certificate_;
 
   // The trusted cache may be accessed from multiple threads.
   mutable Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(MacTrustedCertificates);
 };
 
-void SetMacTestCertificate(X509Certificate* cert) {
-  Singleton<MacTrustedCertificates>::get()->SetTestCertificate(cert);
-}
-
-namespace {
+base::LazyInstance<MacTrustedCertificates,
+    base::LeakyLazyInstanceTraits<MacTrustedCertificates> >
+    g_mac_trusted_certificates(base::LINKER_INITIALIZED);
 
 typedef OSStatus (*SecTrustCopyExtendedResultFuncPtr)(SecTrustRef,
                                                       CFDictionaryRef*);
 
 int NetErrorFromOSStatus(OSStatus status) {
   switch (status) {
     case noErr:
       return OK;
     case errSecNotAvailable:
     case errSecNoCertificateModule:
@@ skipping 345 matching lines @@
       if (IsValidOSCertHandle(cert)) {
         CFRetain(cert);
         output->push_back(cert);
       }
     }
   }
 }
 
 }  // namespace
 
+void SetMacTestCertificate(X509Certificate* cert) {
+  g_mac_trusted_certificates.Get().SetTestCertificate(cert);
+}
+
 void X509Certificate::Initialize() {
   const CSSM_X509_NAME* name;
   OSStatus status = SecCertificateGetSubject(cert_handle_, &name);
   if (!status) {
     subject_.Parse(name);
   }
   status = SecCertificateGetIssuer(cert_handle_, &name);
   if (!status) {
     issuer_.Parse(name);
   }
@@ skipping 82 matching lines @@
 
   SecTrustRef trust_ref = NULL;
   status = SecTrustCreateWithCertificates(cert_array, ssl_policy, &trust_ref);
   if (status)
     return NetErrorFromOSStatus(status);
   ScopedCFTypeRef<SecTrustRef> scoped_trust_ref(trust_ref);
 
   // Set the trusted anchor certificates for the SecTrustRef by merging the
   // system trust anchors and the test root certificate.
   CFArrayRef anchor_array =
-      Singleton<MacTrustedCertificates>::get()->CopyTrustedCertificateArray();
+      g_mac_trusted_certificates.Get().CopyTrustedCertificateArray();
   ScopedCFTypeRef<CFArrayRef> scoped_anchor_array(anchor_array);
   if (anchor_array) {
     status = SecTrustSetAnchorCertificates(trust_ref, anchor_array);
     if (status)
       return NetErrorFromOSStatus(status);
   }
 
   if (flags & VERIFY_REV_CHECKING_ENABLED) {
     // When called with VERIFY_REV_CHECKING_ENABLED, we ask SecTrustEvaluate()
     // to apply OCSP and CRL checking, but we're still subject to the global
@@ skipping 445 matching lines @@
     }
     CFRelease(cert_chain);
   }
 exit:
   if (result)
     LOG(ERROR) << "CreateIdentityCertificateChain error " << result;
   return chain.release();
 }
 
 }  // namespace net