Make members of Singleton<T> private and only visible to the singleton type.

net/socket/dns_cert_provenance_checker.cc

 // Copyright (c) 2010 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/socket/dns_cert_provenance_checker.h"
 
 #if !defined(USE_OPENSSL)
 
 #include <nspr.h>
 
 #include <hasht.h>
 #include <keyhi.h>
 #include <pk11pub.h>
 #include <sechash.h>
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/crypto/encryptor.h"
 #include "base/crypto/symmetric_key.h"
+#include "base/lazy_instance.h"
 #include "base/non_thread_safe.h"
 #include "base/pickle.h"
 #include "base/scoped_ptr.h"
-#include "base/singleton.h"
 #include "net/base/completion_callback.h"
 #include "net/base/dns_util.h"
 #include "net/base/dnsrr_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
 namespace {
 
@@ skipping 29 matching lines @@
   // about the given hostname in this session.
   bool HaveUploadedForHostname(const std::string& hostname) {
     return uploaded_hostnames_.count(hostname) > 0;
   }
 
   void DidUpload(const std::string& hostname) {
     uploaded_hostnames_.insert(hostname);
   }
 
  private:
-  friend struct DefaultSingletonTraits<DnsCertLimits>;
+  friend struct base::DefaultLazyInstanceTraits<DnsCertLimits>;
 
   std::set<std::string> uploaded_hostnames_;
 
   DISALLOW_COPY_AND_ASSIGN(DnsCertLimits);
 };
 
+static base::LazyInstance<DnsCertLimits> g_dns_cert_limits(
+    base::LINKER_INITIALIZED);
+
 // DnsCertProvenanceCheck performs the DNS lookup of the certificate. This
 // class is self-deleting.
 class DnsCertProvenanceCheck : public NonThreadSafe {
  public:
   DnsCertProvenanceCheck(
       const std::string& hostname,
       DnsRRResolver* dnsrr_resolver,
       DnsCertProvenanceChecker::Delegate* delegate,
       const std::vector<base::StringPiece>& der_certs)
       : hostname_(hostname),
         dnsrr_resolver_(dnsrr_resolver),
         delegate_(delegate),
         der_certs_(der_certs.size()),
         handle_(DnsRRResolver::kInvalidHandle),
         ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
               this, &DnsCertProvenanceCheck::ResolutionComplete)) {
     for (size_t i = 0; i < der_certs.size(); i++)
       der_certs_[i] = der_certs[i].as_string();
   }
 
   void Start() {
     DCHECK(CalledOnValidThread());
 
     if (der_certs_.empty())
       return;
 
-    DnsCertLimits* const limits = Singleton<DnsCertLimits>::get();
+    DnsCertLimits* const limits = g_dns_cert_limits.Pointer();
     if (limits->HaveReachedMaxUploads() ||
         limits->HaveUploadedForHostname(hostname_)) {
       return;
     }
 
     uint8 fingerprint[SHA1_LENGTH];
     SECStatus rv = HASH_HashBuf(
         HASH_AlgSHA1, fingerprint, (uint8*) der_certs_[0].data(),
         der_certs_[0].size());
     DCHECK_EQ(SECSuccess, rv);
@@ skipping 20 matching lines @@
 
  private:
   void ResolutionComplete(int status) {
     DCHECK(CalledOnValidThread());
 
     if (status == ERR_NAME_NOT_RESOLVED ||
         (status == OK && response_.rrdatas.empty())) {
       LOG(ERROR) << "FAILED"
                  << " hostname:" << hostname_
                  << " domain:" << domain_;
-      Singleton<DnsCertLimits>::get()->DidUpload(hostname_);
+      g_dns_cert_limits.Get().DidUpload(hostname_);
       delegate_->OnDnsCertLookupFailed(hostname_, der_certs_);
     } else if (status == OK) {
       LOG(ERROR) << "GOOD"
                  << " hostname:" << hostname_
                  << " resp:" << response_.rrdatas[0];
     } else {
       LOG(ERROR) << "Unknown error " << status << " for " << domain_;
     }
 
     delete this;
@@ skipping 161 matching lines @@
 
 DnsCertProvenanceChecker::Delegate::~Delegate() {
 }
 
 DnsCertProvenanceChecker::~DnsCertProvenanceChecker() {
 }
 
 }  // namespace net
 
 #endif  // USE_OPENSSL