base::Bind: Convert SSLHostInfo::WaitForDataReady.

net/socket/ssl_host_info.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/socket/ssl_host_info.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/string_piece.h"
@@ skipping 14 matching lines @@
 }
 
 SSLHostInfo::SSLHostInfo(
     const std::string& hostname,
     const SSLConfig& ssl_config,
     CertVerifier* cert_verifier)
     : cert_verification_complete_(false),
       cert_verification_error_(ERR_CERT_INVALID),
       hostname_(hostname),
       cert_parsing_failed_(false),
-      cert_verification_callback_(NULL),
       rev_checking_enabled_(ssl_config.rev_checking_enabled),
       verify_ev_cert_(ssl_config.verify_ev_cert),
       verifier_(cert_verifier),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       dnsrr_resolver_(NULL),
       dns_callback_(NULL),
       dns_handle_(DnsRRResolver::kInvalidHandle) {
 }
 
 SSLHostInfo::~SSLHostInfo() {
@@ skipping 83 matching lines @@
       verification_end_time_ = base::TimeTicks();
       int rv = verifier_.Verify(
           cert_.get(), hostname_, flags, crl_set_, &cert_verify_result_,
           base::Bind(&SSLHostInfo::VerifyCallback, weak_factory_.GetWeakPtr()),
           // TODO(willchan): Figure out how to use NetLog here.
           BoundNetLog());
       if (rv != ERR_IO_PENDING)
         VerifyCallback(rv);
     } else {
       cert_parsing_failed_ = true;
-      DCHECK(!cert_verification_callback_);
+      DCHECK(cert_verification_callback_.is_null());
     }
   }
 
   return true;
 }
 
 std::string SSLHostInfo::Serialize() const {
   Pickle p(sizeof(Pickle::Header));
 
   static const unsigned kMaxCertificatesSize = 32 * 1024;
@@ skipping 24 matching lines @@
     return "";
   }
 
   return std::string(reinterpret_cast<const char *>(p.data()), p.size());
 }
 
 const CertVerifyResult& SSLHostInfo::cert_verify_result() const {
   return cert_verify_result_;
 }
 
-int SSLHostInfo::WaitForCertVerification(OldCompletionCallback* callback) {
+int SSLHostInfo::WaitForCertVerification(const CompletionCallback& callback) {
   if (cert_verification_complete_)
     return cert_verification_error_;
+
   DCHECK(!cert_parsing_failed_);
-  DCHECK(!cert_verification_callback_);
+  DCHECK(cert_verification_callback_.is_null());
   DCHECK(!state_.certs.empty());
   cert_verification_callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 void SSLHostInfo::VerifyCallback(int rv) {
   DCHECK(!verification_start_time_.is_null());
   base::TimeTicks now = base::TimeTicks::Now();
   const base::TimeDelta duration = now - verification_start_time();
   bool is_google = hostname_ == "google.com" ||
                    (hostname_.size() > 11 &&
                     hostname_.rfind(".google.com") == hostname_.size() - 11);
   if (is_google) {
     UMA_HISTOGRAM_TIMES("Net.SSLHostInfoVerificationTimeMs_Google", duration);
   }
   UMA_HISTOGRAM_TIMES("Net.SSLHostInfoVerificationTimeMs", duration);
   VLOG(1) << "Verification took " << duration.InMilliseconds() << "ms";
   verification_end_time_ = now;
   cert_verification_complete_ = true;
   cert_verification_error_ = rv;
-  if (cert_verification_callback_) {
-    OldCompletionCallback* callback = cert_verification_callback_;
-    cert_verification_callback_ = NULL;
-    callback->Run(rv);
+  if (!cert_verification_callback_.is_null()) {
+    CompletionCallback callback = cert_verification_callback_;
+    cert_verification_callback_.Reset();
+    callback.Run(rv);
   }
 }
 
 SSLHostInfoFactory::~SSLHostInfoFactory() {}
 
 }  // namespace net