Respect QuicAllowed policy for new streams

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 711 matching lines @@
 };
 
 // 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::DynamicSharedParams dynamic_shared_params;
+    dynamic_shared_params.enable_quic = true;
+    params.dynamic_shared_params = &dynamic_shared_params;
     params.quic_disable_preconnect_if_0rtt = false;
     scoped_refptr<SSLConfigServiceDefaults> ssl_config_service(
         new SSLConfigServiceDefaults);
     HttpServerPropertiesImpl http_server_properties;
     MockClientSocketFactory socket_factory;
     params.client_socket_factory = &socket_factory;
     MockHostResolver host_resolver;
     params.host_resolver = &host_resolver;
     MockCertVerifier cert_verifier;
     params.cert_verifier = &cert_verifier;
@@ skipping 114 matching lines @@
     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;
+    bool set_alternative_proxy_server,
+    HttpNetworkSession::DynamicSharedParams* dynamic_shared_parmas) {
+  params->dynamic_shared_params = dynamic_shared_parmas;
+  params->dynamic_shared_params->enable_quic = true;
   params->quic_disable_preconnect_if_0rtt = false;
   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;
@@ skipping 12 matching lines @@
 // 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::DynamicSharedParams dynamic_shared_params;
       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);
+          &transport_security_state, set_alternative_proxy_server,
+          &dynamic_shared_params);
 
       std::unique_ptr<HttpNetworkSession> session(
           new HttpNetworkSession(params));
 
       // 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;
@@ skipping 80 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::DynamicSharedParams dynamic_shared_parmas;
     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);
+        &transport_security_state, true, &dynamic_shared_parmas);
 
     HostPortPair host_port_pair("badproxy", 99);
     std::unique_ptr<HttpNetworkSession> session(new HttpNetworkSession(params));
 
     // 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;
@@ skipping 75 matching lines @@
                                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 =
         SpdySessionDependencies::CreateSessionParams(&session_deps);
-    params.enable_quic = true;
+    HttpNetworkSession::DynamicSharedParams dynamic_shared_params;

[Bence, 2016/12/20 14:58:07]

There should be no need to create an instance here: |session_deps| already owns
one and sets up |params| to point to it.

[pmarko, 2016/12/20 18:00:37]

Good catch!! Done.

+    dynamic_shared_params.enable_quic = true;
+    params.dynamic_shared_params = &dynamic_shared_params;
     params.quic_disable_preconnect_if_0rtt = true;
     params.http_server_properties = &http_server_properties;
 
     std::unique_ptr<HttpNetworkSession> session(new HttpNetworkSession(params));
     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(),
@@ skipping 33 matching lines @@
     url::SchemeHostPort server("https", host_port_pair.host(),
                                host_port_pair.port());
     http_server_properties.SetAlternativeServices(
         server, alternative_service_info_vector);
 
     SpdySessionDependencies session_deps;
 
     // Setup params to disable preconnect, but QUIC does 0RTT.
     HttpNetworkSession::Params params =
         SpdySessionDependencies::CreateSessionParams(&session_deps);
-    params.enable_quic = true;
+    HttpNetworkSession::DynamicSharedParams dynamic_shared_params;

[Bence, 2016/12/20 14:58:07]

Same here.

[pmarko, 2016/12/20 18:00:37]

Done.

+    dynamic_shared_params.enable_quic = true;
+    params.dynamic_shared_params = &dynamic_shared_params;
     params.quic_disable_preconnect_if_0rtt = true;
     params.http_server_properties = &http_server_properties;
 
     std::unique_ptr<HttpNetworkSession> session(new HttpNetworkSession(params));
 
     // Setup 0RTT for QUIC.
     QuicStreamFactory* factory = session->quic_stream_factory();
     factory->set_require_confirmation(false);
     test::QuicStreamFactoryPeer::CacheDummyServerConfig(
         factory, QuicServerId(host_port_pair, PRIVACY_MODE_DISABLED));
@@ skipping 37 matching lines @@
       // 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 =
           SpdySessionDependencies::CreateSessionParams(&session_deps);
-      params.enable_quic = true;
+      HttpNetworkSession::DynamicSharedParams dynamic_shared_params;

[Bence, 2016/12/20 14:58:07]

Same here.

[pmarko, 2016/12/20 18:00:37]

Done.

+      dynamic_shared_params.enable_quic = true;
+      params.dynamic_shared_params = &dynamic_shared_params;
       params.proxy_service = proxy_service.get();
       params.http_server_properties = &http_server_properties;
 
       std::unique_ptr<HttpNetworkSession> session(
           new HttpNetworkSession(params));
 
       HttpNetworkSessionPeer peer(session.get());
       HostPortPair proxy_host("myproxy.org", 443);
 
       for (int preconnect_request = 0; preconnect_request < 2;
@@ skipping 739 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;
+    dynamic_shared_params_.enable_quic = true;
+    params_.dynamic_shared_params = &dynamic_shared_params_;
     params_.http_server_properties = &http_server_properties_;
     params_.quic_host_whitelist.insert("www.example.org");
     params_.quic_random = &random_generator_;
     params_.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;
@@ skipping 50 matching lines @@
   ProofVerifyDetailsChromium verify_details_;
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   TransportSecurityState transport_security_state_;
   MultiLogCTVerifier ct_verifier_;
   CTPolicyEnforcer ct_policy_enforcer_;
   MockHostResolver host_resolver_;
   std::unique_ptr<ProxyService> proxy_service_;
   scoped_refptr<SSLConfigServiceDefaults> ssl_config_service_;
   HttpNetworkSession::Params params_;
+  HttpNetworkSession::DynamicSharedParams dynamic_shared_params_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version,
                         HttpStreamFactoryBidirectionalQuicTest,
                         ::testing::ValuesIn(AllSupportedVersions()));
 
 TEST_P(HttpStreamFactoryBidirectionalQuicTest,
        RequestBidirectionalStreamImplQuicAlternative) {
   MockQuicData mock_quic_data;
   SpdyPriority priority =
@@ skipping 426 matching lines @@
       session->GetTransportSocketPool(
           HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_EQ(1, GetSocketPoolGroupCount(
       session->GetSSLSocketPool(HttpNetworkSession::WEBSOCKET_SOCKET_POOL)));
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 }
 
 }  // namespace
 
 }  // namespace net