Split HttpNetworkSession::Params into two structs.

net/quic/chromium/quic_network_transaction_unittest.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 <algorithm>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 482 matching lines @@
       bool should_include_version,
       bool fin,
       SpdyHeaderBlock headers,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacketWithOffsetTracking(
         packet_number, stream_id, should_include_version, fin,
         std::move(headers), offset);
   }
 
   void CreateSession() {
-    params_.enable_quic = true;
-    params_.quic_clock = &clock_;
-    params_.quic_random = &random_generator_;
-    params_.client_socket_factory = &socket_factory_;
-    params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
-    params_.host_resolver = &host_resolver_;
-    params_.cert_verifier = &cert_verifier_;
-    params_.transport_security_state = &transport_security_state_;
-    params_.cert_transparency_verifier = cert_transparency_verifier_.get();
-    params_.ct_policy_enforcer = &ct_policy_enforcer_;
-    params_.socket_performance_watcher_factory =
+    session_params_.enable_quic = true;
+    session_params_.quic_supported_versions = SupportedVersions(version_);
+
+    session_context_.quic_clock = &clock_;
+    session_context_.quic_random = &random_generator_;
+    session_context_.client_socket_factory = &socket_factory_;
+    session_context_.quic_crypto_client_stream_factory =
+        &crypto_client_stream_factory_;
+    session_context_.host_resolver = &host_resolver_;
+    session_context_.cert_verifier = &cert_verifier_;
+    session_context_.transport_security_state = &transport_security_state_;
+    session_context_.cert_transparency_verifier =
+        cert_transparency_verifier_.get();
+    session_context_.ct_policy_enforcer = &ct_policy_enforcer_;
+    session_context_.socket_performance_watcher_factory =
         &test_socket_performance_watcher_factory_;
-    params_.proxy_service = proxy_service_.get();
-    params_.ssl_config_service = ssl_config_service_.get();
-    params_.http_auth_handler_factory = auth_handler_factory_.get();
-    params_.http_server_properties = &http_server_properties_;
-    params_.quic_supported_versions = SupportedVersions(version_);
-    params_.net_log = net_log_.bound().net_log();
+    session_context_.proxy_service = proxy_service_.get();
+    session_context_.ssl_config_service = ssl_config_service_.get();
+    session_context_.http_auth_handler_factory = auth_handler_factory_.get();
+    session_context_.http_server_properties = &http_server_properties_;
+    session_context_.net_log = net_log_.bound().net_log();
 
-    session_.reset(new HttpNetworkSession(params_));
+    session_.reset(new HttpNetworkSession(session_params_, session_context_));
     session_->quic_stream_factory()->set_require_confirmation(false);
   }
 
   void CheckWasQuicResponse(HttpNetworkTransaction* trans) {
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != nullptr);
     ASSERT_TRUE(response->headers.get() != nullptr);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
     EXPECT_TRUE(response->was_fetched_via_spdy);
     EXPECT_TRUE(response->was_alpn_negotiated);
@@ skipping 157 matching lines @@
     socket_factory_.AddSocketDataProvider(&http_data_1);
     socket_factory_.AddSocketDataProvider(&http_data_2);
     socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
     socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
     TestProxyDelegate test_proxy_delegate;
     // Proxy URL is different from the request URL.
     test_proxy_delegate.set_alternative_proxy_server(
         ProxyServer::FromPacString("QUIC myproxy.org:443"));
 
-    params_.proxy_delegate = &test_proxy_delegate;
+    session_context_.proxy_delegate = &test_proxy_delegate;
     proxy_service_ =
         ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
 
     CreateSession();
     EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_valid());
 
     // The first request should be fetched via the HTTPS proxy.
     SendRequestAndExpectHttpResponseFromProxy("hello from http", true, 443);
 
     // Even through the alternative proxy server job failed, the proxy should
