[SPDY] Enable tests for SPDY/3.1 and SPDY/4

net/http/http_network_transaction_unittest.cc

 // Copyright 2013 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 <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 83 matching lines @@
     const char* value = va_arg(args, const char*);
     if (value == NULL)
       break;
     ret.push_back(value);
   }
   va_end(args);
 
   return ret;
 }
 
-// SpdyNextProtos returns a vector of NPN protocol strings for negotiating
-// SPDY.
-std::vector<std::string> SpdyNextProtos() {
-  return MakeNextProtos("http/1.1", "spdy/2", NULL);
-}
-
 int GetIdleSocketCountInTransportSocketPool(net::HttpNetworkSession* session) {
   return session->GetTransportSocketPool(
       net::HttpNetworkSession::NORMAL_SOCKET_POOL)->IdleSocketCount();
 }
 
 int GetIdleSocketCountInSSLSocketPool(net::HttpNetworkSession* session) {
   return session->GetSSLSocketPool(
       net::HttpNetworkSession::NORMAL_SOCKET_POOL)->IdleSocketCount();
 }
 
@@ skipping 153 matching lines @@
     base::MessageLoop::current()->RunUntilIdle();
     // Empty the current queue.
     base::MessageLoop::current()->RunUntilIdle();
     PlatformTest::TearDown();
     NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
     base::MessageLoop::current()->RunUntilIdle();
     HttpStreamFactory::set_use_alternate_protocols(false);
     HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   }
 
+  // This is the expected return from a current server advertising SPDY.
+  std::string GetAlternateProtocolHttpHeader() {
+    return
+        std::string("Alternate-Protocol: 443:") +
+        AlternateProtocolToString(AlternateProtocolFromNextProto(GetParam())) +
+        "\r\n\r\n";
+  }
+
   // Either |write_failure| specifies a write failure or |read_failure|
   // specifies a read failure when using a reused socket.  In either case, the
   // failure should cause the network transaction to resend the request, and the
   // other argument should be NULL.
   void KeepAliveConnectionResendRequestTest(const MockWrite* write_failure,
                                             const MockRead* read_failure);
 
   SimpleGetHelperResult SimpleGetHelperForData(StaticSocketDataProvider* data[],
                                                size_t data_count) {
     SimpleGetHelperResult out;
@@ skipping 228 matching lines @@
                           std::string(),
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL,
                           NULL) {}
 
 //-----------------------------------------------------------------------------
 
-// This is the expected return from a current server advertising SPDY.
-static const char kAlternateProtocolHttpHeader[] =
-    "Alternate-Protocol: 443:npn-spdy/2\r\n\r\n";
-
 // Helper functions for validating that AuthChallengeInfo's are correctly
 // configured for common cases.
 bool CheckBasicServerAuth(const AuthChallengeInfo* auth_challenge) {
   if (!auth_challenge)
     return false;
   EXPECT_FALSE(auth_challenge->is_proxy);
   EXPECT_EQ("www.google.com:80", auth_challenge->challenger.ToString());
   EXPECT_EQ("MyRealm1", auth_challenge->realm);
   EXPECT_EQ("basic", auth_challenge->scheme);
   return true;
@@ skipping 24 matching lines @@
     return false;
   EXPECT_FALSE(auth_challenge->is_proxy);
   EXPECT_EQ("172.22.68.17:80", auth_challenge->challenger.ToString());
   EXPECT_EQ(std::string(), auth_challenge->realm);
   EXPECT_EQ("ntlm", auth_challenge->scheme);
   return true;
 }
 
 }  // namespace
 
-// TODO(akalin): Don't early-exit in the tests below for values >
-// kProtoSPDY3.
-
 TEST_P(HttpNetworkTransactionTest, Basic) {
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 }
 
 TEST_P(HttpNetworkTransactionTest, SimpleGET) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
