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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/core/quic_spdy_stream_test.cc

Issue 2462823002: Deletes dead code. (Closed)
Patch Set: Updated patchset dependency Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « net/quic/core/quic_spdy_stream.cc ('k') | net/quic/test_tools/mock_quic_spdy_client_stream.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/core/quic_spdy_stream_test.cc
diff --git a/net/quic/core/quic_spdy_stream_test.cc b/net/quic/core/quic_spdy_stream_test.cc
index e12f9e021434c6f4846342f5e19ffefa76c4abdf..9d14ecb4dff242fe4024d6a63141b006bf544b4a 100644
--- a/net/quic/core/quic_spdy_stream_test.cc
+++ b/net/quic/core/quic_spdy_stream_test.cc
@@ -110,6 +110,12 @@ class QuicSpdyStreamTest : public ::testing::TestWithParam<QuicVersion> {
session_->ActivateStream(base::WrapUnique(stream2_));
}
+ QuicHeaderList ProcessHeaders(bool fin, const SpdyHeaderBlock& headers) {
+ QuicHeaderList h = AsHeaderList(headers);
+ stream_->OnStreamHeaderList(fin, h.uncompressed_header_bytes(), h);
+ return h;
+ }
+
protected:
QuicFlagSaver flags_; // Save/restore all QUIC flag values.
MockQuicConnectionHelper helper_;
@@ -128,38 +134,17 @@ INSTANTIATE_TEST_CASE_P(Tests,
QuicSpdyStreamTest,
::testing::ValuesIn(AllSupportedVersions()));
-TEST_P(QuicSpdyStreamTest, ProcessHeaders) {
- Initialize(kShouldProcessData);
-
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeadersPriority(kV3HighestPriority);
- stream_->OnStreamHeaders(headers);
- EXPECT_EQ("", stream_->data());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- stream_->OnStreamHeadersComplete(false, headers.size());
- EXPECT_EQ(kV3HighestPriority, stream_->priority());
- EXPECT_EQ("", stream_->data());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- EXPECT_FALSE(stream_->IsDoneReading());
-}
-
TEST_P(QuicSpdyStreamTest, ProcessHeaderList) {
Initialize(kShouldProcessData);
- size_t total_bytes = 0;
- QuicHeaderList headers;
- for (auto p : headers_) {
- headers.OnHeader(p.first, p.second);
- total_bytes += p.first.size() + p.second.size();
- }
stream_->OnStreamHeadersPriority(kV3HighestPriority);
- stream_->OnStreamHeaderList(false, total_bytes, headers);
+ ProcessHeaders(false, headers_);
EXPECT_EQ("", stream_->data());
EXPECT_FALSE(stream_->header_list().empty());
EXPECT_FALSE(stream_->IsDoneReading());
}
-TEST_P(QuicSpdyStreamTest, ProcessEmptyHeaderList) {
+TEST_P(QuicSpdyStreamTest, ProcessTooLargeHeaderList) {
FLAGS_quic_limit_uncompressed_headers = true;
Initialize(kShouldProcessData);
@@ -172,22 +157,6 @@ TEST_P(QuicSpdyStreamTest, ProcessEmptyHeaderList) {
EXPECT_EQ(QUIC_HEADERS_TOO_LARGE, stream_->stream_error());
}
-TEST_P(QuicSpdyStreamTest, ProcessHeadersWithFin) {
- Initialize(kShouldProcessData);
-
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeadersPriority(kV3HighestPriority);
- stream_->OnStreamHeaders(headers);
- EXPECT_EQ("", stream_->data());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- stream_->OnStreamHeadersComplete(true, headers.size());
- EXPECT_EQ(kV3HighestPriority, stream_->priority());
- EXPECT_EQ("", stream_->data());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- EXPECT_FALSE(stream_->IsDoneReading());
- EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
-}
-
TEST_P(QuicSpdyStreamTest, ProcessHeaderListWithFin) {
Initialize(kShouldProcessData);
@@ -252,55 +221,37 @@ TEST_P(QuicSpdyStreamTest, ParseHeaderStatusCode) {
TEST_P(QuicSpdyStreamTest, MarkHeadersConsumed) {
Initialize(kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
+ QuicHeaderList headers = ProcessHeaders(false, headers_);
+ EXPECT_EQ(headers, stream_->header_list());
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
- EXPECT_EQ(headers, stream_->decompressed_headers());
-
- headers.erase(0, 10);
- stream_->MarkHeadersConsumed(10);
- EXPECT_EQ(headers, stream_->decompressed_headers());
-
- stream_->MarkHeadersConsumed(headers.length());
- EXPECT_EQ("", stream_->decompressed_headers());
+ stream_->ConsumeHeaderList();
+ EXPECT_EQ(QuicHeaderList(), stream_->header_list());
}
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBody) {
Initialize(kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- stream_->OnStreamHeaders(headers);
EXPECT_EQ("", stream_->data());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- stream_->OnStreamHeadersComplete(false, headers.size());
- EXPECT_EQ(headers, stream_->decompressed_headers());
- stream_->MarkHeadersConsumed(headers.length());
+ QuicHeaderList headers = ProcessHeaders(false, headers_);
+ EXPECT_EQ(headers, stream_->header_list());
+ stream_->ConsumeHeaderList();
QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame);
- EXPECT_EQ("", stream_->decompressed_headers());
+ EXPECT_EQ(QuicHeaderList(), stream_->header_list());
EXPECT_EQ(body, stream_->data());
}
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) {
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
for (size_t fragment_size = 1; fragment_size < body.size(); ++fragment_size) {
Initialize(kShouldProcessData);
- 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));
- stream_->OnStreamHeaders(fragment);
- }
- stream_->OnStreamHeadersComplete(false, headers.size());
- ASSERT_EQ(headers, stream_->decompressed_headers()) << "fragment_size: "
- << fragment_size;
- stream_->MarkHeadersConsumed(headers.length());
+ QuicHeaderList headers = ProcessHeaders(false, headers_);
+ ASSERT_EQ(headers, stream_->header_list());
+ stream_->ConsumeHeaderList();
for (size_t offset = 0; offset < body.size(); offset += fragment_size) {
size_t remaining_data = body.size() - offset;
StringPiece fragment(body.data() + offset,
@@ -314,21 +265,13 @@ TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) {
}
TEST_P(QuicSpdyStreamTest, 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());
- ASSERT_EQ(headers, stream_->decompressed_headers()) << "split_point: "
- << split_point;
- stream_->MarkHeadersConsumed(headers.length());
+ QuicHeaderList headers = ProcessHeaders(false, headers_);
+ ASSERT_EQ(headers, stream_->header_list());
+ stream_->ConsumeHeaderList();
StringPiece fragment1(body.data(), split_point);
QuicStreamFrame frame1(kClientDataStreamId1, false, 0,
@@ -347,14 +290,12 @@ TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragmentsSplit) {
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyReadv) {
Initialize(!kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame);
- stream_->MarkHeadersConsumed(headers.length());
+ stream_->ConsumeHeaderList();
char buffer[2048];
ASSERT_LT(body.length(), arraysize(buffer));
@@ -370,14 +311,12 @@ TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyReadv) {
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyMarkConsumed) {
Initialize(!kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame);
- stream_->MarkHeadersConsumed(headers.length());
+ stream_->ConsumeHeaderList();
struct iovec vec;
@@ -392,13 +331,11 @@ TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyMarkConsumed) {
TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
Initialize(!kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame);
- stream_->MarkHeadersConsumed(headers.length());
+ stream_->ConsumeHeaderList();
char buffer[1];
struct iovec vec;
@@ -415,13 +352,11 @@ TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyIncrementalReadv) {
TEST_P(QuicSpdyStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) {
Initialize(!kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
string body = "this is the body";
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame);
- stream_->MarkHeadersConsumed(headers.length());
+ stream_->ConsumeHeaderList();
char buffer1[1];
char buffer2[1];
@@ -492,11 +427,9 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
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);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame1);
@@ -530,12 +463,10 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlWindowUpdate) {
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);
- stream_->OnStreamHeadersComplete(false, headers.size());
- stream_->MarkHeadersConsumed(headers.length());
+ ProcessHeaders(false, headers_);
+ stream_->ConsumeHeaderList();
QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body));
stream_->OnStreamFrame(frame1);
@@ -580,13 +511,13 @@ TEST_P(QuicSpdyStreamTest, ConnectionFlowControlWindowUpdate) {
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());
- stream_->MarkHeadersConsumed(headers.length());
- stream2_->OnStreamHeaders(headers);
- stream2_->OnStreamHeadersComplete(false, headers.size());
- stream2_->MarkHeadersConsumed(headers.length());
+ auto headers = AsHeaderList(headers_);
+ stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+ headers);
+ stream_->ConsumeHeaderList();
+ stream2_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+ headers);
+ stream2_->ConsumeHeaderList();
// Each stream gets a quarter window of data. This should not trigger a
// WINDOW_UPDATE for either stream, nor for the connection.
@@ -624,9 +555,7 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlViolation) {
QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(),
kWindow);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
// Receive data to overflow the window, violating flow control.
string body;
@@ -639,9 +568,7 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlViolation) {
TEST_P(QuicSpdyStreamTest, TestHandlingQuicRstStreamNoError) {
Initialize(kShouldProcessData);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
stream_->OnStreamReset(
QuicRstStreamFrame(stream_->id(), QUIC_STREAM_NO_ERROR, 0));
@@ -666,9 +593,7 @@ TEST_P(QuicSpdyStreamTest, ConnectionFlowControlViolation) {
QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(),
kConnectionWindow);
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ ProcessHeaders(false, headers_);
// Send enough data to overflow the connection level flow control window.
string body;
@@ -703,35 +628,46 @@ TEST_P(QuicSpdyStreamTest, StreamFlowControlFinNotBlocked) {
stream_->WriteOrBufferData(body, fin, nullptr);
}
-TEST_P(QuicSpdyStreamTest, ReceivingTrailers) {
- // Test that receiving trailing headers from the peer works, and can be read
- // from the stream and consumed.
+TEST_P(QuicSpdyStreamTest, ReceivingTrailersViaHeaderList) {
+ // Test that receiving trailing headers from the peer via
+ // OnStreamHeaderList() works, and can be read from the stream and consumed.
Initialize(kShouldProcessData);
// Receive initial headers.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
- stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+ size_t total_bytes = 0;
+ QuicHeaderList headers;
+ for (const auto& p : headers_) {
+ headers.OnHeader(p.first, p.second);
+ total_bytes += p.first.size() + p.second.size();
+ }
+
+ stream_->OnStreamHeadersPriority(kV3HighestPriority);
+ stream_->OnStreamHeaderList(/*fin=*/false, total_bytes, headers);
+ stream_->ConsumeHeaderList();
// Receive trailing headers.
SpdyHeaderBlock trailers_block;
trailers_block["key1"] = "value1";
trailers_block["key2"] = "value2";
trailers_block["key3"] = "value3";
- trailers_block[kFinalOffsetHeaderKey] = "0";
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
- stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+ SpdyHeaderBlock trailers_block_with_final_offset = trailers_block.Clone();
+ trailers_block_with_final_offset[kFinalOffsetHeaderKey] = "0";
+ total_bytes = 0;
+ QuicHeaderList trailers;
+ for (const auto& p : trailers_block_with_final_offset) {
+ trailers.OnHeader(p.first, p.second);
+ total_bytes += p.first.size() + p.second.size();
+ }
+ stream_->OnStreamHeaderList(/*fin=*/true, total_bytes, trailers);
// The trailers should be decompressed, and readable from the stream.
EXPECT_TRUE(stream_->trailers_decompressed());
- const string decompressed_trailers = stream_->decompressed_trailers();
- EXPECT_EQ(trailers, decompressed_trailers);
+ EXPECT_EQ(trailers_block, stream_->received_trailers());
- // Consuming the trailers erases them from the stream.
- stream_->MarkTrailersConsumed(decompressed_trailers.size());
- EXPECT_EQ("", stream_->decompressed_trailers());
+ // IsDoneReading() returns false until trailers marked consumed.
+ EXPECT_FALSE(stream_->IsDoneReading());
+ stream_->MarkTrailersConsumed();
+ EXPECT_TRUE(stream_->IsDoneReading());
}
TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
@@ -739,10 +675,10 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
Initialize(kShouldProcessData);
// Receive initial headers.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
- stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+ auto headers = AsHeaderList(headers_);
+ stream_->OnStreamHeaderList(false, headers.uncompressed_header_bytes(),
+ headers);
+ stream_->ConsumeHeaderList();
const string body = "this is the body";
// Receive trailing headers, without kFinalOffsetHeaderKey.
@@ -750,8 +686,7 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
trailers_block["key1"] = "value1";
trailers_block["key2"] = "value2";
trailers_block["key3"] = "value3";
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
+ auto trailers = AsHeaderList(trailers_block);
// Verify that the trailers block didn't contain a final offset.
EXPECT_EQ("", trailers_block[kFinalOffsetHeaderKey].as_string());
@@ -760,7 +695,8 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) {
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
.Times(1);
- stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+ stream_->OnStreamHeaderList(/*fin=*/true,
+ trailers.uncompressed_header_bytes(), trailers);
}
TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) {
@@ -768,19 +704,19 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) {
Initialize(kShouldProcessData);
// Receive initial headers.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
+ auto headers = AsHeaderList(headers_);
+ stream_->OnStreamHeaderList(/*fin=*/false,
+ headers.uncompressed_header_bytes(), headers);
// Receive trailing headers with FIN deliberately set to false.
SpdyHeaderBlock trailers_block;
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
+ auto trailers = AsHeaderList(trailers_block);
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
.Times(1);
- stream_->OnStreamHeadersComplete(/*fin=*/false, trailers.size());
+ stream_->OnStreamHeaderList(/*fin=*/false,
+ trailers.uncompressed_header_bytes(), trailers);
}
TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterFin) {
@@ -788,19 +724,14 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterFin) {
Initialize(kShouldProcessData);
// Receive initial headers with FIN set.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(/*fin=*/true, headers.size());
+ ProcessHeaders(true, headers_);
// Receive trailing headers after FIN already received.
SpdyHeaderBlock trailers_block;
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
-
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
.Times(1);
- stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+ ProcessHeaders(true, trailers_block);
}
TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) {
@@ -808,9 +739,7 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) {
Initialize(kShouldProcessData);
// Receive initial headers without FIN set.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size());
+ ProcessHeaders(false, headers_);
// Receive body data, with FIN.
QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, "body");
@@ -818,13 +747,10 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) {
// Receive trailing headers after FIN already received.
SpdyHeaderBlock trailers_block;
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
-
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
.Times(1);
- stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+ ProcessHeaders(false, trailers_block);
}
TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) {
@@ -833,10 +759,8 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) {
Initialize(kShouldProcessData);
// Receive initial headers.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(false, headers.size());
- stream_->MarkHeadersConsumed(stream_->decompressed_headers().size());
+ QuicHeaderList headers = ProcessHeaders(false, headers_);
+ stream_->ConsumeHeaderList();
const string body = "this is the body";
// Receive trailing headers.
@@ -845,18 +769,19 @@ TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) {
trailers_block["key2"] = "value2";
trailers_block["key3"] = "value3";
trailers_block[kFinalOffsetHeaderKey] = base::IntToString(body.size());
- string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block);
- stream_->OnStreamHeaders(trailers);
- stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size());
+
+ QuicHeaderList trailers = ProcessHeaders(true, trailers_block);
// The trailers should be decompressed, and readable from the stream.
EXPECT_TRUE(stream_->trailers_decompressed());
- const string decompressed_trailers = stream_->decompressed_trailers();
- EXPECT_EQ(trailers, decompressed_trailers);
+
+ // The final offset trailer will be consumed by QUIC.
+ trailers_block.erase(kFinalOffsetHeaderKey);
+ EXPECT_EQ(trailers_block, stream_->received_trailers());
+
// Consuming the trailers erases them from the stream.
- stream_->MarkTrailersConsumed(decompressed_trailers.size());
stream_->MarkTrailersConsumed();
- EXPECT_EQ("", stream_->decompressed_trailers());
+ EXPECT_TRUE(stream_->FinishedReadingTrailers());
EXPECT_FALSE(stream_->IsDoneReading());
// Receive and consume body.
@@ -872,10 +797,9 @@ TEST_P(QuicSpdyStreamTest, ClosingStreamWithNoTrailers) {
Initialize(kShouldProcessData);
// Receive and consume initial headers with FIN not set.
- string headers = SpdyUtils::SerializeUncompressedHeaders(headers_);
- stream_->OnStreamHeaders(headers);
- stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size());
- stream_->MarkHeadersConsumed(headers.size());
+ auto h = AsHeaderList(headers_);
+ stream_->OnStreamHeaderList(/*fin=*/false, h.uncompressed_header_bytes(), h);
+ stream_->ConsumeHeaderList();
// Receive and consume body with FIN set, and no trailers.
const string kBody = string(1024, 'x');
@@ -926,7 +850,7 @@ TEST_P(QuicSpdyStreamTest, WritingTrailersFinalOffset) {
SpdyHeaderBlock trailers;
trailers["trailer key"] = "trailer value";
SpdyHeaderBlock trailers_with_offset(trailers.Clone());
- trailers_with_offset[kFinalOffsetHeaderKey] = base::IntToString(kBodySize);
+ trailers_with_offset[kFinalOffsetHeaderKey] = base::Uint64ToString(kBodySize);
EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _));
stream_->WriteTrailers(std::move(trailers), nullptr);
EXPECT_EQ(trailers_with_offset, session_->GetWriteHeaders());
« no previous file with comments | « net/quic/core/quic_spdy_stream.cc ('k') | net/quic/test_tools/mock_quic_spdy_client_stream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698