@@ skipping 29 matching lines @@
   MockCertVerifier cert_verifier_;
   TransportSecurityState transport_security_state_;
   std::unique_ptr<CTVerifier> cert_transparency_verifier_;
   CTPolicyEnforcer ct_policy_enforcer_;
   TestSocketPerformanceWatcherFactory test_socket_performance_watcher_factory_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   std::unique_ptr<ProxyService> proxy_service_;
   std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   MockRandom random_generator_;
   HttpServerPropertiesImpl http_server_properties_;
-  HttpNetworkSession::Params params_;
+  HttpNetworkSession::Params session_params_;
+  HttpNetworkSession::Context session_context_;
   HttpRequestInfo request_;
   BoundTestNetLog net_log_;
   std::vector<std::unique_ptr<StaticSocketDataProvider>> hanging_data_;
   SSLSocketDataProvider ssl_data_;
 
  private:
   void SendRequestAndExpectQuicResponseMaybeFromProxy(
       const std::string& expected,
       bool used_proxy,
       uint16_t port) {
@@ skipping 13 matching lines @@
       EXPECT_TRUE(trans.GetResponseInfo()->proxy_server.is_direct());
     }
   }
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         QuicNetworkTransactionTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 TEST_P(QuicNetworkTransactionTest, SocketWatcherEnabled) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
@@ skipping 10 matching lines @@
   test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(true);
 
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, SocketWatcherDisabled) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
@@ skipping 10 matching lines @@
   test_socket_performance_watcher_factory_.set_should_notify_updated_rtt(false);
 
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_FALSE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
@@ skipping 43 matching lines @@
       entries, 0, NetLogEventType::QUIC_SESSION_STREAM_FRAME_RECEIVED,
       NetLogEventPhase::NONE);
   EXPECT_LT(0, pos);
 
   int log_stream_id;
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &log_stream_id));
   EXPECT_EQ(3, log_stream_id);
 }
 
 TEST_P(QuicNetworkTransactionTest, LargeResponseHeaders) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK");