@@ skipping 2034 matching lines @@
   EXPECT_EQ(200, response->headers->response_code());
   EXPECT_EQ(100, response->headers->GetContentLength());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   // The password prompt info should not be set.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 // Test a SPDY get through an HTTPS Proxy.
 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyGet) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 43 matching lines @@
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ(kUploadData, response_data);
 }
 
 // Test a SPDY get through an HTTPS Proxy.
 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyGetWithProxyAuth) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // Configure against https proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("https://myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 83 matching lines @@
 
   ASSERT_TRUE(response_restart != NULL);
   ASSERT_TRUE(response_restart->headers.get() != NULL);
   EXPECT_EQ(200, response_restart->headers->response_code());
   // The password prompt info should not be set.
   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
 }
 
 // Test a SPDY CONNECT through an HTTPS Proxy to an HTTPS (non-SPDY) Server.
 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyConnectHttps) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 66 matching lines @@
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("1234567890", response_data);
 }
 
 // Test a SPDY CONNECT through an HTTPS Proxy to a SPDY server.
 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyConnectSpdy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 68 matching lines @@
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ(kUploadData, response_data);
 }
 
 // Test a SPDY CONNECT failure through an HTTPS Proxy.
 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyConnectFailure) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 39 matching lines @@
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   // TODO(ttuttle): Anything else to check here?
 }
 
 // Test load timing in the case of two HTTPS (non-SPDY) requests through a SPDY
 // HTTPS Proxy to different servers.
 TEST_P(HttpNetworkTransactionTest,
        HttpsProxySpdyConnectHttpsLoadTimingTwoRequestsTwoServers) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
 
   HttpRequestInfo request1;
   request1.method = "GET";
@@ skipping 138 matching lines @@
   // separate stream.
   EXPECT_NE(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
   EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of two HTTPS (non-SPDY) requests through a SPDY
 // HTTPS Proxy to the same server.
 TEST_P(HttpNetworkTransactionTest,
        HttpsProxySpdyConnectHttpsLoadTimingTwoRequestsSameServer) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
 
   HttpRequestInfo request1;
   request1.method = "GET";
@@ skipping 110 matching lines @@
   // The requests should have the same ID.
   EXPECT_EQ(load_timing_info.socket_log_id, load_timing_info2.socket_log_id);
 
   EXPECT_EQ(2, trans2->Read(buf.get(), 256, callback.callback()));
 }
 
 // Test load timing in the case of of two HTTP requests through a SPDY HTTPS
 // Proxy to different servers.
 TEST_P(HttpNetworkTransactionTest,
        HttpsProxySpdyLoadTimingTwoHttpRequests) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // Configure against https proxy server "proxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed(
       "https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
 
   HttpRequestInfo request1;
   request1.method = "GET";
