Fork SPDY/2 and SPDY/3 versions of our SPDY tests, in preparation for landing

net/http/http_proxy_client_socket_pool_spdy2_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_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/net_errors.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_proxy_client_socket.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_histograms.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_protocol.h"
-#include "net/spdy/spdy_test_util.h"
+#include "net/spdy/spdy_test_util_spdy2.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using namespace net::test_spdy2;
+
 namespace net {
 
 namespace {
 
 const int kMaxSockets = 32;
 const int kMaxSocketsPerGroup = 6;
 const char * const kAuthHeaders[] = {
   "proxy-authorization", "Basic Zm9vOmJhcg=="
 };
 const int kAuthHeadersSize = arraysize(kAuthHeaders) / 2;
 
 enum HttpProxyType {
   HTTP,
   HTTPS,
   SPDY
 };
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 }  // namespace
 
-class HttpProxyClientSocketPoolTest : public TestWithHttpParam {
+class HttpProxyClientSocketPoolSpdy2Test : public TestWithHttpParam {
  protected:
-  HttpProxyClientSocketPoolTest()
+  HttpProxyClientSocketPoolSpdy2Test()
       : ssl_config_(),
         ignored_transport_socket_params_(new TransportSocketParams(
             HostPortPair("proxy", 80), LOWEST, false, false)),
         ignored_ssl_socket_params_(new SSLSocketParams(
             ignored_transport_socket_params_, NULL, NULL,
             ProxyServer::SCHEME_DIRECT, HostPortPair("www.google.com", 443),
             ssl_config_, 0, false, false)),
         tcp_histograms_("MockTCP"),
         transport_socket_pool_(
             kMaxSockets, kMaxSocketsPerGroup,
@@ skipping 23 matching lines @@
         ssl_data_(NULL),
         data_(NULL),
         pool_(kMaxSockets, kMaxSocketsPerGroup,
               &http_proxy_histograms_,
               NULL,
               &transport_socket_pool_,
               &ssl_socket_pool_,
               NULL) {
   }
 
-  virtual ~HttpProxyClientSocketPoolTest() {
+  virtual ~HttpProxyClientSocketPoolSpdy2Test() {
   }
 
   void AddAuthToCache() {
     const string16 kFoo(ASCIIToUTF16("foo"));
     const string16 kBar(ASCIIToUTF16("bar"));
     GURL proxy_url(GetParam() == HTTP ? "http://proxy" : "https://proxy:80");
     session_->http_auth_cache()->Add(proxy_url,
                                      "MyRealm1",
                                      HttpAuth::AUTH_SCHEME_BASIC,
                                      "Basic realm=MyRealm1",
@@ skipping 61 matching lines @@
       ssl_data_.reset(new SSLSocketDataProvider(SYNCHRONOUS, OK));
       if (GetParam() == SPDY) {
         InitializeSpdySsl();
       }
       socket_factory_.AddSSLSocketDataProvider(ssl_data_.get());
     }
   }
 
   void InitializeSpdySsl() {
     spdy::SpdyFramer::set_enable_compression_default(false);
-    ssl_data_->SetNextProto(SSLClientSocket::kProtoSPDY21);
+    ssl_data_->SetNextProto(SSLClientSocket::kProtoSPDY2);
   }
 
   HttpNetworkSession* CreateNetworkSession() {
     HttpNetworkSession::Params params;
     params.host_resolver = &host_resolver_;
     params.cert_verifier = &cert_verifier_;
     params.proxy_service = proxy_service_.get();
     params.client_socket_factory = &socket_factory_;
     params.ssl_config_service = ssl_config_service_;
     params.http_auth_handler_factory = http_auth_handler_factory_.get();
@@ skipping 25 matching lines @@
   scoped_ptr<SSLSocketDataProvider> ssl_data_;
   scoped_refptr<DeterministicSocketData> data_;
   HttpProxyClientSocketPool pool_;
   ClientSocketHandle handle_;
   TestCompletionCallback callback_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 // and SPDY.
-INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolTests,
-                        HttpProxyClientSocketPoolTest,
+INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolSpdy2Tests,
+                        HttpProxyClientSocketPoolSpdy2Test,
                         ::testing::Values(HTTP, HTTPS, SPDY));
 
-TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, NoTunnel) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   int rv = handle_.Init("a", GetNoTunnelParams(), LOW, CompletionCallback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, NeedAuth) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, NeedAuth) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0, "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
   MockRead reads[] = {
     // No credentials.
     MockRead(ASYNC, 1, "HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead(ASYNC, 2, "Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead(ASYNC, 3, "Content-Length: 10\r\n\r\n"),
@@ skipping 47 matching lines @@
   if (GetParam() == SPDY) {
     EXPECT_TRUE(tunnel_socket->IsConnected());
     EXPECT_TRUE(tunnel_socket->IsUsingSpdy());
   } else {
     EXPECT_FALSE(tunnel_socket->IsConnected());
     EXPECT_FALSE(tunnel_socket->IsUsingSpdy());
     EXPECT_FALSE(tunnel_socket->IsUsingSpdy());
   }
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, HaveAuth) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, HaveAuth) {
   // It's pretty much impossible to make the SPDY case behave synchronously
   // so we skip this test for SPDY
   if (GetParam() == SPDY)
     return;
   MockWrite writes[] = {
     MockWrite(SYNCHRONOUS, 0,
               "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes), NULL, 0,
              NULL, 0);
   AddAuthToCache();
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, AsyncHaveAuth) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, AsyncHaveAuth) {
   MockWrite writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(SYNCHRONOUS, "HTTP/1.1 200 Connection Established\r\n\r\n"),
   };
 
@@ skipping 21 matching lines @@
 
   data_->RunFor(2);
   EXPECT_EQ(OK, callback_.WaitForResult());
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, TCPError) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, TCPError) {
   if (GetParam() == SPDY) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
   data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
 
   socket_factory().AddSocketDataProvider(data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, SSLError) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, SSLError) {
   if (GetParam() == HTTP) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_CERT_AUTHORITY_INVALID));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, SslClientAuth) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, SslClientAuth) {
   if (GetParam() == HTTP) return;
   data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_SSL_CLIENT_AUTH_CERT_NEEDED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, TunnelUnexpectedClose) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, TunnelUnexpectedClose) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0,
               "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 200 Conn"),
     MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2),
@@ skipping 17 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   data_->RunFor(3);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback_.WaitForResult());
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
-TEST_P(HttpProxyClientSocketPoolTest, TunnelSetupError) {
+TEST_P(HttpProxyClientSocketPoolSpdy2Test, TunnelSetupError) {
   MockWrite writes[] = {
     MockWrite(ASYNC, 0,
               "CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
   MockRead reads[] = {
     MockRead(ASYNC, 1, "HTTP/1.1 304 Not Modified\r\n\r\n"),
   };
@@ skipping 33 matching lines @@
     // HTTPS or SPDY Proxy CONNECT responses are trustworthy
     EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv);
     EXPECT_TRUE(handle_.is_initialized());
     EXPECT_TRUE(handle_.socket());
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net