base::Bind: Convert SSLHostInfo::WaitForDataReady.

net/socket/ssl_client_socket_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.
 
 // This file includes code SSLClientSocketNSS::DoVerifyCertComplete() derived
 // from AuthCertificateCallback() in
 // mozilla/security/manager/ssl/src/nsNSSCallbacks.cpp.
 
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
@@ skipping 47 matching lines @@
 #include <sechash.h>
 #include <ssl.h>
 #include <sslerr.h>
 #include <sslproto.h>
 
 #include <algorithm>
 #include <limits>
 #include <map>
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "crypto/rsa_private_key.h"
@@ skipping 354 matching lines @@
                                        SSLHostInfo* ssl_host_info,
                                        const SSLClientSocketContext& context)
     : ALLOW_THIS_IN_INITIALIZER_LIST(buffer_send_callback_(
           this, &SSLClientSocketNSS::BufferSendComplete)),
       ALLOW_THIS_IN_INITIALIZER_LIST(buffer_recv_callback_(
           this, &SSLClientSocketNSS::BufferRecvComplete)),
       transport_send_busy_(false),
       transport_recv_busy_(false),
       corked_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(handshake_io_callback_(
-          this, &SSLClientSocketNSS::OnHandshakeIOComplete)),
+          base::Bind(&SSLClientSocketNSS::OnHandshakeIOComplete,
+                     base::Unretained(this)))),
       transport_(transport_socket),
       host_and_port_(host_and_port),
       ssl_config_(ssl_config),
       user_connect_callback_(NULL),
       user_read_callback_(NULL),
       user_write_callback_(NULL),
       user_read_buf_len_(0),
       user_write_buf_len_(0),
       server_cert_nss_(NULL),
       server_cert_verify_result_(NULL),
@@ skipping 926 matching lines @@
 
   rv = SSL_SetPredictedPeerCertificates(nss_fd_, certs.get(), certs_in.size());
   DestroyCertificates(&certs[0], certs_in.size());
   DCHECK_EQ(SECSuccess, rv);
 
   return true;
 }
 
 int SSLClientSocketNSS::DoLoadSSLHostInfo() {
   EnterFunction("");
-  int rv = ssl_host_info_->WaitForDataReady(&handshake_io_callback_);
+  int rv = ssl_host_info_->WaitForDataReady(handshake_io_callback_);
   GotoState(STATE_HANDSHAKE);
 
   if (rv == OK) {
     if (!LoadSSLHostInfo())
       LOG(WARNING) << "LoadSSLHostInfo failed: " << host_and_port_.ToString();
   } else {
     DCHECK_EQ(ERR_IO_PENDING, rv);
     GotoState(STATE_LOAD_SSL_HOST_INFO);
   }
 
@@ skipping 260 matching lines @@
     // chain. So, if the prediction was correct, we should wait for that
     // verification to finish rather than start our own.
     net_log_.AddEvent(NetLog::TYPE_SSL_VERIFICATION_MERGED, NULL);
     UMA_HISTOGRAM_ENUMERATION("Net.SSLVerificationMerged", 1 /* true */, 2);
     base::TimeTicks end_time = ssl_host_info_->verification_end_time();
     if (end_time.is_null())
       end_time = base::TimeTicks::Now();
     UMA_HISTOGRAM_TIMES("Net.SSLVerificationMergedMsSaved",
                         end_time - ssl_host_info_->verification_start_time());
     server_cert_verify_result_ = &ssl_host_info_->cert_verify_result();
-    return ssl_host_info_->WaitForCertVerification(&handshake_io_callback_);
+    return ssl_host_info_->WaitForCertVerification(handshake_io_callback_);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Net.SSLVerificationMerged", 0 /* false */, 2);
   }
 
   int flags = 0;
   if (ssl_config_.rev_checking_enabled)
     flags |= X509Certificate::VERIFY_REV_CHECKING_ENABLED;
   if (ssl_config_.verify_ev_cert)
     flags |= X509Certificate::VERIFY_EV_CERT;
   verifier_.reset(new SingleRequestCertVerifier(cert_verifier_));
@@ skipping 187 matching lines @@
 }
 
 // SaveSSLHostInfo saves the certificate chain of the connection so that we can
 // start verification faster in the future.
 void SSLClientSocketNSS::SaveSSLHostInfo() {
   if (!ssl_host_info_.get())
     return;
 
   // If the SSLHostInfo hasn't managed to load from disk yet then we can't save
   // anything.
-  if (ssl_host_info_->WaitForDataReady(NULL) != OK)
+  if (ssl_host_info_->WaitForDataReady(net::CompletionCallback()) != OK)
     return;
 
   SSLHostInfo::State* state = ssl_host_info_->mutable_state();
 
   state->certs.clear();
   PeerCertificateChain certs(nss_fd_);
   for (unsigned i = 0; i < certs.size(); i++) {
     if (certs[i]->derCert.len > std::numeric_limits<uint16>::max())
       return;
 
@@ skipping 727 matching lines @@
   valid_thread_id_ = base::PlatformThread::CurrentId();
 }
 
 bool SSLClientSocketNSS::CalledOnValidThread() const {
   EnsureThreadIdAssigned();
   base::AutoLock auto_lock(lock_);
   return valid_thread_id_ == base::PlatformThread::CurrentId();
 }
 
 }  // namespace net