net: clean up SSLHostInfo construction.

net/socket/ssl_client_socket_nss.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.
 
 // 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 380 matching lines @@
 
 }  // namespace
 
 #if defined(OS_WIN)
 // static
 HCERTSTORE SSLClientSocketNSS::cert_store_ = NULL;
 #endif
 
 SSLClientSocketNSS::SSLClientSocketNSS(ClientSocketHandle* transport_socket,
                                        const std::string& hostname,
-                                       const SSLConfig& ssl_config)
+                                       const SSLConfig& ssl_config,
+                                       SSLHostInfo* ssl_host_info)
     : 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)),
       transport_(transport_socket),
@@ skipping 10 matching lines @@
       completed_handshake_(false),
       pseudo_connected_(false),
       eset_mitm_detected_(false),
       netnanny_mitm_detected_(false),
       dnssec_provider_(NULL),
       next_handshake_state_(STATE_NONE),
       nss_fd_(NULL),
       nss_bufs_(NULL),
       net_log_(transport_socket->socket()->NetLog()),
       predicted_npn_status_(kNextProtoUnsupported),
-      predicted_npn_proto_used_(false) {
+      predicted_npn_proto_used_(false),
+      ssl_host_info_(ssl_host_info) {
   EnterFunction("");
 }
 
 SSLClientSocketNSS::~SSLClientSocketNSS() {
   EnterFunction("");
   Disconnect();
   LeaveFunction("");
 }
 
 int SSLClientSocketNSS::Init() {
@@ skipping 15 matching lines @@
 }
 
 // This is a version number of the Snap Start information saved by
 // |SaveSnapStartInfo| and loaded by |LoadSnapStartInfo|. Since the information
 // can be saved on disk we might have version skew in the future. Any data with
 // a different version is ignored by |LoadSnapStartInfo|.
 static const uint8 kSnapStartInfoVersion = 0;
 
 // SaveSnapStartInfo serialises the information needed to perform a Snap Start
 // with this server in the future (if any) and tells
-// |ssl_config_.ssl_host_info| to preserve it.
+// |ssl_host_info_| to preserve it.
 void SSLClientSocketNSS::SaveSnapStartInfo() {
-  if (!ssl_config_.ssl_host_info.get())
+  if (!ssl_host_info_.get())
     return;
 
   SECStatus rv;
   SSLSnapStartResult snap_start_type;
   rv = SSL_GetSnapStartResult(nss_fd_, &snap_start_type);
   if (rv != SECSuccess) {
     NOTREACHED();
     return;
   }
   LOG(ERROR) << "Snap Start: " << snap_start_type << " " << hostname_;
@@ skipping 102 matching lines @@
        node = CERT_LIST_NEXT(node), i++) {
     data[j++] = node->cert->derCert.len >> 8;
     data[j++] = node->cert->derCert.len;
     memcpy(&data[j], node->cert->derCert.data, node->cert->derCert.len);
     j += node->cert->derCert.len;
   }
 
   DCHECK_EQ(j, len);
 
   LOG(ERROR) << "Setting Snap Start info " << hostname_ << " " << len;
-  ssl_config_.ssl_host_info->Set(std::string(
+  ssl_host_info_->Set(std::string(
         reinterpret_cast<const char *>(&data[0]), len));
 
   CERT_DestroyCertList(cert_list);
 }
 
 static void DestroyCertificates(CERTCertificate** certs, unsigned len) {
   for (unsigned i = 0; i < len; i++)
     CERT_DestroyCertificate(certs[i]);
 }
 
@@ skipping 123 matching lines @@
     net_log_.EndEvent(NetLog::TYPE_SSL_CONNECT, NULL);
     return rv;
   }
 
   rv = InitializeSSLOptions();
   if (rv != OK) {
     net_log_.EndEvent(NetLog::TYPE_SSL_CONNECT, NULL);
     return rv;
   }
 
-  if (ssl_config_.snap_start_enabled && ssl_config_.ssl_host_info.get()) {
+  if (ssl_config_.snap_start_enabled && ssl_host_info_.get()) {
     GotoState(STATE_SNAP_START_LOAD_INFO);
   } else {
     GotoState(STATE_HANDSHAKE);
   }
 
   rv = DoHandshakeLoop(OK);
   if (rv == ERR_IO_PENDING) {
     if (pseudo_connected_) {
       net_log_.EndEvent(NetLog::TYPE_SSL_CONNECT, NULL);
       rv = OK;
@@ skipping 1212 matching lines @@
 
   that->handshake_callback_called_ = true;
 
   that->UpdateServerCert();
 
   that->CheckSecureRenegotiation();
 }
 
 int SSLClientSocketNSS::DoSnapStartLoadInfo() {
   EnterFunction("");
-  int rv = ssl_config_.ssl_host_info->WaitForDataReady(&handshake_io_callback_);
+  int rv = ssl_host_info_->WaitForDataReady(&handshake_io_callback_);
 
   if (rv == OK) {
     LOG(ERROR) << "SSL host info size " << hostname_ << " "
-               << ssl_config_.ssl_host_info->data().size();
-    if (LoadSnapStartInfo(ssl_config_.ssl_host_info->data())) {
+               << ssl_host_info_->data().size();
+    if (LoadSnapStartInfo(ssl_host_info_->data())) {
       pseudo_connected_ = true;
       GotoState(STATE_SNAP_START_WAIT_FOR_WRITE);
       if (user_connect_callback_)
         DoConnectCallback(OK);
     } else {
       GotoState(STATE_HANDSHAKE);
     }
   } else {
     DCHECK_EQ(ERR_IO_PENDING, rv);
     GotoState(STATE_SNAP_START_LOAD_INFO);
@@ skipping 59 matching lines @@
       LOG(WARNING) << "Couldn't invalidate SSL session: " << PR_GetError();
     }
   } else if (rv == SECSuccess) {
     if (handshake_callback_called_) {
       if (eset_mitm_detected_) {
         net_error = ERR_ESET_ANTI_VIRUS_SSL_INTERCEPTION;
       } else if (netnanny_mitm_detected_) {
         net_error = ERR_NETNANNY_SSL_INTERCEPTION;
       } else {
         SaveSnapStartInfo();
-        // SSL handshake is completed. It's possible that we mispredicted the NPN
-        // agreed protocol. In this case, we've just sent a request in the wrong
-        // protocol! The higher levels of this network stack aren't prepared for
-        // switching the protocol like that so we make up an error and rely on
-        // the fact that the request will be retried.
+        // SSL handshake is completed. It's possible that we mispredicted the
+        // NPN agreed protocol. In this case, we've just sent a request in the
+        // wrong protocol! The higher levels of this network stack aren't
+        // prepared for switching the protocol like that so we make up an error
+        // and rely on the fact that the request will be retried.
         if (IsNPNProtocolMispredicted()) {
           LOG(WARNING) << "Mispredicted NPN protocol for " << hostname_;
           net_error = ERR_SSL_SNAP_START_NPN_MISPREDICTION;
         } else {
           // Let's verify the certificate.
           GotoState(STATE_VERIFY_DNSSEC);
         }
       }
       // Done!
     } else {
@@ skipping 374 matching lines @@
     return ERR_IO_PENDING;
   }
   LeaveFunction("");
   rv = MapNSPRError(prerr);
   net_log_.AddEvent(NetLog::TYPE_SSL_WRITE_ERROR,
                     new SSLErrorParams(rv, prerr));
   return rv;
 }
 
 }  // namespace net