@@ skipping 2342 matching lines @@
       load_timing_info.connect_timing,
       CONNECT_TIMING_HAS_DNS_TIMES | CONNECT_TIMING_HAS_SSL_TIMES);
 
   EXPECT_TRUE(load_timing_info.send_start.is_null());
   EXPECT_TRUE(load_timing_info.send_end.is_null());
   EXPECT_TRUE(load_timing_info.receive_headers_end.is_null());
 }
 
 // Test an HTTPS (SPDY) Proxy's ability to redirect a CONNECT request
 TEST_P(HttpNetworkTransactionTest, RedirectOfHttpsConnectViaSpdyProxy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("https://proxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<SpdyFrame> conn(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<SpdyFrame> goaway(
@@ skipping 88 matching lines @@
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   // TODO(ttuttle): Anything else to check here?
 }
 
 // Test that a SPDY proxy's response to a CONNECT request is filtered.
 TEST_P(HttpNetworkTransactionTest,
        ErrorResponseToHttpsConnectViaSpdyProxy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   session_deps_.proxy_service.reset(
      ProxyService::CreateFixed("https://proxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<SpdyFrame> conn(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<SpdyFrame> rst(
@@ skipping 40 matching lines @@
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   // TODO(ttuttle): Anything else to check here?
 }
 
 // Test the request-challenge-retry sequence for basic auth, through
 // a SPDY proxy over a single SPDY session.
 TEST_P(HttpNetworkTransactionTest, BasicAuthSpdyProxy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   // when the no authentication data flag is set.
   request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
 
   // Configure against https proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70"));
   CapturingBoundNetLog log;
@@ skipping 128 matching lines @@
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 // Test that an explicitly trusted SPDY proxy can push a resource from an
 // origin that is different from that of its associated resource.
 TEST_P(HttpNetworkTransactionTest, CrossOriginProxyPush) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
   HttpRequestInfo push_request;
 
-  static const unsigned char kPushBodyFrame[] = {
-    0x00, 0x00, 0x00, 0x02,                                      // header, ID
-    0x01, 0x00, 0x00, 0x06,                                      // FIN, length
-    'p', 'u', 's', 'h', 'e', 'd'                                 // "pushed"
-  };
-
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   push_request.method = "GET";
   push_request.url = GURL("http://www.another-origin.com/foo.dat");
 
   // Configure against https proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 15 matching lines @@
 
   scoped_ptr<SpdyFrame>
       stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame>
       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.another-origin.com/foo.dat"));
+  const char kPushedData[] = "pushed";
+  scoped_ptr<SpdyFrame> stream2_body(
+      spdy_util_.ConstructSpdyBodyFrame(
+          2, kPushedData, strlen(kPushedData), true));
 
   MockRead spdy_reads[] = {
     CreateMockRead(*stream1_reply, 2, ASYNC),
     CreateMockRead(*stream2_syn, 3, ASYNC),
     CreateMockRead(*stream1_body, 4, ASYNC),
-    MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame),
-             arraysize(kPushBodyFrame), 5),
+    CreateMockRead(*stream2_body, 5, ASYNC),
     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
   };
 
   OrderedSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
   // Negotiate SPDY to the proxy
   SSLSocketDataProvider proxy(ASYNC, OK);
   proxy.SetNextProto(GetParam());
@@ skipping 50 matching lines @@
   EXPECT_EQ(load_timing_info.socket_log_id,
             push_load_timing_info.socket_log_id);
 
   trans.reset();
   push_trans.reset();
   session->CloseAllConnections();
 }
 
 // Test that an explicitly trusted SPDY proxy cannot push HTTPS content.
 TEST_P(HttpNetworkTransactionTest, CrossOriginProxyPushCorrectness) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpRequestInfo request;
 
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
   // Configure against https proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("https://myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
@@ skipping 876 matching lines @@
 // Tests that for connection endpoints the group names are correctly set.
 
 struct GroupNameTest {
   std::string proxy_server;
   std::string url;
   std::string expected_group_name;
   bool ssl;
 };
 
 scoped_refptr<HttpNetworkSession> SetupSessionForGroupNameTests(
+    NextProto next_proto,
     SpdySessionDependencies* session_deps_) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   http_server_properties->SetAlternateProtocol(
       HostPortPair("host.with.alternate", 80), 443,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(next_proto));
 
   return session;
 }
 
 int GroupNameTransactionHelper(
     const std::string& url,
     const scoped_refptr<HttpNetworkSession>& session) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(url);
@@ skipping 45 matching lines @@
       true,
     },
   };
 
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
-        SetupSessionForGroupNameTests(&session_deps_));
+        SetupSessionForGroupNameTests(GetParam(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session);
     CaptureGroupNameTransportSocketPool* transport_conn_pool =
         new CaptureGroupNameTransportSocketPool(NULL, NULL);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
         new CaptureGroupNameSSLSocketPool(NULL, NULL);
     MockClientSocketPoolManager* mock_pool_manager =
         new MockClientSocketPoolManager;
     mock_pool_manager->SetTransportSocketPool(transport_conn_pool);
     mock_pool_manager->SetSSLSocketPool(ssl_conn_pool);
@@ skipping 42 matching lines @@
       false,
     },
   };
 
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
-        SetupSessionForGroupNameTests(&session_deps_));
+        SetupSessionForGroupNameTests(GetParam(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session);
 
     HostPortPair proxy_host("http_proxy", 80);
     CaptureGroupNameHttpProxySocketPool* http_proxy_pool =
         new CaptureGroupNameHttpProxySocketPool(NULL, NULL);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
         new CaptureGroupNameSSLSocketPool(NULL, NULL);
 
     MockClientSocketPoolManager* mock_pool_manager =
@@ skipping 49 matching lines @@
       true,
     },
   };
 
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     session_deps_.proxy_service.reset(
         ProxyService::CreateFixed(tests[i].proxy_server));
     scoped_refptr<HttpNetworkSession> session(
-        SetupSessionForGroupNameTests(&session_deps_));
+        SetupSessionForGroupNameTests(GetParam(), &session_deps_));
 
     HttpNetworkSessionPeer peer(session);
 
     HostPortPair proxy_host("socks_proxy", 1080);
     CaptureGroupNameSOCKSSocketPool* socks_conn_pool =
         new CaptureGroupNameSOCKSSocketPool(NULL, NULL);
     CaptureGroupNameSSLSocketPool* ssl_conn_pool =
         new CaptureGroupNameSSLSocketPool(NULL, NULL);
 
     MockClientSocketPoolManager* mock_pool_manager =