@@ skipping 29 matching lines @@
       ConstructClientAckPacket(4, packet_number, 3, 1));
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, TooLargeResponseHeaders) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   SpdyHeaderBlock response_headers = GetResponseHeaders("200 OK");
@@ skipping 35 matching lines @@
   CreateSession();
 
   HttpNetworkTransaction trans(DEFAULT_PRIORITY, session_.get());
   TestCompletionCallback callback;
   int rv = trans.Start(&request_, callback.callback(), net_log_.bound());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuicForAll) {
-  params_.origins_to_force_quic_on.insert(HostPortPair());
+  session_params_.origins_to_force_quic_on.insert(HostPortPair());
 
   AddQuicAlternateProtocolMapping(MockCryptoClientStream::CONFIRM_HANDSHAKE);
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   mock_quic_data.AddRead(ConstructServerResponseHeadersPacket(
       1, GetNthClientInitiatedStreamId(0), false, false,
       GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(ConstructServerDataPacket(
       2, GetNthClientInitiatedStreamId(0), false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructClientAckPacket(3, 2, 1, 1));
   mock_quic_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);  // No more data to read
 
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   CreateSession();
 
   SendRequestAndExpectQuicResponse("hello!");
   EXPECT_TRUE(
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicProxy) {
-  params_.enable_quic = true;
+  session_params_.enable_quic = true;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("QUIC mail.example.org:70");
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "http", "/"), &header_stream_offset));
@@ skipping 21 matching lines @@
       test_socket_performance_watcher_factory_.rtt_notification_received());
 }
 
 // Regression test for https://crbug.com/492458.  Test that for an HTTP
 // connection through a QUIC proxy, the certificate exhibited by the proxy is
 // checked against the proxy hostname, not the origin hostname.
 TEST_P(QuicNetworkTransactionTest, QuicProxyWithCert) {
   const std::string origin_host = "mail.example.com";
   const std::string proxy_host = "www.example.org";
 
-  params_.enable_quic = true;
+  session_params_.enable_quic = true;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("QUIC " + proxy_host + ":70");
 
   client_maker_.set_hostname(origin_host);
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
@@ skipping 144 matching lines @@
 
   // The retry logic must hide the 421 status. The transaction succeeds on
   // |http_data|.
   EXPECT_THAT(callback.WaitForResult(), IsOk());
   CheckWasHttpResponse(&trans);
   CheckResponsePort(&trans, 443);
   CheckResponseData(&trans, "hello!");
 }
 
 TEST_P(QuicNetworkTransactionTest, ForceQuicWithErrorConnecting) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data1;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data1.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data1.AddRead(ASYNC, ERR_SOCKET_NOT_CONNECTED);
   MockQuicData mock_quic_data2;
   header_stream_offset = 0;
   mock_quic_data2.AddWrite(
@@ skipping 13 matching lines @@
     TestCompletionCallback callback;
     int rv = trans.Start(&request_, callback.callback(), net_log_.bound());
     EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
     EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
     EXPECT_EQ(1 + i, test_socket_performance_watcher_factory_.watcher_count());
   }
 }
 
 TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
   // Attempt to "force" quic on 443, which will not be honored.
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("www.google.com:443"));
 
   MockRead http_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider data(http_reads, arraysize(http_reads), nullptr, 0);
   socket_factory_.AddSocketDataProvider(&data);
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 248 matching lines @@
   // because of migrating port.
   NetErrorDetails details;
   EXPECT_FALSE(details.quic_port_migration_detected);
   trans.PopulateNetErrorDetails(&details);
   EXPECT_TRUE(details.quic_port_migration_detected);
 }
 
 // Verify that if a QUIC connection times out, the QuicHttpStream will
 // return QUIC_PROTOCOL_ERROR.
 TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmed) {
-  params_.quic_idle_connection_timeout_seconds = 5;
+  session_params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 69 matching lines @@
   quic_task_runner_->RunUntilIdle();
 
   ExpectQuicAlternateProtocolMapping();
   ASSERT_TRUE(quic_data.AllWriteDataConsumed());
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
 }
 
 // Verify that if a QUIC connection RTOs, the QuicHttpStream will
 // return QUIC_PROTOCOL_ERROR.
 TEST_P(QuicNetworkTransactionTest, TooManyRtosAfterHandshakeConfirmed) {
-  params_.quic_connection_options.push_back(k5RTO);
+  session_params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 78 matching lines @@
 
   ExpectQuicAlternateProtocolMapping();
   ASSERT_TRUE(quic_data.AllWriteDataConsumed());
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
 }
 
 // Verify that if a QUIC connection RTOs, while there are no active streams
 // QUIC will not be marked as broken.
 TEST_P(QuicNetworkTransactionTest,
        TooManyRtosAfterHandshakeConfirmedAndStreamReset) {
-  params_.quic_connection_options.push_back(k5RTO);
+  session_params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 146 matching lines @@
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_QUIC_PROTOCOL_ERROR));
   ExpectQuicAlternateProtocolMapping();
   ASSERT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC
 // connection times out, then QUIC will be marked as broken and the request
 // retried over TCP.
 TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken) {
-  params_.mark_quic_broken_when_network_blackholes = true;
-  params_.quic_idle_connection_timeout_seconds = 5;
+  session_params_.mark_quic_broken_when_network_blackholes = true;
+  session_params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 95 matching lines @@
   // Read the response body over TCP.
   CheckResponseData(&trans, "hello world");
   ASSERT_TRUE(http_data.AllWriteDataConsumed());
   ASSERT_TRUE(http_data.AllReadDataConsumed());
 }
 
 // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC
 // connection times out, then QUIC will be marked as broken and the request
 // retried over TCP.
 TEST_P(QuicNetworkTransactionTest, TimeoutAfterHandshakeConfirmedThenBroken2) {
-  params_.retry_without_alt_svc_on_quic_errors = true;
-  params_.quic_idle_connection_timeout_seconds = 5;
+  session_params_.retry_without_alt_svc_on_quic_errors = true;
+  session_params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 98 matching lines @@
   ExpectBrokenAlternateProtocolMapping();
   ASSERT_TRUE(http_data.AllWriteDataConsumed());
   ASSERT_TRUE(http_data.AllReadDataConsumed());
 }
 
 // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC
 // connection times out, then QUIC will be marked as broken but the request
 // will not be retried over TCP.
 TEST_P(QuicNetworkTransactionTest,
        TimeoutAfterHandshakeConfirmedAndHeadersThenBrokenNotRetried) {
-  params_.mark_quic_broken_when_network_blackholes = true;
-  params_.quic_idle_connection_timeout_seconds = 5;
+  session_params_.mark_quic_broken_when_network_blackholes = true;
+  session_params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 90 matching lines @@
   std::string response_data;
   ASSERT_THAT(ReadTransaction(&trans, &response_data),
               IsError(ERR_QUIC_PROTOCOL_ERROR));
 }
 
 // Verify that with mark_quic_broken_when_network_blackholes enabled, if a QUIC
 // connection RTOs, then QUIC will be marked as broken and the request retried
 // over TCP.
 TEST_P(QuicNetworkTransactionTest,
        TooManyRtosAfterHandshakeConfirmedThenBroken) {
-  params_.mark_quic_broken_when_network_blackholes = true;
-  params_.quic_connection_options.push_back(k5RTO);
+  session_params_.mark_quic_broken_when_network_blackholes = true;
+  session_params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 103 matching lines @@
   // Read the response body over TCP.
   CheckResponseData(&trans, "hello world");
   ASSERT_TRUE(http_data.AllWriteDataConsumed());
   ASSERT_TRUE(http_data.AllReadDataConsumed());
 }
 
 // Verify that if a QUIC connection RTOs, while there are no active streams
 // QUIC will be marked as broken.
 TEST_P(QuicNetworkTransactionTest,
        TooManyRtosAfterHandshakeConfirmedAndStreamResetThenBroken) {
-  params_.mark_quic_broken_when_network_blackholes = true;
-  params_.quic_connection_options.push_back(k5RTO);
+  session_params_.mark_quic_broken_when_network_blackholes = true;
+  session_params_.quic_connection_options.push_back(k5RTO);
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   SpdyPriority priority =
       ConvertRequestPriorityToQuicPriority(DEFAULT_PRIORITY);
 
   std::string request_data;
   quic_data.AddWrite(client_maker_.MakeRequestHeadersPacketAndSaveData(
       1, GetNthClientInitiatedStreamId(0), true, true, priority,
@@ skipping 86 matching lines @@
   ExpectBrokenAlternateProtocolMapping();
 
   ASSERT_TRUE(quic_data.AllWriteDataConsumed());
 }
 
 // Verify that with retry_without_alt_svc_on_quic_errors enabled, if a QUIC
 // protocol error occurs after the handshake is confirmed, the request
 // retried over TCP and the QUIC will be marked as broken.
 TEST_P(QuicNetworkTransactionTest,
        ProtocolErrorAfterHandshakeConfirmedThenBroken) {
-  params_.retry_without_alt_svc_on_quic_errors = true;
-  params_.quic_idle_connection_timeout_seconds = 5;
+  session_params_.retry_without_alt_svc_on_quic_errors = true;
+  session_params_.quic_idle_connection_timeout_seconds = 5;
 
   // The request will initially go out over QUIC.
   MockQuicData quic_data;
   QuicStreamOffset header_stream_offset = 0;
   quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       1, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   quic_data.AddWrite(ConstructInitialSettingsPacket(2, &header_stream_offset));
   // Peer sending data from an non-existing stream causes this end to raise
   // error and close connection.
@@ skipping 203 matching lines @@
 
   AddHangingNonAlternateProtocolSocketData();
 
   TestProxyDelegate test_proxy_delegate;
 
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443");
 
   test_proxy_delegate.set_alternative_proxy_server(
       ProxyServer::FromPacString("QUIC mail.example.org:443"));
-  params_.proxy_delegate = &test_proxy_delegate;
+  session_context_.proxy_delegate = &test_proxy_delegate;
 
   request_.url = GURL("http://mail.example.org/");
 
   CreateSession();
 
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443);
   histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage",
                                       1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */,
                                       1);
 
@@ skipping 386 matching lines @@
   mock_quic_data.AddSocketDataToFactory(&socket_factory_);
 
   // There is no need to set up main job, because no attempt will be made to
   // speak to the proxy over TCP.
   request_.url = GURL("http://mail.example.org/");
   TestProxyDelegate test_proxy_delegate;
   const HostPortPair host_port_pair("mail.example.org", 443);
 
   test_proxy_delegate.set_alternative_proxy_server(
       ProxyServer::FromPacString("QUIC mail.example.org:443"));
-  params_.proxy_delegate = &test_proxy_delegate;
+  session_context_.proxy_delegate = &test_proxy_delegate;
   CreateSession();
   EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic());
 
   // The main job needs to hang in order to guarantee that the alternative
   // proxy server job will "win".
   AddHangingNonAlternateProtocolSocketData();
 
   SendRequestAndExpectQuicResponseFromProxyOnPort("hello!", 443);
 
   // Verify that the alternative proxy server is not marked as broken.
