Split HttpNetworkSession::Params into two structs.

net/http/http_stream_factory_impl_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 "net/http/http_stream_factory_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
@@ skipping 695 matching lines @@
     ERR_MSG_TOO_BIG,
 };
 
 // Tests that a bad QUIC proxy is added to the list of bad proxies.
 TEST_F(HttpStreamFactoryTest, QuicProxyMarkedAsBad) {
   for (size_t i = 0; i < arraysize(quic_proxy_test_mock_errors); ++i) {
     std::unique_ptr<ProxyService> proxy_service;
     proxy_service =
         ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT");
 
-    HttpNetworkSession::Params params;
-    params.enable_quic = true;
+    HttpNetworkSession::Params session_params;
+    session_params.enable_quic = true;
+
+    HttpNetworkSession::Context session_context;
     scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
         new SSLConfigServiceDefaults);
     HttpServerPropertiesImpl http_server_properties;
     MockClientSocketFactory socket_factory;
-    params.client_socket_factory = &socket_factory;
+    session_context.client_socket_factory = &socket_factory;
     MockHostResolver host_resolver;
-    params.host_resolver = &host_resolver;
+    session_context.host_resolver = &host_resolver;
     MockCertVerifier cert_verifier;
-    params.cert_verifier = &cert_verifier;
+    session_context.cert_verifier = &cert_verifier;
     TransportSecurityState transport_security_state;
-    params.transport_security_state = &transport_security_state;
+    session_context.transport_security_state = &transport_security_state;
     MultiLogCTVerifier ct_verifier;
-    params.cert_transparency_verifier = &ct_verifier;
+    session_context.cert_transparency_verifier = &ct_verifier;
     CTPolicyEnforcer ct_policy_enforcer;
-    params.ct_policy_enforcer = &ct_policy_enforcer;
-    params.proxy_service = proxy_service.get();
-    params.ssl_config_service = ssl_config_service.get();
-    params.http_server_properties = &http_server_properties;
+    session_context.ct_policy_enforcer = &ct_policy_enforcer;
+    session_context.proxy_service = proxy_service.get();
+    session_context.ssl_config_service = ssl_config_service.get();
+    session_context.http_server_properties = &http_server_properties;
 
-    auto session = base::MakeUnique<HttpNetworkSession>(params);
+    auto session =
+        base::MakeUnique<HttpNetworkSession>(session_params, session_context);
     session->quic_stream_factory()->set_require_confirmation(false);
 
     StaticSocketDataProvider socket_data1;
     socket_data1.set_connect_data(
         MockConnect(ASYNC, quic_proxy_test_mock_errors[i]));
     socket_factory.AddSocketDataProvider(&socket_data1);
 
     // Second connection attempt succeeds.
     StaticSocketDataProvider socket_data2;
     socket_data2.set_connect_data(MockConnect(ASYNC, OK));
@@ skipping 83 matching lines @@
 
  private:
   std::vector<std::unique_ptr<QuicEncryptedPacket>> packets_;
   std::vector<MockWrite> writes_;
   std::vector<MockRead> reads_;
   size_t packet_number_;
   std::unique_ptr<SequencedSocketData> socket_data_;
 };
 
 void SetupForQuicAlternativeProxyTest(
-    HttpNetworkSession::Params* params,
+    HttpNetworkSession::Params* session_params,
+    HttpNetworkSession::Context* session_context,
     MockClientSocketFactory* socket_factory,
     ProxyService* proxy_service,
     TestProxyDelegate* test_proxy_delegate,
     HttpServerPropertiesImpl* http_server_properties,
     MockCertVerifier* cert_verifier,
     CTPolicyEnforcer* ct_policy_enforcer,
     MultiLogCTVerifier* ct_verifier,
     SSLConfigServiceDefaults* ssl_config_service,
     MockHostResolver* host_resolver,
     TransportSecurityState* transport_security_state,
     bool set_alternative_proxy_server) {
-  params->enable_quic = true;
-  params->client_socket_factory = socket_factory;
-  params->host_resolver = host_resolver;
-  params->transport_security_state = transport_security_state;
-  params->proxy_service = proxy_service;
-  params->ssl_config_service = ssl_config_service;
-  params->http_server_properties = http_server_properties;
-  params->cert_verifier = cert_verifier;
-  params->ct_policy_enforcer = ct_policy_enforcer;
-  params->cert_transparency_verifier = ct_verifier;
+  session_params->enable_quic = true;
+
+  session_context->client_socket_factory = socket_factory;
+  session_context->host_resolver = host_resolver;
+  session_context->transport_security_state = transport_security_state;
+  session_context->proxy_service = proxy_service;
+  session_context->ssl_config_service = ssl_config_service;
+  session_context->http_server_properties = http_server_properties;
+  session_context->cert_verifier = cert_verifier;
+  session_context->ct_policy_enforcer = ct_policy_enforcer;
+  session_context->cert_transparency_verifier = ct_verifier;
 
   if (set_alternative_proxy_server) {
     test_proxy_delegate->set_alternative_proxy_server(
         ProxyServer::FromPacString("QUIC badproxy:99"));
   }
-  params->proxy_delegate = test_proxy_delegate;
+  session_context->proxy_delegate = test_proxy_delegate;
 }
 
 }  // namespace
 
 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is
 // marked as bad if connecting to both the default proxy and the alternative
 // proxy is unsuccessful.
 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyMarkedAsBad) {
   const bool set_alternative_proxy_server_values[] = {
       false, true,
   };
 
   for (auto mock_error : quic_proxy_test_mock_errors) {
     for (auto set_alternative_proxy_server :
          set_alternative_proxy_server_values) {
-      HttpNetworkSession::Params params;
+      HttpNetworkSession::Params session_params;
+      HttpNetworkSession::Context session_context;
       MockClientSocketFactory socket_factory;
       std::unique_ptr<ProxyService> proxy_service =
           ProxyService::CreateFixedFromPacResult(
               "HTTPS badproxy:99; HTTPS badfallbackproxy:98; DIRECT");
       TestProxyDelegate test_proxy_delegate;
       HttpServerPropertiesImpl http_server_properties;
       MockCertVerifier cert_verifier;
       CTPolicyEnforcer ct_policy_enforcer;
       MultiLogCTVerifier ct_verifier;
       scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
           new SSLConfigServiceDefaults);
       MockHostResolver host_resolver;
       TransportSecurityState transport_security_state;
       SetupForQuicAlternativeProxyTest(
-          &params, &socket_factory, proxy_service.get(), &test_proxy_delegate,
-          &http_server_properties, &cert_verifier, &ct_policy_enforcer,
-          &ct_verifier, ssl_config_service.get(), &host_resolver,
-          &transport_security_state, set_alternative_proxy_server);
+          &session_params, &session_context, &socket_factory,
+          proxy_service.get(), &test_proxy_delegate, &http_server_properties,
+          &cert_verifier, &ct_policy_enforcer, &ct_verifier,
+          ssl_config_service.get(), &host_resolver, &transport_security_state,
+          set_alternative_proxy_server);
 
-      auto session = base::MakeUnique<HttpNetworkSession>(params);
+      auto session =
+          base::MakeUnique<HttpNetworkSession>(session_params, session_context);
 
       // Before starting the test, verify that there are no proxies marked as
       // bad.
       ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty())
           << mock_error;
 
       StaticSocketDataProvider socket_data_proxy_main_job;
       socket_data_proxy_main_job.set_connect_data(
           MockConnect(ASYNC, mock_error));
       socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job);
