QUIC - Disable Preconnect when QUIC can be spoken to a server with 0RTT

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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "net/base/port_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_service.h"
+#include "net/quic/quic_server_id.h"
+#include "net/quic/test_tools/quic_stream_factory_peer.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/mock_client_socket_pool_manager.h"
 #include "net/socket/next_proto.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_test_util_common.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 // This file can be included from net/http even though
@@ skipping 69 matching lines @@
 
 // HttpStreamFactoryImpl subclass that can wait until a preconnect is complete.
 class MockHttpStreamFactoryImplForPreconnect : public HttpStreamFactoryImpl {
  public:
   MockHttpStreamFactoryImplForPreconnect(HttpNetworkSession* session,
                                          bool for_websockets)
       : HttpStreamFactoryImpl(session, for_websockets),
         preconnect_done_(false),
         waiting_for_preconnect_(false) {}
 
-
   void WaitForPreconnects() {
     while (!preconnect_done_) {
       waiting_for_preconnect_ = true;
       base::MessageLoop::current()->Run();
       waiting_for_preconnect_ = false;
     }
   }
 
  private:
   // HttpStreamFactoryImpl methods.
@@ skipping 502 matching lines @@
                             ERR_QUIC_HANDSHAKE_FAILED,
                             ERR_SSL_PROTOCOL_ERROR,
                             ERR_MSG_TOO_BIG};
   for (size_t i = 0; i < arraysize(mock_error); ++i) {
     scoped_ptr<ProxyService> proxy_service;
     proxy_service =
         ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT");
 
     HttpNetworkSession::Params params;
     params.enable_quic = true;
+    params.quic_disable_preconnect_if_0rtt = false;
     params.enable_quic_for_proxies = true;
     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;
     TransportSecurityState transport_security_state;
     params.transport_security_state = &transport_security_state;
@@ skipping 41 matching lines @@
 }  // namespace
 
 TEST_P(HttpStreamFactoryTest, QuicLossyProxyMarkedAsBad) {
   // Checks if a
   scoped_ptr<ProxyService> proxy_service;
   proxy_service = ProxyService::CreateFixedFromPacResult("QUIC bad:99; DIRECT");
 
   HttpNetworkSession::Params params;
   params.enable_quic = true;
   params.enable_quic_for_proxies = true;
+  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;
   TransportSecurityState transport_security_state;
   params.transport_security_state = &transport_security_state;
   params.proxy_service = proxy_service.get();
@@ skipping 28 matching lines @@
   // The proxy that failed should now be known to the proxy_service as bad.
   const ProxyRetryInfoMap& retry_info =
       session->proxy_service()->proxy_retry_info();
   EXPECT_EQ(1u, retry_info.size());
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   ProxyRetryInfoMap::const_iterator iter = retry_info.find("quic://bad:99");
   EXPECT_TRUE(iter != retry_info.end());
 }
 
+TEST_P(HttpStreamFactoryTest, UsePreConnectIfNoZeroRTT) {
+  for (int num_streams = 1; num_streams < 3; ++num_streams) {
+    GURL url = GURL("https://www.google.com");
+
+    // Set up QUIC as alternative_service.
+    HttpServerPropertiesImpl http_server_properties;
+    const AlternativeService alternative_service(QUIC, url.host().c_str(),
+                                                 url.IntPort());
+    AlternativeServiceInfoVector alternative_service_info_vector;
+    base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
+    alternative_service_info_vector.push_back(
+        AlternativeServiceInfo(alternative_service, 1.0, expiration));
+    HostPortPair host_port_pair(alternative_service.host_port_pair());
+    http_server_properties.SetAlternativeServices(
+        host_port_pair, alternative_service_info_vector);
+
+    SpdySessionDependencies session_deps(
+        GetParam(), 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;
+    params.quic_disable_preconnect_if_0rtt = true;
+    params.http_server_properties = http_server_properties.GetWeakPtr();
+
+    scoped_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());
+    CapturePreconnectsSSLSocketPool* ssl_conn_pool =
+        new CapturePreconnectsSSLSocketPool(session_deps.host_resolver.get(),
+                                            session_deps.cert_verifier.get());
+    scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
+        new MockClientSocketPoolManager);
+    mock_pool_manager->SetSocketPoolForHTTPProxy(proxy_host, http_proxy_pool);
+    mock_pool_manager->SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
+    peer.SetClientSocketPoolManager(mock_pool_manager.Pass());
+    PreconnectHelperForURL(num_streams, url, session.get());
+    EXPECT_EQ(num_streams, ssl_conn_pool->last_num_streams());
+  }
+}
+
+TEST_P(HttpStreamFactoryTest, QuicDisablePreConnectIfZeroRtt) {
+  for (int num_streams = 1; num_streams < 3; ++num_streams) {
+    GURL url = GURL("https://www.google.com");
+
+    // Set up QUIC as alternative_service.
+    HttpServerPropertiesImpl http_server_properties;
+    const AlternativeService alternative_service(QUIC, "www.google.com", 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, 1.0, expiration));
+    HostPortPair host_port_pair(alternative_service.host_port_pair());
+    http_server_properties.SetAlternativeServices(
+        host_port_pair, alternative_service_info_vector);
+
+    SpdySessionDependencies session_deps(GetParam());
+
+    // Setup params to disable preconnect, but QUIC does 0RTT.
+    HttpNetworkSession::Params params =
+        SpdySessionDependencies::CreateSessionParams(&session_deps);
+    params.enable_quic = true;
+    params.quic_disable_preconnect_if_0rtt = true;
+    params.http_server_properties = http_server_properties.GetWeakPtr();
+
+    scoped_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));
+
+    HttpNetworkSessionPeer peer(session.get());
+    CapturePreconnectsTransportSocketPool* transport_conn_pool =
+        new CapturePreconnectsTransportSocketPool(
+            session_deps.host_resolver.get(), session_deps.cert_verifier.get());
+    scoped_ptr<MockClientSocketPoolManager> mock_pool_manager(
+        new MockClientSocketPoolManager);
+    mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
+    peer.SetClientSocketPoolManager(mock_pool_manager.Pass());
+
+    HttpRequestInfo request;
+    request.method = "GET";
+    request.url = url;
+    request.load_flags = 0;
+
+    SSLConfig ssl_config;
+    session->ssl_config_service()->GetSSLConfig(&ssl_config);
+    session->http_stream_factory()->PreconnectStreams(num_streams, request,
+                                                      ssl_config, ssl_config);
+    EXPECT_EQ(-1, transport_conn_pool->last_num_streams());
+  }
+}
+
 namespace {
 
 TEST_P(HttpStreamFactoryTest, PrivacyModeDisablesChannelId) {
   SpdySessionDependencies session_deps(
       GetParam(), ProxyService::CreateDirect());
 
   StaticSocketDataProvider socket_data;
   socket_data.set_connect_data(MockConnect(ASYNC, OK));
   session_deps.socket_factory->AddSocketDataProvider(&socket_data);
 
@@ skipping 679 matching lines @@
   EXPECT_TRUE(waiter.used_proxy_info().is_direct());
 
   // Make sure there is no orphaned job. it is already canceled.
   ASSERT_EQ(0u, static_cast<HttpStreamFactoryImpl*>(
       session->http_stream_factory_for_websocket())->num_orphaned_jobs());
 }
 
 }  // namespace
 
 }  // namespace net