@@ skipping 691 matching lines @@
                                      0);
   socket_factory_.AddSocketDataProvider(&http_data);
   socket_factory_.AddSSLSocketDataProvider(&ssl_data_);
 
   TestProxyDelegate test_proxy_delegate;
   const HostPortPair host_port_pair("myproxy.org", 443);
   test_proxy_delegate.set_alternative_proxy_server(
       ProxyServer::FromPacString("QUIC myproxy.org:443"));
   EXPECT_TRUE(test_proxy_delegate.alternative_proxy_server().is_quic());
 
-  params_.proxy_delegate = &test_proxy_delegate;
+  session_context_.proxy_delegate = &test_proxy_delegate;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
   request_.url = GURL("http://mail.example.org/");
 
   // In order for a new QUIC session to be established via alternate-protocol
   // without racing an HTTP connection, we need the host resolution to happen
   // synchronously.
   host_resolver_.set_synchronous_mode(true);
   host_resolver_.rules()->AddIPLiteralRule("myproxy.org", "192.168.0.1", "");
   HostResolver::RequestInfo info(HostPortPair("myproxy.org", 443));
@@ skipping 42 matching lines @@
 TEST_P(QuicNetworkTransactionTest,
        DISABLED_QuicUploadToAlternativeProxyServer) {
   base::HistogramTester histogram_tester;
   proxy_service_ =
       ProxyService::CreateFixedFromPacResult("HTTPS mail.example.org:443");
 
   TestProxyDelegate test_proxy_delegate;
 
   test_proxy_delegate.set_alternative_proxy_server(
       ProxyServer::FromPacString("QUIC mail.example.org:443"));
-  params_.proxy_delegate = &test_proxy_delegate;
+  session_context_.proxy_delegate = &test_proxy_delegate;
 
   request_.url = GURL("http://mail.example.org/");
 
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)};
   SequencedSocketData socket_data(reads, arraysize(reads), writes,
                                   arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
@@ skipping 18 matching lines @@
 
   // Verify that the proxy server is not marked as broken.
   EXPECT_TRUE(session_->proxy_service()->proxy_retry_info().empty());
 
   histogram_tester.ExpectUniqueSample("Net.QuicAlternativeProxy.Usage",
                                       1 /* ALTERNATIVE_PROXY_USAGE_WON_RACE */,
                                       1);
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicUpload) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING, 0)};
   MockWrite writes[] = {MockWrite(SYNCHRONOUS, ERR_FAILED, 1)};
   SequencedSocketData socket_data(reads, arraysize(reads), writes,
                                   arraysize(writes));
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   // The non-alternate protocol job needs to hang in order to guarantee that
   // the alternate-protocol job will "win".