@@ skipping 77 matching lines @@
         }
       }
     }
   }
 }
 
 // Tests that a HTTPS proxy that supports QUIC alternative proxy server is
 // not marked as bad if only the alternative proxy server job fails.
 TEST_F(HttpStreamFactoryTest, WithQUICAlternativeProxyNotMarkedAsBad) {
   for (auto mock_error : quic_proxy_test_mock_errors) {
-    HttpNetworkSession::Params params;
+    HttpNetworkSession::Params session_params;
+    HttpNetworkSession::Context session_context;
     MockClientSocketFactory socket_factory;
     std::unique_ptr<ProxyService> proxy_service =
         ProxyService::CreateFixedFromPacResult("HTTPS badproxy:99; DIRECT");
     TestProxyDelegate test_proxy_delegate;
     HttpServerPropertiesImpl http_server_properties;
     MockCertVerifier cert_verifier;
     CTPolicyEnforcer ct_policy_enforcer;
     MultiLogCTVerifier ct_verifier;
 
     scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
         new SSLConfigServiceDefaults);
     MockHostResolver host_resolver;
     TransportSecurityState transport_security_state;
 
     SetupForQuicAlternativeProxyTest(
-        &params, &socket_factory, proxy_service.get(), &test_proxy_delegate,
-        &http_server_properties, &cert_verifier, &ct_policy_enforcer,
-        &ct_verifier, ssl_config_service.get(), &host_resolver,
-        &transport_security_state, true);
+        &session_params, &session_context, &socket_factory, proxy_service.get(),
+        &test_proxy_delegate, &http_server_properties, &cert_verifier,
+        &ct_policy_enforcer, &ct_verifier, ssl_config_service.get(),
+        &host_resolver, &transport_security_state, true);
 
     HostPortPair host_port_pair("badproxy", 99);
