Split HttpNetworkSession::Params into two structs.

net/quic/chromium/quic_end_to_end_unittest.cc

 // Copyright 2013 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 <memory>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/compiler_specific.h"
@@ skipping 38 matching lines @@
 
 namespace test {
 
 namespace {
 
 const char kResponseBody[] = "some arbitrary response body";
 
 // Factory for creating HttpTransactions, used by TestTransactionConsumer.
 class TestTransactionFactory : public HttpTransactionFactory {
  public:
-  explicit TestTransactionFactory(const HttpNetworkSession::Params& params)
-      : session_(new HttpNetworkSession(params)) {}
+  explicit TestTransactionFactory(
+      const HttpNetworkSession::Params& session_params,
+      const HttpNetworkSession::Context& session_context)
+      : session_(new HttpNetworkSession(session_params, session_context)) {}
 
   ~TestTransactionFactory() override {}
 
   // HttpTransactionFactory methods
   int CreateTransaction(RequestPriority priority,
                         std::unique_ptr<HttpTransaction>* trans) override {
     trans->reset(new HttpNetworkTransaction(priority, session_.get()));
     return OK;
   }
 
@@ skipping 30 matching lines @@
         cert_transparency_verifier_(new MultiLogCTVerifier()),
         ssl_config_service_(new SSLConfigServiceDefaults),
         proxy_service_(ProxyService::CreateDirect()),
         auth_handler_factory_(
             HttpAuthHandlerFactory::CreateDefault(&host_resolver_)),
         strike_register_no_startup_period_(false) {
     request_.method = "GET";
     request_.url = GURL("https://test.example.com/");
     request_.load_flags = 0;
 
-    params_.enable_quic = true;
-    params_.quic_random = nullptr;
+    session_params_.enable_quic = true;
     if (GetParam().use_stateless_rejects) {
-      params_.quic_connection_options.push_back(kSREJ);
+      session_params_.quic_connection_options.push_back(kSREJ);
     }
-    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_.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_;
+
+    session_context_.quic_random = nullptr;
+    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_.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_;
     channel_id_service_.reset(
         new ChannelIDService(new DefaultChannelIDStore(nullptr)));
-    params_.channel_id_service = channel_id_service_.get();
+    session_context_.channel_id_service = channel_id_service_.get();
 
     CertVerifyResult verify_result;
     verify_result.verified_cert = ImportCertFromFile(
         GetTestCertsDirectory(), "quic_test.example.com.crt");
     cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
                                            "test.example.com", verify_result,
                                            OK);
     verify_result.verified_cert = ImportCertFromFile(
         GetTestCertsDirectory(), "quic_test_ecc.example.com.crt");
     cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
@@ skipping 13 matching lines @@
     StartServer();
 
     // Use a mapped host resolver so that request for test.example.com (port 80)
     // reach the server running on localhost.
     std::string map_rule = "MAP test.example.com test.example.com:" +
                            base::IntToString(server_->server_address().port());
     EXPECT_TRUE(host_resolver_.AddRuleFromString(map_rule));
 
     // To simplify the test, and avoid the race with the HTTP request, we force
     // QUIC for these requests.
-    params_.origins_to_force_quic_on.insert(
+    session_params_.origins_to_force_quic_on.insert(
         HostPortPair::FromString("test.example.com:443"));
 
-    transaction_factory_.reset(new TestTransactionFactory(params_));
+    transaction_factory_.reset(
+        new TestTransactionFactory(session_params_, session_context_));
   }
 
   void TearDown() override {}
 
   // Starts the QUIC server listening on a random port.
   void StartServer() {
     server_address_ = IPEndPoint(IPAddress(127, 0, 0, 1), 0);
     server_config_.SetInitialStreamFlowControlWindowToSend(
         kInitialStreamFlowControlWindowForTest);
     server_config_.SetInitialSessionFlowControlWindowToSend(
@@ skipping 57 matching lines @@
   MappedHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
   std::unique_ptr<ChannelIDService> channel_id_service_;
   TransportSecurityState transport_security_state_;
   std::unique_ptr<CTVerifier> cert_transparency_verifier_;
   CTPolicyEnforcer ct_policy_enforcer_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   std::unique_ptr<ProxyService> proxy_service_;
   std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
-  HttpNetworkSession::Params params_;
+  HttpNetworkSession::Params session_params_;
+  HttpNetworkSession::Context session_context_;
   std::unique_ptr<TestTransactionFactory> transaction_factory_;
   HttpRequestInfo request_;
   std::string request_body_;
   std::unique_ptr<UploadDataStream> upload_data_stream_;
   std::unique_ptr<QuicSimpleServer> server_;
   QuicHttpResponseCache response_cache_;
   IPEndPoint server_address_;
   std::string server_hostname_;
   QuicConfig server_config_;
   QuicCryptoServerConfig::ConfigOptions server_config_options_;
@@ skipping 15 matching lines @@
   consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   CheckResponse(consumer, "HTTP/1.1 200", response);
 }
 
 TEST_P(QuicEndToEndTest, TokenBinding) {
   // Enable token binding and re-initialize the TestTransactionFactory.
-  params_.enable_token_binding = true;
-  transaction_factory_.reset(new TestTransactionFactory(params_));
+  session_params_.enable_token_binding = true;
+  transaction_factory_.reset(
+      new TestTransactionFactory(session_params_, session_context_));
 
   AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
 
   TestTransactionConsumer consumer(DEFAULT_PRIORITY,
                                    transaction_factory_.get());
   consumer.Start(&request_, NetLogWithSource());
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
@@ skipping 66 matching lines @@
 
   // Will terminate when the last consumer completes.
   base::RunLoop().Run();
 
   for (const auto& consumer : consumers)
     CheckResponse(*consumer.get(), "HTTP/1.1 200", kResponseBody);
 }
 
 }  // namespace test
 }  // namespace net