@@ skipping 14 matching lines @@
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicUploadWriteError) {
   ScopedMockNetworkChangeNotifier network_change_notifier;
   MockNetworkChangeNotifier* mock_ncn =
       network_change_notifier.mock_network_change_notifier();
   mock_ncn->ForceNetworkHandlesSupported();
   mock_ncn->SetConnectedNetworksList(
       {kDefaultNetworkForTests, kNewNetworkForTests});
 
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
-  params_.quic_migrate_sessions_on_network_change = true;
+  session_params_.quic_migrate_sessions_on_network_change = true;
 
   MockQuicData socket_data;
   socket_data.AddRead(SYNCHRONOUS, ERR_IO_PENDING);
   QuicStreamOffset offset = 0;
   socket_data.AddWrite(ConstructInitialSettingsPacket(1, &offset));
   socket_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, false,
       GetRequestHeaders("POST", "https", "/"), &offset));
   socket_data.AddWrite(SYNCHRONOUS, ERR_FAILED);
   socket_data.AddSocketDataToFactory(&socket_factory_);
@@ skipping 22 matching lines @@
   upload_data.AppendData("1", 1, true);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_NE(OK, callback.WaitForResult());
   trans.reset();
   session_.reset();
 }
 
 // Adds coverage to catch regression such as https://crbug.com/622043
 TEST_P(QuicNetworkTransactionTest, QuicServerPush) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   QuicStreamOffset server_header_offset = 0;
