Chromium Code Reviews Chromium Code Reviews
Issue 17760008:
[SPDY] Enable tests for SPDY/3.1 and SPDY/4 (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src| Index: net/spdy/spdy_network_transaction_unittest.cc |
| diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc |
| index 340f4c1dd616a5e9e24b5f5a5df7d19fc17118cf..f0e4c8c7c41171d5cce7b02c46be6dabc6c7be94 100644 |
| --- a/net/spdy/spdy_network_transaction_unittest.cc |
| +++ b/net/spdy/spdy_network_transaction_unittest.cc |
| @@ -83,28 +83,6 @@ HttpResponseInfo::ConnectionInfo NextProtoToConnectionInfo( |
| return HttpResponseInfo::CONNECTION_INFO_SPDY2; |
| } |
| -AlternateProtocol NextProtoToAlternateProtocol(NextProto next_proto) { |
| - switch (next_proto) { |
| - case kProtoSPDY2: |
| - return NPN_SPDY_2; |
| - case kProtoSPDY3: |
| - return NPN_SPDY_3; |
| - case kProtoSPDY31: |
| - return NPN_SPDY_3_1; |
| - case kProtoSPDY4a2: |
| - return NPN_SPDY_4A2; |
| - |
| - case kProtoUnknown: |
| - case kProtoHTTP11: |
| - case kProtoSPDY1: |
| - case kProtoSPDY21: |
| - break; |
| - } |
| - |
| - NOTREACHED(); |
| - return NPN_SPDY_2; |
| -} |
| - |
| SpdySessionDependencies* CreateSpdySessionDependencies( |
| SpdyNetworkTransactionTestParams test_params) { |
| return new SpdySessionDependencies(test_params.protocol); |
| @@ -208,15 +186,13 @@ class SpdyNetworkTransactionTest |
| HttpStreamFactory::set_force_spdy_over_ssl(false); |
| HttpStreamFactory::set_force_spdy_always(false); |
| - std::vector<std::string> next_protos; |
| - next_protos.push_back("http/1.1"); |
| - next_protos.push_back("spdy/2"); |
| + std::vector<std::string> next_protos = SpdyNextProtos(); |
| switch (test_params_.ssl_type) { |
| case SPDYNPN: |
| session_->http_server_properties()->SetAlternateProtocol( |
| HostPortPair("www.google.com", 80), 443, |
| - NextProtoToAlternateProtocol(test_params_.protocol)); |
| + AlternateProtocolFromNextProto(test_params_.protocol)); |
| HttpStreamFactory::set_use_alternate_protocols(true); |
| HttpStreamFactory::SetNextProtos(next_protos); |
| break; |
| @@ -597,7 +573,7 @@ class SpdyNetworkTransactionTest |
| void RunServerPushTest(OrderedSocketData* data, |
| HttpResponseInfo* response, |
| HttpResponseInfo* push_response, |
| - std::string& expected) { |
| + const std::string& expected) { |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| helper.RunPreTestSetup(); |
| @@ -715,13 +691,7 @@ TEST_P(SpdyNetworkTransactionTest, Constructor) { |
| new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
| } |
| -// TODO(akalin): Don't early-exit in the tests below for values > |
| -// kProtoSPDY3. |
| - |
| TEST_P(SpdyNetworkTransactionTest, Get) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -747,9 +717,6 @@ TEST_P(SpdyNetworkTransactionTest, Get) { |
| } |
| TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| for (RequestPriority p = MINIMUM_PRIORITY; p < NUM_PRIORITIES; |
| p = RequestPriority(p + 1)) { |
| // Construct the request. |
| @@ -835,9 +802,6 @@ TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) { |
| // can allow multiple streams in flight. |
| TEST_P(SpdyNetworkTransactionTest, ThreeGets) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| @@ -934,9 +898,6 @@ TEST_P(SpdyNetworkTransactionTest, ThreeGets) { |
| } |
| TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| @@ -1024,9 +985,6 @@ TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) { |
| } |
| TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBindingFromPreconnect) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| @@ -1133,9 +1091,6 @@ TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBindingFromPreconnect) { |
| // stream limit of 1. This means that our IO loop exists after the |
| // second transaction completes, so we can assert on read_index(). |
| TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -1269,9 +1224,6 @@ TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) { |
| // user specified priority, we expect to see them inverted in |
| // the response from the server. |
| TEST_P(SpdyNetworkTransactionTest, FourGetsWithMaxConcurrentPriority) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -1425,9 +1377,6 @@ TEST_P(SpdyNetworkTransactionTest, FourGetsWithMaxConcurrentPriority) { |
| // that we properly remove pendingcreatestream objects from |
| // the spdy_session |
| TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentDelete) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -1564,9 +1513,6 @@ class KillerCallback : public TestCompletionCallbackBase { |
| // closes the socket while we have a pending transaction waiting for |
| // a pending stream creation. http://crbug.com/52901 |
| TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentSocketClose) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -1660,9 +1606,6 @@ TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentSocketClose) { |
| // Test that a simple PUT request works. |
| TEST_P(SpdyNetworkTransactionTest, Put) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Setup the request |
| HttpRequestInfo request; |
| request.method = "PUT"; |
| @@ -1730,9 +1673,6 @@ TEST_P(SpdyNetworkTransactionTest, Put) { |
| // Test that a simple HEAD request works. |
| TEST_P(SpdyNetworkTransactionTest, Head) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Setup the request |
| HttpRequestInfo request; |
| request.method = "HEAD"; |
| @@ -1801,9 +1741,6 @@ TEST_P(SpdyNetworkTransactionTest, Head) { |
| // Test that a simple POST works. |
| TEST_P(SpdyNetworkTransactionTest, Post) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyPost( |
| kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0)); |
| @@ -1833,9 +1770,6 @@ TEST_P(SpdyNetworkTransactionTest, Post) { |
| // Test that a POST with a file works. |
| TEST_P(SpdyNetworkTransactionTest, FilePost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyPost( |
| kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0)); |
| @@ -1865,9 +1799,6 @@ TEST_P(SpdyNetworkTransactionTest, FilePost) { |
| // Test that a complex POST works. |
| TEST_P(SpdyNetworkTransactionTest, ComplexPost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyPost( |
| kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0)); |
| @@ -1898,9 +1829,6 @@ TEST_P(SpdyNetworkTransactionTest, ComplexPost) { |
| // Test that a chunked POST works. |
| TEST_P(SpdyNetworkTransactionTest, ChunkedPost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0)); |
| scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockWrite writes[] = { |
| @@ -1937,9 +1865,6 @@ TEST_P(SpdyNetworkTransactionTest, ChunkedPost) { |
| // Test that a chunked POST works with chunks appended after transaction starts. |
| TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0)); |
| scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false)); |
| scoped_ptr<SpdyFrame> chunk2(spdy_util_.ConstructSpdyBodyFrame(1, false)); |
| @@ -1996,9 +1921,6 @@ TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) { |
| // Test that a POST without any post data works. |
| TEST_P(SpdyNetworkTransactionTest, NullPost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Setup the request |
| HttpRequestInfo request; |
| request.method = "POST"; |
| @@ -2038,9 +1960,6 @@ TEST_P(SpdyNetworkTransactionTest, NullPost) { |
| // Test that a simple POST works. |
| TEST_P(SpdyNetworkTransactionTest, EmptyPost) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Create an empty UploadDataStream. |
| ScopedVector<UploadElementReader> element_readers; |
| UploadDataStream stream(&element_readers, 0); |
| @@ -2082,9 +2001,6 @@ TEST_P(SpdyNetworkTransactionTest, EmptyPost) { |
| // While we're doing a post, the server sends back a SYN_REPLY. |
| TEST_P(SpdyNetworkTransactionTest, PostWithEarlySynReply) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| static const char upload[] = { "hello!" }; |
| ScopedVector<UploadElementReader> element_readers; |
| element_readers.push_back( |
| @@ -2138,9 +2054,6 @@ TEST_P(SpdyNetworkTransactionTest, PostWithEarlySynReply) { |
| // socket causes the TCP write to return zero. This test checks that the client |
| // tries to queue up the RST_STREAM frame again. |
| TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> rst( |
| @@ -2182,9 +2095,6 @@ TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) { |
| // Test that the transaction doesn't crash when we don't have a reply. |
| TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockRead reads[] = { |
| CreateMockRead(*body), |
| @@ -2202,9 +2112,6 @@ TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) { |
| // Test that the transaction doesn't crash when we get two replies on the same |
| // stream ID. See http://crbug.com/45639. |
| TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> rst( |
| @@ -2250,1102 +2157,779 @@ TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) { |
| helper.VerifyDataConsumed(); |
| } |
| -// Test that sent data frames and received WINDOW_UPDATE frames change |
|
Ryan Hamilton
2013/06/27 17:23:50
So this block appears to have been moved but it lo
akalin
2013/06/27 20:00:06
Moved back.
|
| -// the send_window_size_ correctly. |
| - |
| -// WINDOW_UPDATE is different than most other frames in that it can arrive |
| -// while the client is still sending the request body. In order to enforce |
| -// this scenario, we feed a couple of dummy frames and give a delay of 0 to |
| -// socket data provider, so that initial read that is done as soon as the |
| -// stream is created, succeeds and schedules another read. This way reads |
| -// and writes are interleaved; after doing a full frame write, SpdyStream |
| -// will break out of DoLoop and will read and process a WINDOW_UPDATE. |
| -// Once our WINDOW_UPDATE is read, we cannot send SYN_REPLY right away |
| -// since request has not been completely written, therefore we feed |
| -// enough number of WINDOW_UPDATEs to finish the first read and cause a |
| -// write, leading to a complete write of request body; after that we send |
| -// a reply with a body, to cause a graceful shutdown. |
| - |
| -// TODO(agayev): develop a socket data provider where both, reads and |
| -// writes are ordered so that writing tests like these are easy and rewrite |
| -// all these tests using it. Right now we are working around the |
| -// limitations as described above and it's not deterministic, tests may |
| -// fail under specific circumstances. |
| -TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - static int kFrameCount = 2; |
| - scoped_ptr<std::string> content( |
| - new std::string(kMaxSpdyFrameChunkSize, 'a')); |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| - kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0)); |
| - scoped_ptr<SpdyFrame> body( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content->c_str(), content->size(), false)); |
| - scoped_ptr<SpdyFrame> body_end( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content->c_str(), content->size(), true)); |
| - |
| +TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) { |
| + // Construct the request. |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*req, 0), |
| - CreateMockWrite(*body, 1), |
| - CreateMockWrite(*body_end, 2), |
| + CreateMockWrite(*req), |
| + CreateMockWrite(*rst), |
| }; |
| - static const int32 kDeltaWindowSize = 0xff; |
| - static const int kDeltaCount = 4; |
| - scoped_ptr<SpdyFrame> window_update( |
| - spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize)); |
| - scoped_ptr<SpdyFrame> window_update_dummy( |
| - spdy_util_.ConstructSpdyWindowUpdate(2, kDeltaWindowSize)); |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| + const char* const headers[] = { |
| + "transfer-encoding", "chunked" |
| + }; |
| + scoped_ptr<SpdyFrame> resp( |
| + spdy_util_.ConstructSpdyGetSynReply(headers, 1, 1)); |
| + scoped_ptr<SpdyFrame> body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockRead reads[] = { |
| - CreateMockRead(*window_update_dummy, 3), |
| - CreateMockRead(*window_update_dummy, 4), |
| - CreateMockRead(*window_update_dummy, 5), |
| - CreateMockRead(*window_update, 6), // Four updates, therefore window |
| - CreateMockRead(*window_update, 7), // size should increase by |
| - CreateMockRead(*window_update, 8), // kDeltaWindowSize * 4 |
| - CreateMockRead(*window_update, 9), |
| - CreateMockRead(*resp, 10), |
| - CreateMockRead(*body_end, 11), |
| - MockRead(ASYNC, 0, 0, 12) // EOF |
| + CreateMockRead(*resp), |
| + CreateMockRead(*body), |
| + MockRead(ASYNC, 0, 0) // EOF |
| }; |
| - DeterministicSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - |
| - ScopedVector<UploadElementReader> element_readers; |
| - for (int i = 0; i < kFrameCount; ++i) { |
| - element_readers.push_back( |
| - new UploadBytesElementReader(content->c_str(), content->size())); |
| - } |
| - UploadDataStream upload_data_stream(&element_readers, 0); |
| - |
| - // Setup the request |
| - HttpRequestInfo request; |
| - request.method = "POST"; |
| - request.url = GURL(kDefaultURL); |
| - request.upload_data_stream = &upload_data_stream; |
| - |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + DelayedSocketData data(1, reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.SetDeterministic(); |
| - helper.AddDeterministicData(&data); |
| - helper.RunPreTestSetup(); |
| - |
| - HttpNetworkTransaction* trans = helper.trans(); |
| - |
| - TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| + helper.RunToCompletion(&data); |
| + TransactionHelperResult out = helper.output(); |
| + EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| - data.RunFor(11); |
| + helper.session()->spdy_session_pool()->CloseAllSessions(); |
| + helper.VerifyDataConsumed(); |
| +} |
| - SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| - ASSERT_TRUE(stream != NULL); |
| - ASSERT_TRUE(stream->stream() != NULL); |
| - EXPECT_EQ(static_cast<int>(kSpdyStreamInitialWindowSize) + |
| - kDeltaWindowSize * kDeltaCount - |
| - kMaxSpdyFrameChunkSize * kFrameCount, |
| - stream->stream()->send_window_size()); |
| +TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) { |
| + // Construct the request. |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req), |
| + CreateMockWrite(*rst), |
| + }; |
| - data.RunFor(1); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + const char* const headers[] = { |
| + "transfer-encoding", "chunked" |
| + }; |
| + scoped_ptr<SpdyFrame> push( |
| + spdy_util_.ConstructSpdyPush(headers, arraysize(headers) / 2, |
| + 2, 1, "http://www.google.com/1")); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*resp), |
| + CreateMockRead(*push), |
| + CreateMockRead(*body), |
| + MockRead(ASYNC, 0, 0) // EOF |
| + }; |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv); |
| + DelayedSocketData data(1, reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.RunToCompletion(&data); |
| + TransactionHelperResult out = helper.output(); |
| + EXPECT_EQ(OK, out.rv); |
| + EXPECT_EQ("HTTP/1.1 200 OK", out.status_line); |
| + EXPECT_EQ("hello!", out.response_data); |
| + helper.session()->spdy_session_pool()->CloseAllSessions(); |
| helper.VerifyDataConsumed(); |
| } |
| -// Test that received data frames and sent WINDOW_UPDATE frames change |
| -// the recv_window_size_ correctly. |
| -TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - // Set the data in the body frame large enough to trigger sending a |
| - // WINDOW_UPDATE by the stream. |
| - const std::string body_data(kSpdyStreamInitialWindowSize / 2 + 1, 'x'); |
| - |
| +TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) { |
| + // Construct the request. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> window_update( |
| - spdy_util_.ConstructSpdyWindowUpdate(1, body_data.size())); |
| - |
| MockWrite writes[] = { |
| CreateMockWrite(*req), |
| - CreateMockWrite(*window_update), |
| }; |
| - scoped_ptr<SpdyFrame> resp( |
| - spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body_no_fin( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, body_data.data(), body_data.size(), false)); |
| - scoped_ptr<SpdyFrame> body_fin( |
| - spdy_util_.ConstructSpdyBodyFrame(1, NULL, 0, true)); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| MockRead reads[] = { |
| CreateMockRead(*resp), |
| - CreateMockRead(*body_no_fin), |
| - MockRead(ASYNC, ERR_IO_PENDING, 0), // Force a pause |
| - CreateMockRead(*body_fin), |
| - MockRead(ASYNC, ERR_IO_PENDING, 0), // Force a pause |
| + // This following read isn't used by the test, except during the |
| + // RunUntilIdle() call at the end since the SpdySession survives the |
| + // HttpNetworkTransaction and still tries to continue Read()'ing. Any |
| + // MockRead will do here. |
| MockRead(ASYNC, 0, 0) // EOF |
| }; |
| - DelayedSocketData data(1, reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| + StaticSocketDataProvider data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.AddData(&data); |
| helper.RunPreTestSetup(); |
| + helper.AddData(&data); |
| HttpNetworkTransaction* trans = helper.trans(); |
| TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv); |
| - |
| - SpdyHttpStream* stream = |
| - static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| - ASSERT_TRUE(stream != NULL); |
| - ASSERT_TRUE(stream->stream() != NULL); |
| - |
| - EXPECT_EQ( |
| - static_cast<int>(kSpdyStreamInitialWindowSize - body_data.size()), |
| - stream->stream()->recv_window_size()); |
| - |
| - const HttpResponseInfo* response = trans->GetResponseInfo(); |
| - ASSERT_TRUE(response != NULL); |
| - ASSERT_TRUE(response->headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| - EXPECT_TRUE(response->was_fetched_via_spdy); |
| - |
| - // Issue a read which will cause a WINDOW_UPDATE to be sent and window |
| - // size increased to default. |
| - scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(body_data.size())); |
| - rv = trans->Read(buf.get(), body_data.size(), CompletionCallback()); |
| - EXPECT_EQ(static_cast<int>(body_data.size()), rv); |
| - std::string content(buf->data(), buf->data() + body_data.size()); |
| - EXPECT_EQ(body_data, content); |
| - |
| - // Schedule the reading of empty data frame with FIN |
| - data.CompleteRead(); |
| + helper.ResetTrans(); // Cancel the transaction. |
| - // Force write of WINDOW_UPDATE which was scheduled during the above |
| - // read. |
| + // Flush the MessageLoop while the SpdySessionDependencies (in particular, the |
| + // MockClientSocketFactory) are still alive. |
| base::MessageLoop::current()->RunUntilIdle(); |
| - |
| - // Read EOF. |
| - data.CompleteRead(); |
| - |
| - helper.VerifyDataConsumed(); |
| + helper.VerifyDataNotConsumed(); |
| } |
| -// Test that WINDOW_UPDATE frame causing overflow is handled correctly. |
| -TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - // Number of full frames we hope to write (but will not, used to |
| - // set content-length header correctly) |
| - static int kFrameCount = 3; |
| - |
| - scoped_ptr<std::string> content( |
| - new std::string(kMaxSpdyFrameChunkSize, 'a')); |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| - kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0)); |
| - scoped_ptr<SpdyFrame> body( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content->c_str(), content->size(), false)); |
| +// Verify that the client sends a Rst Frame upon cancelling the stream. |
| +TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) { |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR)); |
| - |
| - // We're not going to write a data frame with FIN, we'll receive a bad |
| - // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame. |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*req, 0), |
| - CreateMockWrite(*body, 2), |
| - CreateMockWrite(*rst, 3), |
| + CreateMockWrite(*req, 0, SYNCHRONOUS), |
| + CreateMockWrite(*rst, 2, SYNCHRONOUS), |
| }; |
| - static const int32 kDeltaWindowSize = 0x7fffffff; // cause an overflow |
| - scoped_ptr<SpdyFrame> window_update( |
| - spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize)); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| MockRead reads[] = { |
| - CreateMockRead(*window_update, 1), |
| - MockRead(ASYNC, 0, 4) // EOF |
| + CreateMockRead(*resp, 1, ASYNC), |
| + MockRead(ASYNC, 0, 0, 3) // EOF |
| }; |
| DeterministicSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - ScopedVector<UploadElementReader> element_readers; |
| - for (int i = 0; i < kFrameCount; ++i) { |
| - element_readers.push_back( |
| - new UploadBytesElementReader(content->c_str(), content->size())); |
| - } |
| - UploadDataStream upload_data_stream(&element_readers, 0); |
| - |
| - // Setup the request |
| - HttpRequestInfo request; |
| - request.method = "POST"; |
| - request.url = GURL("http://www.google.com/"); |
| - request.upload_data_stream = &upload_data_stream; |
| - |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), |
| + GetParam(), NULL); |
| helper.SetDeterministic(); |
| helper.RunPreTestSetup(); |
| helper.AddDeterministicData(&data); |
| HttpNetworkTransaction* trans = helper.trans(); |
| TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - ASSERT_EQ(ERR_IO_PENDING, rv); |
| - |
| - data.RunFor(5); |
| - ASSERT_TRUE(callback.have_result()); |
| - EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult()); |
| - helper.VerifyDataConsumed(); |
| -} |
| - |
| -// Test that after hitting a send window size of 0, the write process |
| -// stalls and upon receiving WINDOW_UPDATE frame write resumes. |
| - |
| -// This test constructs a POST request followed by enough data frames |
| -// containing 'a' that would make the window size 0, followed by another |
| -// data frame containing default content (which is "hello!") and this frame |
| -// also contains a FIN flag. DelayedSocketData is used to enforce all |
| -// writes go through before a read could happen. However, the last frame |
| -// ("hello!") is not supposed to go through since by the time its turn |
| -// arrives, window size is 0. At this point MessageLoop::Run() called via |
| -// callback would block. Therefore we call MessageLoop::RunUntilIdle() |
| -// which returns after performing all possible writes. We use DCHECKS to |
| -// ensure that last data frame is still there and stream has stalled. |
| -// After that, next read is artifically enforced, which causes a |
| -// WINDOW_UPDATE to be read and I/O process resumes. |
| -TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - // Number of frames we need to send to zero out the window size: data |
| - // frames plus SYN_STREAM plus the last data frame; also we need another |
| - // data frame that we will send once the WINDOW_UPDATE is received, |
| - // therefore +3. |
| - size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - |
| - // Calculate last frame's size; 0 size data frame is legal. |
| - size_t last_frame_size = |
| - kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - |
| - // Construct content for a data frame of maximum size. |
| - std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| - kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| - LOWEST, NULL, 0)); |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| - // Full frames. |
| - scoped_ptr<SpdyFrame> body1( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), content.size(), false)); |
| + data.SetStop(2); |
| + data.Run(); |
| + helper.ResetTrans(); |
| + data.SetStop(20); |
| + data.Run(); |
| - // Last frame to zero out the window size. |
| - scoped_ptr<SpdyFrame> body2( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), last_frame_size, false)); |
| + helper.VerifyDataConsumed(); |
| +} |
| - // Data frame to be sent once WINDOW_UPDATE frame is received. |
| - scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| +// Verify that the client can correctly deal with the user callback attempting |
| +// to start another transaction on a session that is closing down. See |
| +// http://crbug.com/47455 |
| +TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) { |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + MockWrite writes[] = { CreateMockWrite(*req) }; |
| + MockWrite writes2[] = { CreateMockWrite(*req) }; |
| - // Fill in mock writes. |
| - scoped_ptr<MockWrite[]> writes(new MockWrite[num_writes]); |
| - size_t i = 0; |
| - writes[i] = CreateMockWrite(*req); |
| - for (i = 1; i < num_writes - 2; i++) |
| - writes[i] = CreateMockWrite(*body1); |
| - writes[i++] = CreateMockWrite(*body2); |
| - writes[i] = CreateMockWrite(*body3); |
| + // The indicated length of this frame is longer than its actual length. When |
| + // the session receives an empty frame after this one, it shuts down the |
| + // session, and calls the read callback with the incomplete data. |
| + const uint8 kGetBodyFrame2[] = { |
| + 0x00, 0x00, 0x00, 0x01, |
| + 0x01, 0x00, 0x00, 0x07, |
| + 'h', 'e', 'l', 'l', 'o', '!', |
| + }; |
| - // Construct read frame, give enough space to upload the rest of the |
| - // data. |
| - scoped_ptr<SpdyFrame> window_update( |
| - spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize)); |
| - scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| MockRead reads[] = { |
| - CreateMockRead(*window_update), |
| - CreateMockRead(*window_update), |
| - CreateMockRead(*reply), |
| - CreateMockRead(*body2), |
| - CreateMockRead(*body3), |
| - MockRead(ASYNC, 0, 0) // EOF |
| + CreateMockRead(*resp, 2), |
| + MockRead(ASYNC, ERR_IO_PENDING, 3), // Force a pause |
| + MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2), |
| + arraysize(kGetBodyFrame2), 4), |
| + MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| + MockRead(ASYNC, 0, 0, 6), // EOF |
| + }; |
| + MockRead reads2[] = { |
| + CreateMockRead(*resp, 2), |
| + MockRead(ASYNC, 0, 0, 3), // EOF |
| }; |
| - // Force all writes to happen before any read, last write will not |
| - // actually queue a frame, due to window size being 0. |
| - DelayedSocketData data(num_writes, reads, arraysize(reads), |
| - writes.get(), num_writes); |
| - |
| - ScopedVector<UploadElementReader> element_readers; |
| - std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| - upload_data_string.append(kUploadData, kUploadDataSize); |
| - element_readers.push_back(new UploadBytesElementReader( |
| - upload_data_string.c_str(), upload_data_string.size())); |
| - UploadDataStream upload_data_stream(&element_readers, 0); |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + DelayedSocketData data2(1, reads2, arraysize(reads2), |
| + writes2, arraysize(writes2)); |
| - HttpRequestInfo request; |
| - request.method = "POST"; |
| - request.url = GURL("http://www.google.com/"); |
| - request.upload_data_stream = &upload_data_stream; |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.AddData(&data); |
| helper.RunPreTestSetup(); |
| - |
| + helper.AddData(&data); |
| + helper.AddData(&data2); |
| HttpNetworkTransaction* trans = helper.trans(); |
| + // Start the transaction with basic parameters. |
| TestCompletionCallback callback; |
| int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| - |
| - base::MessageLoop::current()->RunUntilIdle(); // Write as much as we can. |
| - |
| - SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| - ASSERT_TRUE(stream != NULL); |
| - ASSERT_TRUE(stream->stream() != NULL); |
| - EXPECT_EQ(0, stream->stream()->send_window_size()); |
| - // All the body data should have been read. |
| - // TODO(satorux): This is because of the weirdness in reading the request |
| - // body in OnSendBodyComplete(). See crbug.com/113107. |
| - EXPECT_TRUE(upload_data_stream.IsEOF()); |
| - // But the body is not yet fully sent (kUploadData is not yet sent) |
| - // since we're send-stalled. |
| - EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| - |
| - data.ForceNextRead(); // Read in WINDOW_UPDATE frame. |
| rv = callback.WaitForResult(); |
| + |
| + const int kSize = 3000; |
| + scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); |
| + rv = trans->Read( |
| + buf.get(), |
| + kSize, |
| + base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback, |
| + helper.session())); |
| + // This forces an err_IO_pending, which sets the callback. |
| + data.CompleteRead(); |
| + // This finishes the read. |
| + data.CompleteRead(); |
| helper.VerifyDataConsumed(); |
| } |
| -// Test we correctly handle the case where the SETTINGS frame results in |
| -// unstalling the send window. |
| -TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - // Number of frames we need to send to zero out the window size: data |
| - // frames plus SYN_STREAM plus the last data frame; also we need another |
| - // data frame that we will send once the SETTING is received, therefore +3. |
| - size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - |
| - // Calculate last frame's size; 0 size data frame is legal. |
| - size_t last_frame_size = |
| - kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - |
| - // Construct content for a data frame of maximum size. |
| - std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| - |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| - kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| - LOWEST, NULL, 0)); |
| - |
| - // Full frames. |
| - scoped_ptr<SpdyFrame> body1( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), content.size(), false)); |
| - |
| - // Last frame to zero out the window size. |
| - scoped_ptr<SpdyFrame> body2( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), last_frame_size, false)); |
| - |
| - // Data frame to be sent once SETTINGS frame is received. |
| - scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - |
| - // Fill in mock reads/writes. |
| - std::vector<MockRead> reads; |
| - std::vector<MockWrite> writes; |
| - size_t i = 0; |
| - writes.push_back(CreateMockWrite(*req, i++)); |
| - while (i < num_writes - 2) |
| - writes.push_back(CreateMockWrite(*body1, i++)); |
| - writes.push_back(CreateMockWrite(*body2, i++)); |
| - |
| - // Construct read frame for SETTINGS that gives enough space to upload the |
| - // rest of the data. |
| - SettingsMap settings; |
| - settings[SETTINGS_INITIAL_WINDOW_SIZE] = |
| - SettingsFlagsAndValue( |
| - SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize * 2); |
| - scoped_ptr<SpdyFrame> settings_frame_large( |
| - spdy_util_.ConstructSpdySettings(settings)); |
| - |
| - reads.push_back(CreateMockRead(*settings_frame_large, i++)); |
| - |
| - writes.push_back(CreateMockWrite(*body3, i++)); |
| - |
| - scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| - reads.push_back(CreateMockRead(*reply, i++)); |
| - reads.push_back(CreateMockRead(*body2, i++)); |
| - reads.push_back(CreateMockRead(*body3, i++)); |
| - reads.push_back(MockRead(ASYNC, 0, i++)); // EOF |
| +// Verify that the client can correctly deal with the user callback deleting the |
| +// transaction. Failures will usually be valgrind errors. See |
| +// http://crbug.com/46925 |
| +TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) { |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + MockWrite writes[] = { CreateMockWrite(*req) }; |
| - // Force all writes to happen before any read, last write will not |
| - // actually queue a frame, due to window size being 0. |
| - DeterministicSocketData data(vector_as_array(&reads), reads.size(), |
| - vector_as_array(&writes), writes.size()); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*resp.get(), 2), |
| + MockRead(ASYNC, ERR_IO_PENDING, 3), // Force a pause |
| + CreateMockRead(*body.get(), 4), |
| + MockRead(ASYNC, 0, 0, 5), // EOF |
| + }; |
| - ScopedVector<UploadElementReader> element_readers; |
| - std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| - upload_data_string.append(kUploadData, kUploadDataSize); |
| - element_readers.push_back(new UploadBytesElementReader( |
| - upload_data_string.c_str(), upload_data_string.size())); |
| - UploadDataStream upload_data_stream(&element_readers, 0); |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| - HttpRequestInfo request; |
| - request.method = "POST"; |
| - request.url = GURL("http://www.google.com/"); |
| - request.upload_data_stream = &upload_data_stream; |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.SetDeterministic(); |
| helper.RunPreTestSetup(); |
| - helper.AddDeterministicData(&data); |
| - |
| + helper.AddData(&data); |
| HttpNetworkTransaction* trans = helper.trans(); |
| + // Start the transaction with basic parameters. |
| TestCompletionCallback callback; |
| int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback.WaitForResult(); |
| - data.RunFor(num_writes - 1); // Write as much as we can. |
| - |
| - SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| - ASSERT_TRUE(stream != NULL); |
| - ASSERT_TRUE(stream->stream() != NULL); |
| - EXPECT_EQ(0, stream->stream()->send_window_size()); |
| - |
| - // All the body data should have been read. |
| - // TODO(satorux): This is because of the weirdness in reading the request |
| - // body in OnSendBodyComplete(). See crbug.com/113107. |
| - EXPECT_TRUE(upload_data_stream.IsEOF()); |
| - // But the body is not yet fully sent (kUploadData is not yet sent) |
| - // since we're send-stalled. |
| - EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| + // Setup a user callback which will delete the session, and clear out the |
| + // memory holding the stream object. Note that the callback deletes trans. |
| + const int kSize = 3000; |
| + scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); |
| + rv = trans->Read( |
| + buf.get(), |
| + kSize, |
| + base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback, |
| + base::Unretained(&helper))); |
| + ASSERT_EQ(ERR_IO_PENDING, rv); |
| + data.CompleteRead(); |
| - data.RunFor(6); // Read in SETTINGS frame to unstall. |
| - rv = callback.WaitForResult(); |
| + // Finish running rest of tasks. |
| + base::MessageLoop::current()->RunUntilIdle(); |
| helper.VerifyDataConsumed(); |
| - // If stream is NULL, that means it was unstalled and closed. |
| - EXPECT_TRUE(stream->stream() == NULL); |
| } |
| -// Test we correctly handle the case where the SETTINGS frame results in a |
| -// negative send window size. |
| -TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) { |
| - if (GetParam().protocol != kProtoSPDY3) |
| - return; |
| - |
| - // Number of frames we need to send to zero out the window size: data |
| - // frames plus SYN_STREAM plus the last data frame; also we need another |
| - // data frame that we will send once the SETTING is received, therefore +3. |
| - size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - |
| - // Calculate last frame's size; 0 size data frame is legal. |
| - size_t last_frame_size = |
| - kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - |
| - // Construct content for a data frame of maximum size. |
| - std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| +// Send a spdy request to www.google.com that gets redirected to www.foo.com. |
| +TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) { |
| + const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM); |
| + scoped_ptr<SpdyHeaderBlock> headers( |
| + spdy_util_.ConstructGetHeaderBlock("http://www.google.com/")); |
| + (*headers)["user-agent"] = ""; |
| + (*headers)["accept-encoding"] = "gzip,deflate"; |
| + scoped_ptr<SpdyHeaderBlock> headers2( |
| + spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php")); |
| + (*headers2)["user-agent"] = ""; |
| + (*headers2)["accept-encoding"] = "gzip,deflate"; |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| - kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| - LOWEST, NULL, 0)); |
| + // Setup writes/reads to www.google.com |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyFrame( |
| + kSynStartHeader, headers.Pass())); |
| + scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyFrame( |
| + kSynStartHeader, headers2.Pass())); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReplyRedirect(1)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req, 1), |
| + }; |
| + MockRead reads[] = { |
| + CreateMockRead(*resp, 2), |
| + MockRead(ASYNC, 0, 0, 3) // EOF |
| + }; |
| - // Full frames. |
| - scoped_ptr<SpdyFrame> body1( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), content.size(), false)); |
| + // Setup writes/reads to www.foo.com |
| + scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes2[] = { |
| + CreateMockWrite(*req2, 1), |
| + }; |
| + MockRead reads2[] = { |
| + CreateMockRead(*resp2, 2), |
| + CreateMockRead(*body2, 3), |
| + MockRead(ASYNC, 0, 0, 4) // EOF |
| + }; |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + OrderedSocketData data2(reads2, arraysize(reads2), |
| + writes2, arraysize(writes2)); |
| - // Last frame to zero out the window size. |
| - scoped_ptr<SpdyFrame> body2( |
| - spdy_util_.ConstructSpdyBodyFrame( |
| - 1, content.c_str(), last_frame_size, false)); |
| + // TODO(erikchen): Make test support SPDYSSL, SPDYNPN |
| + HttpStreamFactory::set_force_spdy_over_ssl(false); |
| + HttpStreamFactory::set_force_spdy_always(true); |
| + TestDelegate d; |
| + { |
| + SpdyURLRequestContext spdy_url_request_context(GetParam().protocol); |
| + net::URLRequest r( |
| + GURL("http://www.google.com/"), &d, &spdy_url_request_context); |
| + spdy_url_request_context.socket_factory(). |
| + AddSocketDataProvider(&data); |
| + spdy_url_request_context.socket_factory(). |
| + AddSocketDataProvider(&data2); |
| - // Data frame to be sent once SETTINGS frame is received. |
| - scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + d.set_quit_on_redirect(true); |
| + r.Start(); |
| + base::MessageLoop::current()->Run(); |
| - // Fill in mock reads/writes. |
| - std::vector<MockRead> reads; |
| - std::vector<MockWrite> writes; |
| - size_t i = 0; |
| - writes.push_back(CreateMockWrite(*req, i++)); |
| - while (i < num_writes - 2) |
| - writes.push_back(CreateMockWrite(*body1, i++)); |
| - writes.push_back(CreateMockWrite(*body2, i++)); |
| + EXPECT_EQ(1, d.received_redirect_count()); |
| - // Construct read frame for SETTINGS that makes the send_window_size |
| - // negative. |
| - SettingsMap new_settings; |
| - new_settings[SETTINGS_INITIAL_WINDOW_SIZE] = |
| - SettingsFlagsAndValue( |
| - SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize / 2); |
| - scoped_ptr<SpdyFrame> settings_frame_small( |
| - spdy_util_.ConstructSpdySettings(new_settings)); |
| - // Construct read frame for WINDOW_UPDATE that makes the send_window_size |
| - // postive. |
| - scoped_ptr<SpdyFrame> window_update_init_size( |
| - spdy_util_.ConstructSpdyWindowUpdate(1, kSpdyStreamInitialWindowSize)); |
| + r.FollowDeferredRedirect(); |
| + base::MessageLoop::current()->Run(); |
| + EXPECT_EQ(1, d.response_started_count()); |
| + EXPECT_FALSE(d.received_data_before_response()); |
| + EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status()); |
| + std::string contents("hello!"); |
| + EXPECT_EQ(contents, d.data_received()); |
| + } |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| + EXPECT_TRUE(data2.at_read_eof()); |
| + EXPECT_TRUE(data2.at_write_eof()); |
| +} |
| - reads.push_back(CreateMockRead(*settings_frame_small, i++)); |
| - reads.push_back(CreateMockRead(*window_update_init_size, i++)); |
| +// Send a spdy request to www.google.com. Get a pushed stream that redirects to |
| +// www.foo.com. |
| +TEST_P(SpdyNetworkTransactionTest, RedirectServerPush) { |
| + const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM); |
| - writes.push_back(CreateMockWrite(*body3, i++)); |
| + scoped_ptr<SpdyHeaderBlock> headers( |
| + spdy_util_.ConstructGetHeaderBlock("http://www.google.com/")); |
| + (*headers)["user-agent"] = ""; |
| + (*headers)["accept-encoding"] = "gzip,deflate"; |
| - scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| - reads.push_back(CreateMockRead(*reply, i++)); |
| - reads.push_back(CreateMockRead(*body2, i++)); |
| - reads.push_back(CreateMockRead(*body3, i++)); |
| - reads.push_back(MockRead(ASYNC, 0, i++)); // EOF |
| - |
| - // Force all writes to happen before any read, last write will not |
| - // actually queue a frame, due to window size being 0. |
| - DeterministicSocketData data(vector_as_array(&reads), reads.size(), |
| - vector_as_array(&writes), writes.size()); |
| - |
| - ScopedVector<UploadElementReader> element_readers; |
| - std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| - upload_data_string.append(kUploadData, kUploadDataSize); |
| - element_readers.push_back(new UploadBytesElementReader( |
| - upload_data_string.c_str(), upload_data_string.size())); |
| - UploadDataStream upload_data_stream(&element_readers, 0); |
| + // Setup writes/reads to www.google.com |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyFrame(kSynStartHeader, headers.Pass())); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> rep( |
| + spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat", |
| + "301 Moved Permanently", |
| + "http://www.foo.com/index.php")); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req, 1), |
| + CreateMockWrite(*rst, 6), |
| + }; |
| + MockRead reads[] = { |
| + CreateMockRead(*resp, 2), |
| + CreateMockRead(*rep, 3), |
| + CreateMockRead(*body, 4), |
| + MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| + MockRead(ASYNC, 0, 0, 7) // EOF |
| + }; |
| - HttpRequestInfo request; |
| - request.method = "POST"; |
| - request.url = GURL("http://www.google.com/"); |
| - request.upload_data_stream = &upload_data_stream; |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.SetDeterministic(); |
| - helper.RunPreTestSetup(); |
| - helper.AddDeterministicData(&data); |
| + // Setup writes/reads to www.foo.com |
| + scoped_ptr<SpdyHeaderBlock> headers2( |
| + spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php")); |
| + (*headers2)["user-agent"] = ""; |
| + (*headers2)["accept-encoding"] = "gzip,deflate"; |
| + scoped_ptr<SpdyFrame> req2( |
| + spdy_util_.ConstructSpdyFrame(kSynStartHeader, headers2.Pass())); |
| + scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes2[] = { |
| + CreateMockWrite(*req2, 1), |
| + }; |
| + MockRead reads2[] = { |
| + CreateMockRead(*resp2, 2), |
| + CreateMockRead(*body2, 3), |
| + MockRead(ASYNC, 0, 0, 5) // EOF |
| + }; |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + OrderedSocketData data2(reads2, arraysize(reads2), |
| + writes2, arraysize(writes2)); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| + // TODO(erikchen): Make test support SPDYSSL, SPDYNPN |
| + HttpStreamFactory::set_force_spdy_over_ssl(false); |
| + HttpStreamFactory::set_force_spdy_always(true); |
| + TestDelegate d; |
| + TestDelegate d2; |
| + SpdyURLRequestContext spdy_url_request_context(GetParam().protocol); |
| + { |
| + net::URLRequest r( |
| + GURL("http://www.google.com/"), &d, &spdy_url_request_context); |
| + spdy_url_request_context.socket_factory(). |
| + AddSocketDataProvider(&data); |
| - TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| + r.Start(); |
| + base::MessageLoop::current()->Run(); |
| - data.RunFor(num_writes - 1); // Write as much as we can. |
| + EXPECT_EQ(0, d.received_redirect_count()); |
| + std::string contents("hello!"); |
| + EXPECT_EQ(contents, d.data_received()); |
| - SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| - ASSERT_TRUE(stream != NULL); |
| - ASSERT_TRUE(stream->stream() != NULL); |
| - EXPECT_EQ(0, stream->stream()->send_window_size()); |
| + net::URLRequest r2( |
| + GURL("http://www.google.com/foo.dat"), &d2, &spdy_url_request_context); |
| + spdy_url_request_context.socket_factory(). |
| + AddSocketDataProvider(&data2); |
| - // All the body data should have been read. |
| - // TODO(satorux): This is because of the weirdness in reading the request |
| - // body in OnSendBodyComplete(). See crbug.com/113107. |
| - EXPECT_TRUE(upload_data_stream.IsEOF()); |
| - // But the body is not yet fully sent (kUploadData is not yet sent) |
| - // since we're send-stalled. |
| - EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| + d2.set_quit_on_redirect(true); |
| + r2.Start(); |
| + base::MessageLoop::current()->Run(); |
| + EXPECT_EQ(1, d2.received_redirect_count()); |
| - data.RunFor(7); // Read in WINDOW_UPDATE or SETTINGS frame. |
| - rv = callback.WaitForResult(); |
| - helper.VerifyDataConsumed(); |
| + r2.FollowDeferredRedirect(); |
| + base::MessageLoop::current()->Run(); |
| + EXPECT_EQ(1, d2.response_started_count()); |
| + EXPECT_FALSE(d2.received_data_before_response()); |
| + EXPECT_EQ(net::URLRequestStatus::SUCCESS, r2.status().status()); |
| + std::string contents2("hello!"); |
| + EXPECT_EQ(contents2, d2.data_received()); |
| + } |
| + data.CompleteRead(); |
| + data2.CompleteRead(); |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| + EXPECT_TRUE(data2.at_read_eof()); |
| + EXPECT_TRUE(data2.at_write_eof()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - // Construct the request. |
| - scoped_ptr<SpdyFrame> req( |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*req), |
| - CreateMockWrite(*rst), |
| + CreateMockWrite(*stream1_syn, 1), |
| }; |
| - const char* const headers[] = { |
| - "transfer-encoding", "chunked" |
| - }; |
| - scoped_ptr<SpdyFrame> resp( |
| - spdy_util_.ConstructSpdyGetSynReply(headers, 1, 1)); |
| - scoped_ptr<SpdyFrame> body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| MockRead reads[] = { |
| - CreateMockRead(*resp), |
| - CreateMockRead(*body), |
| - MockRead(ASYNC, 0, 0) // EOF |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream1_body, 4, SYNCHRONOUS), |
| + CreateMockRead(*stream2_body, 5), |
| + MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| }; |
| - DelayedSocketData data(1, reads, arraysize(reads), |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + OrderedSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunToCompletion(&data); |
| - TransactionHelperResult out = helper.output(); |
| - EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| + RunServerPushTest(&data, |
| + &response, |
| + &response2, |
| + expected_push_result); |
| - helper.session()->spdy_session_pool()->CloseAllSessions(); |
| - helper.VerifyDataConsumed(); |
| -} |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| -TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| +} |
| - // Construct the request. |
| - scoped_ptr<SpdyFrame> req( |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*req), |
| - CreateMockWrite(*rst), |
| + CreateMockWrite(*stream1_syn, 1), |
| }; |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - const char* const headers[] = { |
| - "transfer-encoding", "chunked" |
| - }; |
| - scoped_ptr<SpdyFrame> push( |
| - spdy_util_.ConstructSpdyPush(headers, arraysize(headers) / 2, |
| - 2, 1, "http://www.google.com/1")); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| MockRead reads[] = { |
| - CreateMockRead(*resp), |
| - CreateMockRead(*push), |
| - CreateMockRead(*body), |
| - MockRead(ASYNC, 0, 0) // EOF |
| + CreateMockRead(*stream2_syn, 2), |
| + CreateMockRead(*stream1_reply, 3), |
| + CreateMockRead(*stream1_body, 4, SYNCHRONOUS), |
| + CreateMockRead(*stream2_body, 5), |
| + MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| }; |
| - DelayedSocketData data(1, reads, arraysize(reads), |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + OrderedSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunToCompletion(&data); |
| - TransactionHelperResult out = helper.output(); |
| - EXPECT_EQ(OK, out.rv); |
| - EXPECT_EQ("HTTP/1.1 200 OK", out.status_line); |
| - EXPECT_EQ("hello!", out.response_data); |
| + RunServerPushTest(&data, |
| + &response, |
| + &response2, |
| + expected_push_result); |
| - helper.session()->spdy_session_pool()->CloseAllSessions(); |
| - helper.VerifyDataConsumed(); |
| -} |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| -TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| +} |
| - // Construct the request. |
| - scoped_ptr<SpdyFrame> req( |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req), |
| - }; |
| + MockWrite writes[] = { CreateMockWrite(*stream1_syn, 1), }; |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockRead reads[] = { |
| - CreateMockRead(*resp), |
| - // This following read isn't used by the test, except during the |
| - // RunUntilIdle() call at the end since the SpdySession survives the |
| - // HttpNetworkTransaction and still tries to continue Read()'ing. Any |
| - // MockRead will do here. |
| - MockRead(ASYNC, 0, 0) // EOF |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream2_body, 4), |
| + CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| + MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| }; |
| - StaticSocketDataProvider data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + RunServerPushTest(&data, |
| + &response, |
| + &response2, |
| + expected_push_result); |
| - TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - helper.ResetTrans(); // Cancel the transaction. |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - // Flush the MessageLoop while the SpdySessionDependencies (in particular, the |
| - // MockClientSocketFactory) are still alive. |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - helper.VerifyDataNotConsumed(); |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| } |
| -// Verify that the client sends a Rst Frame upon cancelling the stream. |
| -TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - scoped_ptr<SpdyFrame> req( |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*req, 0, SYNCHRONOUS), |
| - CreateMockWrite(*rst, 2, SYNCHRONOUS), |
| + CreateMockWrite(*stream1_syn, 1), |
| }; |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + scoped_ptr<SpdyFrame> stream2_rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| MockRead reads[] = { |
| - CreateMockRead(*resp, 1, ASYNC), |
| - MockRead(ASYNC, 0, 0, 3) // EOF |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream2_rst, 4), |
| + CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| + MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| }; |
| - DeterministicSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), |
| - GetParam(), NULL); |
| - helper.SetDeterministic(); |
| + BoundNetLog(), GetParam(), NULL); |
| + |
| helper.RunPreTestSetup(); |
| - helper.AddDeterministicData(&data); |
| + helper.AddData(&data); |
| + |
| HttpNetworkTransaction* trans = helper.trans(); |
| + // Start the transaction with basic parameters. |
| TestCompletionCallback callback; |
| - |
| int rv = trans->Start( |
| &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv); |
| - data.SetStop(2); |
| - data.Run(); |
| - helper.ResetTrans(); |
| - data.SetStop(20); |
| - data.Run(); |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()) << "Read count: " |
| + << data.read_count() |
| + << " Read index: " |
| + << data.read_index(); |
| + EXPECT_TRUE(data.at_write_eof()) << "Write count: " |
| + << data.write_count() |
| + << " Write index: " |
| + << data.write_index(); |
| - helper.VerifyDataConsumed(); |
| + // Verify the SYN_REPLY. |
| + HttpResponseInfo response = *trans->GetResponseInfo(); |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| } |
| -// Verify that the client can correctly deal with the user callback attempting |
| -// to start another transaction on a session that is closing down. See |
| -// http://crbug.com/47455 |
| -TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - scoped_ptr<SpdyFrame> req( |
| +// Verify that we don't leak streams and that we properly send a reset |
| +// if the server pushes the same stream twice. |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushDuplicate) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - MockWrite writes[] = { CreateMockWrite(*req) }; |
| - MockWrite writes2[] = { CreateMockWrite(*req) }; |
| - |
| - // The indicated length of this frame is longer than its actual length. When |
| - // the session receives an empty frame after this one, it shuts down the |
| - // session, and calls the read callback with the incomplete data. |
| - const uint8 kGetBodyFrame2[] = { |
| - 0x00, 0x00, 0x00, 0x01, |
| - 0x01, 0x00, 0x00, 0x07, |
| - 'h', 'e', 'l', 'l', 'o', '!', |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> stream3_rst( |
| + spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 1), |
| + CreateMockWrite(*stream3_rst, 5), |
| }; |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + scoped_ptr<SpdyFrame> |
| + stream3_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 4, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| MockRead reads[] = { |
| - CreateMockRead(*resp, 2), |
| - MockRead(ASYNC, ERR_IO_PENDING, 3), // Force a pause |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2), |
| - arraysize(kGetBodyFrame2), 4), |
| - MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| - MockRead(ASYNC, 0, 0, 6), // EOF |
| - }; |
| - MockRead reads2[] = { |
| - CreateMockRead(*resp, 2), |
| - MockRead(ASYNC, 0, 0, 3), // EOF |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream3_syn, 4), |
| + CreateMockRead(*stream1_body, 6, SYNCHRONOUS), |
| + CreateMockRead(*stream2_body, 7), |
| + MockRead(ASYNC, ERR_IO_PENDING, 8), // Force a pause |
| }; |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| OrderedSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - DelayedSocketData data2(1, reads2, arraysize(reads2), |
| - writes2, arraysize(writes2)); |
| - |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| - helper.AddData(&data2); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| + RunServerPushTest(&data, |
| + &response, |
| + &response2, |
| + expected_push_result); |
| - // Start the transaction with basic parameters. |
| - TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - const int kSize = 3000; |
| - scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); |
| - rv = trans->Read( |
| - buf.get(), |
| - kSize, |
| - base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback, |
| - helper.session())); |
| - // This forces an err_IO_pending, which sets the callback. |
| - data.CompleteRead(); |
| - // This finishes the read. |
| - data.CompleteRead(); |
| - helper.VerifyDataConsumed(); |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| } |
| -// Verify that the client can correctly deal with the user callback deleting the |
| -// transaction. Failures will usually be valgrind errors. See |
| -// http://crbug.com/46925 |
| -TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - scoped_ptr<SpdyFrame> req( |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - MockWrite writes[] = { CreateMockWrite(*req) }; |
| - |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*resp.get(), 2), |
| - MockRead(ASYNC, ERR_IO_PENDING, 3), // Force a pause |
| - CreateMockRead(*body.get(), 4), |
| - MockRead(ASYNC, 0, 0, 5), // EOF |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 1), |
| }; |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| - |
| - // Start the transaction with basic parameters. |
| - TestCompletionCallback callback; |
| - int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| - |
| - // Setup a user callback which will delete the session, and clear out the |
| - // memory holding the stream object. Note that the callback deletes trans. |
| - const int kSize = 3000; |
| - scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize)); |
| - rv = trans->Read( |
| - buf.get(), |
| - kSize, |
| - base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback, |
| - base::Unretained(&helper))); |
| - ASSERT_EQ(ERR_IO_PENDING, rv); |
| - data.CompleteRead(); |
| - |
| - // Finish running rest of tasks. |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - helper.VerifyDataConsumed(); |
| -} |
| - |
| -// Send a spdy request to www.google.com that gets redirected to www.foo.com. |
| -TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM); |
| - scoped_ptr<SpdyHeaderBlock> headers( |
| - spdy_util_.ConstructGetHeaderBlock("http://www.google.com/")); |
| - (*headers)["user-agent"] = ""; |
| - (*headers)["accept-encoding"] = "gzip,deflate"; |
| - scoped_ptr<SpdyHeaderBlock> headers2( |
| - spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php")); |
| - (*headers2)["user-agent"] = ""; |
| - (*headers2)["accept-encoding"] = "gzip,deflate"; |
| - |
| - // Setup writes/reads to www.google.com |
| - scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyFrame( |
| - kSynStartHeader, headers.Pass())); |
| - scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyFrame( |
| - kSynStartHeader, headers2.Pass())); |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReplyRedirect(1)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req, 1), |
| - }; |
| - MockRead reads[] = { |
| - CreateMockRead(*resp, 2), |
| - MockRead(ASYNC, 0, 0, 3) // EOF |
| - }; |
| - |
| - // Setup writes/reads to www.foo.com |
| - scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes2[] = { |
| - CreateMockWrite(*req2, 1), |
| - }; |
| - MockRead reads2[] = { |
| - CreateMockRead(*resp2, 2), |
| - CreateMockRead(*body2, 3), |
| - MockRead(ASYNC, 0, 0, 4) // EOF |
| - }; |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - OrderedSocketData data2(reads2, arraysize(reads2), |
| - writes2, arraysize(writes2)); |
| - |
| - // TODO(erikchen): Make test support SPDYSSL, SPDYNPN |
| - HttpStreamFactory::set_force_spdy_over_ssl(false); |
| - HttpStreamFactory::set_force_spdy_always(true); |
| - TestDelegate d; |
| - { |
| - SpdyURLRequestContext spdy_url_request_context(GetParam().protocol); |
| - net::URLRequest r( |
| - GURL("http://www.google.com/"), &d, &spdy_url_request_context); |
| - spdy_url_request_context.socket_factory(). |
| - AddSocketDataProvider(&data); |
| - spdy_url_request_context.socket_factory(). |
| - AddSocketDataProvider(&data2); |
| - |
| - d.set_quit_on_redirect(true); |
| - r.Start(); |
| - base::MessageLoop::current()->Run(); |
| - |
| - EXPECT_EQ(1, d.received_redirect_count()); |
| - |
| - r.FollowDeferredRedirect(); |
| - base::MessageLoop::current()->Run(); |
| - EXPECT_EQ(1, d.response_started_count()); |
| - EXPECT_FALSE(d.received_data_before_response()); |
| - EXPECT_EQ(net::URLRequestStatus::SUCCESS, r.status().status()); |
| - std::string contents("hello!"); |
| - EXPECT_EQ(contents, d.data_received()); |
| - } |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| - EXPECT_TRUE(data2.at_read_eof()); |
| - EXPECT_TRUE(data2.at_write_eof()); |
| -} |
| - |
| -// Send a spdy request to www.google.com. Get a pushed stream that redirects to |
| -// www.foo.com. |
| -TEST_P(SpdyNetworkTransactionTest, RedirectServerPush) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - const SpdyHeaderInfo kSynStartHeader = spdy_util_.MakeSpdyHeader(SYN_STREAM); |
| - |
| - scoped_ptr<SpdyHeaderBlock> headers( |
| - spdy_util_.ConstructGetHeaderBlock("http://www.google.com/")); |
| - (*headers)["user-agent"] = ""; |
| - (*headers)["accept-encoding"] = "gzip,deflate"; |
| - |
| - // Setup writes/reads to www.google.com |
| - scoped_ptr<SpdyFrame> req( |
| - spdy_util_.ConstructSpdyFrame(kSynStartHeader, headers.Pass())); |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> rep( |
| - spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat", |
| - "301 Moved Permanently", |
| - "http://www.foo.com/index.php")); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req, 1), |
| - CreateMockWrite(*rst, 6), |
| - }; |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + "http://www.google.com/foo.dat")); |
| + static const char kPushedData[] = "pushed my darling hello my baby"; |
| + scoped_ptr<SpdyFrame> stream2_body_base( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + const size_t kChunkSize = strlen(kPushedData) / 4; |
| + scoped_ptr<SpdyFrame> stream2_body1( |
| + new SpdyFrame(stream2_body_base->data(), kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body2( |
| + new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body3( |
| + new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize, |
| + kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body4( |
| + new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize, |
| + stream2_body_base->size() - 3 * kChunkSize, false)); |
| MockRead reads[] = { |
| - CreateMockRead(*resp, 2), |
| - CreateMockRead(*rep, 3), |
| - CreateMockRead(*body, 4), |
| - MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| - MockRead(ASYNC, 0, 0, 7) // EOF |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream2_body1, 4), |
| + CreateMockRead(*stream2_body2, 5), |
| + CreateMockRead(*stream2_body3, 6), |
| + CreateMockRead(*stream2_body4, 7), |
| + CreateMockRead(*stream1_body, 8, SYNCHRONOUS), |
| + MockRead(ASYNC, ERR_IO_PENDING, 9), // Force a pause |
| }; |
| - // Setup writes/reads to www.foo.com |
| - scoped_ptr<SpdyHeaderBlock> headers2( |
| - spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php")); |
| - (*headers2)["user-agent"] = ""; |
| - (*headers2)["accept-encoding"] = "gzip,deflate"; |
| - scoped_ptr<SpdyFrame> req2( |
| - spdy_util_.ConstructSpdyFrame(kSynStartHeader, headers2.Pass())); |
| - scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes2[] = { |
| - CreateMockWrite(*req2, 1), |
| - }; |
| - MockRead reads2[] = { |
| - CreateMockRead(*resp2, 2), |
| - CreateMockRead(*body2, 3), |
| - MockRead(ASYNC, 0, 0, 5) // EOF |
| - }; |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed my darling hello my baby"); |
| OrderedSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - OrderedSocketData data2(reads2, arraysize(reads2), |
| - writes2, arraysize(writes2)); |
| - |
| - // TODO(erikchen): Make test support SPDYSSL, SPDYNPN |
| - HttpStreamFactory::set_force_spdy_over_ssl(false); |
| - HttpStreamFactory::set_force_spdy_always(true); |
| - TestDelegate d; |
| - TestDelegate d2; |
| - SpdyURLRequestContext spdy_url_request_context(GetParam().protocol); |
| - { |
| - net::URLRequest r( |
| - GURL("http://www.google.com/"), &d, &spdy_url_request_context); |
| - spdy_url_request_context.socket_factory(). |
| - AddSocketDataProvider(&data); |
| - |
| - r.Start(); |
| - base::MessageLoop::current()->Run(); |
| - |
| - EXPECT_EQ(0, d.received_redirect_count()); |
| - std::string contents("hello!"); |
| - EXPECT_EQ(contents, d.data_received()); |
| - |
| - net::URLRequest r2( |
| - GURL("http://www.google.com/foo.dat"), &d2, &spdy_url_request_context); |
| - spdy_url_request_context.socket_factory(). |
| - AddSocketDataProvider(&data2); |
| + RunServerPushTest(&data, &response, &response2, kPushedData); |
| - d2.set_quit_on_redirect(true); |
| - r2.Start(); |
| - base::MessageLoop::current()->Run(); |
| - EXPECT_EQ(1, d2.received_redirect_count()); |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - r2.FollowDeferredRedirect(); |
| - base::MessageLoop::current()->Run(); |
| - EXPECT_EQ(1, d2.response_started_count()); |
| - EXPECT_FALSE(d2.received_data_before_response()); |
| - EXPECT_EQ(net::URLRequestStatus::SUCCESS, r2.status().status()); |
| - std::string contents2("hello!"); |
| - EXPECT_EQ(contents2, d2.data_received()); |
| - } |
| - data.CompleteRead(); |
| - data2.CompleteRead(); |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| - EXPECT_TRUE(data2.at_read_eof()); |
| - EXPECT_TRUE(data2.at_write_eof()); |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) { |
| scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> stream1_body( |
| @@ -3362,24 +2946,38 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) { |
| 2, |
| 1, |
| "http://www.google.com/foo.dat")); |
| + static const char kPushedData[] = "pushed my darling hello my baby"; |
| + scoped_ptr<SpdyFrame> stream2_body_base( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + const size_t kChunkSize = strlen(kPushedData) / 4; |
| + scoped_ptr<SpdyFrame> stream2_body1( |
| + new SpdyFrame(stream2_body_base->data(), kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body2( |
| + new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body3( |
| + new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize, |
| + kChunkSize, false)); |
| + scoped_ptr<SpdyFrame> stream2_body4( |
| + new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize, |
| + stream2_body_base->size() - 3 * kChunkSize, false)); |
| MockRead reads[] = { |
| CreateMockRead(*stream1_reply, 2), |
| CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream1_body, 4, SYNCHRONOUS), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 5), |
| + CreateMockRead(*stream2_body1, 4), |
| + CreateMockRead(*stream2_body2, 5), |
| MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| + CreateMockRead(*stream2_body3, 7), |
| + CreateMockRead(*stream2_body4, 8), |
| + CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS), |
| + MockRead(ASYNC, ERR_IO_PENDING, 10) // Force a pause. |
| }; |
| HttpResponseInfo response; |
| HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| OrderedSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| + RunServerPushTest(&data, &response, &response2, kPushedData); |
| // Verify the SYN_REPLY. |
| EXPECT_TRUE(response.headers.get() != NULL); |
| @@ -3390,21 +2988,16 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) { |
| EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) { |
| scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> stream1_body( |
| spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> stream2_rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); |
| MockWrite writes[] = { |
| CreateMockWrite(*stream1_syn, 1), |
| + CreateMockWrite(*stream2_rst, 4), |
| }; |
| scoped_ptr<SpdyFrame> |
| @@ -3413,115 +3006,13 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) { |
| stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| 0, |
| 2, |
| - 1, |
| + 0, |
| "http://www.google.com/foo.dat")); |
| MockRead reads[] = { |
| - CreateMockRead(*stream2_syn, 2), |
| - CreateMockRead(*stream1_reply, 3), |
| - CreateMockRead(*stream1_body, 4, SYNCHRONOUS), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 5), |
| - MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| - }; |
| - |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - MockWrite writes[] = { CreateMockWrite(*stream1_syn, 1), }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - scoped_ptr<SpdyFrame> |
| - stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 5), |
| - CreateMockRead(*stream1_body, 4, SYNCHRONOUS), |
| - MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| - }; |
| - |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - scoped_ptr<SpdyFrame> stream2_rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream2_rst, 4), |
| - CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| - MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream1_body, 4), |
| + MockRead(ASYNC, ERR_IO_PENDING, 5) // Force a pause |
| }; |
| OrderedSocketData data(reads, arraysize(reads), |
| @@ -3558,209 +3049,13 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) { |
| EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushDuplicate) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - // Verify that we don't leak streams and that we properly send a reset |
| - // if the server pushes the same stream twice. |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - scoped_ptr<SpdyFrame> stream3_rst( |
| - spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - CreateMockWrite(*stream3_rst, 5), |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - scoped_ptr<SpdyFrame> |
| - stream3_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 4, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream3_syn, 4), |
| - CreateMockRead(*stream1_body, 6, SYNCHRONOUS), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 7), |
| - MockRead(ASYNC, ERR_IO_PENDING, 8), // Force a pause |
| - }; |
| - |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame1[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x1F, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - static const char kPushBodyFrame2[] = " my darling"; |
| - static const char kPushBodyFrame3[] = " hello"; |
| - static const char kPushBodyFrame4[] = " my baby"; |
| - |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1), |
| - arraysize(kPushBodyFrame1), 4), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2), |
| - arraysize(kPushBodyFrame2) - 1, 5), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3), |
| - arraysize(kPushBodyFrame3) - 1, 6), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4), |
| - arraysize(kPushBodyFrame4) - 1, 7), |
| - CreateMockRead(*stream1_body, 8, SYNCHRONOUS), |
| - MockRead(ASYNC, ERR_IO_PENDING, 9), // Force a pause |
| - }; |
| - |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed my darling hello my baby"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame1[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x1F, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - static const char kPushBodyFrame2[] = " my darling"; |
| - static const char kPushBodyFrame3[] = " hello"; |
| - static const char kPushBodyFrame4[] = " my baby"; |
| - |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - "http://www.google.com/foo.dat")); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame1), |
| - arraysize(kPushBodyFrame1), 4), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame2), |
| - arraysize(kPushBodyFrame2) - 1, 5), |
| - MockRead(ASYNC, ERR_IO_PENDING, 6), // Force a pause |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame3), |
| - arraysize(kPushBodyFrame3) - 1, 7), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame4), |
| - arraysize(kPushBodyFrame4) - 1, 8), |
| - CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS), |
| - MockRead(ASYNC, ERR_IO_PENDING, 10) // Force a pause. |
| - }; |
| - |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed my darling hello my baby"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) { |
| scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> stream1_body( |
| spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| scoped_ptr<SpdyFrame> stream2_rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_INVALID_STREAM)); |
| MockWrite writes[] = { |
| CreateMockWrite(*stream1_syn, 1), |
| CreateMockWrite(*stream2_rst, 4), |
| @@ -3772,13 +3067,13 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) { |
| stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| 0, |
| 2, |
| - 0, |
| + 9, |
| "http://www.google.com/foo.dat")); |
| MockRead reads[] = { |
| CreateMockRead(*stream1_reply, 2), |
| CreateMockRead(*stream2_syn, 3), |
| CreateMockRead(*stream1_body, 4), |
| - MockRead(ASYNC, ERR_IO_PENDING, 5) // Force a pause |
| + MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| }; |
| OrderedSocketData data(reads, arraysize(reads), |
| @@ -3815,80 +3110,13 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) { |
| EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) { |
| scoped_ptr<SpdyFrame> stream1_syn( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> stream1_body( |
| spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| scoped_ptr<SpdyFrame> stream2_rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_INVALID_STREAM)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - CreateMockWrite(*stream2_rst, 4), |
| - }; |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 9, |
| - "http://www.google.com/foo.dat")); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream1_body, 4), |
| - MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
| - }; |
| - |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| - |
| - HttpNetworkTransaction* trans = helper.trans(); |
| - |
| - // Start the transaction with basic parameters. |
| - TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv); |
| - |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()) << "Read count: " |
| - << data.read_count() |
| - << " Read index: " |
| - << data.read_index(); |
| - EXPECT_TRUE(data.at_write_eof()) << "Write count: " |
| - << data.write_count() |
| - << " Write index: " |
| - << data.write_index(); |
| - |
| - // Verify the SYN_REPLY. |
| - HttpResponseInfo response = *trans->GetResponseInfo(); |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| -} |
| - |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - scoped_ptr<SpdyFrame> stream2_rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR)); |
| MockWrite writes[] = { |
| CreateMockWrite(*stream1_syn, 1), |
| CreateMockWrite(*stream2_rst, 4), |
| @@ -3952,9 +3180,6 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) { |
| // Verify that various SynReply headers parse correctly through the |
| // HTTP layer. |
| TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| struct SynReplyHeadersTests { |
| int num_headers; |
| const char* extra_headers[5]; |
| @@ -4042,9 +3267,6 @@ TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) { |
| // Verify that various SynReply headers parse vary fields correctly |
| // through the HTTP layer, and the response matches the request. |
| TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| static const SpdyHeaderInfo syn_reply_info = { |
| SYN_REPLY, // Syn Reply |
| 1, // Stream ID |
| @@ -4214,9 +3436,6 @@ TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) { |
| // Verify that we don't crash on invalid SynReply responses. |
| TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| const SpdyHeaderInfo kSynStartHeader = { |
| SYN_REPLY, // Kind = SynReply |
| 1, // Stream ID |
| @@ -4289,16 +3508,17 @@ TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) { |
| // Verify that we don't crash on some corrupt frames. |
| TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // This is the length field that's too short. |
| scoped_ptr<SpdyFrame> syn_reply_wrong_length( |
| spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - size_t wrong_size = syn_reply_wrong_length->size() - 4; |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| + size_t right_size = |
| + (spdy_util_.spdy_version() < SPDY4) ? |
| + syn_reply_wrong_length->size() - framer.GetControlFrameHeaderSize() : |
| + syn_reply_wrong_length->size(); |
| + size_t wrong_size = right_size - 4; |
| test::SetFrameLength(syn_reply_wrong_length.get(), |
| - wrong_size - framer.GetControlFrameHeaderSize(), |
| + wrong_size, |
| spdy_util_.spdy_version()); |
| struct SynReplyTests { |
| @@ -4332,9 +3552,6 @@ TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) { |
| // Test that we shutdown correctly on write errors. |
| TEST_P(SpdyNetworkTransactionTest, WriteError) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| MockWrite writes[] = { |
| @@ -4356,9 +3573,6 @@ TEST_P(SpdyNetworkTransactionTest, WriteError) { |
| // Test that partial writes work. |
| TEST_P(SpdyNetworkTransactionTest, PartialWrite) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // Chop the SYN_STREAM frame into 5 chunks. |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| @@ -4387,9 +3601,6 @@ TEST_P(SpdyNetworkTransactionTest, PartialWrite) { |
| // In this test, we enable compression, but get a uncompressed SynReply from |
| // the server. Verify that teardown is all clean. |
| TEST_P(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> compressed( |
| spdy_util_.ConstructSpdyGet(NULL, 0, true, 1, LOWEST, true)); |
| scoped_ptr<SpdyFrame> rst( |
| @@ -4419,9 +3630,6 @@ TEST_P(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) { |
| // Test that the NetLog contains good data for a simple GET request. |
| TEST_P(SpdyNetworkTransactionTest, NetLog) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| static const char* const kExtraHeaders[] = { |
| "user-agent", "Chrome", |
| }; |
| @@ -4510,9 +3718,6 @@ TEST_P(SpdyNetworkTransactionTest, NetLog) { |
| // on the network, but issued a Read for only 5 of those bytes) that the data |
| // flow still works correctly. |
| TEST_P(SpdyNetworkTransactionTest, BufferFull) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| scoped_ptr<SpdyFrame> req( |
| @@ -4607,9 +3812,6 @@ TEST_P(SpdyNetworkTransactionTest, BufferFull) { |
| // at the same time, ensure that we don't notify a read completion for |
| // each data frame individually. |
| TEST_P(SpdyNetworkTransactionTest, Buffering) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| scoped_ptr<SpdyFrame> req( |
| @@ -4705,9 +3907,6 @@ TEST_P(SpdyNetworkTransactionTest, Buffering) { |
| // Verify the case where we buffer data but read it after it has been buffered. |
| TEST_P(SpdyNetworkTransactionTest, BufferedAll) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| scoped_ptr<SpdyFrame> req( |
| @@ -4802,9 +4001,6 @@ TEST_P(SpdyNetworkTransactionTest, BufferedAll) { |
| // Verify the case where we buffer data and close the connection. |
| TEST_P(SpdyNetworkTransactionTest, BufferedClosed) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| scoped_ptr<SpdyFrame> req( |
| @@ -4896,9 +4092,6 @@ TEST_P(SpdyNetworkTransactionTest, BufferedClosed) { |
| // Verify the case where we buffer data and cancel the transaction. |
| TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| BufferedSpdyFramer framer(spdy_util_.spdy_version(), false); |
| scoped_ptr<SpdyFrame> req( |
| @@ -4971,9 +4164,6 @@ TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) { |
| // Test that if the server requests persistence of settings, that we save |
| // the settings in the HttpServerProperties. |
| TEST_P(SpdyNetworkTransactionTest, SettingsSaved) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| static const SpdyHeaderInfo kSynReplyInfo = { |
| SYN_REPLY, // Syn Reply |
| 1, // Stream ID |
| @@ -5078,9 +4268,6 @@ TEST_P(SpdyNetworkTransactionTest, SettingsSaved) { |
| // Test that when there are settings saved that they are sent back to the |
| // server upon session establishment. |
| TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| static const SpdyHeaderInfo kSynReplyInfo = { |
| SYN_REPLY, // Syn Reply |
| 1, // Stream ID |
| @@ -5193,9 +4380,6 @@ TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) { |
| } |
| TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| MockWrite writes[] = { CreateMockWrite(*req) }; |
| @@ -5217,9 +4401,6 @@ TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) { |
| } |
| TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| MockWrite writes[] = { CreateMockWrite(*req) }; |
| @@ -5259,9 +4440,6 @@ TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) { |
| // Test to make sure we can correctly connect through a proxy. |
| TEST_P(SpdyNetworkTransactionTest, ProxyConnect) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| helper.session_deps().reset(CreateSpdySessionDependencies( |
| @@ -5365,9 +4543,6 @@ TEST_P(SpdyNetworkTransactionTest, ProxyConnect) { |
| // if there already exists a direct spdy connection to www.google.com. See |
| // http://crbug.com/49874 |
| TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| // When setting up the first transaction, we store the SpdySessionPool so that |
| // we can use the same pool in the second transaction. |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| @@ -5524,386 +4699,1136 @@ TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) { |
| helper_proxy.RunPreTestSetup(); |
| helper_proxy.AddData(data_proxy.get()); |
| - HttpNetworkTransaction* trans_proxy = helper_proxy.trans(); |
| - TestCompletionCallback callback_proxy; |
| - int rv = trans_proxy->Start( |
| - &request_proxy, callback_proxy.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback_proxy.WaitForResult(); |
| - EXPECT_EQ(0, rv); |
| + HttpNetworkTransaction* trans_proxy = helper_proxy.trans(); |
| + TestCompletionCallback callback_proxy; |
| + int rv = trans_proxy->Start( |
| + &request_proxy, callback_proxy.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback_proxy.WaitForResult(); |
| + EXPECT_EQ(0, rv); |
| + |
| + HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo(); |
| + EXPECT_TRUE(response_proxy.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine()); |
| + |
| + std::string response_data; |
| + ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data)); |
| + EXPECT_EQ("hello!", response_data); |
| + |
| + data.CompleteRead(); |
| + helper_proxy.VerifyDataConsumed(); |
| +} |
| + |
| +// When we get a TCP-level RST, we need to retry a HttpNetworkTransaction |
| +// on a new connection, if the connection was previously known to be good. |
| +// This can happen when a server reboots without saying goodbye, or when |
| +// we're behind a NAT that masked the RST. |
| +TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) { |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*resp), |
| + CreateMockRead(*body), |
| + MockRead(ASYNC, ERR_IO_PENDING), |
| + MockRead(ASYNC, ERR_CONNECTION_RESET), |
| + }; |
| + |
| + MockRead reads2[] = { |
| + CreateMockRead(*resp), |
| + CreateMockRead(*body), |
| + MockRead(ASYNC, 0, 0) // EOF |
| + }; |
| + |
| + // This test has a couple of variants. |
| + enum { |
| + // Induce the RST while waiting for our transaction to send. |
| + VARIANT_RST_DURING_SEND_COMPLETION, |
| + // Induce the RST while waiting for our transaction to read. |
| + // In this case, the send completed - everything copied into the SNDBUF. |
| + VARIANT_RST_DURING_READ_COMPLETION |
| + }; |
| + |
| + for (int variant = VARIANT_RST_DURING_SEND_COMPLETION; |
| + variant <= VARIANT_RST_DURING_READ_COMPLETION; |
| + ++variant) { |
| + DelayedSocketData data1(1, reads, arraysize(reads), NULL, 0); |
| + |
| + DelayedSocketData data2(1, reads2, arraysize(reads2), NULL, 0); |
| + |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.AddData(&data1); |
| + helper.AddData(&data2); |
| + helper.RunPreTestSetup(); |
| + |
| + for (int i = 0; i < 2; ++i) { |
| + scoped_ptr<HttpNetworkTransaction> trans( |
| + new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| + |
| + TestCompletionCallback callback; |
| + int rv = trans->Start( |
| + &helper.request(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + // On the second transaction, we trigger the RST. |
| + if (i == 1) { |
| + if (variant == VARIANT_RST_DURING_READ_COMPLETION) { |
| + // Writes to the socket complete asynchronously on SPDY by running |
| + // through the message loop. Complete the write here. |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + } |
| + |
| + // Now schedule the ERR_CONNECTION_RESET. |
| + EXPECT_EQ(3u, data1.read_index()); |
| + data1.CompleteRead(); |
| + EXPECT_EQ(4u, data1.read_index()); |
| + } |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv); |
| + |
| + const HttpResponseInfo* response = trans->GetResponseInfo(); |
| + ASSERT_TRUE(response != NULL); |
| + EXPECT_TRUE(response->headers.get() != NULL); |
| + EXPECT_TRUE(response->was_fetched_via_spdy); |
| + std::string response_data; |
| + rv = ReadTransaction(trans.get(), &response_data); |
| + EXPECT_EQ(OK, rv); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| + EXPECT_EQ("hello!", response_data); |
| + } |
| + |
| + helper.VerifyDataConsumed(); |
| + } |
| +} |
| + |
| +// Test that turning SPDY on and off works properly. |
| +TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) { |
| + net::HttpStreamFactory::set_spdy_enabled(true); |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + MockWrite spdy_writes[] = { CreateMockWrite(*req) }; |
| + |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead spdy_reads[] = { |
| + CreateMockRead(*resp), |
| + CreateMockRead(*body), |
| + MockRead(ASYNC, 0, 0) // EOF |
| + }; |
| + |
| + DelayedSocketData data(1, spdy_reads, arraysize(spdy_reads), |
| + spdy_writes, arraysize(spdy_writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.RunToCompletion(&data); |
| + TransactionHelperResult out = helper.output(); |
| + EXPECT_EQ(OK, out.rv); |
| + EXPECT_EQ("HTTP/1.1 200 OK", out.status_line); |
| + EXPECT_EQ("hello!", out.response_data); |
| + |
| + net::HttpStreamFactory::set_spdy_enabled(false); |
| + MockRead http_reads[] = { |
| + MockRead("HTTP/1.1 200 OK\r\n\r\n"), |
| + MockRead("hello from http"), |
| + MockRead(SYNCHRONOUS, OK), |
| + }; |
| + DelayedSocketData data2(1, http_reads, arraysize(http_reads), NULL, 0); |
| + NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper2.SetSpdyDisabled(); |
| + helper2.RunToCompletion(&data2); |
| + TransactionHelperResult out2 = helper2.output(); |
| + EXPECT_EQ(OK, out2.rv); |
| + EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line); |
| + EXPECT_EQ("hello from http", out2.response_data); |
| + |
| + net::HttpStreamFactory::set_spdy_enabled(true); |
| +} |
| + |
| +// Tests that Basic authentication works over SPDY |
| +TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) { |
| + net::HttpStreamFactory::set_spdy_enabled(true); |
| + |
| + // The first request will be a bare GET, the second request will be a |
| + // GET with an Authorization header. |
| + scoped_ptr<SpdyFrame> req_get( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + const char* const kExtraAuthorizationHeaders[] = { |
| + "authorization", "Basic Zm9vOmJhcg==" |
| + }; |
| + scoped_ptr<SpdyFrame> req_get_authorization( |
| + spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders, |
| + arraysize(kExtraAuthorizationHeaders) / 2, |
| + false, 3, LOWEST, true)); |
| + MockWrite spdy_writes[] = { |
| + CreateMockWrite(*req_get, 1), |
| + CreateMockWrite(*req_get_authorization, 4), |
| + }; |
| + |
| + // The first response is a 401 authentication challenge, and the second |
| + // response will be a 200 response since the second request includes a valid |
| + // Authorization header. |
| + const char* const kExtraAuthenticationHeaders[] = { |
| + "www-authenticate", |
| + "Basic realm=\"MyRealm\"" |
| + }; |
| + scoped_ptr<SpdyFrame> resp_authentication( |
| + spdy_util_.ConstructSpdySynReplyError( |
| + "401 Authentication Required", |
| + kExtraAuthenticationHeaders, |
| + arraysize(kExtraAuthenticationHeaders) / 2, |
| + 1)); |
| + scoped_ptr<SpdyFrame> body_authentication( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> resp_data( |
| + spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
| + scoped_ptr<SpdyFrame> body_data(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
| + MockRead spdy_reads[] = { |
| + CreateMockRead(*resp_authentication, 2), |
| + CreateMockRead(*body_authentication, 3), |
| + CreateMockRead(*resp_data, 5), |
| + CreateMockRead(*body_data, 6), |
| + MockRead(ASYNC, 0, 7), |
| + }; |
| + |
| + OrderedSocketData data(spdy_reads, arraysize(spdy_reads), |
| + spdy_writes, arraysize(spdy_writes)); |
| + HttpRequestInfo request(CreateGetRequest()); |
| + BoundNetLog net_log; |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + net_log, GetParam(), NULL); |
| + |
| + helper.RunPreTestSetup(); |
| + helper.AddData(&data); |
| + HttpNetworkTransaction* trans = helper.trans(); |
| + TestCompletionCallback callback; |
| + const int rv_start = trans->Start(&request, callback.callback(), net_log); |
| + EXPECT_EQ(ERR_IO_PENDING, rv_start); |
| + const int rv_start_complete = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv_start_complete); |
| + |
| + // Make sure the response has an auth challenge. |
| + const HttpResponseInfo* const response_start = trans->GetResponseInfo(); |
| + ASSERT_TRUE(response_start != NULL); |
| + ASSERT_TRUE(response_start->headers.get() != NULL); |
| + EXPECT_EQ(401, response_start->headers->response_code()); |
| + EXPECT_TRUE(response_start->was_fetched_via_spdy); |
| + AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get(); |
| + ASSERT_TRUE(auth_challenge != NULL); |
| + EXPECT_FALSE(auth_challenge->is_proxy); |
| + EXPECT_EQ("basic", auth_challenge->scheme); |
| + EXPECT_EQ("MyRealm", auth_challenge->realm); |
| + |
| + // Restart with a username/password. |
| + AuthCredentials credentials(ASCIIToUTF16("foo"), ASCIIToUTF16("bar")); |
| + TestCompletionCallback callback_restart; |
| + const int rv_restart = trans->RestartWithAuth( |
| + credentials, callback_restart.callback()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv_restart); |
| + const int rv_restart_complete = callback_restart.WaitForResult(); |
| + EXPECT_EQ(OK, rv_restart_complete); |
| + // TODO(cbentzel): This is actually the same response object as before, but |
| + // data has changed. |
| + const HttpResponseInfo* const response_restart = trans->GetResponseInfo(); |
| + ASSERT_TRUE(response_restart != NULL); |
| + ASSERT_TRUE(response_restart->headers.get() != NULL); |
| + EXPECT_EQ(200, response_restart->headers->response_code()); |
| + EXPECT_TRUE(response_restart->auth_challenge.get() == NULL); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) { |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 1), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + spdy_util_.AddUrlToHeaderBlock( |
| + "http://www.google.com/foo.dat", initial_headers.get()); |
| + scoped_ptr<SpdyFrame> stream2_syn( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + SYN_STREAM, |
| + CONTROL_FLAG_NONE, |
| + 1)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| + (*late_headers)["hello"] = "bye"; |
| + (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| + (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| + scoped_ptr<SpdyFrame> stream2_headers( |
| + spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream2_headers, 4), |
| + CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| + CreateMockRead(*stream2_body, 5), |
| + MockRead(ASYNC, ERR_IO_PENDING, 7), // Force a pause |
| + }; |
| + |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + RunServerPushTest(&data, |
| + &response, |
| + &response2, |
| + expected_push_result); |
| + |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) { |
| + // We push a stream and attempt to claim it before the headers come down. |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + spdy_util_.AddUrlToHeaderBlock( |
| + "http://www.google.com/foo.dat", initial_headers.get()); |
| + scoped_ptr<SpdyFrame> stream2_syn( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + SYN_STREAM, |
| + CONTROL_FLAG_NONE, |
| + 1)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| + (*late_headers)["hello"] = "bye"; |
| + (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| + (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| + scoped_ptr<SpdyFrame> stream2_headers( |
| + spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply, 1), |
| + CreateMockRead(*stream2_syn, 2), |
| + CreateMockRead(*stream1_body, 3), |
| + CreateMockRead(*stream2_headers, 4), |
| + CreateMockRead(*stream2_body, 5), |
| + MockRead(ASYNC, 0, 6), // EOF |
| + }; |
| + |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + DeterministicSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.SetDeterministic(); |
| + helper.AddDeterministicData(&data); |
| + helper.RunPreTestSetup(); |
| + |
| + HttpNetworkTransaction* trans = helper.trans(); |
| + |
| + // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| + // and the body of the primary stream, but before we've received the HEADERS |
| + // for the pushed stream. |
| + data.SetStop(3); |
| + |
| + // Start the transaction. |
| + TestCompletionCallback callback; |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.Run(); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(0, rv); |
| + |
| + // Request the pushed path. At this point, we've received the push, but the |
| + // headers are not yet complete. |
| + scoped_ptr<HttpNetworkTransaction> trans2( |
| + new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| + rv = trans2->Start( |
| + &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.RunFor(3); |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + // Read the server push body. |
| + std::string result2; |
| + ReadResult(trans2.get(), &data, &result2); |
| + // Read the response body. |
| + std::string result; |
| + ReadResult(trans, &data, &result); |
| + |
| + // Verify that the received push data is same as the expected push data. |
| + EXPECT_EQ(result2.compare(expected_push_result), 0) |
| + << "Received data: " |
| + << result2 |
| + << "||||| Expected data: " |
| + << expected_push_result; |
| + |
| + // Verify the SYN_REPLY. |
| + // Copy the response info, because trans goes away. |
| + response = *trans->GetResponseInfo(); |
| + response2 = *trans2->GetResponseInfo(); |
| + |
| + VerifyStreamsClosed(helper); |
| + |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| + |
| + // Read the final EOF (which will close the session) |
| + data.RunFor(1); |
| + |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushWithTwoHeaderFrames) { |
| + // We push a stream and attempt to claim it before the headers come down. |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + spdy_util_.AddUrlToHeaderBlock( |
| + "http://www.google.com/foo.dat", initial_headers.get()); |
| + scoped_ptr<SpdyFrame> stream2_syn( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + SYN_STREAM, |
| + CONTROL_FLAG_NONE, |
| + 1)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock()); |
| + (*middle_headers)["hello"] = "bye"; |
| + scoped_ptr<SpdyFrame> stream2_headers1( |
| + spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| + (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| + (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| + scoped_ptr<SpdyFrame> stream2_headers2( |
| + spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply, 1), |
| + CreateMockRead(*stream2_syn, 2), |
| + CreateMockRead(*stream1_body, 3), |
| + CreateMockRead(*stream2_headers1, 4), |
| + CreateMockRead(*stream2_headers2, 5), |
| + CreateMockRead(*stream2_body, 6), |
| + MockRead(ASYNC, 0, 7), // EOF |
| + }; |
| + |
| + HttpResponseInfo response; |
| + HttpResponseInfo response2; |
| + std::string expected_push_result("pushed"); |
| + DeterministicSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.SetDeterministic(); |
| + helper.AddDeterministicData(&data); |
| + helper.RunPreTestSetup(); |
| + |
| + HttpNetworkTransaction* trans = helper.trans(); |
| + |
| + // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| + // the first HEADERS frame, and the body of the primary stream, but before |
| + // we've received the final HEADERS for the pushed stream. |
| + data.SetStop(4); |
| + |
| + // Start the transaction. |
| + TestCompletionCallback callback; |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.Run(); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(0, rv); |
| + |
| + // Request the pushed path. At this point, we've received the push, but the |
| + // headers are not yet complete. |
| + scoped_ptr<HttpNetworkTransaction> trans2( |
| + new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| + rv = trans2->Start( |
| + &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.RunFor(3); |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + // Read the server push body. |
| + std::string result2; |
| + ReadResult(trans2.get(), &data, &result2); |
| + // Read the response body. |
| + std::string result; |
| + ReadResult(trans, &data, &result); |
| + |
| + // Verify that the received push data is same as the expected push data. |
| + EXPECT_EQ(expected_push_result, result2); |
| + |
| + // Verify the SYN_REPLY. |
| + // Copy the response info, because trans goes away. |
| + response = *trans->GetResponseInfo(); |
| + response2 = *trans2->GetResponseInfo(); |
| + |
| + VerifyStreamsClosed(helper); |
| + |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + |
| + // Verify the pushed stream. |
| + EXPECT_TRUE(response2.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| + |
| + // Verify we got all the headers |
| + if (spdy_util_.spdy_version() < SPDY3) { |
| + EXPECT_TRUE(response2.headers->HasHeaderValue( |
| + "url", |
| + "http://www.google.com/foo.dat")); |
| + } else { |
| + EXPECT_TRUE(response2.headers->HasHeaderValue( |
| + "scheme", "http")); |
| + EXPECT_TRUE(response2.headers->HasHeaderValue( |
| + "host", "www.google.com")); |
| + EXPECT_TRUE(response2.headers->HasHeaderValue( |
| + "path", "/foo.dat")); |
| + } |
| + EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye")); |
| + EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200")); |
| + EXPECT_TRUE(response2.headers->HasHeaderValue("version", "HTTP/1.1")); |
| + |
| + // Read the final EOF (which will close the session) |
| + data.RunFor(1); |
| + |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) { |
| + // We push a stream and attempt to claim it before the headers come down. |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + spdy_util_.AddUrlToHeaderBlock( |
| + "http://www.google.com/foo.dat", initial_headers.get()); |
| + scoped_ptr<SpdyFrame> stream2_syn( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + SYN_STREAM, |
| + CONTROL_FLAG_NONE, |
| + 1)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock()); |
| + (*middle_headers)["hello"] = "bye"; |
| + scoped_ptr<SpdyFrame> stream2_headers1( |
| + spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(), |
| + false, |
| + 2, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply, 1), |
| + CreateMockRead(*stream2_syn, 2), |
| + CreateMockRead(*stream1_body, 3), |
| + CreateMockRead(*stream2_headers1, 4), |
| + CreateMockRead(*stream2_body, 5), |
| + MockRead(ASYNC, 0, 6), // EOF |
| + }; |
| + |
| + DeterministicSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.SetDeterministic(); |
| + helper.AddDeterministicData(&data); |
| + helper.RunPreTestSetup(); |
| + |
| + HttpNetworkTransaction* trans = helper.trans(); |
| + |
| + // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| + // the first HEADERS frame, and the body of the primary stream, but before |
| + // we've received the final HEADERS for the pushed stream. |
| + data.SetStop(4); |
| + |
| + // Start the transaction. |
| + TestCompletionCallback callback; |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.Run(); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(0, rv); |
| + |
| + // Request the pushed path. At this point, we've received the push, but the |
| + // headers are not yet complete. |
| + scoped_ptr<HttpNetworkTransaction> trans2( |
| + new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| + rv = trans2->Start( |
| + &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + data.RunFor(2); |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + // Read the server push body. |
| + std::string result2; |
| + ReadResult(trans2.get(), &data, &result2); |
| + // Read the response body. |
| + std::string result; |
| + ReadResult(trans, &data, &result); |
| + EXPECT_EQ("hello!", result); |
| + |
| + // Verify that we haven't received any push data. |
| + EXPECT_EQ("", result2); |
| + |
| + // Verify the SYN_REPLY. |
| + // Copy the response info, because trans goes away. |
| + HttpResponseInfo response = *trans->GetResponseInfo(); |
| + ASSERT_TRUE(trans2->GetResponseInfo() == NULL); |
| + |
| + VerifyStreamsClosed(helper); |
| + |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + |
| + // Read the final EOF (which will close the session). |
| + data.RunFor(1); |
| + |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) { |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req), |
| + CreateMockWrite(*rst), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK"; |
| + (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| + scoped_ptr<SpdyFrame> stream1_reply( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 1, |
| + LOWEST, |
| + SYN_REPLY, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| + (*late_headers)["hello"] = "bye"; |
| + scoped_ptr<SpdyFrame> stream1_headers( |
| + spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| + false, |
| + 1, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply), |
| + CreateMockRead(*stream1_headers), |
| + CreateMockRead(*stream1_body), |
| + MockRead(ASYNC, 0, 0) // EOF |
| + }; |
| + |
| + DelayedSocketData data(1, reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.RunToCompletion(&data); |
| + TransactionHelperResult out = helper.output(); |
| + EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| +} |
| + |
| +TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) { |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req), |
| + CreateMockWrite(*rst), |
| + }; |
| + |
| + scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| + (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK"; |
| + (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| + scoped_ptr<SpdyFrame> stream1_reply( |
| + spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| + false, |
| + 1, |
| + LOWEST, |
| + SYN_REPLY, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + |
| + scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| + (*late_headers)["hello"] = "bye"; |
| + scoped_ptr<SpdyFrame> stream1_headers( |
| + spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| + false, |
| + 1, |
| + LOWEST, |
| + HEADERS, |
| + CONTROL_FLAG_NONE, |
| + 0)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, false)); |
| + scoped_ptr<SpdyFrame> stream1_body2( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply), |
| + CreateMockRead(*stream1_body), |
| + CreateMockRead(*stream1_headers), |
| + CreateMockRead(*stream1_body2), |
| + MockRead(ASYNC, 0, 0) // EOF |
| + }; |
| + |
| + DelayedSocketData data(1, reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.RunToCompletion(&data); |
| + TransactionHelperResult out = helper.output(); |
| + EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| +} |
| - HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo(); |
| - EXPECT_TRUE(response_proxy.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine()); |
| +TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) { |
| + // In this test we want to verify that we can't accidentally push content |
| + // which can't be pushed by this content server. |
| + // This test assumes that: |
| + // - if we're requesting http://www.foo.com/barbaz |
| + // - the browser has made a connection to "www.foo.com". |
| - std::string response_data; |
| - ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data)); |
| - EXPECT_EQ("hello!", response_data); |
| + // A list of the URL to fetch, followed by the URL being pushed. |
| + static const char* const kTestCases[] = { |
| + "http://www.google.com/foo.html", |
| + "http://www.google.com:81/foo.js", // Bad port |
| - data.CompleteRead(); |
| - helper_proxy.VerifyDataConsumed(); |
| -} |
| + "http://www.google.com/foo.html", |
| + "https://www.google.com/foo.js", // Bad protocol |
| -// When we get a TCP-level RST, we need to retry a HttpNetworkTransaction |
| -// on a new connection, if the connection was previously known to be good. |
| -// This can happen when a server reboots without saying goodbye, or when |
| -// we're behind a NAT that masked the RST. |
| -TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + "http://www.google.com/foo.html", |
| + "ftp://www.google.com/foo.js", // Invalid Protocol |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*resp), |
| - CreateMockRead(*body), |
| - MockRead(ASYNC, ERR_IO_PENDING), |
| - MockRead(ASYNC, ERR_CONNECTION_RESET), |
| - }; |
| + "http://www.google.com/foo.html", |
| + "http://blat.www.google.com/foo.js", // Cross subdomain |
| - MockRead reads2[] = { |
| - CreateMockRead(*resp), |
| - CreateMockRead(*body), |
| - MockRead(ASYNC, 0, 0) // EOF |
| + "http://www.google.com/foo.html", |
| + "http://www.foo.com/foo.js", // Cross domain |
| }; |
| - // This test has a couple of variants. |
| - enum { |
| - // Induce the RST while waiting for our transaction to send. |
| - VARIANT_RST_DURING_SEND_COMPLETION, |
| - // Induce the RST while waiting for our transaction to read. |
| - // In this case, the send completed - everything copied into the SNDBUF. |
| - VARIANT_RST_DURING_READ_COMPLETION |
| - }; |
| + for (size_t index = 0; index < arraysize(kTestCases); index += 2) { |
| + const char* url_to_fetch = kTestCases[index]; |
| + const char* url_to_push = kTestCases[index + 1]; |
| - for (int variant = VARIANT_RST_DURING_SEND_COMPLETION; |
| - variant <= VARIANT_RST_DURING_READ_COMPLETION; |
| - ++variant) { |
| - DelayedSocketData data1(1, reads, arraysize(reads), NULL, 0); |
| + scoped_ptr<SpdyFrame> stream1_syn( |
| + spdy_util_.ConstructSpdyGet(url_to_fetch, false, 1, LOWEST)); |
| + scoped_ptr<SpdyFrame> stream1_body( |
| + spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> push_rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*stream1_syn, 1), |
| + CreateMockWrite(*push_rst, 4), |
| + }; |
| - DelayedSocketData data2(1, reads2, arraysize(reads2), NULL, 0); |
| + scoped_ptr<SpdyFrame> |
| + stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> |
| + stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| + 0, |
| + 2, |
| + 1, |
| + url_to_push)); |
| + const char kPushedData[] = "pushed"; |
| + scoped_ptr<SpdyFrame> stream2_body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 2, kPushedData, strlen(kPushedData), true)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.AddData(&data1); |
| - helper.AddData(&data2); |
| - helper.RunPreTestSetup(); |
| + MockRead reads[] = { |
| + CreateMockRead(*stream1_reply, 2), |
| + CreateMockRead(*stream2_syn, 3), |
| + CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| + CreateMockRead(*stream2_body, 6), |
| + MockRead(ASYNC, ERR_IO_PENDING, 7), // Force a pause |
| + }; |
| - for (int i = 0; i < 2; ++i) { |
| - scoped_ptr<HttpNetworkTransaction> trans( |
| - new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| + HttpResponseInfo response; |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| - TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &helper.request(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - // On the second transaction, we trigger the RST. |
| - if (i == 1) { |
| - if (variant == VARIANT_RST_DURING_READ_COMPLETION) { |
| - // Writes to the socket complete asynchronously on SPDY by running |
| - // through the message loop. Complete the write here. |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - } |
| + HttpRequestInfo request; |
| + request.method = "GET"; |
| + request.url = GURL(url_to_fetch); |
| + request.load_flags = 0; |
| - // Now schedule the ERR_CONNECTION_RESET. |
| - EXPECT_EQ(3u, data1.read_index()); |
| - data1.CompleteRead(); |
| - EXPECT_EQ(4u, data1.read_index()); |
| - } |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv); |
| + // Enable cross-origin push. Since we are not using a proxy, this should |
| + // not actually enable cross-origin SPDY push. |
| + scoped_ptr<SpdySessionDependencies> session_deps( |
| + CreateSpdySessionDependencies(GetParam())); |
| + session_deps->trusted_spdy_proxy = "123.45.67.89:8080"; |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), |
| + session_deps.release()); |
| + helper.RunPreTestSetup(); |
| + helper.AddData(&data); |
| - const HttpResponseInfo* response = trans->GetResponseInfo(); |
| - ASSERT_TRUE(response != NULL); |
| - EXPECT_TRUE(response->headers.get() != NULL); |
| - EXPECT_TRUE(response->was_fetched_via_spdy); |
| - std::string response_data; |
| - rv = ReadTransaction(trans.get(), &response_data); |
| - EXPECT_EQ(OK, rv); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| - EXPECT_EQ("hello!", response_data); |
| - } |
| + HttpNetworkTransaction* trans = helper.trans(); |
| - helper.VerifyDataConsumed(); |
| - } |
| -} |
| + // Start the transaction with basic parameters. |
| + TestCompletionCallback callback; |
| -// Test that turning SPDY on and off works properly. |
| -TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback.WaitForResult(); |
| - net::HttpStreamFactory::set_spdy_enabled(true); |
| - scoped_ptr<SpdyFrame> req( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - MockWrite spdy_writes[] = { CreateMockWrite(*req) }; |
| + // Read the response body. |
| + std::string result; |
| + ReadResult(trans, &data, &result); |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockRead spdy_reads[] = { |
| - CreateMockRead(*resp), |
| - CreateMockRead(*body), |
| - MockRead(ASYNC, 0, 0) // EOF |
| - }; |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()); |
| + EXPECT_TRUE(data.at_write_eof()); |
| - DelayedSocketData data(1, spdy_reads, arraysize(spdy_reads), |
| - spdy_writes, arraysize(spdy_writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunToCompletion(&data); |
| - TransactionHelperResult out = helper.output(); |
| - EXPECT_EQ(OK, out.rv); |
| - EXPECT_EQ("HTTP/1.1 200 OK", out.status_line); |
| - EXPECT_EQ("hello!", out.response_data); |
| + // Verify the SYN_REPLY. |
| + // Copy the response info, because trans goes away. |
| + response = *trans->GetResponseInfo(); |
| - net::HttpStreamFactory::set_spdy_enabled(false); |
| - MockRead http_reads[] = { |
| - MockRead("HTTP/1.1 200 OK\r\n\r\n"), |
| - MockRead("hello from http"), |
| - MockRead(SYNCHRONOUS, OK), |
| - }; |
| - DelayedSocketData data2(1, http_reads, arraysize(http_reads), NULL, 0); |
| - NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper2.SetSpdyDisabled(); |
| - helper2.RunToCompletion(&data2); |
| - TransactionHelperResult out2 = helper2.output(); |
| - EXPECT_EQ(OK, out2.rv); |
| - EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line); |
| - EXPECT_EQ("hello from http", out2.response_data); |
| + VerifyStreamsClosed(helper); |
| - net::HttpStreamFactory::set_spdy_enabled(true); |
| + // Verify the SYN_REPLY. |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + } |
| } |
| -// Tests that Basic authentication works over SPDY |
| -TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - net::HttpStreamFactory::set_spdy_enabled(true); |
| - |
| - // The first request will be a bare GET, the second request will be a |
| - // GET with an Authorization header. |
| - scoped_ptr<SpdyFrame> req_get( |
| +TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) { |
| + // Construct the request. |
| + scoped_ptr<SpdyFrame> req( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - const char* const kExtraAuthorizationHeaders[] = { |
| - "authorization", "Basic Zm9vOmJhcg==" |
| - }; |
| - scoped_ptr<SpdyFrame> req_get_authorization( |
| - spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders, |
| - arraysize(kExtraAuthorizationHeaders) / 2, |
| - false, 3, LOWEST, true)); |
| - MockWrite spdy_writes[] = { |
| - CreateMockWrite(*req_get, 1), |
| - CreateMockWrite(*req_get_authorization, 4), |
| - }; |
| - |
| - // The first response is a 401 authentication challenge, and the second |
| - // response will be a 200 response since the second request includes a valid |
| - // Authorization header. |
| - const char* const kExtraAuthenticationHeaders[] = { |
| - "www-authenticate", |
| - "Basic realm=\"MyRealm\"" |
| + scoped_ptr<SpdyFrame> req2( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true)); |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req, 1), |
| + CreateMockWrite(*req2, 3), |
| }; |
| - scoped_ptr<SpdyFrame> resp_authentication( |
| - spdy_util_.ConstructSpdySynReplyError( |
| - "401 Authentication Required", |
| - kExtraAuthenticationHeaders, |
| - arraysize(kExtraAuthenticationHeaders) / 2, |
| - 1)); |
| - scoped_ptr<SpdyFrame> body_authentication( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - scoped_ptr<SpdyFrame> resp_data( |
| - spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
| - scoped_ptr<SpdyFrame> body_data(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
| - MockRead spdy_reads[] = { |
| - CreateMockRead(*resp_authentication, 2), |
| - CreateMockRead(*body_authentication, 3), |
| - CreateMockRead(*resp_data, 5), |
| - CreateMockRead(*body_data, 6), |
| - MockRead(ASYNC, 0, 7), |
| + |
| + scoped_ptr<SpdyFrame> refused( |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM)); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
| + scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
| + MockRead reads[] = { |
| + CreateMockRead(*refused, 2), |
| + CreateMockRead(*resp, 4), |
| + CreateMockRead(*body, 5), |
| + MockRead(ASYNC, 0, 6) // EOF |
| }; |
| - OrderedSocketData data(spdy_reads, arraysize(spdy_reads), |
| - spdy_writes, arraysize(spdy_writes)); |
| - HttpRequestInfo request(CreateGetRequest()); |
| - BoundNetLog net_log; |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| - net_log, GetParam(), NULL); |
| + OrderedSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| helper.RunPreTestSetup(); |
| helper.AddData(&data); |
| + |
| HttpNetworkTransaction* trans = helper.trans(); |
| + |
| + // Start the transaction with basic parameters. |
| TestCompletionCallback callback; |
| - const int rv_start = trans->Start(&request, callback.callback(), net_log); |
| - EXPECT_EQ(ERR_IO_PENDING, rv_start); |
| - const int rv_start_complete = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv_start_complete); |
| + int rv = trans->Start( |
| + &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv); |
| - // Make sure the response has an auth challenge. |
| - const HttpResponseInfo* const response_start = trans->GetResponseInfo(); |
| - ASSERT_TRUE(response_start != NULL); |
| - ASSERT_TRUE(response_start->headers.get() != NULL); |
| - EXPECT_EQ(401, response_start->headers->response_code()); |
| - EXPECT_TRUE(response_start->was_fetched_via_spdy); |
| - AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get(); |
| - ASSERT_TRUE(auth_challenge != NULL); |
| - EXPECT_FALSE(auth_challenge->is_proxy); |
| - EXPECT_EQ("basic", auth_challenge->scheme); |
| - EXPECT_EQ("MyRealm", auth_challenge->realm); |
| + // Verify that we consumed all test data. |
| + EXPECT_TRUE(data.at_read_eof()) << "Read count: " |
| + << data.read_count() |
| + << " Read index: " |
| + << data.read_index(); |
| + EXPECT_TRUE(data.at_write_eof()) << "Write count: " |
| + << data.write_count() |
| + << " Write index: " |
| + << data.write_index(); |
| - // Restart with a username/password. |
| - AuthCredentials credentials(ASCIIToUTF16("foo"), ASCIIToUTF16("bar")); |
| - TestCompletionCallback callback_restart; |
| - const int rv_restart = trans->RestartWithAuth( |
| - credentials, callback_restart.callback()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv_restart); |
| - const int rv_restart_complete = callback_restart.WaitForResult(); |
| - EXPECT_EQ(OK, rv_restart_complete); |
| - // TODO(cbentzel): This is actually the same response object as before, but |
| - // data has changed. |
| - const HttpResponseInfo* const response_restart = trans->GetResponseInfo(); |
| - ASSERT_TRUE(response_restart != NULL); |
| - ASSERT_TRUE(response_restart->headers.get() != NULL); |
| - EXPECT_EQ(200, response_restart->headers->response_code()); |
| - EXPECT_TRUE(response_restart->auth_challenge.get() == NULL); |
| + // Verify the SYN_REPLY. |
| + HttpResponseInfo response = *trans->GetResponseInfo(); |
| + EXPECT_TRUE(response.headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| - |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| +TEST_P(SpdyNetworkTransactionTest, OutOfOrderSynStream) { |
| + // This first request will start to establish the SpdySession. |
| + // Then we will start the second (MEDIUM priority) and then third |
| + // (HIGHEST priority) request in such a way that the third will actually |
| + // start before the second, causing the second to be numbered differently |
| + // than the order they were created. |
| + scoped_ptr<SpdyFrame> req1( |
| spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + scoped_ptr<SpdyFrame> req2( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, HIGHEST, true)); |
| + scoped_ptr<SpdyFrame> req3( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, MEDIUM, true)); |
| MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| + CreateMockWrite(*req1, 0), |
| + CreateMockWrite(*req2, 3), |
| + CreateMockWrite(*req3, 4), |
| }; |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - spdy_util_.AddUrlToHeaderBlock( |
| - "http://www.google.com/foo.dat", initial_headers.get()); |
| - scoped_ptr<SpdyFrame> stream2_syn( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - SYN_STREAM, |
| - CONTROL_FLAG_NONE, |
| - 1)); |
| - |
| - scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| - (*late_headers)["hello"] = "bye"; |
| - (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| - (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| - scoped_ptr<SpdyFrame> stream2_headers( |
| - spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(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> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
| + scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
| + scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5)); |
| + scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true)); |
| MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream2_headers, 4), |
| - CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 6), |
| - MockRead(ASYNC, ERR_IO_PENDING, 7), // Force a pause |
| + CreateMockRead(*resp1, 1), |
| + CreateMockRead(*body1, 2), |
| + CreateMockRead(*resp2, 5), |
| + CreateMockRead(*body2, 6), |
| + CreateMockRead(*resp3, 7), |
| + CreateMockRead(*body3, 8), |
| + MockRead(ASYNC, 0, 9) // EOF |
| }; |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - RunServerPushTest(&data, |
| - &response, |
| - &response2, |
| - expected_push_result); |
| + DeterministicSocketData data(reads, arraysize(reads), |
| + writes, arraysize(writes)); |
| + NormalSpdyTransactionHelper helper(CreateGetRequest(), LOWEST, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.SetDeterministic(); |
| + helper.RunPreTestSetup(); |
| + helper.AddDeterministicData(&data); |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + // Start the first transaction to set up the SpdySession |
| + HttpNetworkTransaction* trans = helper.trans(); |
| + TestCompletionCallback callback; |
| + HttpRequestInfo info1 = CreateGetRequest(); |
| + int rv = trans->Start(&info1, callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| + // Run the message loop, but do not allow the write to complete. |
| + // This leaves the SpdySession with a write pending, which prevents |
| + // SpdySession from attempting subsequent writes until this write completes. |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + // Now, start both new transactions |
| + HttpRequestInfo info2 = CreateGetRequest(); |
| + TestCompletionCallback callback2; |
| + scoped_ptr<HttpNetworkTransaction> trans2( |
| + new HttpNetworkTransaction(MEDIUM, helper.session().get())); |
| + rv = trans2->Start(&info2, callback2.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + HttpRequestInfo info3 = CreateGetRequest(); |
| + TestCompletionCallback callback3; |
| + scoped_ptr<HttpNetworkTransaction> trans3( |
| + new HttpNetworkTransaction(HIGHEST, helper.session().get())); |
| + rv = trans3->Start(&info3, callback3.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + base::MessageLoop::current()->RunUntilIdle(); |
| + |
| + // We now have two SYN_STREAM frames queued up which will be |
| + // dequeued only once the first write completes, which we |
| + // now allow to happen. |
| + data.RunFor(2); |
| + EXPECT_EQ(OK, callback.WaitForResult()); |
| + |
| + // And now we can allow everything else to run to completion. |
| + data.SetStop(10); |
| + data.Run(); |
| + EXPECT_EQ(OK, callback2.WaitForResult()); |
| + EXPECT_EQ(OK, callback3.WaitForResult()); |
| + |
| + helper.VerifyDataConsumed(); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| +// The tests below are only for SPDY/3 and above. |
| + |
| +// Test that sent data frames and received WINDOW_UPDATE frames change |
| +// the send_window_size_ correctly. |
| + |
| +// WINDOW_UPDATE is different than most other frames in that it can arrive |
| +// while the client is still sending the request body. In order to enforce |
| +// this scenario, we feed a couple of dummy frames and give a delay of 0 to |
| +// socket data provider, so that initial read that is done as soon as the |
| +// stream is created, succeeds and schedules another read. This way reads |
| +// and writes are interleaved; after doing a full frame write, SpdyStream |
| +// will break out of DoLoop and will read and process a WINDOW_UPDATE. |
| +// Once our WINDOW_UPDATE is read, we cannot send SYN_REPLY right away |
| +// since request has not been completely written, therefore we feed |
| +// enough number of WINDOW_UPDATEs to finish the first read and cause a |
| +// write, leading to a complete write of request body; after that we send |
| +// a reply with a body, to cause a graceful shutdown. |
| + |
| +// TODO(agayev): develop a socket data provider where both, reads and |
| +// writes are ordered so that writing tests like these are easy and rewrite |
| +// all these tests using it. Right now we are working around the |
| +// limitations as described above and it's not deterministic, tests may |
| +// fail under specific circumstances. |
| +TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| return; |
| - // We push a stream and attempt to claim it before the headers come down. |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + static int kFrameCount = 2; |
| + scoped_ptr<std::string> content( |
| + new std::string(kMaxSpdyFrameChunkSize, 'a')); |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| + kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0)); |
| + scoped_ptr<SpdyFrame> body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content->c_str(), content->size(), false)); |
| + scoped_ptr<SpdyFrame> body_end( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content->c_str(), content->size(), true)); |
| + |
| MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| + CreateMockWrite(*req, 0), |
| + CreateMockWrite(*body, 1), |
| + CreateMockWrite(*body_end, 2), |
| }; |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - spdy_util_.AddUrlToHeaderBlock( |
| - "http://www.google.com/foo.dat", initial_headers.get()); |
| - scoped_ptr<SpdyFrame> stream2_syn( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - SYN_STREAM, |
| - CONTROL_FLAG_NONE, |
| - 1)); |
| - |
| - scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| - (*late_headers)["hello"] = "bye"; |
| - (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| - (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| - scoped_ptr<SpdyFrame> stream2_headers( |
| - spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| - |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + static const int32 kDeltaWindowSize = 0xff; |
| + static const int kDeltaCount = 4; |
| + scoped_ptr<SpdyFrame> window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize)); |
| + scoped_ptr<SpdyFrame> window_update_dummy( |
| + spdy_util_.ConstructSpdyWindowUpdate(2, kDeltaWindowSize)); |
| + scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 1), |
| - CreateMockRead(*stream2_syn, 2), |
| - CreateMockRead(*stream1_body, 3), |
| - CreateMockRead(*stream2_headers, 4), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 5), |
| - MockRead(ASYNC, 0, 6), // EOF |
| + CreateMockRead(*window_update_dummy, 3), |
| + CreateMockRead(*window_update_dummy, 4), |
| + CreateMockRead(*window_update_dummy, 5), |
| + CreateMockRead(*window_update, 6), // Four updates, therefore window |
| + CreateMockRead(*window_update, 7), // size should increase by |
| + CreateMockRead(*window_update, 8), // kDeltaWindowSize * 4 |
| + CreateMockRead(*window_update, 9), |
| + CreateMockRead(*resp, 10), |
| + CreateMockRead(*body_end, 11), |
| + MockRead(ASYNC, 0, 0, 12) // EOF |
| }; |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| DeterministicSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + ScopedVector<UploadElementReader> element_readers; |
| + for (int i = 0; i < kFrameCount; ++i) { |
| + element_readers.push_back( |
| + new UploadBytesElementReader(content->c_str(), content->size())); |
| + } |
| + UploadDataStream upload_data_stream(&element_readers, 0); |
| + |
| + // Setup the request |
| + HttpRequestInfo request; |
| + request.method = "POST"; |
| + request.url = GURL(kDefaultURL); |
| + request.upload_data_stream = &upload_data_stream; |
| + |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| helper.SetDeterministic(); |
| helper.AddDeterministicData(&data); |
| @@ -5911,712 +5836,553 @@ TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) { |
| HttpNetworkTransaction* trans = helper.trans(); |
| - // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| - // and the body of the primary stream, but before we've received the HEADERS |
| - // for the pushed stream. |
| - data.SetStop(3); |
| - |
| - // Start the transaction. |
| TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.Run(); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(0, rv); |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - // Request the pushed path. At this point, we've received the push, but the |
| - // headers are not yet complete. |
| - scoped_ptr<HttpNetworkTransaction> trans2( |
| - new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| - rv = trans2->Start( |
| - &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.RunFor(3); |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - |
| - // Read the server push body. |
| - std::string result2; |
| - ReadResult(trans2.get(), &data, &result2); |
| - // Read the response body. |
| - std::string result; |
| - ReadResult(trans, &data, &result); |
| - |
| - // Verify that the received push data is same as the expected push data. |
| - EXPECT_EQ(result2.compare(expected_push_result), 0) |
| - << "Received data: " |
| - << result2 |
| - << "||||| Expected data: " |
| - << expected_push_result; |
| - // Verify the SYN_REPLY. |
| - // Copy the response info, because trans goes away. |
| - response = *trans->GetResponseInfo(); |
| - response2 = *trans2->GetResponseInfo(); |
| - |
| - VerifyStreamsClosed(helper); |
| - |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + data.RunFor(11); |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| + SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| + ASSERT_TRUE(stream != NULL); |
| + ASSERT_TRUE(stream->stream() != NULL); |
| + EXPECT_EQ(static_cast<int>(kSpdyStreamInitialWindowSize) + |
| + kDeltaWindowSize * kDeltaCount - |
| + kMaxSpdyFrameChunkSize * kFrameCount, |
| + stream->stream()->send_window_size()); |
| - // Read the final EOF (which will close the session) |
| data.RunFor(1); |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv); |
| + |
| + helper.VerifyDataConsumed(); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushWithTwoHeaderFrames) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| +// Test that received data frames and sent WINDOW_UPDATE frames change |
| +// the recv_window_size_ correctly. |
| +TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| return; |
| - // We push a stream and attempt to claim it before the headers come down. |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| - }; |
| - |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - spdy_util_.AddUrlToHeaderBlock( |
| - "http://www.google.com/foo.dat", initial_headers.get()); |
| - scoped_ptr<SpdyFrame> stream2_syn( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - SYN_STREAM, |
| - CONTROL_FLAG_NONE, |
| - 1)); |
| + // Set the data in the body frame large enough to trigger sending a |
| + // WINDOW_UPDATE by the stream. |
| + const std::string body_data(kSpdyStreamInitialWindowSize / 2 + 1, 'x'); |
| - scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock()); |
| - (*middle_headers)["hello"] = "bye"; |
| - scoped_ptr<SpdyFrame> stream2_headers1( |
| - spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| + scoped_ptr<SpdyFrame> req( |
| + spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| + scoped_ptr<SpdyFrame> session_window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(0, body_data.size())); |
| + scoped_ptr<SpdyFrame> window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(1, body_data.size())); |
| - scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| - (*late_headers)[spdy_util_.GetStatusKey()] = "200"; |
| - (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| - scoped_ptr<SpdyFrame> stream2_headers2( |
| - spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| + std::vector<MockWrite> writes; |
| + writes.push_back(CreateMockWrite(*req)); |
| + if (GetParam().protocol >= kProtoSPDY31) |
| + writes.push_back(CreateMockWrite(*session_window_update)); |
| + writes.push_back(CreateMockWrite(*window_update)); |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> resp( |
| + spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + scoped_ptr<SpdyFrame> body_no_fin( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, body_data.data(), body_data.size(), false)); |
| + scoped_ptr<SpdyFrame> body_fin( |
| + spdy_util_.ConstructSpdyBodyFrame(1, NULL, 0, true)); |
| MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 1), |
| - CreateMockRead(*stream2_syn, 2), |
| - CreateMockRead(*stream1_body, 3), |
| - CreateMockRead(*stream2_headers1, 4), |
| - CreateMockRead(*stream2_headers2, 5), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 6), |
| - MockRead(ASYNC, 0, 7), // EOF |
| + CreateMockRead(*resp), |
| + CreateMockRead(*body_no_fin), |
| + MockRead(ASYNC, ERR_IO_PENDING, 0), // Force a pause |
| + CreateMockRead(*body_fin), |
| + MockRead(ASYNC, ERR_IO_PENDING, 0), // Force a pause |
| + MockRead(ASYNC, 0, 0) // EOF |
| }; |
| - HttpResponseInfo response; |
| - HttpResponseInfo response2; |
| - std::string expected_push_result("pushed"); |
| - DeterministicSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| + DelayedSocketData data(1, reads, arraysize(reads), |
| + vector_as_array(&writes), writes.size()); |
| NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.SetDeterministic(); |
| - helper.AddDeterministicData(&data); |
| + helper.AddData(&data); |
| helper.RunPreTestSetup(); |
| - |
| HttpNetworkTransaction* trans = helper.trans(); |
| - // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| - // the first HEADERS frame, and the body of the primary stream, but before |
| - // we've received the final HEADERS for the pushed stream. |
| - data.SetStop(4); |
| - |
| - // Start the transaction. |
| TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.Run(); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(0, rv); |
| - |
| - // Request the pushed path. At this point, we've received the push, but the |
| - // headers are not yet complete. |
| - scoped_ptr<HttpNetworkTransaction> trans2( |
| - new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| - rv = trans2->Start( |
| - &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.RunFor(3); |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - |
| - // Read the server push body. |
| - std::string result2; |
| - ReadResult(trans2.get(), &data, &result2); |
| - // Read the response body. |
| - std::string result; |
| - ReadResult(trans, &data, &result); |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| - // Verify that the received push data is same as the expected push data. |
| - EXPECT_EQ(expected_push_result, result2); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| + rv = callback.WaitForResult(); |
| + EXPECT_EQ(OK, rv); |
| - // Verify the SYN_REPLY. |
| - // Copy the response info, because trans goes away. |
| - response = *trans->GetResponseInfo(); |
| - response2 = *trans2->GetResponseInfo(); |
| + SpdyHttpStream* stream = |
| + static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| + ASSERT_TRUE(stream != NULL); |
| + ASSERT_TRUE(stream->stream() != NULL); |
| - VerifyStreamsClosed(helper); |
| + EXPECT_EQ( |
| + static_cast<int>(kSpdyStreamInitialWindowSize - body_data.size()), |
| + stream->stream()->recv_window_size()); |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + const HttpResponseInfo* response = trans->GetResponseInfo(); |
| + ASSERT_TRUE(response != NULL); |
| + ASSERT_TRUE(response->headers.get() != NULL); |
| + EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
| + EXPECT_TRUE(response->was_fetched_via_spdy); |
| - // Verify the pushed stream. |
| - EXPECT_TRUE(response2.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine()); |
| + // Issue a read which will cause a WINDOW_UPDATE to be sent and window |
| + // size increased to default. |
| + scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(body_data.size())); |
| + rv = trans->Read(buf.get(), body_data.size(), CompletionCallback()); |
| + EXPECT_EQ(static_cast<int>(body_data.size()), rv); |
| + std::string content(buf->data(), buf->data() + body_data.size()); |
| + EXPECT_EQ(body_data, content); |
| - // Verify we got all the headers |
| - if (spdy_util_.spdy_version() < SPDY3) { |
| - EXPECT_TRUE(response2.headers->HasHeaderValue( |
| - "url", |
| - "http://www.google.com/foo.dat")); |
| - } else { |
| - EXPECT_TRUE(response2.headers->HasHeaderValue( |
| - "scheme", "http")); |
| - EXPECT_TRUE(response2.headers->HasHeaderValue( |
| - "host", "www.google.com")); |
| - EXPECT_TRUE(response2.headers->HasHeaderValue( |
| - "path", "/foo.dat")); |
| - } |
| - EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye")); |
| - EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200")); |
| - EXPECT_TRUE(response2.headers->HasHeaderValue("version", "HTTP/1.1")); |
| + // Schedule the reading of empty data frame with FIN |
| + data.CompleteRead(); |
| - // Read the final EOF (which will close the session) |
| - data.RunFor(1); |
| + // Force write of WINDOW_UPDATE which was scheduled during the above |
| + // read. |
| + base::MessageLoop::current()->RunUntilIdle(); |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| + // Read EOF. |
| + data.CompleteRead(); |
| + |
| + helper.VerifyDataConsumed(); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| +// Test that WINDOW_UPDATE frame causing overflow is handled correctly. |
| +TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| return; |
| - // We push a stream and attempt to claim it before the headers come down. |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS), |
| - }; |
| + // Number of full frames we hope to write (but will not, used to |
| + // set content-length header correctly) |
| + static int kFrameCount = 3; |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - spdy_util_.AddUrlToHeaderBlock( |
| - "http://www.google.com/foo.dat", initial_headers.get()); |
| - scoped_ptr<SpdyFrame> stream2_syn( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - SYN_STREAM, |
| - CONTROL_FLAG_NONE, |
| - 1)); |
| + scoped_ptr<std::string> content( |
| + new std::string(kMaxSpdyFrameChunkSize, 'a')); |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| + kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0)); |
| + scoped_ptr<SpdyFrame> body( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content->c_str(), content->size(), false)); |
| + scoped_ptr<SpdyFrame> rst( |
| + spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR)); |
| - scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock()); |
| - (*middle_headers)["hello"] = "bye"; |
| - scoped_ptr<SpdyFrame> stream2_headers1( |
| - spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(), |
| - false, |
| - 2, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| + // We're not going to write a data frame with FIN, we'll receive a bad |
| + // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame. |
| + MockWrite writes[] = { |
| + CreateMockWrite(*req, 0), |
| + CreateMockWrite(*body, 2), |
| + CreateMockWrite(*rst, 3), |
| + }; |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| + static const int32 kDeltaWindowSize = 0x7fffffff; // cause an overflow |
| + scoped_ptr<SpdyFrame> window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize)); |
| MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 1), |
| - CreateMockRead(*stream2_syn, 2), |
| - CreateMockRead(*stream1_body, 3), |
| - CreateMockRead(*stream2_headers1, 4), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 5), |
| - MockRead(ASYNC, 0, 6), // EOF |
| + CreateMockRead(*window_update, 1), |
| + MockRead(ASYNC, 0, 4) // EOF |
| }; |
| DeterministicSocketData data(reads, arraysize(reads), |
| writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + ScopedVector<UploadElementReader> element_readers; |
| + for (int i = 0; i < kFrameCount; ++i) { |
| + element_readers.push_back( |
| + new UploadBytesElementReader(content->c_str(), content->size())); |
| + } |
| + UploadDataStream upload_data_stream(&element_readers, 0); |
| + |
| + // Setup the request |
| + HttpRequestInfo request; |
| + request.method = "POST"; |
| + request.url = GURL("http://www.google.com/"); |
| + request.upload_data_stream = &upload_data_stream; |
| + |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| helper.SetDeterministic(); |
| - helper.AddDeterministicData(&data); |
| helper.RunPreTestSetup(); |
| - |
| + helper.AddDeterministicData(&data); |
| HttpNetworkTransaction* trans = helper.trans(); |
| - // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM, |
| - // the first HEADERS frame, and the body of the primary stream, but before |
| - // we've received the final HEADERS for the pushed stream. |
| - data.SetStop(4); |
| - |
| - // Start the transaction. |
| TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.Run(); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(0, rv); |
| - |
| - // Request the pushed path. At this point, we've received the push, but the |
| - // headers are not yet complete. |
| - scoped_ptr<HttpNetworkTransaction> trans2( |
| - new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get())); |
| - rv = trans2->Start( |
| - &CreateGetPushRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - data.RunFor(2); |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - |
| - // Read the server push body. |
| - std::string result2; |
| - ReadResult(trans2.get(), &data, &result2); |
| - // Read the response body. |
| - std::string result; |
| - ReadResult(trans, &data, &result); |
| - EXPECT_EQ("hello!", result); |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| + ASSERT_EQ(ERR_IO_PENDING, rv); |
| - // Verify that we haven't received any push data. |
| - EXPECT_EQ("", result2); |
| + data.RunFor(5); |
| + ASSERT_TRUE(callback.have_result()); |
| + EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult()); |
| + helper.VerifyDataConsumed(); |
| +} |
| - // Verify the SYN_REPLY. |
| - // Copy the response info, because trans goes away. |
| - HttpResponseInfo response = *trans->GetResponseInfo(); |
| - ASSERT_TRUE(trans2->GetResponseInfo() == NULL); |
| +// Test that after hitting a send window size of 0, the write process |
| +// stalls and upon receiving WINDOW_UPDATE frame write resumes. |
| - VerifyStreamsClosed(helper); |
| +// This test constructs a POST request followed by enough data frames |
| +// containing 'a' that would make the window size 0, followed by another |
| +// data frame containing default content (which is "hello!") and this frame |
| +// also contains a FIN flag. DelayedSocketData is used to enforce all |
| +// writes go through before a read could happen. However, the last frame |
| +// ("hello!") is not supposed to go through since by the time its turn |
| +// arrives, window size is 0. At this point MessageLoop::Run() called via |
| +// callback would block. Therefore we call MessageLoop::RunUntilIdle() |
| +// which returns after performing all possible writes. We use DCHECKS to |
| +// ensure that last data frame is still there and stream has stalled. |
| +// After that, next read is artifically enforced, which causes a |
| +// WINDOW_UPDATE to be read and I/O process resumes. |
| +TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| + return; |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| + // Number of frames we need to send to zero out the window size: data |
| + // frames plus SYN_STREAM plus the last data frame; also we need another |
| + // data frame that we will send once the WINDOW_UPDATE is received, |
| + // therefore +3. |
| + size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - // Read the final EOF (which will close the session). |
| - data.RunFor(1); |
| + // Calculate last frame's size; 0 size data frame is legal. |
| + size_t last_frame_size = |
| + kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| -} |
| + // Construct content for a data frame of maximum size. |
| + std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| -TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| + kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| + LOWEST, NULL, 0)); |
| - scoped_ptr<SpdyFrame> req( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req), |
| - CreateMockWrite(*rst), |
| - }; |
| + // Full frames. |
| + scoped_ptr<SpdyFrame> body1( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), content.size(), false)); |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK"; |
| - (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| - scoped_ptr<SpdyFrame> stream1_reply( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 1, |
| - LOWEST, |
| - SYN_REPLY, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| + // Last frame to zero out the window size. |
| + scoped_ptr<SpdyFrame> body2( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), last_frame_size, false)); |
| - scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| - (*late_headers)["hello"] = "bye"; |
| - scoped_ptr<SpdyFrame> stream1_headers( |
| - spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| - false, |
| - 1, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + // Data frame to be sent once WINDOW_UPDATE frame is received. |
| + scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| + |
| + // Fill in mock writes. |
| + scoped_ptr<MockWrite[]> writes(new MockWrite[num_writes]); |
| + size_t i = 0; |
| + writes[i] = CreateMockWrite(*req); |
| + for (i = 1; i < num_writes - 2; i++) |
| + writes[i] = CreateMockWrite(*body1); |
| + writes[i++] = CreateMockWrite(*body2); |
| + writes[i] = CreateMockWrite(*body3); |
| + |
| + // Construct read frame, give enough space to upload the rest of the |
| + // data. |
| + scoped_ptr<SpdyFrame> session_window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize)); |
| + scoped_ptr<SpdyFrame> window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize)); |
| + scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| MockRead reads[] = { |
| - CreateMockRead(*stream1_reply), |
| - CreateMockRead(*stream1_headers), |
| - CreateMockRead(*stream1_body), |
| + CreateMockRead(*session_window_update), |
| + CreateMockRead(*session_window_update), |
| + CreateMockRead(*window_update), |
| + CreateMockRead(*window_update), |
| + CreateMockRead(*reply), |
| + CreateMockRead(*body2), |
| + CreateMockRead(*body3), |
| MockRead(ASYNC, 0, 0) // EOF |
| }; |
| - DelayedSocketData data(1, reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| + // Skip the session window updates unless we're using SPDY/3.1 and |
| + // above. |
| + size_t read_offset = (GetParam().protocol >= kProtoSPDY31) ? 0 : 2; |
| + size_t num_reads = arraysize(reads) - read_offset; |
| + |
| + // Force all writes to happen before any read, last write will not |
| + // actually queue a frame, due to window size being 0. |
| + DelayedSocketData data(num_writes, reads + read_offset, num_reads, |
| + writes.get(), num_writes); |
| + |
| + ScopedVector<UploadElementReader> element_readers; |
| + std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| + upload_data_string.append(kUploadData, kUploadDataSize); |
| + element_readers.push_back(new UploadBytesElementReader( |
| + upload_data_string.c_str(), upload_data_string.size())); |
| + UploadDataStream upload_data_stream(&element_readers, 0); |
| + |
| + HttpRequestInfo request; |
| + request.method = "POST"; |
| + request.url = GURL("http://www.google.com/"); |
| + request.upload_data_stream = &upload_data_stream; |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| - helper.RunToCompletion(&data); |
| - TransactionHelperResult out = helper.output(); |
| - EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| -} |
| + helper.AddData(&data); |
| + helper.RunPreTestSetup(); |
| -TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + HttpNetworkTransaction* trans = helper.trans(); |
| - scoped_ptr<SpdyFrame> req( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req), |
| - CreateMockWrite(*rst), |
| - }; |
| + TestCompletionCallback callback; |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| - scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock()); |
| - (*initial_headers)[spdy_util_.GetStatusKey()] = "200 OK"; |
| - (*initial_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1"; |
| - scoped_ptr<SpdyFrame> stream1_reply( |
| - spdy_util_.ConstructSpdyControlFrame(initial_headers.Pass(), |
| - false, |
| - 1, |
| - LOWEST, |
| - SYN_REPLY, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| + base::MessageLoop::current()->RunUntilIdle(); // Write as much as we can. |
| - scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock()); |
| - (*late_headers)["hello"] = "bye"; |
| - scoped_ptr<SpdyFrame> stream1_headers( |
| - spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(), |
| - false, |
| - 1, |
| - LOWEST, |
| - HEADERS, |
| - CONTROL_FLAG_NONE, |
| - 0)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, false)); |
| - scoped_ptr<SpdyFrame> stream1_body2( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply), |
| - CreateMockRead(*stream1_body), |
| - CreateMockRead(*stream1_headers), |
| - CreateMockRead(*stream1_body2), |
| - MockRead(ASYNC, 0, 0) // EOF |
| - }; |
| + SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| + ASSERT_TRUE(stream != NULL); |
| + ASSERT_TRUE(stream->stream() != NULL); |
| + EXPECT_EQ(0, stream->stream()->send_window_size()); |
| + // All the body data should have been read. |
| + // TODO(satorux): This is because of the weirdness in reading the request |
| + // body in OnSendBodyComplete(). See crbug.com/113107. |
| + EXPECT_TRUE(upload_data_stream.IsEOF()); |
| + // But the body is not yet fully sent (kUploadData is not yet sent) |
| + // since we're send-stalled. |
| + EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| - DelayedSocketData data(1, reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| - helper.RunToCompletion(&data); |
| - TransactionHelperResult out = helper.output(); |
| - EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv); |
| + data.ForceNextRead(); // Read in WINDOW_UPDATE frame. |
| + rv = callback.WaitForResult(); |
| + helper.VerifyDataConsumed(); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| +// Test we correctly handle the case where the SETTINGS frame results in |
| +// unstalling the send window. |
| +TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| return; |
| - // In this test we want to verify that we can't accidentally push content |
| - // which can't be pushed by this content server. |
| - // This test assumes that: |
| - // - if we're requesting http://www.foo.com/barbaz |
| - // - the browser has made a connection to "www.foo.com". |
| - |
| - // A list of the URL to fetch, followed by the URL being pushed. |
| - static const char* const kTestCases[] = { |
| - "http://www.google.com/foo.html", |
| - "http://www.google.com:81/foo.js", // Bad port |
| + // Number of frames we need to send to zero out the window size: data |
| + // frames plus SYN_STREAM plus the last data frame; also we need another |
| + // data frame that we will send once the SETTING is received, therefore +3. |
| + size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - "http://www.google.com/foo.html", |
| - "https://www.google.com/foo.js", // Bad protocol |
| + // Calculate last frame's size; 0 size data frame is legal. |
| + size_t last_frame_size = |
| + kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - "http://www.google.com/foo.html", |
| - "ftp://www.google.com/foo.js", // Invalid Protocol |
| + // Construct content for a data frame of maximum size. |
| + std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| - "http://www.google.com/foo.html", |
| - "http://blat.www.google.com/foo.js", // Cross subdomain |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| + kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| + LOWEST, NULL, 0)); |
| - "http://www.google.com/foo.html", |
| - "http://www.foo.com/foo.js", // Cross domain |
| - }; |
| + // Full frames. |
| + scoped_ptr<SpdyFrame> body1( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), content.size(), false)); |
| + // Last frame to zero out the window size. |
| + scoped_ptr<SpdyFrame> body2( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), last_frame_size, false)); |
| - static const unsigned char kPushBodyFrame[] = { |
| - 0x00, 0x00, 0x00, 0x02, // header, ID |
| - 0x01, 0x00, 0x00, 0x06, // FIN, length |
| - 'p', 'u', 's', 'h', 'e', 'd' // "pushed" |
| - }; |
| + // Data frame to be sent once SETTINGS frame is received. |
| + scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - for (size_t index = 0; index < arraysize(kTestCases); index += 2) { |
| - const char* url_to_fetch = kTestCases[index]; |
| - const char* url_to_push = kTestCases[index + 1]; |
| + // Fill in mock reads/writes. |
| + std::vector<MockRead> reads; |
| + std::vector<MockWrite> writes; |
| + size_t i = 0; |
| + writes.push_back(CreateMockWrite(*req, i++)); |
| + while (i < num_writes - 2) |
| + writes.push_back(CreateMockWrite(*body1, i++)); |
| + writes.push_back(CreateMockWrite(*body2, i++)); |
| - scoped_ptr<SpdyFrame> stream1_syn( |
| - spdy_util_.ConstructSpdyGet(url_to_fetch, false, 1, LOWEST)); |
| - scoped_ptr<SpdyFrame> stream1_body( |
| - spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - scoped_ptr<SpdyFrame> push_rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*stream1_syn, 1), |
| - CreateMockWrite(*push_rst, 4), |
| - }; |
| + // Construct read frame for SETTINGS that gives enough space to upload the |
| + // rest of the data. |
| + SettingsMap settings; |
| + settings[SETTINGS_INITIAL_WINDOW_SIZE] = |
| + SettingsFlagsAndValue( |
| + SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize * 2); |
| + scoped_ptr<SpdyFrame> settings_frame_large( |
| + spdy_util_.ConstructSpdySettings(settings)); |
| - scoped_ptr<SpdyFrame> |
| - stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
| - scoped_ptr<SpdyFrame> |
| - stream2_syn(spdy_util_.ConstructSpdyPush(NULL, |
| - 0, |
| - 2, |
| - 1, |
| - url_to_push)); |
| - scoped_ptr<SpdyFrame> rst( |
| - spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL)); |
| + reads.push_back(CreateMockRead(*settings_frame_large, i++)); |
| - MockRead reads[] = { |
| - CreateMockRead(*stream1_reply, 2), |
| - CreateMockRead(*stream2_syn, 3), |
| - CreateMockRead(*stream1_body, 5, SYNCHRONOUS), |
| - MockRead(ASYNC, reinterpret_cast<const char*>(kPushBodyFrame), |
| - arraysize(kPushBodyFrame), 6), |
| - MockRead(ASYNC, ERR_IO_PENDING, 7), // Force a pause |
| - }; |
| + scoped_ptr<SpdyFrame> session_window_update( |
| + spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize)); |
| + if (GetParam().protocol >= kProtoSPDY31) |
| + reads.push_back(CreateMockRead(*session_window_update, i++)); |
| - HttpResponseInfo response; |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| + writes.push_back(CreateMockWrite(*body3, i++)); |
| - HttpRequestInfo request; |
| - request.method = "GET"; |
| - request.url = GURL(url_to_fetch); |
| - request.load_flags = 0; |
| + scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| + reads.push_back(CreateMockRead(*reply, i++)); |
| + reads.push_back(CreateMockRead(*body2, i++)); |
| + reads.push_back(CreateMockRead(*body3, i++)); |
| + reads.push_back(MockRead(ASYNC, 0, i++)); // EOF |
| - // Enable cross-origin push. Since we are not using a proxy, this should |
| - // not actually enable cross-origin SPDY push. |
| - scoped_ptr<SpdySessionDependencies> session_deps( |
| - CreateSpdySessionDependencies(GetParam())); |
| - session_deps->trusted_spdy_proxy = "123.45.67.89:8080"; |
| - NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), |
| - session_deps.release()); |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| + // Force all writes to happen before any read, last write will not |
| + // actually queue a frame, due to window size being 0. |
| + DeterministicSocketData data(vector_as_array(&reads), reads.size(), |
| + vector_as_array(&writes), writes.size()); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| + ScopedVector<UploadElementReader> element_readers; |
| + std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| + upload_data_string.append(kUploadData, kUploadDataSize); |
| + element_readers.push_back(new UploadBytesElementReader( |
| + upload_data_string.c_str(), upload_data_string.size())); |
| + UploadDataStream upload_data_stream(&element_readers, 0); |
| - // Start the transaction with basic parameters. |
| - TestCompletionCallback callback; |
| + HttpRequestInfo request; |
| + request.method = "POST"; |
| + request.url = GURL("http://www.google.com/"); |
| + request.upload_data_stream = &upload_data_stream; |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| + BoundNetLog(), GetParam(), NULL); |
| + helper.SetDeterministic(); |
| + helper.RunPreTestSetup(); |
| + helper.AddDeterministicData(&data); |
| - int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| + HttpNetworkTransaction* trans = helper.trans(); |
| - // Read the response body. |
| - std::string result; |
| - ReadResult(trans, &data, &result); |
| + TestCompletionCallback callback; |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| + EXPECT_EQ(ERR_IO_PENDING, rv); |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()); |
| - EXPECT_TRUE(data.at_write_eof()); |
| + data.RunFor(num_writes - 1); // Write as much as we can. |
| - // Verify the SYN_REPLY. |
| - // Copy the response info, because trans goes away. |
| - response = *trans->GetResponseInfo(); |
| + SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| + ASSERT_TRUE(stream != NULL); |
| + ASSERT_TRUE(stream->stream() != NULL); |
| + EXPECT_EQ(0, stream->stream()->send_window_size()); |
| - VerifyStreamsClosed(helper); |
| + // All the body data should have been read. |
| + // TODO(satorux): This is because of the weirdness in reading the request |
| + // body in OnSendBodyComplete(). See crbug.com/113107. |
| + EXPECT_TRUE(upload_data_stream.IsEOF()); |
| + // But the body is not yet fully sent (kUploadData is not yet sent) |
| + // since we're send-stalled. |
| + EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| - // Verify the SYN_REPLY. |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| - } |
| + data.RunFor(6); // Read in SETTINGS frame to unstall. |
| + rv = callback.WaitForResult(); |
| + helper.VerifyDataConsumed(); |
| + // If stream is NULL, that means it was unstalled and closed. |
| + EXPECT_TRUE(stream->stream() == NULL); |
| } |
| -TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| +// Test we correctly handle the case where the SETTINGS frame results in a |
| +// negative send window size. |
| +TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) { |
| + if (GetParam().protocol < kProtoSPDY3) |
| return; |
| - // Construct the request. |
| - scoped_ptr<SpdyFrame> req( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> req2( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req, 1), |
| - CreateMockWrite(*req2, 3), |
| - }; |
| + // Number of frames we need to send to zero out the window size: data |
| + // frames plus SYN_STREAM plus the last data frame; also we need another |
| + // data frame that we will send once the SETTING is received, therefore +3. |
| + size_t num_writes = kSpdyStreamInitialWindowSize / kMaxSpdyFrameChunkSize + 3; |
| - scoped_ptr<SpdyFrame> refused( |
| - spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM)); |
| - scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
| - scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*refused, 2), |
| - CreateMockRead(*resp, 4), |
| - CreateMockRead(*body, 5), |
| - MockRead(ASYNC, 0, 6) // EOF |
| - }; |
| + // Calculate last frame's size; 0 size data frame is legal. |
| + size_t last_frame_size = |
| + kSpdyStreamInitialWindowSize % kMaxSpdyFrameChunkSize; |
| - OrderedSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY, |
| - BoundNetLog(), GetParam(), NULL); |
| + // Construct content for a data frame of maximum size. |
| + std::string content(kMaxSpdyFrameChunkSize, 'a'); |
| - helper.RunPreTestSetup(); |
| - helper.AddData(&data); |
| + scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost( |
| + kRequestUrl, 1, kSpdyStreamInitialWindowSize + kUploadDataSize, |
| + LOWEST, NULL, 0)); |
| - HttpNetworkTransaction* trans = helper.trans(); |
| + // Full frames. |
| + scoped_ptr<SpdyFrame> body1( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), content.size(), false)); |
| - // Start the transaction with basic parameters. |
| - TestCompletionCallback callback; |
| - int rv = trans->Start( |
| - &CreateGetRequest(), callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - rv = callback.WaitForResult(); |
| - EXPECT_EQ(OK, rv); |
| + // Last frame to zero out the window size. |
| + scoped_ptr<SpdyFrame> body2( |
| + spdy_util_.ConstructSpdyBodyFrame( |
| + 1, content.c_str(), last_frame_size, false)); |
| - // Verify that we consumed all test data. |
| - EXPECT_TRUE(data.at_read_eof()) << "Read count: " |
| - << data.read_count() |
| - << " Read index: " |
| - << data.read_index(); |
| - EXPECT_TRUE(data.at_write_eof()) << "Write count: " |
| - << data.write_count() |
| - << " Write index: " |
| - << data.write_index(); |
| + // Data frame to be sent once SETTINGS frame is received. |
| + scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
| - // Verify the SYN_REPLY. |
| - HttpResponseInfo response = *trans->GetResponseInfo(); |
| - EXPECT_TRUE(response.headers.get() != NULL); |
| - EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine()); |
| -} |
| + // Fill in mock reads/writes. |
| + std::vector<MockRead> reads; |
| + std::vector<MockWrite> writes; |
| + size_t i = 0; |
| + writes.push_back(CreateMockWrite(*req, i++)); |
| + while (i < num_writes - 2) |
| + writes.push_back(CreateMockWrite(*body1, i++)); |
| + writes.push_back(CreateMockWrite(*body2, i++)); |
| -TEST_P(SpdyNetworkTransactionTest, OutOfOrderSynStream) { |
| - if (GetParam().protocol > kProtoSPDY3) |
| - return; |
| + // Construct read frame for SETTINGS that makes the send_window_size |
| + // negative. |
| + SettingsMap new_settings; |
| + new_settings[SETTINGS_INITIAL_WINDOW_SIZE] = |
| + SettingsFlagsAndValue( |
| + SETTINGS_FLAG_NONE, kSpdyStreamInitialWindowSize / 2); |
| + scoped_ptr<SpdyFrame> settings_frame_small( |
| + spdy_util_.ConstructSpdySettings(new_settings)); |
| + // Construct read frames for WINDOW_UPDATE that makes the send_window_size |
| + // positive. |
| + scoped_ptr<SpdyFrame> session_window_update_init_size( |
| + spdy_util_.ConstructSpdyWindowUpdate(0, kSpdyStreamInitialWindowSize)); |
| + scoped_ptr<SpdyFrame> window_update_init_size( |
| + spdy_util_.ConstructSpdyWindowUpdate(1, kSpdyStreamInitialWindowSize)); |
| - // This first request will start to establish the SpdySession. |
| - // Then we will start the second (MEDIUM priority) and then third |
| - // (HIGHEST priority) request in such a way that the third will actually |
| - // start before the second, causing the second to be numbered differently |
| - // than the order they were created. |
| - scoped_ptr<SpdyFrame> req1( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
| - scoped_ptr<SpdyFrame> req2( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, HIGHEST, true)); |
| - scoped_ptr<SpdyFrame> req3( |
| - spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, MEDIUM, true)); |
| - MockWrite writes[] = { |
| - CreateMockWrite(*req1, 0), |
| - CreateMockWrite(*req2, 3), |
| - CreateMockWrite(*req3, 4), |
| - }; |
| + reads.push_back(CreateMockRead(*settings_frame_small, i++)); |
| - 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)); |
| - scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5)); |
| - scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true)); |
| - MockRead reads[] = { |
| - CreateMockRead(*resp1, 1), |
| - CreateMockRead(*body1, 2), |
| - CreateMockRead(*resp2, 5), |
| - CreateMockRead(*body2, 6), |
| - CreateMockRead(*resp3, 7), |
| - CreateMockRead(*body3, 8), |
| - MockRead(ASYNC, 0, 9) // EOF |
| - }; |
| + if (GetParam().protocol >= kProtoSPDY3) |
| + reads.push_back(CreateMockRead(*session_window_update_init_size, i++)); |
| - DeterministicSocketData data(reads, arraysize(reads), |
| - writes, arraysize(writes)); |
| - NormalSpdyTransactionHelper helper(CreateGetRequest(), LOWEST, |
| + reads.push_back(CreateMockRead(*window_update_init_size, i++)); |
| + |
| + writes.push_back(CreateMockWrite(*body3, i++)); |
| + |
| + scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0)); |
| + reads.push_back(CreateMockRead(*reply, i++)); |
| + reads.push_back(CreateMockRead(*body2, i++)); |
| + reads.push_back(CreateMockRead(*body3, i++)); |
| + reads.push_back(MockRead(ASYNC, 0, i++)); // EOF |
| + |
| + // Force all writes to happen before any read, last write will not |
| + // actually queue a frame, due to window size being 0. |
| + DeterministicSocketData data(vector_as_array(&reads), reads.size(), |
| + vector_as_array(&writes), writes.size()); |
| + |
| + ScopedVector<UploadElementReader> element_readers; |
| + std::string upload_data_string(kSpdyStreamInitialWindowSize, 'a'); |
| + upload_data_string.append(kUploadData, kUploadDataSize); |
| + element_readers.push_back(new UploadBytesElementReader( |
| + upload_data_string.c_str(), upload_data_string.size())); |
| + UploadDataStream upload_data_stream(&element_readers, 0); |
| + |
| + HttpRequestInfo request; |
| + request.method = "POST"; |
| + request.url = GURL("http://www.google.com/"); |
| + request.upload_data_stream = &upload_data_stream; |
| + NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, |
| BoundNetLog(), GetParam(), NULL); |
| helper.SetDeterministic(); |
| helper.RunPreTestSetup(); |
| helper.AddDeterministicData(&data); |
| - // Start the first transaction to set up the SpdySession |
| HttpNetworkTransaction* trans = helper.trans(); |
| - TestCompletionCallback callback; |
| - HttpRequestInfo info1 = CreateGetRequest(); |
| - int rv = trans->Start(&info1, callback.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - |
| - // Run the message loop, but do not allow the write to complete. |
| - // This leaves the SpdySession with a write pending, which prevents |
| - // SpdySession from attempting subsequent writes until this write completes. |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - // Now, start both new transactions |
| - HttpRequestInfo info2 = CreateGetRequest(); |
| - TestCompletionCallback callback2; |
| - scoped_ptr<HttpNetworkTransaction> trans2( |
| - new HttpNetworkTransaction(MEDIUM, helper.session().get())); |
| - rv = trans2->Start(&info2, callback2.callback(), BoundNetLog()); |
| + TestCompletionCallback callback; |
| + int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog()); |
| EXPECT_EQ(ERR_IO_PENDING, rv); |
| - base::MessageLoop::current()->RunUntilIdle(); |
| - HttpRequestInfo info3 = CreateGetRequest(); |
| - TestCompletionCallback callback3; |
| - scoped_ptr<HttpNetworkTransaction> trans3( |
| - new HttpNetworkTransaction(HIGHEST, helper.session().get())); |
| - rv = trans3->Start(&info3, callback3.callback(), BoundNetLog()); |
| - EXPECT_EQ(ERR_IO_PENDING, rv); |
| - base::MessageLoop::current()->RunUntilIdle(); |
| + data.RunFor(num_writes - 1); // Write as much as we can. |
| - // We now have two SYN_STREAM frames queued up which will be |
| - // dequeued only once the first write completes, which we |
| - // now allow to happen. |
| - data.RunFor(2); |
| - EXPECT_EQ(OK, callback.WaitForResult()); |
| + SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get()); |
| + ASSERT_TRUE(stream != NULL); |
| + ASSERT_TRUE(stream->stream() != NULL); |
| + EXPECT_EQ(0, stream->stream()->send_window_size()); |
| - // And now we can allow everything else to run to completion. |
| - data.SetStop(10); |
| - data.Run(); |
| - EXPECT_EQ(OK, callback2.WaitForResult()); |
| - EXPECT_EQ(OK, callback3.WaitForResult()); |
| + // All the body data should have been read. |
| + // TODO(satorux): This is because of the weirdness in reading the request |
| + // body in OnSendBodyComplete(). See crbug.com/113107. |
| + EXPECT_TRUE(upload_data_stream.IsEOF()); |
| + // But the body is not yet fully sent (kUploadData is not yet sent) |
| + // since we're send-stalled. |
| + EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control()); |
| + // Read in WINDOW_UPDATE or SETTINGS frame. |
| + data.RunFor((GetParam().protocol >= kProtoSPDY31) ? 8 : 7); |
| + rv = callback.WaitForResult(); |
| helper.VerifyDataConsumed(); |
| } |