@@ skipping 687 matching lines @@
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 TEST_P(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   HttpStreamFactory::set_use_alternate_protocols(true);
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
@@ skipping 26 matching lines @@
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 
   ASSERT_TRUE(http_server_properties.HasAlternateProtocol(http_host_port_pair));
   const PortAlternateProtocolPair alternate =
       http_server_properties.GetAlternateProtocol(http_host_port_pair);
   PortAlternateProtocolPair expected_alternate;
   expected_alternate.port = 443;
-  expected_alternate.protocol = NPN_SPDY_2;
+  expected_alternate.protocol = AlternateProtocolFromNextProto(GetParam());
   EXPECT_TRUE(expected_alternate.Equals(alternate));
 
   HttpStreamFactory::SetNextProtos(std::vector<std::string>());
 }
 
 TEST_P(HttpNetworkTransactionTest,
        MarkBrokenAlternateProtocolAndFallback) {
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo request;
@@ skipping 17 matching lines @@
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   // Port must be < 1024, or the header will be ignored (since initial port was
   // port 80 (another restricted port).
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(request.url),
       666 /* port is ignored by MockConnect anyway */,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
@@ skipping 41 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(restricted_port_request.url),
       kUnrestrictedAlternatePort,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &restricted_port_request,
       callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Invalid change to unrestricted port should fail.
@@ skipping 30 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(restricted_port_request.url),
       kUnrestrictedAlternatePort,
-      NPN_SPDY_3);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   EXPECT_EQ(ERR_IO_PENDING, trans->Start(
       &restricted_port_request,
       callback.callback(), BoundNetLog()));
   // Change to unrestricted port should succeed.
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 27 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(restricted_port_request.url),
       kRestrictedAlternatePort,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &restricted_port_request,
       callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
@@ skipping 28 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kRestrictedAlternatePort = 80;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(unrestricted_port_request.url),
       kRestrictedAlternatePort,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to restricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 27 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&second_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnrestrictedAlternatePort = 1024;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(unrestricted_port_request.url),
       kUnrestrictedAlternatePort,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(
       &unrestricted_port_request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Valid change to an unrestricted port should pass.
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 23 matching lines @@
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpServerProperties* http_server_properties =
       session->http_server_properties();
   const int kUnsafePort = 7;
   http_server_properties->SetAlternateProtocol(
       HostPortPair::FromURL(request.url),
       kUnsafePort,
-      NPN_SPDY_2);
+      AlternateProtocolFromNextProto(GetParam()));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // The HTTP request should succeed.
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Disable alternate protocol before the asserts.
   HttpStreamFactory::set_use_alternate_protocols(false);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
   EXPECT_EQ("hello world", response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, UseAlternateProtocolForNpnSpdy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK)
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 56 matching lines @@
   ASSERT_TRUE(response->headers.get() != 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(trans.get(), &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, AlternateProtocolWithSpdyLateBinding) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   // Socket 1 is the HTTP transaction with the Alternate-Protocol header.
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
@@ skipping 91 matching lines @@
 
 TEST_P(HttpNetworkTransactionTest, StallAlternateProtocolForNpnSpdy) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 85 matching lines @@
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
   std::vector<GURL> resolved_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingProxyResolver);
 };
 
 TEST_P(HttpNetworkTransactionTest,
        UseAlternateProtocolForTunneledNpnSpdy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   ProxyConfig proxy_config;
   proxy_config.set_auto_detect(true);
   proxy_config.set_pac_url(GURL("http://fooproxyurl"));
 
   CapturingProxyResolver* capturing_proxy_resolver =
       new CapturingProxyResolver();
   session_deps_.proxy_service.reset(new ProxyService(
       new ProxyConfigServiceFixed(proxy_config), capturing_proxy_resolver,
       NULL));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
     MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 76 matching lines @@
             capturing_proxy_resolver->resolved()[1].spec());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 TEST_P(HttpNetworkTransactionTest,
        UseAlternateProtocolForNpnSpdyWithExistingSpdySession) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(ASYNC, OK),
   };
 
   StaticSocketDataProvider first_transaction(
       data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&first_transaction);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.SetNextProto(GetParam());