@@ skipping 37 matching lines @@
   EXPECT_LT(0u, entries.size());
 
   // Check that we logged a QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM
   int pos = ExpectLogContainsSomewhere(
       entries, 0, NetLogEventType::QUIC_HTTP_STREAM_ADOPTED_PUSH_STREAM,
       NetLogEventPhase::NONE);
   EXPECT_LT(0, pos);
 }
 
 TEST_P(QuicNetworkTransactionTest, QuicForceHolBlocking) {
-  params_.quic_force_hol_blocking = true;
-  params_.origins_to_force_quic_on.insert(
+  session_params_.quic_force_hol_blocking = true;
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
 
   QuicStreamOffset offset = 0;
   mock_quic_data.AddWrite(ConstructInitialSettingsPacket(1, &offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, false,
       GetRequestHeaders("POST", "https", "/"), &offset));
 
@@ skipping 61 matching lines @@
   ~QuicURLRequestContext() override { AssertNoURLRequests(); }
 
   MockClientSocketFactory& socket_factory() { return *socket_factory_; }
 
  private:
   MockClientSocketFactory* socket_factory_;
   URLRequestContextStorage storage_;
 };
 
 TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullRequest) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/"));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
@@ skipping 38 matching lines @@
             request->GetTotalSentBytes());
   EXPECT_EQ(network_delegate.total_network_bytes_received(),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(static_cast<int>(expected_raw_header_response_size),
             request->raw_header_size());
   EXPECT_TRUE(mock_quic_data.AllReadDataConsumed());
   EXPECT_TRUE(mock_quic_data.AllWriteDataConsumed());
 }
 
 TEST_P(QuicNetworkTransactionTest, RawHeaderSizeSuccessfullPushHeadersFirst) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   SpdyHeaderBlock headers(GetRequestHeaders("GET", "https", "/"));
   headers["user-agent"] = "";
   headers["accept-encoding"] = "gzip, deflate";
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
@@ skipping 75 matching lines @@
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
         random_generator_(0),
         ssl_data_(ASYNC, OK) {}
 
   void SetUp() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::RunLoop().RunUntilIdle();
 
