Always enable the STATE_LOAD_SSL_HOST_INFO state to verify the crash fix

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 593 matching lines @@
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv);
     return rv;
   }
 
   rv = InitializeSSLPeerName();
   if (rv != OK) {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv);
     return rv;
   }
 
-  if (ssl_config_.cached_info_enabled && ssl_host_info_.get()) {
+  if (ssl_host_info_.get()) {
     GotoState(STATE_LOAD_SSL_HOST_INFO);
   } else {
     GotoState(STATE_HANDSHAKE);
   }
 
   rv = DoHandshakeLoop(OK);
   if (rv == ERR_IO_PENDING) {
     user_connect_callback_ = callback;
   } else {
     net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SSL_CONNECT, rv);
@@ skipping 730 matching lines @@
   } while (rv == ERR_IO_PENDING && network_moved);
 
   LeaveFunction("");
   return rv;
 }
 
 bool SSLClientSocketNSS::LoadSSLHostInfo() {
   const SSLHostInfo::State& state(ssl_host_info_->state());
 
   if (state.certs.empty())
-    return false;
+    return true;
 
   SECStatus rv;
   const std::vector<std::string>& certs_in = state.certs;
   scoped_array<CERTCertificate*> certs(new CERTCertificate*[certs_in.size()]);
 
   for (size_t i = 0; i < certs_in.size(); i++) {
     SECItem derCert;
     derCert.data =
       const_cast<uint8*>(reinterpret_cast<const uint8*>(certs_in[i].data()));
     derCert.len = certs_in[i].size();
     certs[i] = CERT_NewTempCertificate(
         CERT_GetDefaultCertDB(), &derCert, NULL /* no nickname given */,
         PR_FALSE /* not permanent */, PR_TRUE /* copy DER data */);
     if (!certs[i]) {
       DestroyCertificates(&certs[0], i);
       NOTREACHED();
       return false;
     }
   }
 
   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() {
-  int rv;
-
   EnterFunction("");
-  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())
+    if (ssl_config_.cached_info_enabled && !LoadSSLHostInfo())
       LOG(WARNING) << "LoadSSLHostInfo failed: " << host_and_port_.ToString();
   } else {
     DCHECK_EQ(ERR_IO_PENDING, rv);
     GotoState(STATE_LOAD_SSL_HOST_INFO);
   }
 
   LeaveFunction("");
   return rv;
 }
 
@@ skipping 1033 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