Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(268)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/http/http_network_transaction_unittest.cc

Issue 17028007: Merge the HttpNetworkTransaction tests and parametrize them on a NextProto (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 7 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/http/http_network_transaction_spdy3_unittest.cc ('k') | net/net.gyp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/http/http_network_transaction_unittest.cc
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_unittest.cc
similarity index 94%
rename from net/http/http_network_transaction_spdy2_unittest.cc
rename to net/http/http_network_transaction_unittest.cc
index ffe23b256db45cdfa18c072a9210f64012a58a32..a13f156ccb0514b0ff218950b4be915f46234526 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -56,7 +56,7 @@
#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"
@@ -64,8 +64,6 @@
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
-using namespace net::test_spdy2;
-
//-----------------------------------------------------------------------------
namespace {
@@ -235,9 +233,11 @@ HttpNetworkSession* CreateSession(SpdySessionDependencies* 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(
@@ -247,9 +247,9 @@ class HttpNetworkTransactionSpdy2Test : public PlatformTest {
}
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(
@@ -383,6 +383,11 @@ class HttpNetworkTransactionSpdy2Test : public PlatformTest {
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.
@@ -562,13 +567,16 @@ bool CheckNTLMServerAuth(const AuthChallengeInfo* auth_challenge) {
} // 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"),
@@ -582,7 +590,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SimpleGET) {
}
// Response with no status line.
-TEST_F(HttpNetworkTransactionSpdy2Test, SimpleGETNoHeaders) {
+TEST_P(HttpNetworkTransactionTest, SimpleGETNoHeaders) {
MockRead data_reads[] = {
MockRead("hello world"),
MockRead(SYNCHRONOUS, OK),
@@ -595,7 +603,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SimpleGETNoHeaders) {
}
// 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),
@@ -608,7 +616,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk3Bytes) {
}
// 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),
@@ -621,7 +629,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk4Bytes) {
}
// 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),
@@ -634,7 +642,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk5Bytes) {
}
// 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"),
@@ -651,7 +659,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StatusLineJunk4Bytes_Slow) {
}
// 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),
@@ -666,7 +674,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StatusLinePartial) {
// 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!!
@@ -681,7 +689,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StopsReading204) {
// 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"),
@@ -700,7 +708,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ChunkedEncoding) {
// 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"),
@@ -712,7 +720,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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"),
@@ -727,7 +735,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
EXPECT_EQ("Hello", out.response_data);
}
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
ComplexContentLengthHeadersNoTransferEncoding) {
// More than 2 dupes.
{
@@ -773,7 +781,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
}
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
MultipleContentLengthHeadersTransferEncoding) {
MockRead data_reads[] = {
MockRead("HTTP/1.1 200 OK\r\n"),
@@ -797,7 +805,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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"),
@@ -812,7 +820,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SingleContentDispositionHeader) {
}
// 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"),
@@ -829,7 +837,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
// 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"),
@@ -844,7 +852,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, TwoDistinctContentDispositionHeaders) {
// 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"),
@@ -881,7 +889,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, TwoIdenticalLocationHeaders) {
}
// 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"),
@@ -896,7 +904,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, TwoDistinctLocationHeaders) {
// 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/");
@@ -956,7 +964,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Head) {
EXPECT_EQ("", response_data);
}
-TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
+TEST_P(HttpNetworkTransactionTest, ReuseConnection) {
scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
MockRead data_reads[] = {
@@ -1003,7 +1011,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReuseConnection) {
}
}
-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);
@@ -1050,7 +1058,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Ignores100) {
// 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/");
@@ -1089,7 +1097,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Ignores1xx) {
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/");
@@ -1120,7 +1128,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, Incomplete100ThenEOF) {
EXPECT_EQ("", response_data);
}
-TEST_F(HttpNetworkTransactionSpdy2Test, EmptyResponse) {
+TEST_P(HttpNetworkTransactionTest, EmptyResponse) {
HttpRequestInfo request;
request.method = "POST";
request.url = GURL("http://www.foo.com/");
@@ -1145,7 +1153,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, EmptyResponse) {
EXPECT_EQ(ERR_EMPTY_RESPONSE, rv);
}
-void HttpNetworkTransactionSpdy2Test::KeepAliveConnectionResendRequestTest(
+void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
const MockWrite* write_failure,
const MockRead* read_failure) {
HttpRequestInfo request;
@@ -1234,23 +1242,23 @@ void HttpNetworkTransactionSpdy2Test::KeepAliveConnectionResendRequestTest(
}
}
-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/");
@@ -1290,7 +1298,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NonKeepAliveConnectionReset) {
// 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
@@ -1306,7 +1314,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NonKeepAliveConnectionEOF) {
// 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/");
@@ -1347,7 +1355,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose) {
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/");
@@ -1387,7 +1395,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveEarlyClose2) {
// 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/");
@@ -1496,7 +1504,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, KeepAliveAfterUnreadBody) {
// 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/");
@@ -1591,7 +1599,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuth) {
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/");
@@ -1634,7 +1642,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotSendAuth) {
// 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/");
@@ -1728,7 +1736,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAlive) {
// 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/");
@@ -1804,7 +1812,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveNoBody) {
// 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/");
@@ -1888,7 +1896,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveLargeBody) {
// 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/");
@@ -1974,7 +1982,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthKeepAliveImpatientServer) {
// 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/");
@@ -2090,7 +2098,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyNoKeepAlive) {
// 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/");
@@ -2194,7 +2202,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyKeepAlive) {
// 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/");
@@ -2253,7 +2261,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyCancelTunnel) {
// 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/");
@@ -2298,7 +2306,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UnexpectedProxyAuth) {
// 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";
@@ -2357,7 +2365,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
// 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");
@@ -2455,7 +2463,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingNoPacTwoRequests) {
}
// 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");
@@ -2554,7 +2562,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpProxyLoadTimingWithPacTwoRequests) {
}
// 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/");
@@ -2615,7 +2623,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyGet) {
}
// 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/");
@@ -2633,8 +2644,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
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),
@@ -2648,7 +2659,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
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;
@@ -2678,7 +2689,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGet) {
}
// 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/");
@@ -2717,14 +2731,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
"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),
@@ -2739,7 +2754,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
session_deps_.socket_factory->AddSocketDataProvider(&data);
SSLSocketDataProvider ssl(ASYNC, OK);
- ssl.SetNextProto(kProtoSPDY2);
+ ssl.SetNextProto(GetParam());
session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
TestCompletionCallback callback1;
@@ -2780,7 +2795,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyGetWithProxyAuth) {
}
// 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/");
@@ -2804,14 +2822,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
"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()));
@@ -2835,7 +2854,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
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;
@@ -2865,7 +2884,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectHttps) {
}
// 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/");
@@ -2887,13 +2909,17 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
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(
@@ -2919,11 +2945,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
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;
@@ -2949,7 +2975,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectSpdy) {
}
// 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/");
@@ -2975,8 +3004,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectFailure) {
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),
@@ -2988,10 +3017,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectFailure) {
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;
@@ -3007,8 +3036,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxySpdyConnectFailure) {
// 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"));
@@ -3029,28 +3061,30 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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,
@@ -3063,20 +3097,21 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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),
@@ -3101,7 +3136,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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;
@@ -3162,8 +3197,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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"));
@@ -3184,19 +3222,21 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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()));
@@ -3205,13 +3245,13 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
"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),
@@ -3234,7 +3274,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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;
@@ -3290,8 +3330,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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"));
@@ -3311,32 +3354,24 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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),
@@ -3357,7 +3392,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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;
@@ -3411,7 +3446,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
// 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/");
@@ -3509,7 +3544,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HttpsProxyAuthRetry) {
EXPECT_TRUE(response->auth_challenge.get() == NULL);
}
-void HttpNetworkTransactionSpdy2Test::ConnectStatusHelperWithExpectedStatus(
+void HttpNetworkTransactionTest::ConnectStatusHelperWithExpectedStatus(
const MockRead& status, int expected_status) {
HttpRequestInfo request;
request.method = "GET";
@@ -3551,180 +3586,180 @@ void HttpNetworkTransactionSpdy2Test::ConnectStatusHelperWithExpectedStatus(
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/");
@@ -3853,7 +3888,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthProxyThenServer) {
// 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");
@@ -3982,7 +4017,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth1) {
}
// 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");
@@ -4184,7 +4219,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NTLMAuth2) {
// 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/");
@@ -4222,7 +4257,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, LargeHeadersNoBody) {
// 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";
@@ -4282,7 +4317,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
// 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/");
@@ -4338,7 +4373,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocket) {
// 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/");
@@ -4397,7 +4432,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSSLSocket) {
// 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/");
@@ -4492,7 +4527,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleDeadSSLSocket) {
// 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=&"
@@ -4547,7 +4582,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RecycleSocketAfterZeroContentLength) {
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);
@@ -4639,7 +4674,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ResendRequestOnWriteBodyError) {
// 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/");
@@ -4717,7 +4752,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AuthIdentityInURL) {
// 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
@@ -4825,7 +4860,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, WrongAuthIdentityInURL) {
}
// 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
@@ -5209,7 +5244,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthCacheAndPreauth) {
// 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 =
@@ -5343,7 +5378,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DigestPreAuthNonceCount) {
}
// 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,
@@ -5386,7 +5421,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ResetStateForRestart) {
}
// 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/");
@@ -5442,7 +5477,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificate) {
// 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;
@@ -5521,7 +5556,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificateViaProxy) {
// 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;
@@ -5585,7 +5620,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSViaHttpsProxy) {
}
// 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;
@@ -5661,7 +5696,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaHttpsProxy) {
}
// 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"));
@@ -5682,7 +5720,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaSpdyProxy) {
"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),
@@ -5694,7 +5732,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaSpdyProxy) {
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);
@@ -5721,7 +5759,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RedirectOfHttpsConnectViaSpdyProxy) {
}
// 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"));
@@ -5767,8 +5805,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
// 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"));
@@ -5790,10 +5831,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
"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),
@@ -5805,7 +5847,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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);
@@ -5827,7 +5869,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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/");
@@ -5858,7 +5903,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
"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),
@@ -5870,8 +5915,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
// 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\"",
};
@@ -5887,14 +5932,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
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),
@@ -5909,7 +5955,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
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);
@@ -5974,7 +6020,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BasicAuthSpdyProxy) {
// 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;
@@ -6008,13 +6057,13 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
};
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,
@@ -6035,7 +6084,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
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(
@@ -6095,7 +6144,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPush) {
}
// 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";
@@ -6124,13 +6176,13 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPushCorrectness) {
};
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,
@@ -6149,7 +6201,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPushCorrectness) {
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(
@@ -6179,7 +6231,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CrossOriginProxyPushCorrectness) {
// 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"));
@@ -6260,7 +6312,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSBadCertificateViaHttpsProxy) {
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/");
@@ -6299,7 +6351,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_UserAgent) {
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/");
@@ -6338,7 +6390,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_UserAgentOverTunnel) {
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/");
@@ -6378,7 +6430,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_Referer) {
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/");
@@ -6415,7 +6467,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_PostContentLengthZero) {
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/");
@@ -6452,7 +6504,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_PutContentLengthZero) {
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/");
@@ -6489,7 +6541,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_HeadContentLengthZero) {
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/");
@@ -6528,7 +6580,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_CacheControlNoCache) {
EXPECT_EQ(OK, rv);
}
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
BuildRequest_CacheControlValidateCache) {
HttpRequestInfo request;
request.method = "GET";
@@ -6567,7 +6619,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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/");
@@ -6605,7 +6657,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_ExtraHeaders) {
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/");
@@ -6647,7 +6699,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, BuildRequest_ExtraHeadersStripped) {
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/");
@@ -6706,7 +6758,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_HTTP_GET) {
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/");
@@ -6770,7 +6822,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_SSL_GET) {
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/");
@@ -6829,7 +6881,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS4_HTTP_GET_no_PAC) {
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/");
@@ -6902,7 +6954,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SOCKS5_HTTP_GET) {
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/");
@@ -7023,7 +7075,7 @@ int GroupNameTransactionHelper(
} // namespace
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForDirectConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForDirectConnections) {
const GroupNameTest tests[] = {
{
"", // unused
@@ -7090,7 +7142,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForDirectConnections) {
}
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForHTTPProxyConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForHTTPProxyConnections) {
const GroupNameTest tests[] = {
{
"http_proxy",
@@ -7155,7 +7207,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForHTTPProxyConnections) {
}
}
-TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForSOCKSConnections) {
+TEST_P(HttpNetworkTransactionTest, GroupNameForSOCKSConnections) {
const GroupNameTest tests[] = {
{
"socks4://socks_proxy:1080",
@@ -7228,7 +7280,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GroupNameForSOCKSConnections) {
}
}
-TEST_F(HttpNetworkTransactionSpdy2Test, ReconsiderProxyAfterFailedConnection) {
+TEST_P(HttpNetworkTransactionTest, ReconsiderProxyAfterFailedConnection) {
HttpRequestInfo request;
request.method = "GET";
request.url = GURL("http://www.google.com/");
@@ -7255,7 +7307,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReconsiderProxyAfterFailedConnection) {
// 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;
@@ -7309,20 +7361,20 @@ void HttpNetworkTransactionSpdy2Test::BypassHostCacheOnRefreshHelper(
// 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;
@@ -7351,7 +7403,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, RequestWriteError) {
}
// 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;
@@ -7393,7 +7445,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ConnectionClosedAfterStartOfHeaders) {
// 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;
@@ -7472,7 +7524,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DrainResetOK) {
}
// 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;
@@ -7506,7 +7558,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HTTPSViaProxyWithExtraData) {
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/");
@@ -7542,7 +7594,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, LargeContentLengthThenClose) {
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
@@ -7598,7 +7650,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadFileSmallerThanLength) {
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.");
@@ -7658,7 +7710,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UploadUnreadableFile) {
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.");
@@ -7750,7 +7802,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UnreadableUploadFileAfterAuthRestart) {
}
// Tests that changes to Auth realms are treated like auth rejections.
-TEST_F(HttpNetworkTransactionSpdy2Test, ChangeAuthRealms) {
+TEST_P(HttpNetworkTransactionTest, ChangeAuthRealms) {
HttpRequestInfo request;
request.method = "GET";
@@ -7902,7 +7954,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ChangeAuthRealms) {
EXPECT_TRUE(response->auth_challenge.get() == NULL);
}
-TEST_F(HttpNetworkTransactionSpdy2Test, HonorAlternateProtocolHeader) {
+TEST_P(HttpNetworkTransactionTest, HonorAlternateProtocolHeader) {
HttpStreamFactory::SetNextProtos(SpdyNextProtos());
HttpStreamFactory::set_use_alternate_protocols(true);
@@ -7961,7 +8013,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, HonorAlternateProtocolHeader) {
HttpStreamFactory::SetNextProtos(std::vector<std::string>());
}
-TEST_F(HttpNetworkTransactionSpdy2Test,
+TEST_P(HttpNetworkTransactionTest,
MarkBrokenAlternateProtocolAndFallback) {
HttpStreamFactory::set_use_alternate_protocols(true);
@@ -8020,7 +8072,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8069,7 +8121,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8119,7 +8171,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8168,7 +8220,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8216,7 +8268,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8264,7 +8316,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8319,7 +8371,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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());
@@ -8341,15 +8396,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
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),
@@ -8406,7 +8461,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseAlternateProtocolForNpnSpdy) {
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());
@@ -8438,7 +8496,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
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(
@@ -8449,10 +8507,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
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),
@@ -8520,7 +8578,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, AlternateProtocolWithSpdyLateBinding) {
EXPECT_EQ("hello!", response_data);
}
-TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
+TEST_P(HttpNetworkTransactionTest, StallAlternateProtocolForNpnSpdy) {
HttpStreamFactory::set_use_alternate_protocols(true);
HttpStreamFactory::SetNextProtos(SpdyNextProtos());
@@ -8542,7 +8600,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, StallAlternateProtocolForNpnSpdy) {
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);
@@ -8635,8 +8693,11 @@ class CapturingProxyResolver : public ProxyResolver {
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());
@@ -8670,7 +8731,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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(
@@ -8684,8 +8745,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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
@@ -8754,8 +8815,11 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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());
@@ -8776,15 +8840,15 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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),
@@ -8891,7 +8955,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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";
@@ -9289,7 +9353,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, GenerateAuthToken) {
}
}
-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());
@@ -9477,7 +9541,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MultiRoundAuth) {
// 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));
@@ -9534,7 +9598,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, NpnWithHttpOverSSL) {
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
@@ -9547,7 +9611,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyPostNPNServerHangup) {
request.load_flags = 0;
SSLSocketDataProvider ssl(ASYNC, OK);
- ssl.SetNextProto(kProtoSPDY2);
+ ssl.SetNextProto(GetParam());
session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
scoped_ptr<SpdyFrame> req(
@@ -9575,7 +9639,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyPostNPNServerHangup) {
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);
@@ -9635,8 +9702,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
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.
@@ -9680,7 +9747,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
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(
@@ -9735,7 +9802,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SpdyAlternateProtocolThroughProxy) {
// 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.
@@ -9773,7 +9840,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SimpleCancel) {
}
// 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;
@@ -9828,7 +9895,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyGet) {
}
// 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;
@@ -9902,7 +9969,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGet) {
// 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();
@@ -9957,14 +10024,16 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ProxyTunnelGetHangup) {
}
// 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),
@@ -9978,7 +10047,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, PreconnectWithExistingSpdySession) {
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_));
@@ -10024,7 +10093,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, PreconnectWithExistingSpdySession) {
// 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/");
@@ -10051,7 +10120,7 @@ void HttpNetworkTransactionSpdy2Test::CheckErrorIsPassedBack(
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,
@@ -10070,7 +10139,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SSLWriteCertError) {
// 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/");
@@ -10180,7 +10249,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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/");
@@ -10303,7 +10372,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
// 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;
@@ -10396,13 +10465,26 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ClientAuthCertCache_Proxy_Fail) {
}
}
+// 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());
@@ -10413,7 +10495,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
pool_peer.DisableDomainAuthenticationVerification();
SSLSocketDataProvider ssl(ASYNC, OK);
- ssl.SetNextProto(kProtoSPDY2);
+ ssl.SetNextProto(GetParam());
session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
scoped_ptr<SpdyFrame> host1_req(
@@ -10424,10 +10506,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
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),
@@ -10498,7 +10584,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, MAYBE_UseIPConnectionPooling) {
}
#undef MAYBE_UseIPConnectionPooling
-TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
+TEST_P(HttpNetworkTransactionTest, UseIPConnectionPoolingAfterResolution) {
+ if (GetParam() > kProtoSPDY3)
+ return;
+
HttpStreamFactory::set_use_alternate_protocols(true);
HttpStreamFactory::SetNextProtos(SpdyNextProtos());
@@ -10509,7 +10598,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
pool_peer.DisableDomainAuthenticationVerification();
SSLSocketDataProvider ssl(ASYNC, OK);
- ssl.SetNextProto(kProtoSPDY2);
+ ssl.SetNextProto(GetParam());
session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
scoped_ptr<SpdyFrame> host1_req(
@@ -10520,10 +10609,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseIPConnectionPoolingAfterResolution) {
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),
@@ -10630,8 +10723,17 @@ class OneTimeCachingHostResolver : public net::HostResolver {
#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());
@@ -10645,7 +10747,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
pool_peer.DisableDomainAuthenticationVerification();
SSLSocketDataProvider ssl(ASYNC, OK);
- ssl.SetNextProto(kProtoSPDY2);
+ ssl.SetNextProto(GetParam());
session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
scoped_ptr<SpdyFrame> host1_req(
@@ -10656,10 +10758,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
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),
@@ -10728,7 +10834,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test,
}
#undef MAYBE_UseIPConnectionPoolingWithHostCacheExpiration
-TEST_F(HttpNetworkTransactionSpdy2Test, ReadPipelineEvictionFallback) {
+TEST_P(HttpNetworkTransactionTest, ReadPipelineEvictionFallback) {
MockRead data_reads1[] = {
MockRead(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
};
@@ -10748,7 +10854,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ReadPipelineEvictionFallback) {
EXPECT_EQ("hello world", out.response_data);
}
-TEST_F(HttpNetworkTransactionSpdy2Test, SendPipelineEvictionFallback) {
+TEST_P(HttpNetworkTransactionTest, SendPipelineEvictionFallback) {
MockWrite data_writes1[] = {
MockWrite(SYNCHRONOUS, ERR_PIPELINE_EVICTION),
};
@@ -10775,7 +10881,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SendPipelineEvictionFallback) {
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/";
@@ -10787,8 +10896,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
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),
@@ -10820,7 +10929,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
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);
@@ -10856,7 +10965,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttp) {
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/";
@@ -10866,13 +10978,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
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,
@@ -10884,13 +10997,16 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
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),
@@ -10910,10 +11026,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
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);
@@ -10964,7 +11080,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionForHttpOverTunnel) {
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/";
@@ -10981,10 +11100,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
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),
@@ -10997,7 +11116,7 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
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);
@@ -11036,29 +11155,26 @@ TEST_F(HttpNetworkTransactionSpdy2Test, UseSpdySessionForHttpWhenForced) {
// 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),
@@ -11082,8 +11198,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
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),
@@ -11116,14 +11232,14 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
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());
@@ -11171,7 +11287,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, DoNotUseSpdySessionIfCertDoesNotMatch) {
// 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[] = {
@@ -11188,8 +11307,8 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
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),
@@ -11201,13 +11320,13 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
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());
@@ -11245,7 +11364,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, ErrorSocketNotConnected) {
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);
@@ -11258,9 +11380,9 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
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);
@@ -11269,8 +11391,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
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),
@@ -11288,8 +11412,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
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),
« no previous file with comments | « net/http/http_network_transaction_spdy3_unittest.cc ('k') | net/net.gyp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698