-    HttpNetworkSession::Params params;
+    HttpNetworkSession::Params session_params;
+    session_params.enable_quic = true;
+    session_params.quic_supported_versions = SupportedVersions(version_);
+
+    HttpNetworkSession::Context session_context;
 
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
-    params.quic_clock = &clock_;
+    session_context.quic_clock = &clock_;
 
     crypto_client_stream_factory_.set_handshake_mode(
         MockCryptoClientStream::CONFIRM_HANDSHAKE);
-    params.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
+    session_context.quic_crypto_client_stream_factory =
+        &crypto_client_stream_factory_;
 
-    params.enable_quic = true;
-    params.quic_random = &random_generator_;
-    params.client_socket_factory = &socket_factory_;
-    params.host_resolver = &host_resolver_;
-    params.cert_verifier = &cert_verifier_;
-    params.transport_security_state = &transport_security_state_;
-    params.cert_transparency_verifier = cert_transparency_verifier_.get();
-    params.ct_policy_enforcer = &ct_policy_enforcer_;
-    params.socket_performance_watcher_factory =
+    session_context.quic_random = &random_generator_;
+    session_context.client_socket_factory = &socket_factory_;
+    session_context.host_resolver = &host_resolver_;
+    session_context.cert_verifier = &cert_verifier_;
+    session_context.transport_security_state = &transport_security_state_;
+    session_context.cert_transparency_verifier =
+        cert_transparency_verifier_.get();
+    session_context.ct_policy_enforcer = &ct_policy_enforcer_;
+    session_context.socket_performance_watcher_factory =
         &test_socket_performance_watcher_factory_;
-    params.ssl_config_service = ssl_config_service_.get();
-    params.proxy_service = proxy_service_.get();
-    params.http_auth_handler_factory = auth_handler_factory_.get();
-    params.http_server_properties = &http_server_properties_;
-    params.quic_supported_versions = SupportedVersions(version_);
+    session_context.ssl_config_service = ssl_config_service_.get();
+    session_context.proxy_service = proxy_service_.get();
+    session_context.http_auth_handler_factory = auth_handler_factory_.get();
+    session_context.http_server_properties = &http_server_properties_;
 
-    session_.reset(new HttpNetworkSession(params));
+    session_.reset(new HttpNetworkSession(session_params, session_context));
     session_->quic_stream_factory()->set_require_confirmation(true);
   }
 
   void TearDown() override {
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     // Empty the current queue.
     base::RunLoop().RunUntilIdle();
     PlatformTest::TearDown();
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::RunLoop().RunUntilIdle();
@@ skipping 374 matching lines @@
 
   SendRequestAndExpectQuicResponse(origin1_);
   SendRequestAndExpectQuicResponse(origin2_);
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 // crbug.com/705109 - this confirms that matching request with a body
 // triggers a crash (pre-fix).
 TEST_P(QuicNetworkTransactionTest, QuicServerPushMatchesRequestWithBody) {
-  params_.origins_to_force_quic_on.insert(
+  session_params_.origins_to_force_quic_on.insert(
       HostPortPair::FromString("mail.example.org:443"));
 
   MockQuicData mock_quic_data;
   QuicStreamOffset header_stream_offset = 0;
   mock_quic_data.AddWrite(
       ConstructInitialSettingsPacket(1, &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, GetNthClientInitiatedStreamId(0), true, true,
       GetRequestHeaders("GET", "https", "/"), &header_stream_offset));
   QuicStreamOffset server_header_offset = 0;
@@ skipping 50 matching lines @@
 
   request_.url = GURL("https://mail.example.org/pushed.jpg");
   ChunkedUploadDataStream upload_data(0);
   upload_data.AppendData("1", 1, true);
   request_.upload_data_stream = &upload_data;
   SendRequestAndExpectQuicResponse("and hello!");
 }
 
 }  // namespace test
 }  // namespace net