diff options
Diffstat (limited to 'chromium/net/quic/quic_data_stream_test.cc')
| -rw-r--r-- | chromium/net/quic/quic_data_stream_test.cc | 615 |
1 files changed, 369 insertions, 246 deletions
diff --git a/chromium/net/quic/quic_data_stream_test.cc b/chromium/net/quic/quic_data_stream_test.cc index 551ef445715..b72f3cebf06 100644 --- a/chromium/net/quic/quic_data_stream_test.cc +++ b/chromium/net/quic/quic_data_stream_test.cc @@ -6,28 +6,30 @@ #include "net/quic/quic_ack_notifier.h" #include "net/quic/quic_connection.h" -#include "net/quic/quic_spdy_compressor.h" -#include "net/quic/quic_spdy_decompressor.h" +#include "net/quic/quic_flags.h" #include "net/quic/quic_utils.h" +#include "net/quic/quic_write_blocked_list.h" #include "net/quic/spdy_utils.h" +#include "net/quic/test_tools/quic_flow_controller_peer.h" #include "net/quic/test_tools/quic_session_peer.h" #include "net/quic/test_tools/quic_test_utils.h" +#include "net/quic/test_tools/reliable_quic_stream_peer.h" +#include "net/test/gtest_util.h" #include "testing/gmock/include/gmock/gmock.h" using base::StringPiece; using std::min; -using testing::_; +using testing::AnyNumber; using testing::InSequence; using testing::Return; using testing::SaveArg; -using testing::StrEq; using testing::StrictMock; +using testing::_; namespace net { namespace test { namespace { -const QuicGuid kStreamId = 3; const bool kIsServer = true; const bool kShouldProcessData = true; @@ -57,7 +59,7 @@ class TestStream : public QuicDataStream { string data_; }; -class QuicDataStreamTest : public ::testing::TestWithParam<bool> { +class QuicDataStreamTest : public ::testing::TestWithParam<QuicVersion> { public: QuicDataStreamTest() { headers_[":host"] = "www.google.com"; @@ -90,16 +92,15 @@ class QuicDataStreamTest : public ::testing::TestWithParam<bool> { } void Initialize(bool stream_should_process_data) { - connection_ = new StrictMock<MockConnection>(kIsServer); - session_.reset(new StrictMock<MockSession>(connection_)); - stream_.reset(new TestStream(kStreamId, session_.get(), - stream_should_process_data)); - stream2_.reset(new TestStream(kStreamId + 2, session_.get(), + connection_ = new testing::StrictMock<MockConnection>( + kIsServer, SupportedVersions(GetParam())); + session_.reset(new testing::StrictMock<MockSession>(connection_)); + stream_.reset(new TestStream(kClientDataStreamId1, session_.get(), stream_should_process_data)); - compressor_.reset(new QuicSpdyCompressor()); - decompressor_.reset(new QuicSpdyDecompressor); + stream2_.reset(new TestStream(kClientDataStreamId2, session_.get(), + stream_should_process_data)); write_blocked_list_ = - QuicSessionPeer::GetWriteblockedStreams(session_.get()); + QuicSessionPeer::GetWriteBlockedStreams(session_.get()); } protected: @@ -107,172 +108,160 @@ class QuicDataStreamTest : public ::testing::TestWithParam<bool> { scoped_ptr<MockSession> session_; scoped_ptr<TestStream> stream_; scoped_ptr<TestStream> stream2_; - scoped_ptr<QuicSpdyCompressor> compressor_; - scoped_ptr<QuicSpdyDecompressor> decompressor_; SpdyHeaderBlock headers_; - WriteBlockedList<QuicStreamId>* write_blocked_list_; + QuicWriteBlockedList* write_blocked_list_; }; -TEST_F(QuicDataStreamTest, ProcessHeaders) { - Initialize(kShouldProcessData); - - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers)); - - stream_->OnStreamFrame(frame); - EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_), stream_->data()); - EXPECT_EQ(QuicUtils::HighestPriority(), stream_->EffectivePriority()); -} +INSTANTIATE_TEST_CASE_P(Tests, QuicDataStreamTest, + ::testing::ValuesIn(QuicSupportedVersions())); -TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidHeaderId) { +TEST_P(QuicDataStreamTest, ProcessHeaders) { Initialize(kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - compressed_headers[4] = '\xFF'; // Illegal header id. - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers)); - - EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID)); - stream_->OnStreamFrame(frame); -} - -TEST_F(QuicDataStreamTest, ProcessHeadersWithInvalidPriority) { - Initialize(kShouldProcessData); - - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - compressed_headers[0] = '\xFF'; // Illegal priority. - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(compressed_headers)); - - EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_PRIORITY)); - stream_->OnStreamFrame(frame); + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + stream_->OnStreamHeadersPriority(QuicUtils::HighestPriority()); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + EXPECT_EQ(QuicUtils::HighestPriority(), stream_->EffectivePriority()); + EXPECT_EQ(headers, stream_->data()); + EXPECT_FALSE(stream_->IsDoneReading()); } -TEST_F(QuicDataStreamTest, ProcessHeadersAndBody) { +TEST_P(QuicDataStreamTest, ProcessHeadersAndBody) { Initialize(kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); string body = "this is the body"; - string data = compressed_headers + body; - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data)); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame); - EXPECT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body, - stream_->data()); -} -TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyFragments) { - Initialize(kShouldProcessData); + EXPECT_EQ(headers + body, stream_->data()); +} - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::LowestPriority(), headers_); +TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragments) { + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); string body = "this is the body"; - string data = compressed_headers + body; - for (size_t fragment_size = 1; fragment_size < data.size(); ++fragment_size) { + for (size_t fragment_size = 1; fragment_size < body.size(); + ++fragment_size) { Initialize(kShouldProcessData); - for (size_t offset = 0; offset < data.size(); offset += fragment_size) { - size_t remaining_data = data.length() - offset; - StringPiece fragment(data.data() + offset, + for (size_t offset = 0; offset < headers.size(); + offset += fragment_size) { + size_t remaining_data = headers.size() - offset; + StringPiece fragment(headers.data() + offset, min(fragment_size, remaining_data)); - QuicStreamFrame frame(kStreamId, false, offset, MakeIOVector(fragment)); - + stream_->OnStreamHeaders(fragment); + } + stream_->OnStreamHeadersComplete(false, headers.size()); + for (size_t offset = 0; offset < body.size(); offset += fragment_size) { + size_t remaining_data = body.size() - offset; + StringPiece fragment(body.data() + offset, + min(fragment_size, remaining_data)); + QuicStreamFrame frame(kClientDataStreamId1, false, offset, + MakeIOVector(fragment)); stream_->OnStreamFrame(frame); } - ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body, + ASSERT_EQ(headers + body, stream_->data()) << "fragment_size: " << fragment_size; } +} - for (size_t split_point = 1; split_point < data.size() - 1; ++split_point) { +TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyFragmentsSplit) { + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + string body = "this is the body"; + + for (size_t split_point = 1; split_point < body.size() - 1; ++split_point) { Initialize(kShouldProcessData); + StringPiece headers1(headers.data(), split_point); + stream_->OnStreamHeaders(headers1); + + StringPiece headers2(headers.data() + split_point, + headers.size() - split_point); + stream_->OnStreamHeaders(headers2); + stream_->OnStreamHeadersComplete(false, headers.size()); - StringPiece fragment1(data.data(), split_point); - QuicStreamFrame frame1(kStreamId, false, 0, MakeIOVector(fragment1)); + StringPiece fragment1(body.data(), split_point); + QuicStreamFrame frame1(kClientDataStreamId1, false, 0, + MakeIOVector(fragment1)); stream_->OnStreamFrame(frame1); - StringPiece fragment2(data.data() + split_point, data.size() - split_point); - QuicStreamFrame frame2( - kStreamId, false, split_point, MakeIOVector(fragment2)); + StringPiece fragment2(body.data() + split_point, + body.size() - split_point); + QuicStreamFrame frame2(kClientDataStreamId1, false, split_point, + MakeIOVector(fragment2)); stream_->OnStreamFrame(frame2); - ASSERT_EQ(SpdyUtils::SerializeUncompressedHeaders(headers_) + body, + ASSERT_EQ(headers + body, stream_->data()) << "split_point: " << split_point; } - EXPECT_EQ(QuicUtils::LowestPriority(), stream_->EffectivePriority()); } -TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyReadv) { +TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyReadv) { Initialize(!kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); string body = "this is the body"; - string data = compressed_headers + body; - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data)); - string uncompressed_headers = - SpdyUtils::SerializeUncompressedHeaders(headers_); - string uncompressed_data = uncompressed_headers + body; + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame); - EXPECT_EQ(uncompressed_headers, stream_->data()); char buffer[2048]; - ASSERT_LT(data.length(), arraysize(buffer)); + ASSERT_LT(headers.length() + body.length(), arraysize(buffer)); struct iovec vec; vec.iov_base = buffer; vec.iov_len = arraysize(buffer); size_t bytes_read = stream_->Readv(&vec, 1); - EXPECT_EQ(uncompressed_headers.length(), bytes_read); - EXPECT_EQ(uncompressed_headers, string(buffer, bytes_read)); + EXPECT_EQ(headers.length(), bytes_read); + EXPECT_EQ(headers, string(buffer, bytes_read)); bytes_read = stream_->Readv(&vec, 1); EXPECT_EQ(body.length(), bytes_read); EXPECT_EQ(body, string(buffer, bytes_read)); } -TEST_F(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) { +TEST_P(QuicDataStreamTest, ProcessHeadersAndBodyIncrementalReadv) { Initialize(!kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); string body = "this is the body"; - string data = compressed_headers + body; - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data)); - string uncompressed_headers = - SpdyUtils::SerializeUncompressedHeaders(headers_); - string uncompressed_data = uncompressed_headers + body; - + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame); - EXPECT_EQ(uncompressed_headers, stream_->data()); char buffer[1]; struct iovec vec; vec.iov_base = buffer; vec.iov_len = arraysize(buffer); - for (size_t i = 0; i < uncompressed_data.length(); ++i) { + + string data = headers + body; + for (size_t i = 0; i < data.length(); ++i) { size_t bytes_read = stream_->Readv(&vec, 1); ASSERT_EQ(1u, bytes_read); - EXPECT_EQ(uncompressed_data.data()[i], buffer[0]); + EXPECT_EQ(data.data()[i], buffer[0]); } } -TEST_F(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) { +TEST_P(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) { Initialize(!kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); string body = "this is the body"; - string data = compressed_headers + body; - QuicStreamFrame frame(kStreamId, false, 0, MakeIOVector(data)); - string uncompressed_headers = - SpdyUtils::SerializeUncompressedHeaders(headers_); - string uncompressed_data = uncompressed_headers + body; - + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame); - EXPECT_EQ(uncompressed_headers, stream_->data()); char buffer1[1]; char buffer2[1]; @@ -281,168 +270,302 @@ TEST_F(QuicDataStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) { vec[0].iov_len = arraysize(buffer1); vec[1].iov_base = buffer2; vec[1].iov_len = arraysize(buffer2); - for (size_t i = 0; i < uncompressed_data.length(); i += 2) { + string data = headers + body; + for (size_t i = 0; i < data.length(); i += 2) { size_t bytes_read = stream_->Readv(vec, 2); ASSERT_EQ(2u, bytes_read) << i; - ASSERT_EQ(uncompressed_data.data()[i], buffer1[0]) << i; - ASSERT_EQ(uncompressed_data.data()[i + 1], buffer2[0]) << i; + ASSERT_EQ(data.data()[i], buffer1[0]) << i; + ASSERT_EQ(data.data()[i + 1], buffer2[0]) << i; } } -TEST_F(QuicDataStreamTest, ProcessCorruptHeadersEarly) { +TEST_P(QuicDataStreamTest, StreamFlowControlBlocked) { + // Tests that we send a BLOCKED frame to the peer when we attempt to write, + // but are flow control blocked. + if (GetParam() < QUIC_VERSION_17) { + return; + } + ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true); + Initialize(kShouldProcessData); - string compressed_headers1 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame1( - stream_->id(), false, 0, MakeIOVector(compressed_headers1)); - string decompressed_headers1 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - headers_["content-type"] = "text/plain"; - string compressed_headers2 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - // Corrupt the compressed data. - compressed_headers2[compressed_headers2.length() - 1] ^= 0xA1; - QuicStreamFrame frame2( - stream2_->id(), false, 0, MakeIOVector(compressed_headers2)); - string decompressed_headers2 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - // Deliver frame2 to stream2 out of order. The decompressor is not - // available yet, so no data will be processed. The compressed data - // will be buffered until OnDecompressorAvailable() is called - // to process it. - stream2_->OnStreamFrame(frame2); - EXPECT_EQ("", stream2_->data()); + // Set a small flow control limit. + const uint64 kWindow = 36; + QuicFlowControllerPeer::SetSendWindowOffset(stream_->flow_controller(), + kWindow); + EXPECT_EQ(kWindow, QuicFlowControllerPeer::SendWindowOffset( + stream_->flow_controller())); + + // Try to send more data than the flow control limit allows. + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + string body; + const uint64 kOverflow = 15; + GenerateBody(&body, kWindow + kOverflow); + + EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)); + EXPECT_CALL(*session_, WritevData(kClientDataStreamId1, _, _, _, _, _)) + .WillOnce(Return(QuicConsumedData(kWindow, true))); + stream_->WriteOrBufferData(body, false, NULL); + + // Should have sent as much as possible, resulting in no send window left. + EXPECT_EQ(0u, + QuicFlowControllerPeer::SendWindowSize(stream_->flow_controller())); + + // And we should have queued the overflowed data. + EXPECT_EQ(kOverflow, + ReliableQuicStreamPeer::SizeOfQueuedData(stream_.get())); +} + +TEST_P(QuicDataStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) { + // The flow control receive window decreases whenever we add new bytes to the + // sequencer, whether they are consumed immediately or buffered. However we + // only send WINDOW_UPDATE frames based on increasing number of bytes + // consumed. + if (GetParam() < QUIC_VERSION_17) { + return; + } + ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true); + + // Don't process data - it will be buffered instead. + Initialize(!kShouldProcessData); - // Now deliver frame1 to stream1. The decompressor is available so - // the data will be processed, and the decompressor will become - // available for stream2. + // Expect no WINDOW_UPDATE frames to be sent. + EXPECT_CALL(*connection_, SendWindowUpdate(_, _)).Times(0); + + // Set a small flow control receive window. + const uint64 kWindow = 36; + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), + kWindow); + EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset( + stream_->flow_controller())); + + // Stream receives enough data to fill a fraction of the receive window. + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + string body; + GenerateBody(&body, kWindow / 3); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + + QuicStreamFrame frame1(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame1); - EXPECT_EQ(decompressed_headers1, stream_->data()); - - // Verify that the decompressor is available, and inform stream2 - // that it can now decompress the buffered compressed data. Since - // the compressed data is corrupt, the stream will shutdown the session. - EXPECT_EQ(2u, session_->decompressor()->current_header_id()); - EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE)); - stream2_->OnDecompressorAvailable(); - EXPECT_EQ("", stream2_->data()); + EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize( + stream_->flow_controller())); + + // Now receive another frame which results in the receive window being over + // half full. This should all be buffered, decreasing the receive window but + // not sending WINDOW_UPDATE. + QuicStreamFrame frame2(kClientDataStreamId1, false, kWindow / 3, + MakeIOVector(body)); + stream_->OnStreamFrame(frame2); + EXPECT_EQ( + kWindow - (2 * kWindow / 3), + QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller())); } -TEST_F(QuicDataStreamTest, ProcessPartialHeadersEarly) { - Initialize(kShouldProcessData); +TEST_P(QuicDataStreamTest, StreamFlowControlWindowUpdate) { + // Tests that on receipt of data, the stream updates its receive window offset + // appropriately, and sends WINDOW_UPDATE frames when its receive window drops + // too low. + if (GetParam() < QUIC_VERSION_17) { + return; + } + ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true); - string compressed_headers1 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame1( - stream_->id(), false, 0, MakeIOVector(compressed_headers1)); - string decompressed_headers1 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - headers_["content-type"] = "text/plain"; - string compressed_headers2 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - string partial_compressed_headers = - compressed_headers2.substr(0, compressed_headers2.length() / 2); - QuicStreamFrame frame2( - stream2_->id(), false, 0, MakeIOVector(partial_compressed_headers)); - string decompressed_headers2 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - // Deliver frame2 to stream2 out of order. The decompressor is not - // available yet, so no data will be processed. The compressed data - // will be buffered until OnDecompressorAvailable() is called - // to process it. - stream2_->OnStreamFrame(frame2); - EXPECT_EQ("", stream2_->data()); + Initialize(kShouldProcessData); - // Now deliver frame1 to stream1. The decompressor is available so - // the data will be processed, and the decompressor will become - // available for stream2. + // Set a small flow control limit. + const uint64 kWindow = 36; + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), + kWindow); + EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset( + stream_->flow_controller())); + + // Stream receives enough data to fill a fraction of the receive window. + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + string body; + GenerateBody(&body, kWindow / 3); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + + QuicStreamFrame frame1(kClientDataStreamId1, false, 0, MakeIOVector(body)); stream_->OnStreamFrame(frame1); - EXPECT_EQ(decompressed_headers1, stream_->data()); - - // Verify that the decompressor is available, and inform stream2 - // that it can now decompress the buffered compressed data. Since - // the compressed data is incomplete it will not be passed to - // the stream. - EXPECT_EQ(2u, session_->decompressor()->current_header_id()); - stream2_->OnDecompressorAvailable(); - EXPECT_EQ("", stream2_->data()); - - // Now send remaining data and verify that we have now received the - // compressed headers. - string remaining_compressed_headers = - compressed_headers2.substr(partial_compressed_headers.length()); - - QuicStreamFrame frame3(stream2_->id(), false, - partial_compressed_headers.length(), - MakeIOVector(remaining_compressed_headers)); - stream2_->OnStreamFrame(frame3); - EXPECT_EQ(decompressed_headers2, stream2_->data()); + EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize( + stream_->flow_controller())); + + // Now receive another frame which results in the receive window being over + // half full. This will trigger the stream to increase its receive window + // offset and send a WINDOW_UPDATE. The result will be again an available + // window of kWindow bytes. + QuicStreamFrame frame2(kClientDataStreamId1, false, kWindow / 3, + MakeIOVector(body)); + EXPECT_CALL(*connection_, + SendWindowUpdate(kClientDataStreamId1, + QuicFlowControllerPeer::ReceiveWindowOffset( + stream_->flow_controller()) + + 2 * kWindow / 3)); + stream_->OnStreamFrame(frame2); + EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize( + stream_->flow_controller())); } -TEST_F(QuicDataStreamTest, ProcessHeadersEarly) { +TEST_P(QuicDataStreamTest, ConnectionFlowControlWindowUpdate) { + // Tests that on receipt of data, the connection updates its receive window + // offset appropriately, and sends WINDOW_UPDATE frames when its receive + // window drops too low. + if (GetParam() < QUIC_VERSION_19) { + return; + } + ValueRestore<bool> old_flag2(&FLAGS_enable_quic_stream_flow_control_2, true); + ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2, + true); + Initialize(kShouldProcessData); - string compressed_headers1 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame1( - stream_->id(), false, 0, MakeIOVector(compressed_headers1)); - string decompressed_headers1 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - headers_["content-type"] = "text/plain"; - string compressed_headers2 = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame2( - stream2_->id(), false, 0, MakeIOVector(compressed_headers2)); - string decompressed_headers2 = - SpdyUtils::SerializeUncompressedHeaders(headers_); - - // Deliver frame2 to stream2 out of order. The decompressor is not - // available yet, so no data will be processed. The compressed data - // will be buffered until OnDecompressorAvailable() is called - // to process it. + // Set a small flow control limit for streams and connection. + const uint64 kWindow = 36; + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetReceiveWindowOffset(stream2_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetMaxReceiveWindow(stream2_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(), + kWindow); + QuicFlowControllerPeer::SetMaxReceiveWindow(session_->flow_controller(), + kWindow); + + // Supply headers to both streams so that they are happy to receive data. + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + stream_->OnStreamHeaders(headers); + stream_->OnStreamHeadersComplete(false, headers.size()); + stream2_->OnStreamHeaders(headers); + stream2_->OnStreamHeadersComplete(false, headers.size()); + + // Each stream gets a quarter window of data. This should not trigger a + // WINDOW_UPDATE for either stream, nor for the connection. + string body; + GenerateBody(&body, kWindow / 4); + QuicStreamFrame frame1(kClientDataStreamId1, false, 0, MakeIOVector(body)); + stream_->OnStreamFrame(frame1); + QuicStreamFrame frame2(kClientDataStreamId2, false, 0, MakeIOVector(body)); stream2_->OnStreamFrame(frame2); - EXPECT_EQ("", stream2_->data()); - // Now deliver frame1 to stream1. The decompressor is available so - // the data will be processed, and the decompressor will become - // available for stream2. - stream_->OnStreamFrame(frame1); - EXPECT_EQ(decompressed_headers1, stream_->data()); + // Now receive a further single byte on one stream - again this does not + // trigger a stream WINDOW_UPDATE, but now the connection flow control window + // is over half full and thus a connection WINDOW_UPDATE is sent. + EXPECT_CALL(*connection_, SendWindowUpdate(kClientDataStreamId1, _)).Times(0); + EXPECT_CALL(*connection_, SendWindowUpdate(kClientDataStreamId2, _)).Times(0); + EXPECT_CALL(*connection_, + SendWindowUpdate(0, QuicFlowControllerPeer::ReceiveWindowOffset( + session_->flow_controller()) + + 1 + kWindow / 2)); + QuicStreamFrame frame3(kClientDataStreamId1, false, (kWindow / 4), + MakeIOVector("a")); + stream_->OnStreamFrame(frame3); +} + +TEST_P(QuicDataStreamTest, StreamFlowControlViolation) { + // Tests that on if the peer sends too much data (i.e. violates the flow + // control protocol), then we terminate the connection. + if (GetParam() < QUIC_VERSION_17) { + return; + } + ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true); + + // Stream should not process data, so that data gets buffered in the + // sequencer, triggering flow control limits. + Initialize(!kShouldProcessData); - // Verify that the decompressor is available, and inform stream2 - // that it can now decompress the buffered compressed data. - EXPECT_EQ(2u, session_->decompressor()->current_header_id()); - stream2_->OnDecompressorAvailable(); - EXPECT_EQ(decompressed_headers2, stream2_->data()); + // Set a small flow control limit. + const uint64 kWindow = 50; + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), + kWindow); + + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + + // Receive data to overflow the window, violating flow control. + string body; + GenerateBody(&body, kWindow + 1); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); + EXPECT_CALL(*connection_, + SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA)); + stream_->OnStreamFrame(frame); } -TEST_F(QuicDataStreamTest, ProcessHeadersDelay) { +TEST_P(QuicDataStreamTest, ConnectionFlowControlViolation) { + // Tests that on if the peer sends too much data (i.e. violates the flow + // control protocol), at the connection level (rather than the stream level) + // then we terminate the connection. + if (GetParam() < QUIC_VERSION_19) { + return; + } + ValueRestore<bool> old_flag2(&FLAGS_enable_quic_stream_flow_control_2, true); + ValueRestore<bool> old_flag(&FLAGS_enable_quic_connection_flow_control_2, + true); + + // Stream should not process data, so that data gets buffered in the + // sequencer, triggering flow control limits. Initialize(!kShouldProcessData); - string compressed_headers = compressor_->CompressHeadersWithPriority( - QuicUtils::HighestPriority(), headers_); - QuicStreamFrame frame1( - stream_->id(), false, 0, MakeIOVector(compressed_headers)); - string decompressed_headers = - SpdyUtils::SerializeUncompressedHeaders(headers_); + // Set a small flow control window on streams, and connection. + const uint64 kStreamWindow = 50; + const uint64 kConnectionWindow = 10; + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), + kStreamWindow); + QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(), + kConnectionWindow); + + string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); + stream_->OnStreamHeaders(headers); + EXPECT_EQ(headers, stream_->data()); + stream_->OnStreamHeadersComplete(false, headers.size()); + + // Send enough data to overflow the connection level flow control window. + string body; + GenerateBody(&body, kConnectionWindow + 1); + EXPECT_LT(body.size(), kStreamWindow); + QuicStreamFrame frame(kClientDataStreamId1, false, 0, MakeIOVector(body)); + + EXPECT_CALL(*connection_, + SendConnectionClose(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA)); + stream_->OnStreamFrame(frame); +} - // Send the headers to the stream and verify they were decompressed. - stream_->OnStreamFrame(frame1); - EXPECT_EQ(2u, session_->decompressor()->current_header_id()); - - // Verify that we are now able to handle the body data, - // even though the stream has not processed the headers. - EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_HEADER_ID)) - .Times(0); - QuicStreamFrame frame2(stream_->id(), false, compressed_headers.length(), - MakeIOVector("body data")); - stream_->OnStreamFrame(frame2); +TEST_P(QuicDataStreamTest, StreamFlowControlFinNotBlocked) { + // An attempt to write a FIN with no data should not be flow control blocked, + // even if the send window is 0. + if (GetParam() < QUIC_VERSION_17) { + return; + } + ValueRestore<bool> old_flag(&FLAGS_enable_quic_stream_flow_control_2, true); + + Initialize(kShouldProcessData); + + // Set a flow control limit of zero. + QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), 0); + EXPECT_EQ(0u, QuicFlowControllerPeer::ReceiveWindowOffset( + stream_->flow_controller())); + + // Send a frame with a FIN but no data. This should not be blocked. + string body = ""; + bool fin = true; + + EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0); + EXPECT_CALL(*session_, WritevData(kClientDataStreamId1, _, _, _, _, _)) + .WillOnce(Return(QuicConsumedData(0, fin))); + + stream_->WriteOrBufferData(body, fin, NULL); } } // namespace |