Race preconnects to HTTP2 proxies that support alternate proxies

net/http/http_stream_factory_impl_unittest.cc

Index: net/http/http_stream_factory_impl_unittest.cc
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index 26b305abad77d6925dd0032049ef4ceb9575575e..83036ef6dbd0ef5257342f7f818daee61fc3f45d 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -388,6 +388,8 @@ class CapturePreconnectsSocketPool : public ParentPool {
     return last_num_streams_;
   }
 
+  int total_num_streams() const { return total_num_streams_; }
+
   int RequestSocket(const std::string& group_name,
                     const void* socket_params,
                     RequestPriority priority,
@@ -404,6 +406,7 @@ class CapturePreconnectsSocketPool : public ParentPool {
                       int num_sockets,
                       const NetLogWithSource& net_log) override {
     last_num_streams_ = num_sockets;
+    total_num_streams_ += num_sockets;
   }
 
   void CancelRequest(const std::string& group_name,
@@ -435,6 +438,7 @@ class CapturePreconnectsSocketPool : public ParentPool {
 
  private:
   int last_num_streams_;
+  int total_num_streams_;
 };
 
 typedef CapturePreconnectsSocketPool<TransportClientSocketPool>
@@ -454,7 +458,8 @@ CapturePreconnectsSocketPool<ParentPool>::CapturePreconnectsSocketPool(
     CTVerifier*,
     CTPolicyEnforcer*)
     : ParentPool(0, 0, host_resolver, nullptr, nullptr, nullptr),
-      last_num_streams_(-1) {}
+      last_num_streams_(-1),
+      total_num_streams_(0) {}
 
 template <>
 CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool(
@@ -464,7 +469,8 @@ CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool(
     CTVerifier*,
     CTPolicyEnforcer*)
     : HttpProxyClientSocketPool(0, 0, nullptr, nullptr, nullptr),
-      last_num_streams_(-1) {}
+      last_num_streams_(-1),
+      total_num_streams_(0) {}
 
 template <>
 CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
@@ -487,7 +493,8 @@ CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
                           nullptr,
                           nullptr,   // ssl_config_service
                           nullptr),  // net_log
-      last_num_streams_(-1) {}
+      last_num_streams_(-1),
+      total_num_streams_(0) {}
 
 class HttpStreamFactoryTest : public ::testing::Test,
                               public ::testing::WithParamInterface<NextProto> {
@@ -1217,6 +1224,106 @@ TEST_F(HttpStreamFactoryTest, QuicDisablePreConnectIfZeroRtt) {
   }
 }
 
+TEST_F(HttpStreamFactoryTest, QuicRacePreconnectsToProxyServer) {
+  for (bool race_preconnects_to_http2_proxies : {false, true}) {
+    for (int num_streams = 1; num_streams < 3; ++num_streams) {
+      TestProxyDelegate test_proxy_delegate;
+      base::HistogramTester histogram_tester;
+      GURL url = GURL("http://www.google.com");
+      std::unique_ptr<ProxyService> proxy_service =
+          ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
+
+      // Set up QUIC as alternative_service.
+      HttpServerPropertiesImpl http_server_properties;
+      const AlternativeService alternative_service(kProtoQUIC, "myproxy.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));
+      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;
+      HttpNetworkSession::Params params =
+          SpdySessionDependencies::CreateSessionParams(&session_deps);
+      params.enable_quic = true;
+      params.proxy_service = proxy_service.get();
+      params.race_preconnects_to_http2_proxies =
+          race_preconnects_to_http2_proxies;
+      // |quic_disable_preconnect_if_0rtt| has no effect on preconnect for
+      // proxies.
+      params.quic_disable_preconnect_if_0rtt = false;
+      params.http_server_properties = &http_server_properties;
+
+      test_proxy_delegate.set_alternative_proxy_server(
+          ProxyServer::FromPacString("QUIC myproxy.org:443"));
+      params.proxy_delegate = &test_proxy_delegate;
+
+      std::unique_ptr<HttpNetworkSession> session(
+          new HttpNetworkSession(params));
+
+      HttpNetworkSessionPeer peer(session.get());
+      HostPortPair proxy_host("myproxy.org", 443);
+
+      CapturePreconnectsTransportSocketPool* transport_conn_pool =
+          new CapturePreconnectsTransportSocketPool(
+              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());
+
+      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(
+              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());
+
+      std::unique_ptr<MockClientSocketPoolManager> mock_pool_manager(
+          new MockClientSocketPoolManager);
+      mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
+      mock_pool_manager->SetSocketPoolForHTTPProxy(
+          proxy_host, base::WrapUnique(http_proxy_pool));
+      mock_pool_manager->SetSocketPoolForSSLWithProxy(
+          proxy_host, base::WrapUnique(ssl_conn_pool));
+      peer.SetClientSocketPoolManager(std::move(mock_pool_manager));
+
+      HttpRequestInfo request_info;
+      request_info.method = "GET";
+      request_info.url = url;
+      request_info.load_flags = 0;
+
+      session->http_stream_factory()->PreconnectStreams(num_streams,
+                                                        request_info);
+      base::RunLoop().RunUntilIdle();
+      EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
+      EXPECT_EQ(0, transport_conn_pool->total_num_streams());
+      EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
+      EXPECT_EQ(0, ssl_conn_pool->total_num_streams());
+      EXPECT_EQ(race_preconnects_to_http2_proxies ? 1 : num_streams,
+                http_proxy_pool->last_num_streams());
+      EXPECT_EQ(race_preconnects_to_http2_proxies ? 1 : num_streams,
+                http_proxy_pool->total_num_streams());
+      histogram_tester.ExpectTotalCount(
+          "Net.QuicAlternativeProxy.PreconnectJobsRaced",
+          race_preconnects_to_http2_proxies ? 1 : 0);
+    }
+  }
+}
+
 // Verify that only one preconnect job succeeds to a proxy server that supports
 // request priorities.
 TEST_F(HttpStreamFactoryTest, OnlyOnePreconnectToProxyServer) {