@@ skipping 705 matching lines @@
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
+  std::string alternate_protocol_http_header =
+      GetAlternateProtocolHttpHeader();
+
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kAlternateProtocolHttpHeader),
+    MockRead(alternate_protocol_http_header.c_str()),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
 
   SSLSocketDataProvider ssl(ASYNC, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "http/1.1";
   ssl.protocol_negotiated = kProtoHTTP11;
 
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
@@ skipping 61 matching lines @@
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 }
 
 TEST_P(HttpNetworkTransactionTest, SpdyAlternateProtocolThroughProxy) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   // This test ensures that the URL passed into the proxy is upgraded
   // to https when doing an Alternate Protocol upgrade.
   HttpStreamFactory::set_use_alternate_protocols(true);
-  HttpStreamFactory::SetNextProtos(
-      MakeNextProtos(
-          "http/1.1", "http1.1", "spdy/2", "spdy", NULL));
+  HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
   HttpAuthHandlerMock::Factory* auth_factory =
       new HttpAuthHandlerMock::Factory();
   HttpAuthHandlerMock* auth_handler = new HttpAuthHandlerMock();
   auth_factory->AddMockHandler(auth_handler, HttpAuth::AUTH_PROXY);
   auth_factory->set_do_init_from_challenge(true);
@@ skipping 356 matching lines @@
       entries, 0, NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
       NetLog::PHASE_NONE);
   ExpectLogContainsSomewhere(
       entries, pos,
       NetLog::TYPE_HTTP_TRANSACTION_READ_TUNNEL_RESPONSE_HEADERS,
       NetLog::PHASE_NONE);
 }
 
 // Test for crbug.com/55424.
 TEST_P(HttpNetworkTransactionTest, PreconnectWithExistingSpdySession) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet("https://www.google.com", false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
     MockRead(ASYNC, 0, 0),
@@ skipping 434 matching lines @@
 #define WRAPPED_TEST_P(test_case_name, test_name) \
   TEST_P(test_case_name, test_name)
 
 // Times out on Win7 dbg(2) bot. http://crbug.com/124776
 #if defined(OS_WIN)
 #define MAYBE_UseIPConnectionPooling DISABLED_UseIPConnectionPooling
 #else
 #define MAYBE_UseIPConnectionPooling UseIPConnectionPooling
 #endif
 WRAPPED_TEST_P(HttpNetworkTransactionTest, MAYBE_UseIPConnectionPooling) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
   session_deps_.host_resolver.reset(new MockCachingHostResolver());
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 80 matching lines @@
   ASSERT_TRUE(response->headers.get() != 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);
 }
 #undef MAYBE_UseIPConnectionPooling
 
 TEST_P(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   // Set up a special HttpNetworkSession with a MockCachingHostResolver.
   session_deps_.host_resolver.reset(new MockCachingHostResolver());
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
   SSLSocketDataProvider ssl(ASYNC, OK);
@@ skipping 117 matching lines @@
 // Times out on Win7 dbg(2) bot. http://crbug.com/124776
 #if defined(OS_WIN)
 #define MAYBE_UseIPConnectionPoolingWithHostCacheExpiration \
     DISABLED_UseIPConnectionPoolingWithHostCacheExpiration
 #else
 #define MAYBE_UseIPConnectionPoolingWithHostCacheExpiration \
     UseIPConnectionPoolingWithHostCacheExpiration
 #endif
 WRAPPED_TEST_P(HttpNetworkTransactionTest,
                MAYBE_UseIPConnectionPoolingWithHostCacheExpiration) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
 // Times out on Win7 dbg(2) bot. http://crbug.com/124776 . (MAYBE_
 // prefix doesn't work with parametrized tests).
 #if defined(OS_WIN)
   return;
 #endif
 
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
@@ skipping 134 matching lines @@
   StaticSocketDataProvider* data[] = { &data1, &data2 };
 
   SimpleGetHelperResult out = SimpleGetHelperForData(data, arraysize(data));
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttp) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   const std::string https_url = "https://www.google.com/";
   const std::string http_url = "http://www.google.com:443/";
 
   // SPDY GET for HTTPS URL
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST));
 
   MockWrite writes1[] = {
     CreateMockWrite(*req1, 0),
   };
