Merge the HttpNetworkTransaction tests and parametrize them on a NextProto

net/http/http_network_transaction_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_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 38 matching lines @@
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_pool_manager.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/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
-#include "net/spdy/spdy_test_util_spdy2.h"
+#include "net/spdy/spdy_test_util_common.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/ssl/ssl_info.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
-using namespace net::test_spdy2;
-
 //-----------------------------------------------------------------------------
 
 namespace {
 
 const base::string16 kBar(ASCIIToUTF16("bar"));
 const base::string16 kBar2(ASCIIToUTF16("bar2"));
 const base::string16 kBar3(ASCIIToUTF16("bar3"));
 const base::string16 kBaz(ASCIIToUTF16("baz"));
 const base::string16 kFirst(ASCIIToUTF16("first"));
 const base::string16 kFoo(ASCIIToUTF16("foo"));
@@ skipping 149 matching lines @@
 namespace net {
 
 namespace {
 
 HttpNetworkSession* CreateSession(SpdySessionDependencies* session_deps) {
   return SpdySessionDependencies::SpdyCreateSession(session_deps);
 }
 
 }  // namespace
 
-class HttpNetworkTransactionSpdy2Test : public PlatformTest {
+class HttpNetworkTransactionTest
+    : public PlatformTest,
+      public ::testing::WithParamInterface<NextProto> {
  public:
-  virtual ~HttpNetworkTransactionSpdy2Test() {
+  virtual ~HttpNetworkTransactionTest() {
     // Important to restore the per-pool limit first, since the pool limit must
     // always be greater than group limit, and the tests reduce both limits.
     ClientSocketPoolManager::set_max_sockets_per_pool(
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_);
     ClientSocketPoolManager::set_max_sockets_per_group(
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_);
   }
 
  protected:
-  HttpNetworkTransactionSpdy2Test()
-      : spdy_util_(kProtoSPDY2),
-        session_deps_(kProtoSPDY2),
+  HttpNetworkTransactionTest()
+      : spdy_util_(GetParam()),
+        session_deps_(GetParam()),
         old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group(
             HttpNetworkSession::NORMAL_SOCKET_POOL)),
         old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool(
             HttpNetworkSession::NORMAL_SOCKET_POOL)) {
   }
 
   struct SimpleGetHelperResult {
     int rv;
     std::string status_line;
     std::string response_data;
@@ skipping 113 matching lines @@
 
   SpdyTestUtil spdy_util_;
   SpdySessionDependencies session_deps_;
 
   // Original socket limits.  Some tests set these.  Safest to always restore
   // them once each test has been run.
   int old_max_group_sockets_;
   int old_max_pool_sockets_;
 };
 
+INSTANTIATE_TEST_CASE_P(
+    NextProto,
+    HttpNetworkTransactionTest,
+    testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
+
 namespace {
 
 // Fill |str| with a long header list that consumes >= |size| bytes.
 void FillLargeHeadersString(std::string* str, int size) {
   const char* row =
       "SomeHeaderName: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\r\n";
   const int sizeof_row = strlen(row);
   const int num_rows = static_cast<int>(
       ceil(static_cast<float>(size) / sizeof_row));
   const int sizeof_data = num_rows * sizeof_row;
@@ skipping 159 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
 
-TEST_F(HttpNetworkTransactionSpdy2Test, Basic) {
+// 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_F(HttpNetworkTransactionSpdy2Test, SimpleGET) {
+TEST_P(HttpNetworkTransactionTest, SimpleGET) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Response with no status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, SimpleGETNoHeaders) {
+TEST_P(HttpNetworkTransactionTest, SimpleGETNoHeaders) {
   MockRead data_reads[] = {
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk3Bytes) {
+TEST_P(HttpNetworkTransactionTest, StatusLineJunk3Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk4Bytes) {
+TEST_P(HttpNetworkTransactionTest, StatusLineJunk4Bytes) {
   MockRead data_reads[] = {
     MockRead("\n\nQJHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Beyond 4 bytes of slop and it should fail to find a status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk5Bytes) {
+TEST_P(HttpNetworkTransactionTest, StatusLineJunk5Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxxxHTTP/1.1 404 Not Found\nServer: blah"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("xxxxxHTTP/1.1 404 Not Found\nServer: blah", out.response_data);
 }
 
 // Same as StatusLineJunk4Bytes, except the read chunks are smaller.
-TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk4Bytes_Slow) {
+TEST_P(HttpNetworkTransactionTest, StatusLineJunk4Bytes_Slow) {
   MockRead data_reads[] = {
     MockRead("\n"),
     MockRead("\n"),
     MockRead("Q"),
     MockRead("J"),
     MockRead("HTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Close the connection before enough bytes to have a status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, StatusLinePartial) {
+TEST_P(HttpNetworkTransactionTest, StatusLinePartial) {
   MockRead data_reads[] = {
     MockRead("HTT"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("HTT", out.response_data);
 }
 
 // Simulate a 204 response, lacking a Content-Length header, sent over a
 // persistent connection.  The response should still terminate since a 204
 // cannot have a response body.
-TEST_F(HttpNetworkTransactionSpdy2Test, StopsReading204) {
+TEST_P(HttpNetworkTransactionTest, StopsReading204) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 204 No Content", out.status_line);
   EXPECT_EQ("", out.response_data);
 }
 
 // A simple request using chunked encoding with some extra data after.
 // (Like might be seen in a pipelined response.)
-TEST_F(HttpNetworkTransactionSpdy2Test, ChunkedEncoding) {
+TEST_P(HttpNetworkTransactionTest, ChunkedEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"),
     MockRead("5\r\nHello\r\n"),
     MockRead("1\r\n"),
     MockRead(" \r\n"),
     MockRead("5\r\nworld\r\n"),
     MockRead("0\r\n\r\nHTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello world", out.response_data);
 }
 
 // Next tests deal with http://crbug.com/56344.
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        MultipleContentLengthHeadersNoTransferEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 10\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH, out.rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        DuplicateContentLengthHeadersNoTransferEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 5\r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("Hello"),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello", out.response_data);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        ComplexContentLengthHeadersNoTransferEncoding) {
   // More than 2 dupes.
   {
     MockRead data_reads[] = {
       MockRead("HTTP/1.1 200 OK\r\n"),
       MockRead("Content-Length: 5\r\n"),
       MockRead("Content-Length: 5\r\n"),
       MockRead("Content-Length: 5\r\n\r\n"),
       MockRead("Hello"),
     };
@@ skipping 25 matching lines @@
       MockRead("Content-Length: 10\r\n"),
       MockRead("Content-Length: 10\r\n"),
       MockRead("Content-Length: 5\r\n\r\n"),
     };
     SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                                 arraysize(data_reads));
     EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_LENGTH, out.rv);
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        MultipleContentLengthHeadersTransferEncoding) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Length: 666\r\n"),
     MockRead("Content-Length: 1337\r\n"),
     MockRead("Transfer-Encoding: chunked\r\n\r\n"),
     MockRead("5\r\nHello\r\n"),
     MockRead("1\r\n"),
     MockRead(" \r\n"),
     MockRead("5\r\nworld\r\n"),
     MockRead("0\r\n\r\nHTTP/1.1 200 OK\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello world", out.response_data);
 }
 
 // Next tests deal with http://crbug.com/98895.
 
 // Checks that a single Content-Disposition header results in no error.
-TEST_F(HttpNetworkTransactionSpdy2Test, SingleContentDispositionHeader) {
+TEST_P(HttpNetworkTransactionTest, SingleContentDispositionHeader) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Disposition: attachment;filename=\"salutations.txt\"r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("Hello"),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello", out.response_data);
 }
 
 // Checks that two identical Content-Disposition headers result in no error.
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        TwoIdenticalContentDispositionHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Disposition: attachment;filename=\"greetings.txt\"r\n"),
     MockRead("Content-Disposition: attachment;filename=\"greetings.txt\"r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("Hello"),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("Hello", out.response_data);
 }
 
 // Checks that two distinct Content-Disposition headers result in an error.
-TEST_F(HttpNetworkTransactionSpdy2Test, TwoDistinctContentDispositionHeaders) {
+TEST_P(HttpNetworkTransactionTest, TwoDistinctContentDispositionHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Disposition: attachment;filename=\"greetings.txt\"r\n"),
     MockRead("Content-Disposition: attachment;filename=\"hi.txt\"r\n"),
     MockRead("Content-Length: 5\r\n\r\n"),
     MockRead("Hello"),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_CONTENT_DISPOSITION, out.rv);
 }
 
 // Checks that two identical Location headers result in no error.
 // Also tests Location header behavior.
-TEST_F(HttpNetworkTransactionSpdy2Test, TwoIdenticalLocationHeaders) {
+TEST_P(HttpNetworkTransactionTest, TwoIdenticalLocationHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
 
   HttpRequestInfo request;
   request.method = "GET";
@@ skipping 16 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL && response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 302 Redirect", response->headers->GetStatusLine());
   std::string url;
   EXPECT_TRUE(response->headers->IsRedirect(&url));
   EXPECT_EQ("http://good.com/", url);
 }
 
 // Checks that two distinct Location headers result in an error.
-TEST_F(HttpNetworkTransactionSpdy2Test, TwoDistinctLocationHeaders) {
+TEST_P(HttpNetworkTransactionTest, TwoDistinctLocationHeaders) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 302 Redirect\r\n"),
     MockRead("Location: http://good.com/\r\n"),
     MockRead("Location: http://evil.com/\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_RESPONSE_HEADERS_MULTIPLE_LOCATION, out.rv);
 }
 
 // Do a request using the HEAD method. Verify that we don't try to read the
 // message body (since HEAD has none).
-TEST_F(HttpNetworkTransactionSpdy2Test, Head) {
+TEST_P(HttpNetworkTransactionTest, Head) {
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes1[] = {
@@ skipping 39 matching lines @@
   EXPECT_EQ("Blah", server_header);
 
   // Reading should give EOF right away, since there is no message body
   // (despite non-zero content-length).
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
+TEST_P(HttpNetworkTransactionTest, ReuseConnection) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
     MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
@@ skipping 26 matching lines @@
     EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
     EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, Ignores100) {
+TEST_P(HttpNetworkTransactionTest, Ignores100) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
   UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.upload_data_stream = &upload_data_stream;
   request.load_flags = 0;
 
@@ skipping 26 matching lines @@
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 }
 
 // This test is almost the same as Ignores100 above, but the response contains
 // a 102 instead of a 100. Also, instead of HTTP/1.0 the response is
 // HTTP/1.1 and the two status headers are read in one read.
-TEST_F(HttpNetworkTransactionSpdy2Test, Ignores1xx) {
+TEST_P(HttpNetworkTransactionTest, Ignores1xx) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockRead data_reads[] = {
@@ skipping 18 matching lines @@
 
   EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, Incomplete100ThenEOF) {
+TEST_P(HttpNetworkTransactionTest, Incomplete100ThenEOF) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockRead data_reads[] = {
@@ skipping 10 matching lines @@
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, EmptyResponse) {
+TEST_P(HttpNetworkTransactionTest, EmptyResponse) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockRead data_reads[] = {
     MockRead(ASYNC, 0),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), NULL, 0);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_EMPTY_RESPONSE, rv);
 }
 
-void HttpNetworkTransactionSpdy2Test::KeepAliveConnectionResendRequestTest(
+void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
     const MockWrite* write_failure,
     const MockRead* read_failure) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
@@ skipping 68 matching lines @@
     EXPECT_TRUE(response->headers.get() != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
     EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        KeepAliveConnectionNotConnectedOnWrite) {
   MockWrite write_failure(ASYNC, ERR_SOCKET_NOT_CONNECTED);
   KeepAliveConnectionResendRequestTest(&write_failure, NULL);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveConnectionReset) {
+TEST_P(HttpNetworkTransactionTest, KeepAliveConnectionReset) {
   MockRead read_failure(ASYNC, ERR_CONNECTION_RESET);
   KeepAliveConnectionResendRequestTest(NULL, &read_failure);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveConnectionEOF) {
+TEST_P(HttpNetworkTransactionTest, KeepAliveConnectionEOF) {
   MockRead read_failure(SYNCHRONOUS, OK);  // EOF
   KeepAliveConnectionResendRequestTest(NULL, &read_failure);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, NonKeepAliveConnectionReset) {
+TEST_P(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockRead data_reads[] = {
@@ skipping 19 matching lines @@
 
 // What do various browsers do when the server closes a non-keepalive
 // connection without sending any response header or body?
 //
 // IE7: error page
 // Safari 3.1.2 (Windows): error page
 // Firefox 3.0.1: blank page
 // Opera 9.52: after five attempts, blank page
 // Us with WinHTTP: error page (ERR_INVALID_RESPONSE)
 // Us: error page (EMPTY_RESPONSE)
-TEST_F(HttpNetworkTransactionSpdy2Test, NonKeepAliveConnectionEOF) {
+TEST_P(HttpNetworkTransactionTest, NonKeepAliveConnectionEOF) {
   MockRead data_reads[] = {
     MockRead(SYNCHRONOUS, OK),  // EOF
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads,
                                               arraysize(data_reads));
   EXPECT_EQ(ERR_EMPTY_RESPONSE, out.rv);
 }
 
 // Next 2 cases (KeepAliveEarlyClose and KeepAliveEarlyClose2) are regression
 // tests. There was a bug causing HttpNetworkTransaction to hang in the
 // destructor in such situations.
 // See http://crbug.com/154712 and http://crbug.com/156609.
-TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose) {
+TEST_P(HttpNetworkTransactionTest, KeepAliveEarlyClose) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
@@ skipping 20 matching lines @@
     rv = callback.WaitForResult();
   EXPECT_EQ(5, rv);
   rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
 
   trans.reset();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose2) {
+TEST_P(HttpNetworkTransactionTest, KeepAliveEarlyClose2) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   MockRead data_reads[] = {
@@ skipping 19 matching lines @@
     rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
 
   trans.reset();
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Test that we correctly reuse a keep-alive connection after not explicitly
 // reading the body.
-TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveAfterUnreadBody) {
+TEST_P(HttpNetworkTransactionTest, KeepAliveAfterUnreadBody) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Note that because all these reads happen in the same
@@ skipping 88 matching lines @@
   ASSERT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello", response_data);
 }
 
 // Test the request-challenge-retry sequence for basic auth.
 // (basic auth is the easiest to mock, because it has no randomness).
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuth) {
+TEST_P(HttpNetworkTransactionTest, BasicAuth) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   CapturingNetLog log;
   session_deps_.net_log = &log;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
@@ skipping 74 matching lines @@
   EXPECT_LE(load_timing_info1.receive_headers_end,
             load_timing_info2.connect_timing.connect_start);
   EXPECT_NE(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, DoNotSendAuth) {
+TEST_P(HttpNetworkTransactionTest, DoNotSendAuth) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
@@ skipping 22 matching lines @@
   rv = callback.WaitForResult();
   EXPECT_EQ(0, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAlive) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAlive) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   CapturingNetLog log;
   session_deps_.net_log = &log;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
@@ skipping 73 matching lines @@
   EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection and with no response body to drain.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveNoBody) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAliveNoBody) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 55 matching lines @@
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection and with a large response body to drain.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveLargeBody) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAliveLargeBody) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 63 matching lines @@
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection, but the server gets impatient and closes the connection.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveImpatientServer) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthKeepAliveImpatientServer) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 65 matching lines @@
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(5, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a connection
 // that requires a restart when setting up an SSL tunnel.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyNoKeepAlive) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthProxyNoKeepAlive) {
   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 proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   CapturingBoundNetLog log;
@@ skipping 95 matching lines @@
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // proxy connection, when setting up an SSL tunnel.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyKeepAlive) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthProxyKeepAlive) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   // Ensure that proxy authentication is attempted even
   // when the no authentication data flag is set.
   request.load_flags = net::LOAD_DO_NOT_SEND_AUTH_DATA;
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
   CapturingBoundNetLog log;
@@ skipping 83 matching lines @@
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
   EXPECT_TRUE(CheckBasicProxyAuth(response->auth_challenge.get()));
 
   // Flush the idle socket before the NetLog and HttpNetworkTransaction go
   // out of scope.
   session->CloseAllConnections();
 }
 
 // Test that we don't read the response body when we fail to establish a tunnel,
 // even if the user cancels the proxy's auth attempt.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyCancelTunnel) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthProxyCancelTunnel) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
@@ skipping 38 matching lines @@
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   // Flush the idle socket before the HttpNetworkTransaction goes out of scope.
   session->CloseAllConnections();
 }
 
 // Test when a server (non-proxy) returns a 407 (proxy-authenticate).
 // The request should fail with ERR_UNEXPECTED_PROXY_AUTH.
-TEST_F(HttpNetworkTransactionSpdy2Test, UnexpectedProxyAuth) {
+TEST_P(HttpNetworkTransactionTest, UnexpectedProxyAuth) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // We are using a DIRECT connection (i.e. no proxy) for this session.
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(ERR_UNEXPECTED_PROXY_AUTH, rv);
 }
 
 // Tests when an HTTPS server (non-proxy) returns a 407 (proxy-authentication)
 // through a non-authenticating proxy. The request should fail with
 // ERR_UNEXPECTED_PROXY_AUTH.
 // Note that it is impossible to detect if an HTTP server returns a 407 through
 // a non-authenticating proxy - there is nothing to indicate whether the
 // response came from the proxy or the server, so it is treated as if the proxy
 // issued the challenge.
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        HttpsServerRequestsProxyAuthThroughProxy) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
 
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
@@ skipping 38 matching lines @@
   size_t pos = ExpectLogContainsSomewhere(
       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 the load timing for HTTPS requests with an HTTP proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
+TEST_P(HttpNetworkTransactionTest, HttpProxyLoadTimingNoPacTwoRequests) {
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/1");
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.google.com/2");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
@@ skipping 77 matching lines @@
   EXPECT_TRUE(trans2->GetLoadTimingInfo(&load_timing_info2));
   TestLoadTimingReused(load_timing_info2);
 
   EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   trans2.reset();
   session->CloseAllConnections();
 }
 
 // Test the load timing for HTTPS requests with an HTTP proxy and a PAC script.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
+TEST_P(HttpNetworkTransactionTest, HttpProxyLoadTimingWithPacTwoRequests) {
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/1");
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.google.com/2");
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(
@@ skipping 78 matching lines @@
   EXPECT_TRUE(trans2->GetLoadTimingInfo(&load_timing_info2));
   TestLoadTimingReusedWithPac(load_timing_info2);
 
   EXPECT_EQ(load_timing_info1.socket_log_id, load_timing_info2.socket_log_id);
 
   trans2.reset();
   session->CloseAllConnections();
 }
 
 // Test a simple get through an HTTPS Proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyGet) {
+TEST_P(HttpNetworkTransactionTest, HttpsProxyGet) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
   // 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(CreateSession(&session_deps_));
@@ skipping 40 matching lines @@
   EXPECT_TRUE(response->headers->IsKeepAlive());
   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_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
+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();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // fetch http://www.google.com/ via SPDY
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, false));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  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),
   };
 
   DelayedSocketData spdy_data(
       1,  // wait for one write to finish before reading.
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info,
                           CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   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(kUploadData, response_data);
 }
 
 // Test a SPDY get through an HTTPS Proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
+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 18 matching lines @@
     CreateMockWrite(*req_get_authorization, 4),
   };
 
   // The first response is a 407 proxy authentication challenge, and the second
   // response will be a 200 response since the second request includes a valid
   // Authorization header.
   const char* const kExtraAuthenticationHeaders[] = {
     "proxy-authenticate", "Basic realm=\"MyRealm1\""
   };
   scoped_ptr<SpdyFrame> resp_authentication(
-      ConstructSpdySynReplyError(
+      spdy_util_.ConstructSpdySynReplyError(
           "407 Proxy Authentication Required",
           kExtraAuthenticationHeaders, arraysize(kExtraAuthenticationHeaders)/2,
           1));
   scoped_ptr<SpdyFrame> body_authentication(
-      ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> resp_data(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> body_data(ConstructSpdyBodyFrame(3, true));
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp_data(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> body_data(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp_authentication, 2),
     CreateMockRead(*body_authentication, 3),
     CreateMockRead(*resp_data, 5),
     CreateMockRead(*body_data, 6),
     MockRead(ASYNC, 0, 7),
   };
 
   OrderedSocketData data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
@@ skipping 20 matching lines @@
   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
 
   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_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
+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();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   // fetch https://www.google.com/ via HTTP
 
   const char get[] = "GET / HTTP/1.1\r\n"
     "Host: www.google.com\r\n"
     "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get(
-      ConstructSpdyBodyFrame(1, get, strlen(get), false));
-  scoped_ptr<SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+      spdy_util_.ConstructSpdyBodyFrame(1, get, strlen(get), false));
+  scoped_ptr<SpdyFrame> conn_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   const char resp[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 10\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get_resp(
-      ConstructSpdyBodyFrame(1, resp, strlen(resp), false));
+      spdy_util_.ConstructSpdyBodyFrame(1, resp, strlen(resp), false));
   scoped_ptr<SpdyFrame> wrapped_body(
-      ConstructSpdyBodyFrame(1, "1234567890", 10, false));
+      spdy_util_.ConstructSpdyBodyFrame(1, "1234567890", 10, false));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp->size()));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*wrapped_get, 3),
       CreateMockWrite(*window_update, 5),
   };
 
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp, 2, ASYNC),
     CreateMockRead(*wrapped_get_resp, 4, ASYNC),
     CreateMockRead(*wrapped_body, 6, ASYNC),
     CreateMockRead(*wrapped_body, 7, ASYNC),
     MockRead(ASYNC, 0, 8),
   };
 
   OrderedSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.was_npn_negotiated = false;
   ssl2.protocol_negotiated = kProtoUnknown;
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES);
 
   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("1234567890", response_data);
 }
 
 // Test a SPDY CONNECT through an HTTPS Proxy to a SPDY server.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
+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();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   // fetch https://www.google.com/ via SPDY
   const char* const kMyUrl = "https://www.google.com/";
   scoped_ptr<SpdyFrame> get(
       spdy_util_.ConstructSpdyGet(kMyUrl, false, 1, LOWEST));
-  scoped_ptr<SpdyFrame> wrapped_get(ConstructWrappedSpdyFrame(get, 1));
-  scoped_ptr<SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> get_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> wrapped_get(
+      spdy_util_.ConstructWrappedSpdyFrame(get, 1));
+  scoped_ptr<SpdyFrame> conn_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> get_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<SpdyFrame> wrapped_get_resp(
-      ConstructWrappedSpdyFrame(get_resp, 1));
-  scoped_ptr<SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> wrapped_body(ConstructWrappedSpdyFrame(body, 1));
+      spdy_util_.ConstructWrappedSpdyFrame(get_resp, 1));
+  scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> wrapped_body(
+      spdy_util_.ConstructWrappedSpdyFrame(body, 1));
   scoped_ptr<SpdyFrame> window_update_get_resp(
       spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp->size()));
   scoped_ptr<SpdyFrame> window_update_body(
       spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_body->size()));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*wrapped_get, 3),
       CreateMockWrite(*window_update_get_resp, 5),
       CreateMockWrite(*window_update_body, 7),
   };
 
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp, 2, ASYNC),
     CreateMockRead(*wrapped_get_resp, 4, ASYNC),
     CreateMockRead(*wrapped_body, 6, ASYNC),
     MockRead(ASYNC, 0, 8),
   };
 
   OrderedSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
