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/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.disable_preconnects = 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.disable_preconnects = 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, PreconnectDisabled) {

[Ryan Hamilton, 2015/12/05 04:16:17]

It'd be good to have a test where preconnect works when QUIC can not do 0-rtt.

[ramant (doing other things), 2015/12/07 20:05:39]

Done.

+  // Set up QUIC as alternative_service.
+  HttpServerPropertiesImpl http_server_properties;
+  const AlternativeService alternative_service1(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_service1, 1.0, expiration));
+  HostPortPair host_port_pair(alternative_service1.host_port_pair());
+  http_server_properties.SetAlternativeServices(
+      host_port_pair, alternative_service_info_vector);
+
+  SpdySessionDependencies session_deps(GetParam());
+
+  // Setup params.
+  HttpNetworkSession::Params params =
+      SpdySessionDependencies::CreateSessionParams(&session_deps);
+  params.enable_quic = true;
+  params.disable_preconnects = 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, 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 = GURL("https://www.google.com:443");

[Ryan Hamilton, 2015/12/05 04:16:17]

nit: do you need :443?

[ramant (doing other things), 2015/12/07 20:05:39]

Done.

+  request.load_flags = 0;
+
+  SSLConfig ssl_config;
+  session->ssl_config_service()->GetSSLConfig(&ssl_config);
+  session->http_stream_factory()->PreconnectStreams(1, 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