Merging SPDY IP connection pooling changes from the trunk (r93105)

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2011 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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 8666 matching lines @@
 
     // Now that the new handshake has failed, ensure that the client
     // certificate was removed from the client auth cache.
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup("proxy:70",
                                                           &client_cert));
     ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup("www.example.com:443",
                                                           &client_cert));
   }
 }
 
+void IPPoolingPreloadHostCache(MockCachingHostResolver* host_resolver,
+                               SpdySessionPoolPeer* pool_peer) {
+  const int kTestPort = 443;
+  struct TestHosts {
+    std::string name;
+    std::string iplist;
+  } test_hosts[] = {
+    { "www.google.com", "127.0.0.1"},
+  };
+
+  // Preload cache entries into HostCache.
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) {
+    host_resolver->rules()->AddIPLiteralRule(test_hosts[i].name,
+        test_hosts[i].iplist, "");
+
+    AddressList addresses;
+    // This test requires that the HostResolver cache be populated.  Normal
+    // code would have done this already, but we do it manually.
+    HostResolver::RequestInfo info(HostPortPair(test_hosts[i].name, kTestPort));
+    host_resolver->Resolve(
+        info, &addresses, NULL, NULL, BoundNetLog());
+
+    // Setup a HostPortProxyPair
+    HostPortProxyPair pair = HostPortProxyPair(
+        HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct());
+
+    const addrinfo* address = addresses.head();
+    pool_peer->AddAlias(address, pair);
+  }
+}
+
 TEST_F(HttpNetworkTransactionTest, UseIPConnectionPooling) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::set_next_protos(kExpectedNPNString);
   DisableSpdySessionDomainVerification();
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
   SessionDependencies session_deps;
   MockCachingHostResolver host_resolver;
   net::HttpNetworkSession::Params params;
   params.client_socket_factory = &session_deps.socket_factory;
   params.host_resolver = &host_resolver;
   params.cert_verifier = session_deps.cert_verifier.get();
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
   params.http_auth_handler_factory =
       session_deps.http_auth_handler_factory.get();
   params.net_log = session_deps.net_log;
   scoped_refptr<HttpNetworkSession> session(new HttpNetworkSession(params));
+  SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> host1_req(ConstructSpdyGet(
       "https://www.google.com", false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> host2_req(ConstructSpdyGet(
@@ skipping 39 matching lines @@
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(&trans1, &response_data));
   EXPECT_EQ("hello!", response_data);
 
   // Preload www.gmail.com into HostCache.
   HostPortPair host_port("www.gmail.com", 443);
   HostResolver::RequestInfo resolve_info(host_port);
   AddressList ignored;
   host_resolver.Resolve(resolve_info, &ignored, NULL, NULL, BoundNetLog());
 
+  IPPoolingPreloadHostCache(&host_resolver, &pool_peer);
+
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(session);
 
   rv = trans2.Start(&request2, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 39 matching lines @@
   }
 
   virtual void AddObserver(Observer* observer) {
     return host_resolver_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) {
     return host_resolver_.RemoveObserver(observer);
   }
 
+  MockCachingHostResolver* GetMockHostResolver() {
+    return &host_resolver_;
+  }
+
  private:
   MockCachingHostResolver host_resolver_;
   const HostPortPair host_port_;
 };
 
 TEST_F(HttpNetworkTransactionTest,
        UseIPConnectionPoolingWithHostCacheExpiration) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::set_next_protos(kExpectedNPNString);
   DisableSpdySessionDomainVerification();
 
   // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
   SessionDependencies session_deps;
   OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443));
   net::HttpNetworkSession::Params params;
   params.client_socket_factory = &session_deps.socket_factory;
   params.host_resolver = &host_resolver;
   params.cert_verifier = session_deps.cert_verifier.get();
   params.proxy_service = session_deps.proxy_service.get();
   params.ssl_config_service = session_deps.ssl_config_service;
   params.http_auth_handler_factory =
       session_deps.http_auth_handler_factory.get();
   params.net_log = session_deps.net_log;
   scoped_refptr<HttpNetworkSession> session(new HttpNetworkSession(params));
+  SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> host1_req(ConstructSpdyGet(
       "https://www.google.com", false, 1, LOWEST));
   scoped_ptr<spdy::SpdyFrame> host2_req(ConstructSpdyGet(
@@ skipping 44 matching lines @@
   HostResolver::RequestInfo resolve_info(HostPortPair("www.gmail.com", 443));
   AddressList ignored;
   host_resolver.Resolve(resolve_info, &ignored, NULL, NULL, BoundNetLog());
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.gmail.com/");
   request2.load_flags = 0;
   HttpNetworkTransaction trans2(session);
 
+  IPPoolingPreloadHostCache(host_resolver.GetMockHostResolver(), &pool_peer);
+
   rv = trans2.Start(&request2, &callback, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   response = trans2.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   EXPECT_TRUE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
   ASSERT_EQ(OK, ReadTransaction(&trans2, &response_data));
   EXPECT_EQ("hello!", response_data);
 
   HttpStreamFactory::set_next_protos("");
   HttpStreamFactory::set_use_alternate_protocols(false);
 }
 
 }  // namespace net