@@ skipping 61 matching lines @@
   TestCompletionCallback callback2;
   EXPECT_EQ(ERR_IO_PENDING,
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_FALSE(trans2.GetResponseInfo()->was_fetched_via_spdy);
 }
 
 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttpOverTunnel) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   const std::string https_url = "https://www.google.com/";
   const std::string http_url = "http://www.google.com:443/";
 
   // SPDY GET for HTTPS URL (through CONNECT tunnel)
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST));
 
   // SPDY GET for HTTP URL (through the proxy, but not the tunnel)
   scoped_ptr<SpdyFrame> wrapped_req1(
@@ skipping 92 matching lines @@
   LoadTimingInfo load_timing_info2;
   EXPECT_TRUE(trans2.GetLoadTimingInfo(&load_timing_info2));
   // The established SPDY sessions is considered reused by the HTTP request.
   TestLoadTimingReusedWithPac(load_timing_info2);
   // HTTP requests over a SPDY session should have a different connection
   // socket_log_id than requests over a tunnel.
   EXPECT_NE(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 }
 
 TEST_P(HttpNetworkTransactionTest, UseSpdySessionForHttpWhenForced) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::set_force_spdy_always(true);
   const std::string https_url = "https://www.google.com/";
   const std::string http_url = "http://www.google.com:443/";
 
   // SPDY GET for HTTPS URL
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST));
   // SPDY GET for the HTTP URL
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(http_url.c_str(), false, 3, MEDIUM));
@@ skipping 52 matching lines @@
 
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
 }
 
 // Test that in the case where we have a SPDY session to a SPDY proxy
 // that we do not pool other origins that resolve to the same IP when
 // the certificate does not match the new origin.
 // http://crbug.com/134690
 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionIfCertDoesNotMatch) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   const std::string url1 = "http://www.google.com/";
   const std::string url2 = "https://mail.google.com/";
   const std::string ip_addr = "1.2.3.4";
 
   // SPDY GET for HTTP URL (through SPDY proxy)
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructGetHeaderBlockForProxy("http://www.google.com/"));
   scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyControlFrame(
       headers.Pass(), false, 1, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN, 0));
 
@@ skipping 109 matching lines @@
   ASSERT_TRUE(callback2.have_result());
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
 }
 
 // Test to verify that a failed socket read (due to an ERR_CONNECTION_CLOSED
 // error) in SPDY session, removes the socket from pool and closes the SPDY
 // session. Verify that new url's from the same HttpNetworkSession (and a new
 // SpdySession) do work. http://crbug.com/224701
 TEST_P(HttpNetworkTransactionTest, ErrorSocketNotConnected) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   const std::string https_url = "https://www.google.com/";
 
   MockRead reads1[] = {
     MockRead(SYNCHRONOUS, ERR_CONNECTION_CLOSED, 0)
   };
 
   scoped_ptr<DeterministicSocketData> data1(
       new DeterministicSocketData(reads1, arraysize(reads1), NULL, 0));
   data1->SetStop(1);
 
@@ skipping 54 matching lines @@
             trans2.Start(&request2, callback2.callback(), BoundNetLog()));
   base::MessageLoop::current()->RunUntilIdle();
   data2->RunFor(3);
 
   ASSERT_TRUE(callback2.have_result());
   EXPECT_EQ(OK, callback2.WaitForResult());
   EXPECT_TRUE(trans2.GetResponseInfo()->was_fetched_via_spdy);
 }
 
 TEST_P(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
-  if (GetParam() > kProtoSPDY3)
-    return;
-
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   ClientSocketPoolManager::set_max_sockets_per_group(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
   ClientSocketPoolManager::set_max_sockets_per_pool(
       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 
   // Use two different hosts with different IPs so they don't get pooled.
   session_deps_.host_resolver->rules()->AddRule("www.a.com", "10.0.0.1");
   session_deps_.host_resolver->rules()->AddRule("www.b.com", "10.0.0.2");
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
@@ skipping 399 matching lines @@
   EXPECT_EQ(OK, rv);
 
   HttpRequestHeaders request_headers;
   EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
   std::string foo;
   EXPECT_TRUE(request_headers.GetHeader("X-Foo", &foo));
   EXPECT_EQ("bar", foo);
 }
 
 }  // namespace net