Race preconnects to HTTP2 proxies that support alternate proxies

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 370 matching lines @@
   CapturePreconnectsSocketPool(HostResolver* host_resolver,
                                CertVerifier* cert_verifier,
                                TransportSecurityState* transport_security_state,
                                CTVerifier* cert_transparency_verifier,
                                CTPolicyEnforcer* ct_policy_enforcer);
 
   int last_num_streams() const {
     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,
                     ClientSocketPool::RespectLimits respect_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const NetLogWithSource& net_log) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
   void RequestSockets(const std::string& group_name,
                       const void* socket_params,
                       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,
                      ClientSocketHandle* handle) override {
     ADD_FAILURE();
   }
   void ReleaseSocket(const std::string& group_name,
                      std::unique_ptr<StreamSocket> socket,
                      int id) override {
     ADD_FAILURE();
@@ skipping 11 matching lines @@
                          const ClientSocketHandle* handle) const override {
     ADD_FAILURE();
     return LOAD_STATE_IDLE;
   }
   base::TimeDelta ConnectionTimeout() const override {
     return base::TimeDelta();
   }
 
  private:
   int last_num_streams_;
+  int total_num_streams_;
 };
 
 typedef CapturePreconnectsSocketPool<TransportClientSocketPool>
 CapturePreconnectsTransportSocketPool;
 typedef CapturePreconnectsSocketPool<HttpProxyClientSocketPool>
 CapturePreconnectsHttpProxySocketPool;
 typedef CapturePreconnectsSocketPool<SOCKSClientSocketPool>
 CapturePreconnectsSOCKSSocketPool;
 typedef CapturePreconnectsSocketPool<SSLClientSocketPool>
 CapturePreconnectsSSLSocketPool;
 
 template <typename ParentPool>
 CapturePreconnectsSocketPool<ParentPool>::CapturePreconnectsSocketPool(
     HostResolver* host_resolver,
     CertVerifier*,
     TransportSecurityState*,
     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(
     HostResolver*,
     CertVerifier*,
     TransportSecurityState*,
     CTVerifier*,
     CTPolicyEnforcer*)
     : HttpProxyClientSocketPool(0, 0, nullptr, nullptr, nullptr),
-      last_num_streams_(-1) {}
+      last_num_streams_(-1),
+      total_num_streams_(0) {}
 
 template <>
 CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
     HostResolver* /* host_resolver */,
     CertVerifier* cert_verifier,
     TransportSecurityState* transport_security_state,
     CTVerifier* cert_transparency_verifier,
     CTPolicyEnforcer* ct_policy_enforcer)
     : SSLClientSocketPool(0,
                           0,
                           cert_verifier,
                           nullptr,  // channel_id_store
                           transport_security_state,
                           cert_transparency_verifier,
                           ct_policy_enforcer,
                           std::string(),  // ssl_session_cache_shard
                           nullptr,        // deterministic_socket_factory
                           nullptr,        // transport_socket_pool
                           nullptr,
                           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> {
 };
 
 TEST_F(HttpStreamFactoryTest, PreconnectDirect) {
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     SpdySessionDependencies session_deps(ProxyService::CreateDirect());
     std::unique_ptr<HttpNetworkSession> session(
         SpdySessionDependencies::SpdyCreateSession(&session_deps));
@@ skipping 709 matching lines @@
     HttpRequestInfo request;
     request.method = "GET";
     request.url = url;
     request.load_flags = 0;
 
     session->http_stream_factory()->PreconnectStreams(num_streams, request);
     EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
   }
 }
 
+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) {
   for (bool set_http_server_properties : {false, true}) {
     for (int num_streams = 1; num_streams < 3; ++num_streams) {
       base::HistogramTester histogram_tester;
       GURL url = GURL("http://www.google.com");
       std::unique_ptr<ProxyService> proxy_service =
           ProxyService::CreateFixedFromPacResult("HTTPS myproxy.org:443");
 
@@ skipping 1274 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