Remove HttpStreamFactoryImpl::Job::ssl_info_.

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2012 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/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 369 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("Net.HttpStreamFactoryJob.Main.State", state_,
                               STATE_MAX);
   } else if (job_type_ == ALTERNATIVE) {
     UMA_HISTOGRAM_ENUMERATION("Net.HttpStreamFactoryJob.Alt.NextState",
                               next_state_, STATE_MAX);
     UMA_HISTOGRAM_ENUMERATION("Net.HttpStreamFactoryJob.Alt.State", state_,
                               STATE_MAX);
   }
 }
 
-void HttpStreamFactoryImpl::Job::GetSSLInfo() {
+void HttpStreamFactoryImpl::Job::GetSSLInfo(SSLInfo* ssl_info) {
   DCHECK(using_ssl_);
   DCHECK(!establishing_tunnel_);
   DCHECK(connection_.get() && connection_->socket());
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
-  ssl_socket->GetSSLInfo(&ssl_info_);
+  ssl_socket->GetSSLInfo(ssl_info);
 }
 
 SpdySessionKey HttpStreamFactoryImpl::Job::GetSpdySessionKey() const {
   // In the case that we're using an HTTPS proxy for an HTTP url,
   // we look for a SPDY session *to* the proxy, instead of to the
   // origin server.
   if (!spdy_session_direct_) {
     return SpdySessionKey(proxy_info_.proxy_server().host_port_pair(),
                           ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
   }
@@ skipping 151 matching lines @@
   if (job_type_ == PRECONNECT) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnPreconnectsComplete,
                    ptr_factory_.GetWeakPtr()));
     return;
   }
 
   if (IsCertificateError(result)) {
     // Retrieve SSL information from the socket.
-    GetSSLInfo();
+    SSLInfo ssl_info;
+    GetSSLInfo(&ssl_info);
 
     next_state_ = STATE_WAITING_USER_ACTION;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnCertificateErrorCallback,
-                   ptr_factory_.GetWeakPtr(), result, ssl_info_));
+                   ptr_factory_.GetWeakPtr(), result, ssl_info));
     return;
   }
 
   switch (result) {
     case ERR_PROXY_AUTH_REQUESTED: {
       UMA_HISTOGRAM_BOOLEAN("Net.ProxyAuthRequested.HasConnection",
                             connection_.get() != NULL);
       if (!connection_.get()) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
@@ skipping 778 matching lines @@
   }
 
   should_reconsider_proxy_ = true;
   return error;
 }
 
 int HttpStreamFactoryImpl::Job::HandleCertificateError(int error) {
   DCHECK(using_ssl_);
   DCHECK(IsCertificateError(error));
 
-  SSLClientSocket* ssl_socket =
-      static_cast<SSLClientSocket*>(connection_->socket());
-  ssl_socket->GetSSLInfo(&ssl_info_);
+  SSLInfo ssl_info;
+  GetSSLInfo(&ssl_info);
 
-  if (!ssl_info_.cert) {
+  if (!ssl_info.cert) {
     // If the server's certificate could not be parsed, there is no way
     // to gracefully recover this, so just pass the error up.
     return error;
   }
 
   // Add the bad certificate to the set of allowed certificates in the
   // SSL config object. This data structure will be consulted after calling
   // RestartIgnoringLastError(). And the user will be asked interactively
   // before RestartIgnoringLastError() is ever called.
-  server_ssl_config_.allowed_bad_certs.emplace_back(ssl_info_.cert,
-                                                    ssl_info_.cert_status);
+  server_ssl_config_.allowed_bad_certs.emplace_back(ssl_info.cert,
+                                                    ssl_info.cert_status);
 
   int load_flags = request_info_.load_flags;
   if (session_->params().ignore_certificate_errors)
     load_flags |= LOAD_IGNORE_ALL_CERT_ERRORS;
-  if (ssl_socket->IgnoreCertError(error, load_flags))
+  if (SSLClientSocket::IgnoreCertError(error, load_flags))
     return OK;
   return error;
 }
 
 ClientSocketPoolManager::SocketGroupType
 HttpStreamFactoryImpl::Job::GetSocketGroup() const {
   std::string scheme = origin_url_.scheme();
   if (scheme == url::kHttpsScheme || scheme == url::kWssScheme)
     return ClientSocketPoolManager::SSL_GROUP;
 
@@ skipping 82 matching lines @@
     bool enable_ip_based_pooling,
     NetLog* net_log) {
   return base::MakeUnique<HttpStreamFactoryImpl::Job>(
       delegate, job_type, session, request_info, priority, proxy_info,
       server_ssl_config, proxy_ssl_config, destination, origin_url,
       AlternativeService(), alternative_proxy_server, enable_ip_based_pooling,
       net_log);
 }
 
 }  // namespace net