-  ssl2.SetNextProto(kProtoSPDY2);
-  ssl2.protocol_negotiated = kProtoSPDY2;
+  ssl2.SetNextProto(GetParam());
+  ssl2.protocol_negotiated = GetParam();
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES);
 
   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(kUploadData, response_data);
 }
 
 // Test a SPDY CONNECT failure through an HTTPS Proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectFailure) {
+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();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   // CONNECT to www.google.com:443 via SPDY
   scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
   scoped_ptr<SpdyFrame> get(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect, 1),
       CreateMockWrite(*get, 3),
   };
 
-  scoped_ptr<SpdyFrame> resp(ConstructSpdySynReplyError(1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdySynReplyError(1));
+  scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 2, ASYNC),
     MockRead(ASYNC, 0, 4),
   };
 
   OrderedSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
-  ssl2.SetNextProto(kProtoSPDY2);
+  ssl2.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_F(HttpNetworkTransactionSpdy2Test,
+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";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://news.google.com/");
   request2.load_flags = 0;
 
   // CONNECT to www.google.com:443 via SPDY.
   scoped_ptr<SpdyFrame> connect1(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> conn_resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> conn_resp1(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   // Fetch https://www.google.com/ via HTTP.
   const char get1[] = "GET / HTTP/1.1\r\n"
       "Host: www.google.com\r\n"
       "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get1(
-      ConstructSpdyBodyFrame(1, get1, strlen(get1), false));
+      spdy_util_.ConstructSpdyBodyFrame(1, get1, strlen(get1), false));
   const char resp1[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 1\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get_resp1(
-      ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false));
-  scoped_ptr<SpdyFrame> wrapped_body1(ConstructSpdyBodyFrame(1, "1", 1, false));
+      spdy_util_.ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false));
+  scoped_ptr<SpdyFrame> wrapped_body1(
+      spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, false));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp1->size()));
 
   // CONNECT to news.google.com:443 via SPDY.
   const char* const kConnectHeaders2[] = {
-    "method", "CONNECT",
-    "url", "news.google.com:443",
-    "host", "news.google.com",
-    "version", "HTTP/1.1",
+    spdy_util_.GetMethodKey(), "CONNECT",
+    spdy_util_.GetPathKey(), "news.google.com:443",
+    spdy_util_.GetHostKey(), "news.google.com",
+    spdy_util_.GetVersionKey(), "HTTP/1.1",
   };
   scoped_ptr<SpdyFrame> connect2(
       spdy_util_.ConstructSpdyControlFrame(NULL,
                                            0,
                                            /*compressed*/ false,
                                            3,
                                            LOWEST,
                                            SYN_STREAM,
                                            CONTROL_FLAG_NONE,
                                            kConnectHeaders2,
                                            arraysize(kConnectHeaders2),
                                            0));