-    auto session = base::MakeUnique<HttpNetworkSession>(params);
+    auto session =
+        base::MakeUnique<HttpNetworkSession>(session_params, session_context);
 
     // Before starting the test, verify that there are no proxies marked as
     // bad.
     ASSERT_TRUE(session->proxy_service()->proxy_retry_info().empty())
         << mock_error;
 
     StaticSocketDataProvider socket_data_proxy_main_job;
     socket_data_proxy_main_job.set_connect_data(MockConnect(ASYNC, mock_error));
     socket_factory.AddSocketDataProvider(&socket_data_proxy_main_job);
 
@@ skipping 71 matching lines @@
     HostPortPair host_port_pair(alternative_service.host_port_pair());
     url::SchemeHostPort server("https", host_port_pair.host(),
                                host_port_pair.port());
     http_server_properties.SetAlternativeServices(
         server, alternative_service_info_vector);
 
     SpdySessionDependencies session_deps(
         ProxyService::CreateFixed("http_proxy"));
 
     // Setup params to disable preconnect, but QUIC doesn't 0RTT.
-    HttpNetworkSession::Params params =
+    HttpNetworkSession::Params session_params =
         SpdySessionDependencies::CreateSessionParams(&session_deps);
-    params.enable_quic = true;
-    params.http_server_properties = &http_server_properties;
+    session_params.enable_quic = true;
 
