Prevent over-preconnecting when we already have a SpdySession.

net/http/http_stream_factory_unittest.cc

 // Copyright (c) 2010 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.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_log.h"
 #include "net/base/ssl_config_service_defaults.h"
 #include "net/base/test_completion_callback.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_request_info.h"
 #include "net/socket/socket_test_util.h"
+#include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 struct SessionDependencies {
   // Custom proxy service dependency.
   explicit SessionDependencies(ProxyService* proxy_service)
@@ skipping 126 matching lines @@
 typedef CapturePreconnectsSocketPool<HttpProxyClientSocketPool>
 CapturePreconnectsHttpProxySocketPool;
 typedef CapturePreconnectsSocketPool<SOCKSClientSocketPool>
 CapturePreconnectsSOCKSSocketPool;
 typedef CapturePreconnectsSocketPool<SSLClientSocketPool>
 CapturePreconnectsSSLSocketPool;
 
 template<typename ParentPool>
 CapturePreconnectsSocketPool<ParentPool>::CapturePreconnectsSocketPool(
     HttpNetworkSession* session)
-    : ParentPool(0, 0, NULL, session->host_resolver(), NULL, NULL) {}
+    : ParentPool(0, 0, NULL, session->host_resolver(), NULL, NULL),
+      last_num_streams_(-1) {}
 
 template<>
 CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool(
     HttpNetworkSession* session)
     : HttpProxyClientSocketPool(0, 0, NULL, session->host_resolver(), NULL,
-                                NULL, NULL) {}
+                                NULL, NULL),
+      last_num_streams_(-1) {}
 
 template<>
 CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool(
     HttpNetworkSession* session)
     : SSLClientSocketPool(0, 0, NULL, session->host_resolver(),
                           session->cert_verifier(), NULL, NULL,
-                          NULL, NULL, NULL, NULL, NULL, NULL, NULL) {}
+                          NULL, NULL, NULL, NULL, NULL, NULL, NULL),
+      last_num_streams_(-1) {}
 
 TEST(HttpStreamFactoryTest, PreconnectDirect) {
   for (size_t i = 0; i < arraysize(kTests); ++i) {
     SessionDependencies session_deps(ProxyService::CreateDirect());
     scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
     HttpNetworkSessionPeer peer(session);
     CapturePreconnectsTCPSocketPool* tcp_conn_pool =
         new CapturePreconnectsTCPSocketPool(session);
     peer.SetTCPSocketPool(tcp_conn_pool);
     CapturePreconnectsSSLSocketPool* ssl_conn_pool =
@@ skipping 41 matching lines @@
         new CapturePreconnectsSSLSocketPool(session);
     peer.SetSocketPoolForSSLWithProxy(proxy_host, ssl_conn_pool);
     EXPECT_EQ(OK, PreconnectHelper(kTests[i], session));
     if (kTests[i].ssl)
       EXPECT_EQ(kTests[i].num_streams, ssl_conn_pool->last_num_streams());
     else
       EXPECT_EQ(kTests[i].num_streams, socks_proxy_pool->last_num_streams());
   }
 }
 
+TEST(HttpStreamFactoryTest, PreconnectDirectWithExistingSpdySession) {
+  for (size_t i = 0; i < arraysize(kTests); ++i) {
+    SessionDependencies session_deps(ProxyService::CreateDirect());
+    scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+    HttpNetworkSessionPeer peer(session);
+
+    // Set an existing SpdySession in the pool.
+    HostPortPair host_port_pair("www.google.com", 443);
+    HostPortProxyPair pair(host_port_pair, ProxyServer::Direct());
+    scoped_refptr<SpdySession> spdy_session =
+        session->spdy_session_pool()->Get(
+            pair, session->mutable_spdy_settings(), BoundNetLog());
+
+    CapturePreconnectsTCPSocketPool* tcp_conn_pool =
+        new CapturePreconnectsTCPSocketPool(session);
+    peer.SetTCPSocketPool(tcp_conn_pool);
+    CapturePreconnectsSSLSocketPool* ssl_conn_pool =
+        new CapturePreconnectsSSLSocketPool(session.get());
+    peer.SetSSLSocketPool(ssl_conn_pool);
+    EXPECT_EQ(OK, PreconnectHelper(kTests[i], session));
+    // We shouldn't be preconnecting if we have an existing session, which is
+    // the case for https://www.google.com.
+    if (kTests[i].ssl)
+      EXPECT_EQ(-1, ssl_conn_pool->last_num_streams());
+    else
+      EXPECT_EQ(kTests[i].num_streams, tcp_conn_pool->last_num_streams());
+  }
+}
+
 }  // namespace
 
 }  // namespace net