-  scoped_ptr<SpdyFrame> conn_resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> conn_resp2(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
 
   // Fetch https://news.google.com/ via HTTP.
   const char get2[] = "GET / HTTP/1.1\r\n"
       "Host: news.google.com\r\n"
       "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get2(
-      ConstructSpdyBodyFrame(3, get2, strlen(get2), false));
+      spdy_util_.ConstructSpdyBodyFrame(3, get2, strlen(get2), false));
   const char resp2[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 2\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get_resp2(
-      ConstructSpdyBodyFrame(3, resp2, strlen(resp2), false));
+      spdy_util_.ConstructSpdyBodyFrame(3, resp2, strlen(resp2), false));
   scoped_ptr<SpdyFrame> wrapped_body2(
-      ConstructSpdyBodyFrame(3, "22", 2, false));
+      spdy_util_.ConstructSpdyBodyFrame(3, "22", 2, false));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect1, 0),
       CreateMockWrite(*wrapped_get1, 2),
       CreateMockWrite(*connect2, 5),
       CreateMockWrite(*wrapped_get2, 7),
   };
 
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp1, 1, ASYNC),
     CreateMockRead(*wrapped_get_resp1, 3, ASYNC),
     CreateMockRead(*wrapped_body1, 4, ASYNC),
     CreateMockRead(*conn_resp2, 6, ASYNC),
     CreateMockRead(*wrapped_get_resp2, 8, ASYNC),
     CreateMockRead(*wrapped_body2, 9, ASYNC),
     MockRead(ASYNC, 0, 10),
   };
 
   DeterministicSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.was_npn_negotiated = false;
   ssl2.protocol_negotiated = kProtoUnknown;
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
   SSLSocketDataProvider ssl3(ASYNC, OK);
   ssl3.was_npn_negotiated = false;
   ssl3.protocol_negotiated = kProtoUnknown;
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl3);
 
@@ skipping 40 matching lines @@
 
   // The requests should have different IDs, since they each are using their own
   // 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_F(HttpNetworkTransactionSpdy2Test,
+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";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("https://www.google.com/2");
   request2.load_flags = 0;
 
   // CONNECT to www.google.com:443 via SPDY.
   scoped_ptr<SpdyFrame> connect1(spdy_util_.ConstructSpdyConnect(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> conn_resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> conn_resp1(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   // Fetch https://www.google.com/ via HTTP.
   const char get1[] = "GET / HTTP/1.1\r\n"
       "Host: www.google.com\r\n"
       "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get1(
-      ConstructSpdyBodyFrame(1, get1, strlen(get1), false));
+      spdy_util_.ConstructSpdyBodyFrame(1, get1, strlen(get1), false));
   const char resp1[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 1\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get_resp1(
-      ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false));
-  scoped_ptr<SpdyFrame> wrapped_body1(ConstructSpdyBodyFrame(1, "1", 1, false));
+      spdy_util_.ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false));
+  scoped_ptr<SpdyFrame> wrapped_body1(
+      spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, false));
   scoped_ptr<SpdyFrame> window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp1->size()));
 
   // Fetch https://www.google.com/2 via HTTP.
   const char get2[] = "GET /2 HTTP/1.1\r\n"
       "Host: www.google.com\r\n"
       "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get2(
-      ConstructSpdyBodyFrame(1, get2, strlen(get2), false));
+      spdy_util_.ConstructSpdyBodyFrame(1, get2, strlen(get2), false));
   const char resp2[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 2\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get_resp2(
-      ConstructSpdyBodyFrame(1, resp2, strlen(resp2), false));
+      spdy_util_.ConstructSpdyBodyFrame(1, resp2, strlen(resp2), false));
   scoped_ptr<SpdyFrame> wrapped_body2(
-      ConstructSpdyBodyFrame(1, "22", 2, false));
+      spdy_util_.ConstructSpdyBodyFrame(1, "22", 2, false));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*connect1, 0),
       CreateMockWrite(*wrapped_get1, 2),
       CreateMockWrite(*wrapped_get2, 5),
   };
 
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp1, 1, ASYNC),
     CreateMockRead(*wrapped_get_resp1, 3, ASYNC),
     CreateMockRead(*wrapped_body1, 4, ASYNC),
     CreateMockRead(*wrapped_get_resp2, 6, ASYNC),
     CreateMockRead(*wrapped_body2, 7, ASYNC),
     MockRead(ASYNC, 0, 8),
   };
 
   DeterministicSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(ASYNC, OK);
   ssl2.was_npn_negotiated = false;
   ssl2.protocol_negotiated = kProtoUnknown;
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
@@ skipping 35 matching lines @@
   TestLoadTimingReused(load_timing_info2);
 
   // 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_F(HttpNetworkTransactionSpdy2Test,
+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";
   request1.url = GURL("http://www.google.com/");
   request1.load_flags = 0;
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("http://news.google.com/");
   request2.load_flags = 0;
 
   // http://www.google.com/
-  const char* const headers1[] = {
-    "method", "GET",
-    "url", "http://www.google.com/",
-    "host",  "www.google.com",
-    "scheme", "http",
-    "version", "HTTP/1.1"
-  };
+  scoped_ptr<SpdyHeaderBlock> headers(
+      spdy_util_.ConstructGetHeaderBlockForProxy("http://www.google.com/"));
   scoped_ptr<SpdyFrame> get1(spdy_util_.ConstructSpdyControlFrame(
-      NULL, 0, false, 1, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN,
-      headers1, arraysize(headers1), 0));
-  scoped_ptr<SpdyFrame> get_resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(1, "1", 1, true));
+      headers.Pass(), false, 1, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN, 0));
+  scoped_ptr<SpdyFrame> get_resp1(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body1(
+      spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, true));
 
   // http://news.google.com/
-  const char* const headers2[] = {
-    "method", "GET",
-    "url", "http://news.google.com/",
-    "host",  "news.google.com",
-    "scheme", "http",
-    "version", "HTTP/1.1"
-  };
+  scoped_ptr<SpdyHeaderBlock> headers2(
+      spdy_util_.ConstructGetHeaderBlockForProxy("http://news.google.com/"));
   scoped_ptr<SpdyFrame> get2(spdy_util_.ConstructSpdyControlFrame(
-      NULL, 0, false, 3, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN,
-      headers2, arraysize(headers2), 0));
-  scoped_ptr<SpdyFrame> get_resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(3, "22", 2, true));
+      headers2.Pass(), false, 3, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN, 0));
+  scoped_ptr<SpdyFrame> get_resp2(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> body2(
+      spdy_util_.ConstructSpdyBodyFrame(3, "22", 2, true));
 
   MockWrite spdy_writes[] = {
       CreateMockWrite(*get1, 0),
       CreateMockWrite(*get2, 3),
   };
 
   MockRead spdy_reads[] = {
     CreateMockRead(*get_resp1, 1, ASYNC),
     CreateMockRead(*body1, 2, ASYNC),
     CreateMockRead(*get_resp2, 4, ASYNC),
     CreateMockRead(*body2, 5, ASYNC),
     MockRead(ASYNC, 0, 6),
   };
 
   DeterministicSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   spdy_data.RunFor(2);
 
@@ skipping 33 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(ERR_IO_PENDING, trans2->Read(buf.get(), 256, callback.callback()));
   spdy_data.RunFor(1);
   EXPECT_EQ(2, callback.WaitForResult());
 }
 
 // Test the challenge-response-retry sequence through an HTTPS Proxy
-TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyAuthRetry) {
+TEST_P(HttpNetworkTransactionTest, HttpsProxyAuthRetry) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://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::CreateFixed("https://myproxy:70"));
   CapturingBoundNetLog log;
@@ skipping 77 matching lines @@
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   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);
 }
 
-void HttpNetworkTransactionSpdy2Test::ConnectStatusHelperWithExpectedStatus(
+void HttpNetworkTransactionTest::ConnectStatusHelperWithExpectedStatus(
     const MockRead& status, int expected_status) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
@@ skipping 21 matching lines @@
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(expected_status, rv);
 }
 