-    auto session = base::MakeUnique<HttpNetworkSession>(params);
+    HttpNetworkSession::Context session_context =
+        SpdySessionDependencies::CreateSessionContext(&session_deps);
+    session_context.http_server_properties = &http_server_properties;
+
+    auto session =
+        base::MakeUnique<HttpNetworkSession>(session_params, session_context);
     HttpNetworkSessionPeer peer(session.get());
     HostPortPair proxy_host("http_proxy", 80);
     CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
         new CapturePreconnectsHttpProxySocketPool(
             session_deps.host_resolver.get(), session_deps.cert_verifier.get(),
             session_deps.transport_security_state.get(),
             session_deps.cert_transparency_verifier.get(),
             session_deps.ct_policy_enforcer.get());
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
         new CapturePreconnectsSSLSocketPool(
@@ skipping 23 matching lines @@
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
 
       // Set up the proxy server as a server that supports request priorities.
       HttpServerPropertiesImpl http_server_properties;
       if (set_http_server_properties) {
         url::SchemeHostPort spdy_server("https", "myproxy.org", 443);
         http_server_properties.SetSupportsSpdy(spdy_server, true);
       }
 
       SpdySessionDependencies session_deps;
-      HttpNetworkSession::Params params =
+      HttpNetworkSession::Params session_params =
           SpdySessionDependencies::CreateSessionParams(&session_deps);
-      params.enable_quic = true;
-      params.proxy_service = proxy_service.get();
-      params.http_server_properties = &http_server_properties;
+      session_params.enable_quic = true;
 
-      auto session = base::MakeUnique<HttpNetworkSession>(params);
+      HttpNetworkSession::Context session_context =
+          SpdySessionDependencies::CreateSessionContext(&session_deps);
+      session_context.proxy_service = proxy_service.get();
+      session_context.http_server_properties = &http_server_properties;
+
+      auto session =
+          base::MakeUnique<HttpNetworkSession>(session_params, session_context);
 
       HttpNetworkSessionPeer peer(session.get());
       HostPortPair proxy_host("myproxy.org", 443);
 
       for (int preconnect_request = 0; preconnect_request < 2;
            ++preconnect_request) {
         CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
             new CapturePreconnectsHttpProxySocketPool(
                 session_deps.host_resolver.get(),
                 session_deps.cert_verifier.get(),
@@ skipping 61 matching lines @@
   std::unique_ptr<ProxyService> proxy_service =
       ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
 
   // Set up the proxy server as a server that supports request priorities.
   HttpServerPropertiesImpl http_server_properties;
 
   url::SchemeHostPort spdy_server("https", "myproxy.org", 443);
   http_server_properties.SetSupportsSpdy(spdy_server, true);
 
   SpdySessionDependencies session_deps;
-  HttpNetworkSession::Params params =
+  HttpNetworkSession::Params session_params =
       SpdySessionDependencies::CreateSessionParams(&session_deps);
-  params.enable_quic = true;
-  params.proxy_service = proxy_service.get();
-  params.http_server_properties = &http_server_properties;
+  session_params.enable_quic = true;
 
-  auto session = base::MakeUnique<HttpNetworkSession>(params);
+  HttpNetworkSession::Context session_context =
+      SpdySessionDependencies::CreateSessionContext(&session_deps);
+  session_context.proxy_service = proxy_service.get();
+  session_context.http_server_properties = &http_server_properties;
+
+  auto session =
+      base::MakeUnique<HttpNetworkSession>(session_params, session_context);
 
   HttpNetworkSessionPeer peer(session.get());
   HostPortPair proxy_host("myproxy.org", 443);
 
   CapturePreconnectsHttpProxySocketPool* http_proxy_pool =
       new CapturePreconnectsHttpProxySocketPool(
           session_deps.host_resolver.get(), session_deps.cert_verifier.get(),
           session_deps.transport_security_state.get(),
           session_deps.cert_transparency_verifier.get(),
           session_deps.ct_policy_enforcer.get());
@@ skipping 875 matching lines @@
   void TearDown() override { session_.reset(); }
 
   // Disable bidirectional stream over QUIC. This should be invoked before
   // Initialize().
   void DisableQuicBidirectionalStream() {
     params_.quic_disable_bidirectional_streams = true;
   }
 
   void Initialize() {
     params_.enable_quic = true;
-    params_.http_server_properties = &http_server_properties_;
-    params_.quic_random = &random_generator_;
-    params_.quic_clock = &clock_;
+    params_.quic_supported_versions = test::SupportedVersions(GetParam());
+
+    HttpNetworkSession::Context session_context;
+    session_context.http_server_properties = &http_server_properties_;
+    session_context.quic_random = &random_generator_;
+    session_context.quic_clock = &clock_;
 
     // Load a certificate that is valid for *.example.org
     scoped_refptr<X509Certificate> test_cert(
         ImportCertFromFile(GetTestCertsDirectory(), "wildcard.pem"));
     EXPECT_TRUE(test_cert.get());
     verify_details_.cert_verify_result.verified_cert = test_cert;
     verify_details_.cert_verify_result.is_issued_by_known_root = true;
     crypto_client_stream_factory_.AddProofVerifyDetails(&verify_details_);
     crypto_client_stream_factory_.set_handshake_mode(
         MockCryptoClientStream::CONFIRM_HANDSHAKE);
-    params_.cert_verifier = &cert_verifier_;
-    params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
-    params_.quic_supported_versions = test::SupportedVersions(GetParam());
-    params_.transport_security_state = &transport_security_state_;
-    params_.cert_transparency_verifier = &ct_verifier_;
-    params_.ct_policy_enforcer = &ct_policy_enforcer_;
-    params_.host_resolver = &host_resolver_;
-    params_.proxy_service = proxy_service_.get();
-    params_.ssl_config_service = ssl_config_service_.get();
-    params_.client_socket_factory = &socket_factory_;
-    session_ = base::MakeUnique<HttpNetworkSession>(params_);
+    session_context.cert_verifier = &cert_verifier_;
+    session_context.quic_crypto_client_stream_factory =
+        &crypto_client_stream_factory_;
+    session_context.transport_security_state = &transport_security_state_;
+    session_context.cert_transparency_verifier = &ct_verifier_;
+    session_context.ct_policy_enforcer = &ct_policy_enforcer_;
+    session_context.host_resolver = &host_resolver_;
+    session_context.proxy_service = proxy_service_.get();
+    session_context.ssl_config_service = ssl_config_service_.get();
+    session_context.client_socket_factory = &socket_factory_;
+    session_.reset(new HttpNetworkSession(params_, session_context));
     session_->quic_stream_factory()->set_require_confirmation(false);
   }
 
   void AddQuicAlternativeService() {
     const AlternativeService alternative_service(kProtoQUIC, "www.example.org",
                                                  443);
     AlternativeServiceInfoVector alternative_service_info_vector;
     base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
     alternative_service_info_vector.push_back(
         AlternativeServiceInfo(alternative_service, expiration));
@@ skipping 295 matching lines @@
                    HttpNetworkSession::NORMAL_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetTransportSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(0, GetSocketPoolGroupCount(session->GetSSLSocketPool(
                    HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
 }
 
 }  // namespace
 
 }  // namespace net