Respect QuicAllowed policy for new streams

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 <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 461 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_.dynamic_shared_params = &dynamic_shared_params_;
+    dynamic_shared_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 =
@@ skipping 223 matching lines @@
   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::DynamicSharedParams dynamic_shared_params_;
   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 110 matching lines @@
   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;
+  dynamic_shared_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(ConstructSettingsPacket(
       1, SETTINGS_MAX_HEADER_LIST_SIZE, kDefaultMaxUncompressedHeaderSize,
       &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
       2, kClientDataStreamId1, true, true,
@@ 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;
+  dynamic_shared_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(ConstructSettingsPacket(
       1, SETTINGS_MAX_HEADER_LIST_SIZE, kDefaultMaxUncompressedHeaderSize,
       &header_stream_offset));
   mock_quic_data.AddWrite(ConstructClientRequestHeadersPacket(
@@ skipping 2115 matching lines @@
 
     HttpNetworkSession::Params params;
 
     clock_->AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
     params.quic_clock = clock_;
 
     crypto_client_stream_factory_.set_handshake_mode(
         MockCryptoClientStream::CONFIRM_HANDSHAKE);
     params.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
 
-    params.enable_quic = true;
+    dynamic_shared_params_.enable_quic = true;
+    params.dynamic_shared_params = &dynamic_shared_params_;
     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 =
         &test_socket_performance_watcher_factory_;
     params.ssl_config_service = ssl_config_service_.get();
@@ skipping 182 matching lines @@
   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_;
   BoundTestNetLog net_log_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   std::vector<std::unique_ptr<StaticSocketDataProvider>>
       static_socket_data_provider_vector_;
   SSLSocketDataProvider ssl_data_;
+  HttpNetworkSession::DynamicSharedParams dynamic_shared_params_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         QuicNetworkTransactionWithDestinationTest,
                         ::testing::ValuesIn(GetPoolingTestParams()));
 
 // A single QUIC request fails because the certificate does not match the origin
 // hostname, regardless of whether it matches the alternative service hostname.
 TEST_P(QuicNetworkTransactionWithDestinationTest, InvalidCertificate) {
   if (destination_type_ == DIFFERENT)
@@ skipping 191 matching lines @@
   AddHangingSocketData();
 
   SendRequestAndExpectQuicResponse(origin1_);
   SendRequestAndExpectQuicResponse(origin2_);
 
   EXPECT_TRUE(AllDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net