Split HttpNetworkSession::Params into two structs.

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 767 matching lines @@
   }
 
   // If an alternative proxy server was provided, use that.
   if (alternative_proxy_server_.is_valid()) {
     proxy_info_.UseProxyServer(alternative_proxy_server_);
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
       origin_url_, request_info_.method, &proxy_info_, io_callback_,
-      &pac_request_, session_->params().proxy_delegate, net_log_);
+      &pac_request_, session_->context().proxy_delegate, net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   net_log_.AddEvent(
       NetLogEventType::HTTP_STREAM_JOB_PROXY_SERVER_RESOLVED,
       base::Bind(
           &NetLogHttpStreamJobProxyServerResolved,
           proxy_info_.is_empty() ? ProxyServer() : proxy_info_.proxy_server()));
@@ skipping 407 matching lines @@
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "462811 HttpStreamFactoryImpl::Job::DoCreateStream"));
   DCHECK(connection_->socket() || existing_spdy_session_.get() || using_quic_);
   DCHECK(!IsQuicAlternative());
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
 
   if (using_ssl_ && connection_->socket()) {
     SSLClientSocket* ssl_socket =
         static_cast<SSLClientSocket*>(connection_->socket());
-    RecordChannelIDKeyMatch(ssl_socket, session_->params().channel_id_service,
+    RecordChannelIDKeyMatch(ssl_socket, session_->context().channel_id_service,
                             destination_.HostForURL());
   }
 
   // We only set the socket motivation if we're the first to use
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   if (!using_spdy_) {
@@ skipping 71 matching lines @@
   // bubble up to the request.
   return SetSpdyHttpStreamOrBidirectionalStreamImpl(new_spdy_session_,
                                                     spdy_session_direct_);
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
   session_->proxy_service()->ReportSuccess(proxy_info_,
-                                           session_->params().proxy_delegate);
+                                           session_->context().proxy_delegate);
   next_state_ = STATE_NONE;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuth() {
   next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
   ProxyClientSocket* proxy_socket =
       static_cast<ProxyClientSocket*>(connection_->socket());
   return proxy_socket->RestartWithAuth(io_callback_);
 }
@@ skipping 159 matching lines @@
     return error;
   }
 
   if (proxy_info_.is_https() && proxy_ssl_config_.send_client_cert) {
     session_->ssl_client_auth_cache()->Remove(
         proxy_info_.proxy_server().host_port_pair());
   }
 
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
       request_info_.url, request_info_.method, error, &proxy_info_,
-      io_callback_, &pac_request_, session_->params().proxy_delegate, net_log_);
+      io_callback_, &pac_request_, session_->context().proxy_delegate,
+      net_log_);
   if (rv == OK || rv == ERR_IO_PENDING) {
     // If the error was during connection setup, there is no socket to
     // disconnect.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
     delegate_->RemoveRequestFromSpdySessionRequestMapForJob(this);
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
@@ skipping 59 matching lines @@
 
   ConnectionAttempts socket_attempts = connection_->connection_attempts();
   if (connection_->socket()) {
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
   }
 
   delegate_->AddConnectionAttemptsToRequest(this, socket_attempts);
 }
 
 }  // namespace net