-void HttpNetworkTransactionSpdy2Test::ConnectStatusHelper(
+void HttpNetworkTransactionTest::ConnectStatusHelper(
     const MockRead& status) {
   ConnectStatusHelperWithExpectedStatus(
       status, ERR_TUNNEL_CONNECTION_FAILED);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus100) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus100) {
   ConnectStatusHelper(MockRead("HTTP/1.1 100 Continue\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus101) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus101) {
   ConnectStatusHelper(MockRead("HTTP/1.1 101 Switching Protocols\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus201) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus201) {
   ConnectStatusHelper(MockRead("HTTP/1.1 201 Created\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus202) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus202) {
   ConnectStatusHelper(MockRead("HTTP/1.1 202 Accepted\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus203) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus203) {
   ConnectStatusHelper(
       MockRead("HTTP/1.1 203 Non-Authoritative Information\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus204) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus204) {
   ConnectStatusHelper(MockRead("HTTP/1.1 204 No Content\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus205) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus205) {
   ConnectStatusHelper(MockRead("HTTP/1.1 205 Reset Content\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus206) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus206) {
   ConnectStatusHelper(MockRead("HTTP/1.1 206 Partial Content\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus300) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus300) {
   ConnectStatusHelper(MockRead("HTTP/1.1 300 Multiple Choices\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus301) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus301) {
   ConnectStatusHelper(MockRead("HTTP/1.1 301 Moved Permanently\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus302) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus302) {
   ConnectStatusHelper(MockRead("HTTP/1.1 302 Found\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus303) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus303) {
   ConnectStatusHelper(MockRead("HTTP/1.1 303 See Other\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus304) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus304) {
   ConnectStatusHelper(MockRead("HTTP/1.1 304 Not Modified\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus305) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus305) {
   ConnectStatusHelper(MockRead("HTTP/1.1 305 Use Proxy\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus306) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus306) {
   ConnectStatusHelper(MockRead("HTTP/1.1 306\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus307) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus307) {
   ConnectStatusHelper(MockRead("HTTP/1.1 307 Temporary Redirect\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus400) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus400) {
   ConnectStatusHelper(MockRead("HTTP/1.1 400 Bad Request\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus401) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus401) {
   ConnectStatusHelper(MockRead("HTTP/1.1 401 Unauthorized\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus402) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus402) {
   ConnectStatusHelper(MockRead("HTTP/1.1 402 Payment Required\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus403) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus403) {
   ConnectStatusHelper(MockRead("HTTP/1.1 403 Forbidden\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus404) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus404) {
   ConnectStatusHelper(MockRead("HTTP/1.1 404 Not Found\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus405) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus405) {
   ConnectStatusHelper(MockRead("HTTP/1.1 405 Method Not Allowed\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus406) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus406) {
   ConnectStatusHelper(MockRead("HTTP/1.1 406 Not Acceptable\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus407) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus407) {
   ConnectStatusHelperWithExpectedStatus(
       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
       ERR_PROXY_AUTH_UNSUPPORTED);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus408) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus408) {
   ConnectStatusHelper(MockRead("HTTP/1.1 408 Request Timeout\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus409) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus409) {
   ConnectStatusHelper(MockRead("HTTP/1.1 409 Conflict\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus410) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus410) {
   ConnectStatusHelper(MockRead("HTTP/1.1 410 Gone\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus411) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus411) {
   ConnectStatusHelper(MockRead("HTTP/1.1 411 Length Required\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus412) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus412) {
   ConnectStatusHelper(MockRead("HTTP/1.1 412 Precondition Failed\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus413) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus413) {
   ConnectStatusHelper(MockRead("HTTP/1.1 413 Request Entity Too Large\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus414) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus414) {
   ConnectStatusHelper(MockRead("HTTP/1.1 414 Request-URI Too Long\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus415) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus415) {
   ConnectStatusHelper(MockRead("HTTP/1.1 415 Unsupported Media Type\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus416) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus416) {
   ConnectStatusHelper(
       MockRead("HTTP/1.1 416 Requested Range Not Satisfiable\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus417) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus417) {
   ConnectStatusHelper(MockRead("HTTP/1.1 417 Expectation Failed\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus500) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus500) {
   ConnectStatusHelper(MockRead("HTTP/1.1 500 Internal Server Error\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus501) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus501) {
   ConnectStatusHelper(MockRead("HTTP/1.1 501 Not Implemented\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus502) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus502) {
   ConnectStatusHelper(MockRead("HTTP/1.1 502 Bad Gateway\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus503) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus503) {
   ConnectStatusHelper(MockRead("HTTP/1.1 503 Service Unavailable\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus504) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus504) {
   ConnectStatusHelper(MockRead("HTTP/1.1 504 Gateway Timeout\r\n"));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectStatus505) {
+TEST_P(HttpNetworkTransactionTest, ConnectStatus505) {
   ConnectStatusHelper(MockRead("HTTP/1.1 505 HTTP Version Not Supported\r\n"));
 }
 
 // Test the flow when both the proxy server AND origin server require
 // authentication. Again, this uses basic auth for both since that is
 // the simplest to mock.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyThenServer) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthProxyThenServer) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   // Configure against proxy server "myproxy:70".
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(DEFAULT_PRIORITY,
       CreateSession(&session_deps_)));
@@ skipping 108 matching lines @@
 
 // For the NTLM implementation using SSPI, we skip the NTLM tests since we
 // can't hook into its internals to cause it to generate predictable NTLM
 // authorization headers.
 #if defined(NTLM_PORTABLE)
 // The NTLM authentication unit tests were generated by capturing the HTTP
 // requests and responses using Fiddler 2 and inspecting the generated random
 // bytes in the debugger.
 
 // Enter the correct password and authenticate successfully.
-TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth1) {
+TEST_P(HttpNetworkTransactionTest, NTLMAuth1) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://172.22.68.17/kids/login.aspx");
   request.load_flags = 0;
 
   HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom1,
                                                     MockGetHostName);
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
@@ skipping 108 matching lines @@
   rv = callback3.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 
 // Enter a wrong password, and then the correct one.
-TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth2) {
+TEST_P(HttpNetworkTransactionTest, NTLMAuth2) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://172.22.68.17/kids/login.aspx");
   request.load_flags = 0;
 
   HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2,
                                                     MockGetHostName);
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   MockWrite data_writes1[] = {
@@ skipping 181 matching lines @@
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 #endif  // NTLM_PORTABLE
 
 // Test reading a server response which has only headers, and no body.
 // After some maximum number of bytes is consumed, the transaction should
 // fail with ERR_RESPONSE_HEADERS_TOO_BIG.
-TEST_F(HttpNetworkTransactionSpdy2Test, LargeHeadersNoBody) {
+TEST_P(HttpNetworkTransactionTest, LargeHeadersNoBody) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   // Respond with 300 kb of headers (we should fail after 256 kb).
@@ skipping 17 matching lines @@
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // Make sure that we don't try to reuse a TCPClientSocket when failing to
 // establish tunnel.
 // http://code.google.com/p/chromium/issues/detail?id=3772
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        DontRecycleTransportSocketForSSLTunnel) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Configure against proxy server "myproxy:70".
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
@@ skipping 39 matching lines @@
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
   trans.reset();
   base::MessageLoop::current()->RunUntilIdle();
   // Make sure that the socket didn't get recycled after calling the destructor.
   EXPECT_EQ(0, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after reading all of the response body.
-TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocket) {
+TEST_P(HttpNetworkTransactionTest, RecycleSocket) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
@@ skipping 35 matching lines @@
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
 // Make sure that we recycle a SSL socket after reading all of the response
 // body.
-TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSSLSocket) {
+TEST_P(HttpNetworkTransactionTest, RecycleSSLSocket) {
   HttpRequestInfo request;
   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"),
   };
@@ skipping 38 matching lines @@
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Grab a SSL socket, use it, and put it back into the pool.  Then, reuse it
 // from the pool and make sure that we recover okay.
-TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
+TEST_P(HttpNetworkTransactionTest, RecycleDeadSSLSocket) {
   HttpRequestInfo request;
   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"),
     MockWrite("GET / HTTP/1.1\r\n"
@@ skipping 74 matching lines @@
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, GetIdleSocketCountInSSLSocketPool(session.get()));
 }
 
 // Make sure that we recycle a socket after a zero-length response.
 // http://crbug.com/9880
-TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
+TEST_P(HttpNetworkTransactionTest, RecycleSocketAfterZeroContentLength) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/csi?v=3&s=web&action=&"
                      "tran=undefined&ei=mAXcSeegAo-SMurloeUN&"
                      "e=17259,18167,19592,19773,19981,20133,20173,20233&"
                      "rt=prt.2642,ol.2649,xjs.2951");
   request.load_flags = 0;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
@@ skipping 34 matching lines @@
   EXPECT_EQ("", response_data);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   base::MessageLoop::current()->RunUntilIdle();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session.get()));
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
+TEST_P(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
   UploadDataStream upload_data_stream(&element_readers, 0);
 
   HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
   // after use.
   request[0].method = "GET";
   request[0].url = GURL("http://www.google.com/");
   request[0].load_flags = 0;
@@ skipping 71 matching lines @@
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
     EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
 // Test the request-challenge-retry sequence for basic auth when there is
 // an identity in the URL. The request should be sent as normal, but when
 // it fails the identity from the URL is used to answer the challenge.
-TEST_F(HttpNetworkTransactionSpdy2Test, AuthIdentityInURL) {
+TEST_P(HttpNetworkTransactionTest, AuthIdentityInURL) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://foo:b@r@www.google.com/");
   request.load_flags = LOAD_NORMAL;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   // The password contains an escaped character -- for this test to pass it
@@ skipping 57 matching lines @@
 
   EXPECT_EQ(100, response->headers->GetContentLength());
 
   // Empty the current queue.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Test the request-challenge-retry sequence for basic auth when there is an
 // incorrect identity in the URL. The identity from the URL should be used only
 // once.
-TEST_F(HttpNetworkTransactionSpdy2Test, WrongAuthIdentityInURL) {
+TEST_P(HttpNetworkTransactionTest, WrongAuthIdentityInURL) {
   HttpRequestInfo request;
   request.method = "GET";
   // Note: the URL has a username:password in it.  The password "baz" is
   // wrong (should be "bar").
   request.url = GURL("http://foo:baz@www.google.com/");
 
   request.load_flags = LOAD_NORMAL;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
@@ skipping 87 matching lines @@
   // There is no challenge info, since the identity worked.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 
   EXPECT_EQ(100, response->headers->GetContentLength());
 
   // Empty the current queue.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Test that previously tried username/passwords for a realm get re-used.
-TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
+TEST_P(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Transaction 1: authenticate (foo, bar) on MyRealm1
   {
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/x/y/z");
     request.load_flags = 0;
 
     scoped_ptr<HttpTransaction> trans(
@@ skipping 363 matching lines @@
 
     response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 // Tests that nonce count increments when multiple auth attempts
 // are started with the same nonce.
-TEST_F(HttpNetworkTransactionSpdy2Test, DigestPreAuthNonceCount) {
+TEST_P(HttpNetworkTransactionTest, DigestPreAuthNonceCount) {
   HttpAuthHandlerDigest::Factory* digest_factory =
       new HttpAuthHandlerDigest::Factory();
   HttpAuthHandlerDigest::FixedNonceGenerator* nonce_generator =
       new HttpAuthHandlerDigest::FixedNonceGenerator("0123456789abcdef");
   digest_factory->set_nonce_generator(nonce_generator);
   session_deps_.http_auth_handler_factory.reset(digest_factory);
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Transaction 1: authenticate (foo, bar) on MyRealm1
   {
@@ skipping 113 matching lines @@
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     ASSERT_TRUE(response != NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
   }
 }
 
 // Test the ResetStateForRestart() private method.
-TEST_F(HttpNetworkTransactionSpdy2Test, ResetStateForRestart) {
+TEST_P(HttpNetworkTransactionTest, ResetStateForRestart) {
   // Create a transaction (the dependencies aren't important).
   scoped_ptr<HttpNetworkTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   // Setup some state (which we expect ResetStateForRestart() will clear).
   trans->read_buf_ = new IOBuffer(15);
   trans->read_buf_len_ = 15;
   trans->request_headers_.SetHeader("Authorization", "NTLM");
 
@@ skipping 22 matching lines @@
   EXPECT_EQ(0, trans->read_buf_len_);
   EXPECT_TRUE(trans->request_headers_.IsEmpty());
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_TRUE(response->headers.get() == NULL);
   EXPECT_FALSE(response->was_cached);
   EXPECT_EQ(0U, response->ssl_info.cert_status);
   EXPECT_FALSE(response->vary_data.is_valid());
 }
 
 // Test HTTPS connections to a site with a bad certificate
-TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificate) {
+TEST_P(HttpNetworkTransactionTest, HTTPSBadCertificate) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
@@ skipping 35 matching lines @@
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test HTTPS connections to a site with a bad certificate, going through a
 // proxy
-TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificateViaProxy) {
+TEST_P(HttpNetworkTransactionTest, HTTPSBadCertificateViaProxy) {
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockWrite proxy_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 58 matching lines @@
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
 
     ASSERT_TRUE(response != NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 
 // Test HTTPS connections to a site, going through an HTTPS proxy
-TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSViaHttpsProxy) {
+TEST_P(HttpNetworkTransactionTest, HTTPSViaHttpsProxy) {
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(100, response->headers->GetContentLength());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 // Test an HTTPS Proxy's ability to redirect a CONNECT request
-TEST_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaHttpsProxy) {
+TEST_P(HttpNetworkTransactionTest, RedirectOfHttpsConnectViaHttpsProxy) {
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
@@ skipping 55 matching lines @@
   ExpectConnectTimingHasTimes(
       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_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaSpdyProxy) {
+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(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite data_writes[] = {
     CreateMockWrite(*conn.get(), 0, SYNCHRONOUS),
   };
 
   static const char* const kExtraHeaders[] = {
     "location",
     "http://login.example.com/",
   };
   scoped_ptr<SpdyFrame> resp(
-      ConstructSpdySynReplyError("302 Redirect", kExtraHeaders,
+      spdy_util_.ConstructSpdySynReplyError("302 Redirect", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   MockRead data_reads[] = {
     CreateMockRead(*resp.get(), 1, SYNCHRONOUS),
     MockRead(ASYNC, 0, 2),  // EOF
   };
 
   DelayedSocketData data(
       1,  // wait for one write to finish before reading.
       data_reads, arraysize(data_reads),
       data_writes, arraysize(data_writes));
   SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
-  proxy_ssl.SetNextProto(kProtoSPDY2);
+  proxy_ssl.SetNextProto(GetParam());
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
 
   EXPECT_EQ(302, response->headers->response_code());
   std::string url;
   EXPECT_TRUE(response->headers->IsRedirect(&url));
   EXPECT_EQ("http://login.example.com/", url);
 }
 
 // Test that an HTTPS proxy's response to a CONNECT request is filtered.
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        ErrorResponseToHttpsConnectViaHttpsProxy) {
   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;
 
   MockWrite data_writes[] = {
@@ skipping 25 matching lines @@
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_F(HttpNetworkTransactionSpdy2Test,
+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(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite data_writes[] = {
     CreateMockWrite(*conn.get(), 0, SYNCHRONOUS),
     CreateMockWrite(*rst.get(), 3, SYNCHRONOUS),
   };
 
   static const char* const kExtraHeaders[] = {
     "location",
     "http://login.example.com/",
   };
   scoped_ptr<SpdyFrame> resp(
-      ConstructSpdySynReplyError("404 Not Found", kExtraHeaders,
+      spdy_util_.ConstructSpdySynReplyError("404 Not Found", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   scoped_ptr<SpdyFrame> body(
-      ConstructSpdyBodyFrame(1, "The host does not exist", 23, true));
+      spdy_util_.ConstructSpdyBodyFrame(
+          1, "The host does not exist", 23, true));
   MockRead data_reads[] = {
     CreateMockRead(*resp.get(), 1, SYNCHRONOUS),
     CreateMockRead(*body.get(), 2, SYNCHRONOUS),
     MockRead(ASYNC, 0, 4),  // EOF
   };
 
   DelayedSocketData data(
       1,  // wait for one write to finish before reading.
       data_reads, arraysize(data_reads),
       data_writes, arraysize(data_writes));
   SSLSocketDataProvider proxy_ssl(ASYNC, OK);  // SSL to the proxy
-  proxy_ssl.SetNextProto(kProtoSPDY2);
+  proxy_ssl.SetNextProto(GetParam());
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   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_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
+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 10 matching lines @@
   const char* const kAuthCredentials[] = {
       "proxy-authorization", "Basic Zm9vOmJhcg==",
   };
   scoped_ptr<SpdyFrame> connect2(spdy_util_.ConstructSpdyConnect(
       kAuthCredentials, arraysize(kAuthCredentials) / 2, 3));
   // fetch https://www.google.com/ via HTTP
   const char get[] = "GET / HTTP/1.1\r\n"
     "Host: www.google.com\r\n"
     "Connection: keep-alive\r\n\r\n";
   scoped_ptr<SpdyFrame> wrapped_get(
-      ConstructSpdyBodyFrame(3, get, strlen(get), false));
+      spdy_util_.ConstructSpdyBodyFrame(3, get, strlen(get), false));
 
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req, 1, ASYNC),
     CreateMockWrite(*rst, 4, ASYNC),
     CreateMockWrite(*connect2, 5),
     CreateMockWrite(*wrapped_get, 8),
   };
 
   // The proxy responds to the connect with a 407, using a persistent
   // connection.
   const char* const kAuthChallenge[] = {
-    "status", "407 Proxy Authentication Required",
-    "version", "HTTP/1.1",
+    spdy_util_.GetStatusKey(), "407 Proxy Authentication Required",
+    spdy_util_.GetVersionKey(), "HTTP/1.1",
     "proxy-authenticate", "Basic realm=\"MyRealm1\"",
   };
 
   scoped_ptr<SpdyFrame> conn_auth_resp(
       spdy_util_.ConstructSpdyControlFrame(NULL,
                                            0,
                                            false,
                                            1,
                                            LOWEST,
                                            SYN_REPLY,
                                            CONTROL_FLAG_NONE,
                                            kAuthChallenge,
                                            arraysize(kAuthChallenge),
                                            0));
 
-  scoped_ptr<SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> conn_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
   const char resp[] = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 5\r\n\r\n";
 
   scoped_ptr<SpdyFrame> wrapped_get_resp(
-      ConstructSpdyBodyFrame(3, resp, strlen(resp), false));
+      spdy_util_.ConstructSpdyBodyFrame(3, resp, strlen(resp), false));
   scoped_ptr<SpdyFrame> wrapped_body(
-      ConstructSpdyBodyFrame(3, "hello", 5, false));
+      spdy_util_.ConstructSpdyBodyFrame(3, "hello", 5, false));
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_auth_resp, 2, ASYNC),
     CreateMockRead(*conn_resp, 6, ASYNC),
     CreateMockRead(*wrapped_get_resp, 9, ASYNC),
     CreateMockRead(*wrapped_body, 10, ASYNC),
     MockRead(ASYNC, OK, 11),  // EOF.  May or may not be read.
   };
 
   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(kProtoSPDY2);
+  proxy.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
   // Vanilla SSL to the server
   SSLSocketDataProvider server(ASYNC, OK);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&server);
 
   TestCompletionCallback callback1;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
@@ skipping 44 matching lines @@
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   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_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
+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";
@@ skipping 13 matching lines @@
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, false));
 
   MockWrite spdy_writes[] = {
     CreateMockWrite(*stream1_syn, 1, ASYNC),
   };
 
   scoped_ptr<SpdyFrame>
-      stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
+      stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyFrame>
-      stream1_body(ConstructSpdyBodyFrame(1, true));
+      stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame>
-      stream2_syn(ConstructSpdyPush(NULL,
+      stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "http://www.another-origin.com/foo.dat"));
 
   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),
     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(kProtoSPDY2);
+  proxy.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ skipping 39 matching lines @@
   // origins.
   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_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPushCorrectness) {
+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();
 
   // Enable cross-origin push.
   session_deps_.trusted_spdy_proxy = "myproxy:70";
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   scoped_ptr<SpdyFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, false));
 
   scoped_ptr<SpdyFrame> push_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
 
   MockWrite spdy_writes[] = {
     CreateMockWrite(*stream1_syn, 1, ASYNC),
     CreateMockWrite(*push_rst, 4),
   };
 
   scoped_ptr<SpdyFrame>
-      stream1_reply(ConstructSpdyGetSynReply(NULL, 0, 1));
+      stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   scoped_ptr<SpdyFrame>
-      stream1_body(ConstructSpdyBodyFrame(1, true));
+      stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   scoped_ptr<SpdyFrame>
-      stream2_syn(ConstructSpdyPush(NULL,
+      stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
                                     0,
                                     2,
                                     1,
                                     "https://www.another-origin.com/foo.dat"));
 
   MockRead spdy_reads[] = {
     CreateMockRead(*stream1_reply, 2, ASYNC),
     CreateMockRead(*stream2_syn, 3, ASYNC),
     CreateMockRead(*stream1_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(kProtoSPDY2);
+  proxy.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy);
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
   TestCompletionCallback callback;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->headers->IsKeepAlive());
 
   EXPECT_EQ(200, response->headers->response_code());
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello!", response_data);
 
   trans.reset();
   session->CloseAllConnections();
 }
 
 // Test HTTPS connections to a site with a bad certificate, going through an
 // HTTPS proxy
-TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificateViaHttpsProxy) {
+TEST_P(HttpNetworkTransactionTest, HTTPSBadCertificateViaHttpsProxy) {
   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;
 
   // Attempt to fetch the URL from a server with a bad cert
   MockWrite bad_cert_writes[] = {
@@ skipping 60 matching lines @@
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
 
   ASSERT_TRUE(response != NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_UserAgent) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_UserAgent) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                   "Chromium Ultra Awesome X Edition");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
@@ skipping 18 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_UserAgentOverTunnel) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_UserAgentOverTunnel) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                   "Chromium Ultra Awesome X Edition");
 
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
@@ skipping 18 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_Referer) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_Referer) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
   request.extra_headers.SetHeader(HttpRequestHeaders::kReferer,
                                   "http://the.previous.site.com/");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
@@ skipping 19 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_PostContentLengthZero) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) {
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
     MockWrite("POST / HTTP/1.1\r\n"
@@ skipping 16 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_PutContentLengthZero) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) {
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL("http://www.google.com/");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
     MockWrite("PUT / HTTP/1.1\r\n"
@@ skipping 16 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_HeadContentLengthZero) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) {
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
     MockWrite("HEAD / HTTP/1.1\r\n"
@@ skipping 16 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_CacheControlNoCache) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = LOAD_BYPASS_CACHE;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
@@ skipping 18 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        BuildRequest_CacheControlValidateCache) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = LOAD_VALIDATE_CACHE;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
@@ skipping 18 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_ExtraHeaders) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.extra_headers.SetHeader("FooHeader", "Bar");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockWrite data_writes[] = {
@@ skipping 17 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_ExtraHeadersStripped) {
+TEST_P(HttpNetworkTransactionTest, BuildRequest_ExtraHeadersStripped) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.extra_headers.SetHeader("referer", "www.foo.com");
   request.extra_headers.SetHeader("hEllo", "Kitty");
   request.extra_headers.SetHeader("FoO", "bar");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
@@ skipping 21 matching lines @@
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_HTTP_GET) {
+TEST_P(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("SOCKS myproxy:1080"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
@@ skipping 38 matching lines @@
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_SSL_GET) {
+TEST_P(HttpNetworkTransactionTest, SOCKS4_SSL_GET) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("SOCKS myproxy:1080"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
@@ skipping 43 matching lines @@
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_HTTP_GET_no_PAC) {
+TEST_P(HttpNetworkTransactionTest, SOCKS4_HTTP_GET_no_PAC) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("socks4://myproxy:1080"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
@@ skipping 38 matching lines @@
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReused(load_timing_info,
                           CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS5_HTTP_GET) {
+TEST_P(HttpNetworkTransactionTest, SOCKS5_HTTP_GET) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("SOCKS5 myproxy:1080"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
@@ skipping 52 matching lines @@
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("Payload", response_text);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS5_SSL_GET) {
+TEST_P(HttpNetworkTransactionTest, SOCKS5_SSL_GET) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("SOCKS5 myproxy:1080"));
   CapturingNetLog net_log;
   session_deps_.net_log = &net_log;
 
@@ skipping 100 matching lines @@
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
 
   // We do not complete this request, the dtor will clean the transaction up.
   return trans->Start(&request, callback.callback(), BoundNetLog());
 }
 
 }  // namespace
 
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForDirectConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
   const GroupNameTest tests[] = {
     {
       "",  // unused
       "http://www.google.com/direct",
       "www.google.com:80",
       false,
     },
     {
       "",  // unused
       "http://[2001:1418:13:1::25]/direct",
@@ skipping 46 matching lines @@
     if (tests[i].ssl)
       EXPECT_EQ(tests[i].expected_group_name,
                 ssl_conn_pool->last_group_name_received());
     else
       EXPECT_EQ(tests[i].expected_group_name,
                 transport_conn_pool->last_group_name_received());
   }
 
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForHTTPProxyConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForHTTPProxyConnections) {
   const GroupNameTest tests[] = {
     {
       "http_proxy",
       "http://www.google.com/http_proxy_normal",
       "www.google.com:80",
       false,
     },
 
     // SSL Tests
     {
@@ skipping 44 matching lines @@
               GroupNameTransactionHelper(tests[i].url, session));
     if (tests[i].ssl)
       EXPECT_EQ(tests[i].expected_group_name,
                 ssl_conn_pool->last_group_name_received());
     else
       EXPECT_EQ(tests[i].expected_group_name,
                 http_proxy_pool->last_group_name_received());
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForSOCKSConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForSOCKSConnections) {
   const GroupNameTest tests[] = {
     {
       "socks4://socks_proxy:1080",
       "http://www.google.com/socks4_direct",
       "socks4/www.google.com:80",
       false,
     },
     {
       "socks5://socks_proxy:1080",
       "http://www.google.com/socks5_direct",
@@ skipping 52 matching lines @@
               GroupNameTransactionHelper(tests[i].url, session));
     if (tests[i].ssl)
       EXPECT_EQ(tests[i].expected_group_name,
                 ssl_conn_pool->last_group_name_received());
     else
       EXPECT_EQ(tests[i].expected_group_name,
                 socks_conn_pool->last_group_name_received());
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ReconsiderProxyAfterFailedConnection) {
+TEST_P(HttpNetworkTransactionTest, ReconsiderProxyAfterFailedConnection) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("myproxy:70;foobar:80"));
 
   // This simulates failure resolving all hostnames; that means we will fail
   // connecting to both proxies (myproxy:70 and foobar:80).
   session_deps_.host_resolver->rules()->AddSimulatedFailure("*");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, rv);
 }
 
 // Base test to make sure that when the load flags for a request specify to
 // bypass the cache, the DNS cache is not used.
-void HttpNetworkTransactionSpdy2Test::BypassHostCacheOnRefreshHelper(
+void HttpNetworkTransactionTest::BypassHostCacheOnRefreshHelper(
     int load_flags) {
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = load_flags;
   request.url = GURL("http://www.google.com/");
 
   // Select a host resolver that does caching.
   session_deps_.host_resolver.reset(new MockCachingHostResolver);
 
@@ skipping 33 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 // There are multiple load flags that should trigger the host cache bypass.
 // Test each in isolation:
-TEST_F(HttpNetworkTransactionSpdy2Test, BypassHostCacheOnRefresh1) {
+TEST_P(HttpNetworkTransactionTest, BypassHostCacheOnRefresh1) {
   BypassHostCacheOnRefreshHelper(LOAD_BYPASS_CACHE);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BypassHostCacheOnRefresh2) {
+TEST_P(HttpNetworkTransactionTest, BypassHostCacheOnRefresh2) {
   BypassHostCacheOnRefreshHelper(LOAD_VALIDATE_CACHE);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, BypassHostCacheOnRefresh3) {
+TEST_P(HttpNetworkTransactionTest, BypassHostCacheOnRefresh3) {
   BypassHostCacheOnRefreshHelper(LOAD_DISABLE_CACHE);
 }
 
 // Make sure we can handle an error when writing the request.
-TEST_F(HttpNetworkTransactionSpdy2Test, RequestWriteError) {
+TEST_P(HttpNetworkTransactionTest, RequestWriteError) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockWrite write_failure[] = {
     MockWrite(ASYNC, ERR_CONNECTION_RESET),
   };
   StaticSocketDataProvider data(NULL, 0,
                                 write_failure, arraysize(write_failure));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 }
 
 // Check that a connection closed after the start of the headers finishes ok.
-TEST_F(HttpNetworkTransactionSpdy2Test, ConnectionClosedAfterStartOfHeaders) {
+TEST_P(HttpNetworkTransactionTest, ConnectionClosedAfterStartOfHeaders) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1."),
     MockRead(SYNCHRONOUS, OK),
@@ skipping 21 matching lines @@
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
 // Make sure that a dropped connection while draining the body for auth
 // restart does the right thing.
-TEST_F(HttpNetworkTransactionSpdy2Test, DrainResetOK) {
+TEST_P(HttpNetworkTransactionTest, DrainResetOK) {
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
@@ skipping 58 matching lines @@
   rv = callback2.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test HTTPS connections going through a proxy that sends extra data.
-TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSViaProxyWithExtraData) {
+TEST_P(HttpNetworkTransactionTest, HTTPSViaProxyWithExtraData) {
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockRead proxy_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\nExtra data"),
     MockRead(SYNCHRONOUS, OK)
@@ skipping 13 matching lines @@
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, LargeContentLengthThenClose) {
+TEST_P(HttpNetworkTransactionTest, LargeContentLengthThenClose) {
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY,
                                  CreateSession(&session_deps_)));
 
   MockRead data_reads[] = {
@@ skipping 15 matching lines @@
   ASSERT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, UploadFileSmallerThanLength) {
+TEST_P(HttpNetworkTransactionTest, UploadFileSmallerThanLength) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file_path));
   const uint64 kFakeSize = 100000;  // file is actually blank
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
@@ skipping 35 matching lines @@
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
   EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 
   file_util::Delete(temp_file_path, false);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, UploadUnreadableFile) {
+TEST_P(HttpNetworkTransactionTest, UploadUnreadableFile) {
   base::FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file));
   std::string temp_file_content("Unreadable file.");
   ASSERT_TRUE(file_util::WriteFile(temp_file, temp_file_content.c_str(),
                                    temp_file_content.length()));
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
@@ skipping 39 matching lines @@
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   file_util::Delete(temp_file, false);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, UnreadableUploadFileAfterAuthRestart) {
+TEST_P(HttpNetworkTransactionTest, UnreadableUploadFileAfterAuthRestart) {
   base::FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file));
   std::string temp_file_contents("Unreadable file.");
   std::string unreadable_contents(temp_file_contents.length(), '\0');
   ASSERT_TRUE(file_util::WriteFile(temp_file, temp_file_contents.c_str(),
                                    temp_file_contents.length()));
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
@@ skipping 71 matching lines @@
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->headers.get() != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   file_util::Delete(temp_file, false);
 }
 
 // Tests that changes to Auth realms are treated like auth rejections.
-TEST_F(HttpNetworkTransactionSpdy2Test, ChangeAuthRealms) {
+TEST_P(HttpNetworkTransactionTest, ChangeAuthRealms) {
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // First transaction will request a resource and receive a Basic challenge
   // with realm="first_realm".
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
@@ skipping 131 matching lines @@
   rv = trans->RestartWithAuth(
       AuthCredentials(kFirst, kBar), callback4.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback4.WaitForResult();
   EXPECT_EQ(OK, rv);
   response = trans->GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, HonorAlternateProtocolHeader) {
+TEST_P(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
 
@@ skipping 38 matching lines @@
   const PortAlternateProtocolPair alternate =
       http_server_properties.GetAlternateProtocol(http_host_port_pair);
   PortAlternateProtocolPair expected_alternate;
   expected_alternate.port = 443;
   expected_alternate.protocol = NPN_SPDY_2;
   EXPECT_TRUE(expected_alternate.Equals(alternate));
 
   HttpStreamFactory::SetNextProtos(std::vector<std::string>());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        MarkBrokenAlternateProtocolAndFallback) {
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
   StaticSocketDataProvider first_data;
@@ skipping 38 matching lines @@
   EXPECT_EQ("hello world", response_data);
 
   ASSERT_TRUE(http_server_properties->HasAlternateProtocol(
       HostPortPair::FromURL(request.url)));
   const PortAlternateProtocolPair alternate =
       http_server_properties->GetAlternateProtocol(
           HostPortPair::FromURL(request.url));
   EXPECT_EQ(ALTERNATE_PROTOCOL_BROKEN, alternate.protocol);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedBlocked) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.google.com:1023/");
@@ skipping 28 matching lines @@
   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.
   EXPECT_EQ(ERR_CONNECTION_REFUSED, callback.WaitForResult());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedPermitted) {
   // Ensure that we're allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
   // on a restricted port (port < 1024) if we set
   // enable_user_alternate_protocol_ports.
 
   HttpStreamFactory::set_use_alternate_protocols(true);
   session_deps_.enable_user_alternate_protocol_ports = true;
 
   HttpRequestInfo restricted_port_request;
@@ skipping 29 matching lines @@
       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());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortRestrictedAllowed) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo restricted_port_request;
   restricted_port_request.method = "GET";
   restricted_port_request.url = GURL("http://www.google.com:1023/");
@@ skipping 28 matching lines @@
   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.
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed1) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.google.com:1024/");
@@ skipping 27 matching lines @@
       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());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolPortUnrestrictedAllowed2) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unrestricted (port >= 1024) when the original traffic was
   // on a restricted port (port < 1024).  Ensure that we can redirect in all
   // other cases.
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo unrestricted_port_request;
   unrestricted_port_request.method = "GET";
   unrestricted_port_request.url = GURL("http://www.google.com:1024/");
@@ skipping 27 matching lines @@
       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());
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        AlternateProtocolUnsafeBlocked) {
   // Ensure that we're not allowed to redirect traffic via an alternate
   // protocol to an unsafe port, and that we resume the second
   // HttpStreamFactoryImpl::Job once the alternate protocol request fails.
   HttpStreamFactory::set_use_alternate_protocols(true);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
@@ skipping 34 matching lines @@
   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_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
+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;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     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);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  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),
   };
 
   DelayedSocketData spdy_data(
       1,  // wait for one write to finish before reading.
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
@@ skipping 36 matching lines @@
   ASSERT_TRUE(response != NULL);
   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_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
+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;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
@@ skipping 11 matching lines @@
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_socket(
       NULL, 0, NULL, 0);
   hanging_socket.set_connect_data(never_finishing_connect);
   // Socket 2 and 3 are the hanging Alternate-Protocol and
   // non-Alternate-Protocol jobs from the 2nd transaction.
   session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket);
   session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> req1(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*req1),
     CreateMockWrite(*req2),
   };
-  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data1(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> data2(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> data1(spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> data2(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp1),
     CreateMockRead(*data1),
     CreateMockRead(*resp2),
     CreateMockRead(*data2),
     MockRead(ASYNC, 0, 0),
   };
 
   DelayedSocketData spdy_data(
       2,  // wait for writes to finish before reading.
@@ skipping 47 matching lines @@
   response = trans3.GetResponseInfo();
   ASSERT_TRUE(response != NULL);
   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(&trans3, &response_data));
   EXPECT_EQ("hello!", response_data);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
+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;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     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);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps_.socket_factory->AddSocketDataProvider(
       &hanging_alternate_protocol_socket);
 
@@ skipping 72 matching lines @@
   }
 
   const std::vector<GURL>& resolved() const { return resolved_; }
 
  private:
   std::vector<GURL> resolved_;
 
   DISALLOW_COPY_AND_ASSIGN(CapturingProxyResolver);
 };
 
-TEST_F(HttpNetworkTransactionSpdy2Test,
+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(
@@ skipping 13 matching lines @@
     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);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite spdy_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),  // 0
     CreateMockWrite(*req),                              // 3
   };
 
   const char kCONNECTResponse[] = "HTTP/1.1 200 Connected\r\n\r\n";
 
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     MockRead(ASYNC, kCONNECTResponse, arraysize(kCONNECTResponse) - 1, 1),  // 1
     CreateMockRead(*resp.get(), 4),  // 2, 4
     CreateMockRead(*data.get(), 4),  // 5
     MockRead(ASYNC, 0, 0, 4),  // 6
   };
 
   OrderedSocketData spdy_data(
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
@@ skipping 48 matching lines @@
             capturing_proxy_resolver->resolved()[0].spec());
   EXPECT_EQ("https://www.google.com/",
             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_F(HttpNetworkTransactionSpdy2Test,
+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;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead(kAlternateProtocolHttpHeader),
     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(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  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),
   };
 
   DelayedSocketData spdy_data(
       1,  // wait for one write to finish before reading.
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
@@ skipping 86 matching lines @@
 //   - Non-authenticating and authenticating backend.
 //
 // In all, there are 44 reasonable permuations (for example, if there are
 // problems generating an auth token for an authenticating proxy, we don't
 // need to test all permutations of the backend server).
 //
 // The test proceeds by going over each of the configuration cases, and
 // potentially running up to three rounds in each of the tests. The TestConfig
 // specifies both the configuration for the test as well as the expectations
 // for the results.
-TEST_F(HttpNetworkTransactionSpdy2Test, GenerateAuthToken) {
+TEST_P(HttpNetworkTransactionTest, GenerateAuthToken) {
   static const char kServer[] = "http://www.example.com";
   static const char kSecureServer[] = "https://www.example.com";
   static const char kProxy[] = "myproxy:70";
   const int kAuthErr = ERR_INVALID_AUTH_CREDENTIALS;
 
   enum AuthTiming {
     AUTH_NONE,
     AUTH_SYNC,
     AUTH_ASYNC,
   };
@@ skipping 377 matching lines @@
       }
       if (round + 1 < test_config.num_auth_rounds) {
         EXPECT_FALSE(response->auth_challenge.get() == NULL);
       } else {
         EXPECT_TRUE(response->auth_challenge.get() == NULL);
       }
     }
   }
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
+TEST_P(HttpNetworkTransactionTest, MultiRoundAuth) {
   // Do multi-round authentication and make sure it works correctly.
   HttpAuthHandlerMock::Factory* auth_factory(
       new HttpAuthHandlerMock::Factory());
   session_deps_.http_auth_handler_factory.reset(auth_factory);
   session_deps_.proxy_service.reset(ProxyService::CreateDirect());
   session_deps_.host_resolver->rules()->AddRule("www.example.com", "10.0.0.1");
   session_deps_.host_resolver->set_synchronous_mode(true);
 
   HttpAuthHandlerMock* auth_handler(new HttpAuthHandlerMock());
   auth_handler->set_connection_based(true);
@@ skipping 167 matching lines @@
   EXPECT_EQ(3, rv);
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
   EXPECT_EQ(1, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 }
 
 // This tests the case that a request is issued via http instead of spdy after
 // npn is negotiated.
-TEST_F(HttpNetworkTransactionSpdy2Test, NpnWithHttpOverSSL) {
+TEST_P(HttpNetworkTransactionTest, NpnWithHttpOverSSL) {
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(
       MakeNextProtos("http/1.1", "http1.1", NULL));
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes[] = {
     MockWrite("GET / HTTP/1.1\r\n"
@@ skipping 36 matching lines @@
   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);
 
   EXPECT_FALSE(response->was_fetched_via_spdy);
   EXPECT_TRUE(response->was_npn_negotiated);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SpdyPostNPNServerHangup) {
+TEST_P(HttpNetworkTransactionTest, SpdyPostNPNServerHangup) {
   // Simulate the SSL handshake completing with an NPN negotiation
   // followed by an immediate server closing of the socket.
   // Fix crash:  http://crbug.com/46369
   HttpStreamFactory::set_use_alternate_protocols(true);
   HttpStreamFactory::SetNextProtos(SpdyNextProtos());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   MockRead spdy_reads[] = {
     MockRead(SYNCHRONOUS, 0, 0)   // Not async - return 0 immediately.
   };
 
   DelayedSocketData spdy_data(
       0,  // don't wait in this case, immediate hangup.
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   TestCompletionCallback callback;
 
   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_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
+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));
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   CapturingNetLog net_log;
@@ skipping 39 matching lines @@
   // to obtain a new one.
   //
   // NOTE: Originally, the proxy response to the second CONNECT request
   // simply returned another 407 so the unit test could skip the SSL connection
   // establishment and SPDY framing issues. Alas, the
   // retry-http-when-alternate-protocol fails logic kicks in, which was more
   // complicated to set up expectations for than the SPDY session.
 
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
-  scoped_ptr<SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   MockWrite data_writes_2[] = {
     // First connection attempt without Proxy-Authorization.
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "\r\n"),
 
     // Second connection attempt with Proxy-Authorization.
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
@@ skipping 23 matching lines @@
     // SPDY response
     CreateMockRead(*resp.get(), 6),
     CreateMockRead(*data.get(), 6),
     MockRead(ASYNC, 0, 0, 6),
   };
   OrderedSocketData data_2(
       data_reads_2, arraysize(data_reads_2),
       data_writes_2, arraysize(data_writes_2));
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
 
   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data_1);
   session_deps_.socket_factory->AddSocketDataProvider(&data_2);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
@@ skipping 34 matching lines @@
   EXPECT_EQ("www.google.com", request_url.host());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans_2->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 // Test that if we cancel the transaction as the connection is completing, that
 // everything tears down correctly.
-TEST_F(HttpNetworkTransactionSpdy2Test, SimpleCancel) {
+TEST_P(HttpNetworkTransactionTest, SimpleCancel) {
   // Setup everything about the connection to complete synchronously, so that
   // after calling HttpNetworkTransaction::Start, the only thing we're waiting
   // for is the callback from the HttpStreamRequest.
   // Then cancel the transaction.
   // Verify that we don't crash.
   MockConnect mock_connect(SYNCHRONOUS, OK);
   MockRead data_reads[] = {
     MockRead(SYNCHRONOUS, "HTTP/1.0 200 OK\r\n\r\n"),
     MockRead(SYNCHRONOUS, "hello world"),
     MockRead(SYNCHRONOUS, OK),
@@ skipping 17 matching lines @@
 
   CapturingBoundNetLog log;
   int rv = trans->Start(&request, callback.callback(), log.bound());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   trans.reset();  // Cancel the transaction here.
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 // Test a basic GET request through a proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, ProxyGet) {
+TEST_P(HttpNetworkTransactionTest, ProxyGet) {
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
@@ skipping 34 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_proxy);
   EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
 }
 
 // Test a basic HTTPS GET request through a proxy.
-TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGet) {
+TEST_P(HttpNetworkTransactionTest, ProxyTunnelGet) {
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
 
@@ skipping 53 matching lines @@
   EXPECT_TRUE(response->was_fetched_via_proxy);
 
   LoadTimingInfo load_timing_info;
   EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info));
   TestLoadTimingNotReusedWithPac(load_timing_info,
                                  CONNECT_TIMING_HAS_SSL_TIMES);
 }
 
 // Test a basic HTTPS GET request through a proxy, but the server hangs up
 // while establishing the tunnel.
-TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGetHangup) {
+TEST_P(HttpNetworkTransactionTest, ProxyTunnelGetHangup) {
   session_deps_.proxy_service.reset(ProxyService::CreateFixed("myproxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
 
   // Since we have proxy, should try to establish tunnel.
@@ skipping 34 matching lines @@
   size_t pos = ExpectLogContainsSomewhere(
       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_F(HttpNetworkTransactionSpdy2Test, PreconnectWithExistingSpdySession) {
+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(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
+  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),
   };
 
   DelayedSocketData spdy_data(
       1,  // wait for one write to finish before reading.
       spdy_reads, arraysize(spdy_reads),
       spdy_writes, arraysize(spdy_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&spdy_data);
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Set up an initial SpdySession in the pool to reuse.
   HostPortPair host_port_pair("www.google.com", 443);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      kPrivacyModeDisabled);
   scoped_refptr<SpdySession> spdy_session =
       session->spdy_session_pool()->Get(key, BoundNetLog());
@@ skipping 25 matching lines @@
   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(OK, callback.WaitForResult());
 }
 
 // Given a net error, cause that error to be returned from the first Write()
 // call and verify that the HttpTransaction fails with that error.
-void HttpNetworkTransactionSpdy2Test::CheckErrorIsPassedBack(
+void HttpNetworkTransactionTest::CheckErrorIsPassedBack(
     int error, IoMode mode) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   SSLSocketDataProvider ssl_data(mode, OK);
   net::MockWrite data_writes[] = {
     net::MockWrite(mode, error),
   };
   net::StaticSocketDataProvider data(NULL, 0,
                                      data_writes, arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 
   TestCompletionCallback callback;
   int rv = trans->Start(&request_info, callback.callback(), net::BoundNetLog());
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(error, rv);
 }
 
-TEST_F(HttpNetworkTransactionSpdy2Test, SSLWriteCertError) {
+TEST_P(HttpNetworkTransactionTest, SSLWriteCertError) {
   // Just check a grab bag of cert errors.
   static const int kErrors[] = {
     ERR_CERT_COMMON_NAME_INVALID,
     ERR_CERT_AUTHORITY_INVALID,
     ERR_CERT_DATE_INVALID,
   };
   for (size_t i = 0; i < arraysize(kErrors); i++) {
     CheckErrorIsPassedBack(kErrors[i], ASYNC);
     CheckErrorIsPassedBack(kErrors[i], SYNCHRONOUS);
   }
 }
 
 // Ensure that a client certificate is removed from the SSL client auth
 // cache when:
 //  1) No proxy is involved.
 //  2) TLS False Start is disabled.
 //  3) The initial TLS handshake requests a client certificate.
 //  4) The client supplies an invalid/unacceptable certificate.
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        ClientAuthCertCache_Direct_NoFalseStart) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   scoped_refptr<SSLCertRequestInfo> cert_request(new SSLCertRequestInfo());
   cert_request->host_and_port = "www.example.com:443";
 
   // [ssl_]data1 contains the data for the first SSL handshake. When a
@@ skipping 89 matching lines @@
   ASSERT_FALSE(session->ssl_client_auth_cache()->Lookup("www.example.com:443",
                                                         &client_cert));
 }
 
 // Ensure that a client certificate is removed from the SSL client auth
 // cache when:
 //  1) No proxy is involved.
 //  2) TLS False Start is enabled.
 //  3) The initial TLS handshake requests a client certificate.
 //  4) The client supplies an invalid/unacceptable certificate.
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
        ClientAuthCertCache_Direct_FalseStart) {
   net::HttpRequestInfo request_info;
   request_info.url = GURL("https://www.example.com/");
   request_info.method = "GET";
   request_info.load_flags = net::LOAD_NORMAL;
 
   scoped_refptr<SSLCertRequestInfo> cert_request(new SSLCertRequestInfo());
   cert_request->host_and_port = "www.example.com:443";
 
   // When TLS False Start is used, SSLClientSocket::Connect() calls will
@@ skipping 102 matching lines @@
 }
 
 // Ensure that a client certificate is removed from the SSL client auth
 // cache when:
 //  1) An HTTPS proxy is involved.
 //  3) The HTTPS proxy requests a client certificate.
 //  4) The client supplies an invalid/unacceptable certificate for the
 //     proxy.
 // The test is repeated twice, first for connecting to an HTTPS endpoint,
 // then for connecting to an HTTP endpoint.
-TEST_F(HttpNetworkTransactionSpdy2Test, ClientAuthCertCache_Proxy_Fail) {
+TEST_P(HttpNetworkTransactionTest, ClientAuthCertCache_Proxy_Fail) {
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixed("https://proxy:70"));
   CapturingBoundNetLog log;
   session_deps_.net_log = log.bound().net_log();
 
   scoped_refptr<SSLCertRequestInfo> cert_request(new SSLCertRequestInfo());
   cert_request->host_and_port = "proxy:70";
 
   // See ClientAuthCertCache_Direct_NoFalseStart for the explanation of
   // [ssl_]data[1-3]. Rather than represending the endpoint
@@ skipping 72 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));
   }
 }
 
+// Unlike TEST/TEST_F, which are macros that expand to further macros,
+// TEST_P is a macro that expands directly to code that stringizes the
+// arguments. As a result, macros passed as parameters (such as prefix
+// or test_case_name) will not be expanded by the preprocessor. To
+// work around this, indirect the macro for TEST_P, so that the
+// pre-processor will expand macros such as MAYBE_test_name before
+// instantiating the test.
+#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
-TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
+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);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> host1_req(
       spdy_util_.ConstructSpdyGet("https://www.google.com", false, 1, LOWEST));
   scoped_ptr<SpdyFrame> host2_req(
       spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*host1_req, 1),
     CreateMockWrite(*host2_req, 4),
   };
-  scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> host1_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> host1_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> host2_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> host2_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
     MockRead(ASYNC, 0, 7),
   };
 
   IPAddressNumber ip;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &ip));
@@ skipping 50 matching lines @@
   ASSERT_TRUE(response != NULL);
   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_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
+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);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> host1_req(
       spdy_util_.ConstructSpdyGet("https://www.google.com", false, 1, LOWEST));
   scoped_ptr<SpdyFrame> host2_req(
       spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*host1_req, 1),
     CreateMockWrite(*host2_req, 4),
   };
-  scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> host1_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> host1_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> host2_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> host2_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
     MockRead(ASYNC, 0, 7),
   };
 
   IPAddressNumber ip;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &ip));
@@ skipping 86 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
-TEST_F(HttpNetworkTransactionSpdy2Test,
-       MAYBE_UseIPConnectionPoolingWithHostCacheExpiration) {
+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.
   OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443));
   HttpNetworkSession::Params params =
       SpdySessionDependencies::CreateSessionParams(&session_deps_);
   params.host_resolver = &host_resolver;
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
   pool_peer.DisableDomainAuthenticationVerification();
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<SpdyFrame> host1_req(
       spdy_util_.ConstructSpdyGet("https://www.google.com", false, 1, LOWEST));
   scoped_ptr<SpdyFrame> host2_req(
       spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST));
   MockWrite spdy_writes[] = {
     CreateMockWrite(*host1_req, 1),
     CreateMockWrite(*host2_req, 4),
   };
-  scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> host1_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> host1_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> host2_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> host2_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
     MockRead(ASYNC, 0, 7),
   };
 
   IPAddressNumber ip;
   ASSERT_TRUE(ParseIPLiteralToNumber("127.0.0.1", &ip));
@@ skipping 48 matching lines @@
   ASSERT_TRUE(response != NULL);
   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_UseIPConnectionPoolingWithHostCacheExpiration
 
-TEST_F(HttpNetworkTransactionSpdy2Test, ReadPipelineEvictionFallback) {
+TEST_P(HttpNetworkTransactionTest, ReadPipelineEvictionFallback) {
   MockRead data_reads1[] = {
     MockRead(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
   };
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data1(data_reads1, arraysize(data_reads1), NULL, 0);
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2), NULL, 0);
   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_F(HttpNetworkTransactionSpdy2Test, SendPipelineEvictionFallback) {
+TEST_P(HttpNetworkTransactionTest, SendPipelineEvictionFallback) {
   MockWrite data_writes1[] = {
     MockWrite(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
   };
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data1(NULL, 0,
                                  data_writes1, arraysize(data_writes1));
   StaticSocketDataProvider data2(data_reads2, arraysize(data_reads2),
                                  data_writes2, arraysize(data_writes2));
   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_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
+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),
   };
 
-  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads1[] = {
     CreateMockRead(*resp1, 1),
     CreateMockRead(*body1, 2),
     MockRead(ASYNC, ERR_IO_PENDING, 3)
   };
 
   DelayedSocketData data1(
       1, reads1, arraysize(reads1),
       writes1, arraysize(writes1));
   MockConnect connect_data1(ASYNC, OK);
@@ skipping 11 matching lines @@
     MockRead(ASYNC, 5, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead(ASYNC, 6, "hello"),
     MockRead(ASYNC, 7, OK),
   };
 
   DelayedSocketData data2(
       1, reads2, arraysize(reads2),
       writes2, arraysize(writes2));
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   session_deps_.socket_factory->AddSocketDataProvider(&data1);
   session_deps_.socket_factory->AddSocketDataProvider(&data2);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Start the first transaction to set up the SpdySession
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(https_url);
@@ skipping 15 matching lines @@
   HttpNetworkTransaction trans2(MEDIUM, session.get());
   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_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
+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(ConstructWrappedSpdyFrame(req1, 1));
+  scoped_ptr<SpdyFrame> wrapped_req1(
+      spdy_util_.ConstructWrappedSpdyFrame(req1, 1));
   const char* const headers[] = {
-    "method", "GET",
-    "url", http_url.c_str(),
-    "host",  "www.google.com:443",
-    "scheme", "http",
-    "version", "HTTP/1.1"
+    spdy_util_.GetMethodKey(), "GET",
+    spdy_util_.GetPathKey(), spdy_util_.is_spdy2() ? http_url.c_str() : "/",
+    spdy_util_.GetHostKey(),  "www.google.com:443",
+    spdy_util_.GetSchemeKey(), "http",
+    spdy_util_.GetVersionKey(), "HTTP/1.1"
   };
   scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyControlFrame(
       NULL, 0, false, 3, MEDIUM, SYN_STREAM, CONTROL_FLAG_FIN,
       headers, arraysize(headers), 0));
 
   MockWrite writes1[] = {
     CreateMockWrite(*connect, 0),
     CreateMockWrite(*wrapped_req1, 2),
     CreateMockWrite(*req2, 5),
   };
 
-  scoped_ptr<SpdyFrame> conn_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> wrapped_resp1(ConstructWrappedSpdyFrame(resp1, 1));
-  scoped_ptr<SpdyFrame> wrapped_body1(ConstructWrappedSpdyFrame(body1, 1));
-  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> conn_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> wrapped_resp1(
+      spdy_util_.ConstructWrappedSpdyFrame(resp1, 1));
+  scoped_ptr<SpdyFrame> wrapped_body1(
+      spdy_util_.ConstructWrappedSpdyFrame(body1, 1));
+  scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead reads1[] = {
     CreateMockRead(*conn_resp, 1),
     CreateMockRead(*wrapped_resp1, 3),
     CreateMockRead(*wrapped_body1, 4),
     CreateMockRead(*resp2, 6),
     CreateMockRead(*body2, 7),
     MockRead(ASYNC, ERR_IO_PENDING, 8)
   };
 
   DeterministicSocketData data1(reads1, arraysize(reads1),
                                 writes1, arraysize(writes1));
   MockConnect connect_data1(ASYNC, OK);
   data1.set_connect_data(connect_data1);
 
   session_deps_.proxy_service.reset(
       ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"));
   CapturingNetLog log;
   session_deps_.net_log = &log;
   SSLSocketDataProvider ssl1(ASYNC, OK);  // to the proxy
-  ssl1.SetNextProto(kProtoSPDY2);
+  ssl1.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1);
   SSLSocketDataProvider ssl2(ASYNC, OK);  // to the server
-  ssl2.SetNextProto(kProtoSPDY2);
+  ssl2.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data1);
 
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
 
   // Start the first transaction to set up the SpdySession
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(https_url);
@@ skipping 30 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_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
+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));
 
   MockWrite writes[] = {
     CreateMockWrite(*req1, 1),
     CreateMockWrite(*req2, 4),
   };
 
-  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(1, true));
-  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
-  scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(3, true));
+  scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+  scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
   MockRead reads[] = {
     CreateMockRead(*resp1, 2),
     CreateMockRead(*body1, 3),
     CreateMockRead(*resp2, 5),
     CreateMockRead(*body2, 6),
     MockRead(ASYNC, ERR_IO_PENDING, 7)
   };
 
   OrderedSocketData data(reads, arraysize(reads),
                          writes, arraysize(writes));
 
   SSLSocketDataProvider ssl(ASYNC, OK);
-  ssl.SetNextProto(kProtoSPDY2);
+  ssl.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
 
   // Start the first transaction to set up the SpdySession
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL(https_url);
   request1.load_flags = 0;
@@ skipping 18 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
 
   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_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
+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)
-  const char* const headers[] = {
-    "method", "GET",
-    "url", url1.c_str(),
-    "host",  "www.google.com",
-    "scheme", "http",
-    "version", "HTTP/1.1"
-  };
+  scoped_ptr<SpdyHeaderBlock> headers(
+      spdy_util_.ConstructGetHeaderBlockForProxy("http://www.google.com/"));
   scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyControlFrame(
-      NULL, 0, false, 1, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN,
-      headers, arraysize(headers), 0));
+      headers.Pass(), false, 1, LOWEST, SYN_STREAM, CONTROL_FLAG_FIN, 0));
 
   MockWrite writes1[] = {
     CreateMockWrite(*req1, 0),
   };
 
-  scoped_ptr<SpdyFrame> resp1(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body1(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads1[] = {
     CreateMockRead(*resp1, 1),
     CreateMockRead(*body1, 2),
     MockRead(ASYNC, OK, 3) // EOF
   };
 
   scoped_ptr<DeterministicSocketData> data1(
       new DeterministicSocketData(reads1, arraysize(reads1),
                                   writes1, arraysize(writes1)));
   IPAddressNumber ip;
   ASSERT_TRUE(ParseIPLiteralToNumber(ip_addr, &ip));
   IPEndPoint peer_addr = IPEndPoint(ip, 443);
   MockConnect connect_data1(ASYNC, OK, peer_addr);
   data1->set_connect_data(connect_data1);
 
   // SPDY GET for HTTPS URL (direct)
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(url2.c_str(), false, 1, MEDIUM));
 
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 0),
   };
 
-  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads2[] = {
     CreateMockRead(*resp2, 1),
     CreateMockRead(*body2, 2),
     MockRead(ASYNC, OK, 3) // EOF
   };
 
   scoped_ptr<DeterministicSocketData> data2(
       new DeterministicSocketData(reads2, arraysize(reads2),
                                   writes2, arraysize(writes2)));
   MockConnect connect_data2(ASYNC, OK);
@@ skipping 12 matching lines @@
   // Load a valid cert.  Note, that this does not need to
   // be valid for proxy because the MockSSLClientSocket does
   // not actually verify it.  But SpdySession will use this
   // to see if it is valid for the new origin
   base::FilePath certs_dir = GetTestCertsDirectory();
   scoped_refptr<X509Certificate> server_cert(
       ImportCertFromFile(certs_dir, "ok_cert.pem"));
   ASSERT_NE(static_cast<X509Certificate*>(NULL), server_cert);
 
   SSLSocketDataProvider ssl1(ASYNC, OK);  // to the proxy
-  ssl1.SetNextProto(kProtoSPDY2);
+  ssl1.SetNextProto(GetParam());
   ssl1.cert = server_cert;
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(
       data1.get());
 
   SSLSocketDataProvider ssl2(ASYNC, OK);  // to the server
-  ssl2.SetNextProto(kProtoSPDY2);
+  ssl2.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(
       data2.get());
 
   session_deps_.host_resolver.reset(new MockCachingHostResolver());
   session_deps_.host_resolver->rules()->AddRule("mail.google.com", ip_addr);
   session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr);
 
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
@@ skipping 27 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_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
+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);
 
   scoped_ptr<SpdyFrame> req2(
       spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, MEDIUM));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 0),
   };
 
-  scoped_ptr<SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> body2(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads2[] = {
     CreateMockRead(*resp2, 1),
     CreateMockRead(*body2, 2),
     MockRead(ASYNC, OK, 3)  // EOF
   };
 
   scoped_ptr<DeterministicSocketData> data2(
       new DeterministicSocketData(reads2, arraysize(reads2),
                                   writes2, arraysize(writes2)));
 
   SSLSocketDataProvider ssl1(ASYNC, OK);
-  ssl1.SetNextProto(kProtoSPDY2);
+  ssl1.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(
       data1.get());
 
   SSLSocketDataProvider ssl2(ASYNC, OK);
-  ssl2.SetNextProto(kProtoSPDY2);
+  ssl2.SetNextProto(GetParam());
   session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
   session_deps_.deterministic_socket_factory->AddSocketDataProvider(
       data2.get());
 
   scoped_refptr<HttpNetworkSession> session(
       SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
 
   // Start the first transaction to set up the SpdySession and verify that
   // connection was closed.
   HttpRequestInfo request1;
@@ skipping 17 matching lines @@
   EXPECT_EQ(ERR_IO_PENDING,
             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_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
+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_));
 
   SSLSocketDataProvider ssl1(ASYNC, OK);
-  ssl1.SetNextProto(kProtoSPDY2);
+  ssl1.SetNextProto(GetParam());
   SSLSocketDataProvider ssl2(ASYNC, OK);
-  ssl2.SetNextProto(kProtoSPDY2);
+  ssl2.SetNextProto(GetParam());
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1);
   session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
 
   scoped_ptr<SpdyFrame> host1_req(spdy_util_.ConstructSpdyGet(
       "https://www.a.com", false, 1, DEFAULT_PRIORITY));
   MockWrite spdy1_writes[] = {
     CreateMockWrite(*host1_req, 1),
   };
-  scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> host1_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> host1_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy1_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     MockRead(ASYNC, ERR_IO_PENDING, 4),
   };
 
   scoped_ptr<OrderedSocketData> spdy1_data(
       new OrderedSocketData(
           spdy1_reads, arraysize(spdy1_reads),
           spdy1_writes, arraysize(spdy1_writes)));
   session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get());
 
   scoped_ptr<SpdyFrame> host2_req(spdy_util_.ConstructSpdyGet(
       "https://www.b.com", false, 1, DEFAULT_PRIORITY));
   MockWrite spdy2_writes[] = {
     CreateMockWrite(*host2_req, 1),
   };
-  scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
-  scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(1, true));
+  scoped_ptr<SpdyFrame> host2_resp(
+      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  scoped_ptr<SpdyFrame> host2_resp_body(
+      spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead spdy2_reads[] = {
     CreateMockRead(*host2_resp, 2),
     CreateMockRead(*host2_resp_body, 3),
     MockRead(ASYNC, ERR_IO_PENDING, 4),
   };
 
   scoped_ptr<OrderedSocketData> spdy2_data(
       new OrderedSocketData(
           spdy2_reads, arraysize(spdy2_reads),
           spdy2_writes, arraysize(spdy2_writes)));
@@ skipping 100 matching lines @@
   EXPECT_EQ("hello!", response_data);
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(spdy_session_key_a));
   EXPECT_FALSE(
       session->spdy_session_pool()->HasSession(spdy_session_key_b));
 
   HttpStreamFactory::SetNextProtos(std::vector<std::string>());
 }
 
 }  // namespace net