| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/quic/quic_spdy_stream.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/strings/string_number_conversions.h" | |
| 11 #include "net/quic/quic_connection.h" | |
| 12 #include "net/quic/quic_utils.h" | |
| 13 #include "net/quic/quic_write_blocked_list.h" | |
| 14 #include "net/quic/spdy_utils.h" | |
| 15 #include "net/quic/test_tools/quic_flow_controller_peer.h" | |
| 16 #include "net/quic/test_tools/quic_session_peer.h" | |
| 17 #include "net/quic/test_tools/quic_test_utils.h" | |
| 18 #include "net/quic/test_tools/reliable_quic_stream_peer.h" | |
| 19 #include "net/test/gtest_util.h" | |
| 20 #include "testing/gmock/include/gmock/gmock.h" | |
| 21 | |
| 22 using base::StringPiece; | |
| 23 using std::min; | |
| 24 using std::string; | |
| 25 using testing::AnyNumber; | |
| 26 using testing::Invoke; | |
| 27 using testing::Return; | |
| 28 using testing::StrictMock; | |
| 29 using testing::_; | |
| 30 | |
| 31 namespace net { | |
| 32 namespace test { | |
| 33 namespace { | |
| 34 | |
| 35 const bool kShouldProcessData = true; | |
| 36 | |
| 37 class TestStream : public QuicSpdyStream { | |
| 38 public: | |
| 39 TestStream(QuicStreamId id, | |
| 40 QuicSpdySession* session, | |
| 41 bool should_process_data) | |
| 42 : QuicSpdyStream(id, session), | |
| 43 should_process_data_(should_process_data) {} | |
| 44 | |
| 45 void OnDataAvailable() override { | |
| 46 if (!should_process_data_) { | |
| 47 return; | |
| 48 } | |
| 49 char buffer[2048]; | |
| 50 struct iovec vec; | |
| 51 vec.iov_base = buffer; | |
| 52 vec.iov_len = arraysize(buffer); | |
| 53 size_t bytes_read = Readv(&vec, 1); | |
| 54 data_ += string(buffer, bytes_read); | |
| 55 } | |
| 56 | |
| 57 using ReliableQuicStream::WriteOrBufferData; | |
| 58 using ReliableQuicStream::CloseWriteSide; | |
| 59 | |
| 60 const string& data() const { return data_; } | |
| 61 | |
| 62 private: | |
| 63 bool should_process_data_; | |
| 64 string data_; | |
| 65 }; | |
| 66 | |
| 67 class QuicSpdyStreamTest : public ::testing::TestWithParam<QuicVersion> { | |
| 68 public: | |
| 69 QuicSpdyStreamTest() { | |
| 70 FLAGS_quic_always_log_bugs_for_tests = true; | |
| 71 headers_[":host"] = "www.google.com"; | |
| 72 headers_[":path"] = "/index.hml"; | |
| 73 headers_[":scheme"] = "https"; | |
| 74 headers_["cookie"] = | |
| 75 "__utma=208381060.1228362404.1372200928.1372200928.1372200928.1; " | |
| 76 "__utmc=160408618; " | |
| 77 "GX=DQAAAOEAAACWJYdewdE9rIrW6qw3PtVi2-d729qaa-74KqOsM1NVQblK4VhX" | |
| 78 "hoALMsy6HOdDad2Sz0flUByv7etmo3mLMidGrBoljqO9hSVA40SLqpG_iuKKSHX" | |
| 79 "RW3Np4bq0F0SDGDNsW0DSmTS9ufMRrlpARJDS7qAI6M3bghqJp4eABKZiRqebHT" | |
| 80 "pMU-RXvTI5D5oCF1vYxYofH_l1Kviuiy3oQ1kS1enqWgbhJ2t61_SNdv-1XJIS0" | |
| 81 "O3YeHLmVCs62O6zp89QwakfAWK9d3IDQvVSJzCQsvxvNIvaZFa567MawWlXg0Rh" | |
| 82 "1zFMi5vzcns38-8_Sns; " | |
| 83 "GA=v*2%2Fmem*57968640*47239936%2Fmem*57968640*47114716%2Fno-nm-" | |
| 84 "yj*15%2Fno-cc-yj*5%2Fpc-ch*133685%2Fpc-s-cr*133947%2Fpc-s-t*1339" | |
| 85 "47%2Fno-nm-yj*4%2Fno-cc-yj*1%2Fceft-as*1%2Fceft-nqas*0%2Fad-ra-c" | |
| 86 "v_p%2Fad-nr-cv_p-f*1%2Fad-v-cv_p*859%2Fad-ns-cv_p-f*1%2Ffn-v-ad%" | |
| 87 "2Fpc-t*250%2Fpc-cm*461%2Fpc-s-cr*722%2Fpc-s-t*722%2Fau_p*4" | |
| 88 "SICAID=AJKiYcHdKgxum7KMXG0ei2t1-W4OD1uW-ecNsCqC0wDuAXiDGIcT_HA2o1" | |
| 89 "3Rs1UKCuBAF9g8rWNOFbxt8PSNSHFuIhOo2t6bJAVpCsMU5Laa6lewuTMYI8MzdQP" | |
| 90 "ARHKyW-koxuhMZHUnGBJAM1gJODe0cATO_KGoX4pbbFxxJ5IicRxOrWK_5rU3cdy6" | |
| 91 "edlR9FsEdH6iujMcHkbE5l18ehJDwTWmBKBzVD87naobhMMrF6VvnDGxQVGp9Ir_b" | |
| 92 "Rgj3RWUoPumQVCxtSOBdX0GlJOEcDTNCzQIm9BSfetog_eP_TfYubKudt5eMsXmN6" | |
| 93 "QnyXHeGeK2UINUzJ-D30AFcpqYgH9_1BvYSpi7fc7_ydBU8TaD8ZRxvtnzXqj0RfG" | |
| 94 "tuHghmv3aD-uzSYJ75XDdzKdizZ86IG6Fbn1XFhYZM-fbHhm3mVEXnyRW4ZuNOLFk" | |
| 95 "Fas6LMcVC6Q8QLlHYbXBpdNFuGbuZGUnav5C-2I_-46lL0NGg3GewxGKGHvHEfoyn" | |
| 96 "EFFlEYHsBQ98rXImL8ySDycdLEFvBPdtctPmWCfTxwmoSMLHU2SCVDhbqMWU5b0yr" | |
| 97 "JBCScs_ejbKaqBDoB7ZGxTvqlrB__2ZmnHHjCr8RgMRtKNtIeuZAo "; | |
| 98 } | |
| 99 | |
| 100 void Initialize(bool stream_should_process_data) { | |
| 101 connection_ = new testing::StrictMock<MockQuicConnection>( | |
| 102 &helper_, &alarm_factory_, Perspective::IS_SERVER, | |
| 103 SupportedVersions(GetParam())); | |
| 104 session_.reset(new testing::StrictMock<MockQuicSpdySession>(connection_)); | |
| 105 stream_ = new TestStream(kClientDataStreamId1, session_.get(), | |
| 106 stream_should_process_data); | |
| 107 session_->ActivateStream(stream_); | |
| 108 stream2_ = new TestStream(kClientDataStreamId2, session_.get(), | |
| 109 stream_should_process_data); | |
| 110 session_->ActivateStream(stream2_); | |
| 111 } | |
| 112 | |
| 113 protected: | |
| 114 MockQuicConnectionHelper helper_; | |
| 115 MockAlarmFactory alarm_factory_; | |
| 116 MockQuicConnection* connection_; | |
| 117 std::unique_ptr<MockQuicSpdySession> session_; | |
| 118 | |
| 119 // Owned by the |session_|. | |
| 120 TestStream* stream_; | |
| 121 TestStream* stream2_; | |
| 122 | |
| 123 SpdyHeaderBlock headers_; | |
| 124 }; | |
| 125 | |
| 126 INSTANTIATE_TEST_CASE_P(Tests, | |
| 127 QuicSpdyStreamTest, | |
| 128 ::testing::ValuesIn(QuicSupportedVersions())); | |
| 129 | |
| 130 TEST_P(QuicSpdyStreamTest, ProcessHeaders) { | |
| 131 Initialize(kShouldProcessData); | |
| 132 | |
| 133 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 134 stream_->OnStreamHeadersPriority(kV3HighestPriority); | |
| 135 stream_->OnStreamHeaders(headers); | |
| 136 EXPECT_EQ("", stream_->data()); | |
| 137 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 138 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 139 EXPECT_EQ(kV3HighestPriority, stream_->priority()); | |
| 140 EXPECT_EQ("", stream_->data()); | |
| 141 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 142 EXPECT_FALSE(stream_->IsDoneReading()); | |
| 143 } | |
| 144 | |
| 145 TEST_P(QuicSpdyStreamTest, ProcessHeaderList) { | |
| 146 Initialize(kShouldProcessData); | |
| 147 | |
| 148 size_t total_bytes = 0; | |
| 149 QuicHeaderList headers; | |
| 150 for (auto p : headers_) { | |
| 151 headers.OnHeader(p.first, p.second); | |
| 152 total_bytes += p.first.size() + p.second.size(); | |
| 153 } | |
| 154 stream_->OnStreamHeadersPriority(kV3HighestPriority); | |
| 155 stream_->OnStreamHeaderList(false, total_bytes, headers); | |
| 156 EXPECT_EQ("", stream_->data()); | |
| 157 EXPECT_FALSE(stream_->header_list().empty()); | |
| 158 EXPECT_FALSE(stream_->IsDoneReading()); | |
| 159 } | |
| 160 | |
| 161 TEST_P(QuicSpdyStreamTest, ProcessHeadersWithFin) { | |
| 162 Initialize(kShouldProcessData); | |
| 163 | |
| 164 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 165 stream_->OnStreamHeadersPriority(kV3HighestPriority); | |
| 166 stream_->OnStreamHeaders(headers); | |
| 167 EXPECT_EQ("", stream_->data()); | |
| 168 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 169 stream_->OnStreamHeadersComplete(true, headers.size()); | |
| 170 EXPECT_EQ(kV3HighestPriority, stream_->priority()); | |
| 171 EXPECT_EQ("", stream_->data()); | |
| 172 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 173 EXPECT_FALSE(stream_->IsDoneReading()); | |
| 174 EXPECT_TRUE(stream_->HasFinalReceivedByteOffset()); | |
| 175 } | |
| 176 | |
| 177 TEST_P(QuicSpdyStreamTest, ProcessHeaderListWithFin) { | |
| 178 Initialize(kShouldProcessData); | |
| 179 | |
| 180 size_t total_bytes = 0; | |
| 181 QuicHeaderList headers; | |
| 182 for (auto p : headers_) { | |
| 183 headers.OnHeader(p.first, p.second); | |
| 184 total_bytes += p.first.size() + p.second.size(); | |
| 185 } | |
| 186 stream_->OnStreamHeadersPriority(kV3HighestPriority); | |
| 187 stream_->OnStreamHeaderList(true, total_bytes, headers); | |
| 188 EXPECT_EQ("", stream_->data()); | |
| 189 EXPECT_FALSE(stream_->header_list().empty()); | |
| 190 EXPECT_FALSE(stream_->IsDoneReading()); | |
| 191 EXPECT_TRUE(stream_->HasFinalReceivedByteOffset()); | |
| 192 } | |
| 193 | |
| 194 TEST_P(QuicSpdyStreamTest, ParseHeaderStatusCode) { | |
| 195 // A valid status code should be 3-digit integer. The first digit should be in | |
| 196 // the range of [1, 5]. All the others are invalid. | |
| 197 Initialize(kShouldProcessData); | |
| 198 int status_code = 0; | |
| 199 | |
| 200 // Valid status code. | |
| 201 headers_.ReplaceOrAppendHeader(":status", "404"); | |
| 202 EXPECT_TRUE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 203 EXPECT_EQ(404, status_code); | |
| 204 | |
| 205 // Invalid status codes. | |
| 206 headers_.ReplaceOrAppendHeader(":status", "010"); | |
| 207 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 208 | |
| 209 headers_.ReplaceOrAppendHeader(":status", "600"); | |
| 210 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 211 | |
| 212 headers_.ReplaceOrAppendHeader(":status", "200 ok"); | |
| 213 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 214 | |
| 215 headers_.ReplaceOrAppendHeader(":status", "2000"); | |
| 216 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 217 | |
| 218 headers_.ReplaceOrAppendHeader(":status", "+200"); | |
| 219 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 220 | |
| 221 headers_.ReplaceOrAppendHeader(":status", "+20"); | |
| 222 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 223 | |
| 224 // Leading or trailing spaces are also invalid. | |
| 225 headers_.ReplaceOrAppendHeader(":status", " 200"); | |
| 226 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 227 | |
| 228 headers_.ReplaceOrAppendHeader(":status", "200 "); | |
| 229 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 230 | |
| 231 headers_.ReplaceOrAppendHeader(":status", " 200 "); | |
| 232 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 233 | |
| 234 headers_.ReplaceOrAppendHeader(":status", " "); | |
| 235 EXPECT_FALSE(stream_->ParseHeaderStatusCode(headers_, &status_code)); | |
| 236 } | |
| 237 | |
| 238 TEST_P(QuicSpdyStreamTest, MarkHeadersConsumed) { | |
| 239 Initialize(kShouldProcessData); | |
| 240 | |
| 241 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 242 string body = "this is the body"; | |
| 243 | |
| 244 stream_->OnStreamHeaders(headers); | |
| 245 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 246 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 247 | |
| 248 headers.erase(0, 10); | |
| 249 stream_->MarkHeadersConsumed(10); | |
| 250 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 251 | |
| 252 stream_->MarkHeadersConsumed(headers.length()); | |
| 253 EXPECT_EQ("", stream_->decompressed_headers()); | |
| 254 } | |
| 255 | |
| 256 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBody) { | |
| 257 Initialize(kShouldProcessData); | |
| 258 | |
| 259 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 260 string body = "this is the body"; | |
| 261 | |
| 262 stream_->OnStreamHeaders(headers); | |
| 263 EXPECT_EQ("", stream_->data()); | |
| 264 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 265 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 266 EXPECT_EQ(headers, stream_->decompressed_headers()); | |
| 267 stream_->MarkHeadersConsumed(headers.length()); | |
| 268 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 269 stream_->OnStreamFrame(frame); | |
| 270 EXPECT_EQ("", stream_->decompressed_headers()); | |
| 271 EXPECT_EQ(body, stream_->data()); | |
| 272 } | |
| 273 | |
| 274 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragments) { | |
| 275 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 276 string body = "this is the body"; | |
| 277 | |
| 278 for (size_t fragment_size = 1; fragment_size < body.size(); ++fragment_size) { | |
| 279 Initialize(kShouldProcessData); | |
| 280 for (size_t offset = 0; offset < headers.size(); offset += fragment_size) { | |
| 281 size_t remaining_data = headers.size() - offset; | |
| 282 StringPiece fragment(headers.data() + offset, | |
| 283 min(fragment_size, remaining_data)); | |
| 284 stream_->OnStreamHeaders(fragment); | |
| 285 } | |
| 286 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 287 ASSERT_EQ(headers, stream_->decompressed_headers()) << "fragment_size: " | |
| 288 << fragment_size; | |
| 289 stream_->MarkHeadersConsumed(headers.length()); | |
| 290 for (size_t offset = 0; offset < body.size(); offset += fragment_size) { | |
| 291 size_t remaining_data = body.size() - offset; | |
| 292 StringPiece fragment(body.data() + offset, | |
| 293 min(fragment_size, remaining_data)); | |
| 294 QuicStreamFrame frame(kClientDataStreamId1, false, offset, | |
| 295 StringPiece(fragment)); | |
| 296 stream_->OnStreamFrame(frame); | |
| 297 } | |
| 298 ASSERT_EQ(body, stream_->data()) << "fragment_size: " << fragment_size; | |
| 299 } | |
| 300 } | |
| 301 | |
| 302 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyFragmentsSplit) { | |
| 303 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 304 string body = "this is the body"; | |
| 305 | |
| 306 for (size_t split_point = 1; split_point < body.size() - 1; ++split_point) { | |
| 307 Initialize(kShouldProcessData); | |
| 308 StringPiece headers1(headers.data(), split_point); | |
| 309 stream_->OnStreamHeaders(headers1); | |
| 310 | |
| 311 StringPiece headers2(headers.data() + split_point, | |
| 312 headers.size() - split_point); | |
| 313 stream_->OnStreamHeaders(headers2); | |
| 314 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 315 ASSERT_EQ(headers, stream_->decompressed_headers()) << "split_point: " | |
| 316 << split_point; | |
| 317 stream_->MarkHeadersConsumed(headers.length()); | |
| 318 | |
| 319 StringPiece fragment1(body.data(), split_point); | |
| 320 QuicStreamFrame frame1(kClientDataStreamId1, false, 0, | |
| 321 StringPiece(fragment1)); | |
| 322 stream_->OnStreamFrame(frame1); | |
| 323 | |
| 324 StringPiece fragment2(body.data() + split_point, body.size() - split_point); | |
| 325 QuicStreamFrame frame2(kClientDataStreamId1, false, split_point, | |
| 326 StringPiece(fragment2)); | |
| 327 stream_->OnStreamFrame(frame2); | |
| 328 | |
| 329 ASSERT_EQ(body, stream_->data()) << "split_point: " << split_point; | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyReadv) { | |
| 334 Initialize(!kShouldProcessData); | |
| 335 | |
| 336 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 337 string body = "this is the body"; | |
| 338 | |
| 339 stream_->OnStreamHeaders(headers); | |
| 340 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 341 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 342 stream_->OnStreamFrame(frame); | |
| 343 stream_->MarkHeadersConsumed(headers.length()); | |
| 344 | |
| 345 char buffer[2048]; | |
| 346 ASSERT_LT(body.length(), arraysize(buffer)); | |
| 347 struct iovec vec; | |
| 348 vec.iov_base = buffer; | |
| 349 vec.iov_len = arraysize(buffer); | |
| 350 | |
| 351 size_t bytes_read = stream_->Readv(&vec, 1); | |
| 352 EXPECT_EQ(body.length(), bytes_read); | |
| 353 EXPECT_EQ(body, string(buffer, bytes_read)); | |
| 354 } | |
| 355 | |
| 356 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyMarkConsumed) { | |
| 357 Initialize(!kShouldProcessData); | |
| 358 | |
| 359 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 360 string body = "this is the body"; | |
| 361 | |
| 362 stream_->OnStreamHeaders(headers); | |
| 363 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 364 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 365 stream_->OnStreamFrame(frame); | |
| 366 stream_->MarkHeadersConsumed(headers.length()); | |
| 367 | |
| 368 struct iovec vec; | |
| 369 | |
| 370 EXPECT_EQ(1, stream_->GetReadableRegions(&vec, 1)); | |
| 371 EXPECT_EQ(body.length(), vec.iov_len); | |
| 372 EXPECT_EQ(body, string(static_cast<char*>(vec.iov_base), vec.iov_len)); | |
| 373 | |
| 374 stream_->MarkConsumed(body.length()); | |
| 375 EXPECT_EQ(body.length(), stream_->flow_controller()->bytes_consumed()); | |
| 376 } | |
| 377 | |
| 378 TEST_P(QuicSpdyStreamTest, ProcessHeadersAndBodyIncrementalReadv) { | |
| 379 Initialize(!kShouldProcessData); | |
| 380 | |
| 381 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 382 string body = "this is the body"; | |
| 383 stream_->OnStreamHeaders(headers); | |
| 384 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 385 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 386 stream_->OnStreamFrame(frame); | |
| 387 stream_->MarkHeadersConsumed(headers.length()); | |
| 388 | |
| 389 char buffer[1]; | |
| 390 struct iovec vec; | |
| 391 vec.iov_base = buffer; | |
| 392 vec.iov_len = arraysize(buffer); | |
| 393 | |
| 394 for (size_t i = 0; i < body.length(); ++i) { | |
| 395 size_t bytes_read = stream_->Readv(&vec, 1); | |
| 396 ASSERT_EQ(1u, bytes_read); | |
| 397 EXPECT_EQ(body.data()[i], buffer[0]); | |
| 398 } | |
| 399 } | |
| 400 | |
| 401 TEST_P(QuicSpdyStreamTest, ProcessHeadersUsingReadvWithMultipleIovecs) { | |
| 402 Initialize(!kShouldProcessData); | |
| 403 | |
| 404 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 405 string body = "this is the body"; | |
| 406 stream_->OnStreamHeaders(headers); | |
| 407 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 408 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 409 stream_->OnStreamFrame(frame); | |
| 410 stream_->MarkHeadersConsumed(headers.length()); | |
| 411 | |
| 412 char buffer1[1]; | |
| 413 char buffer2[1]; | |
| 414 struct iovec vec[2]; | |
| 415 vec[0].iov_base = buffer1; | |
| 416 vec[0].iov_len = arraysize(buffer1); | |
| 417 vec[1].iov_base = buffer2; | |
| 418 vec[1].iov_len = arraysize(buffer2); | |
| 419 | |
| 420 for (size_t i = 0; i < body.length(); i += 2) { | |
| 421 size_t bytes_read = stream_->Readv(vec, 2); | |
| 422 ASSERT_EQ(2u, bytes_read) << i; | |
| 423 ASSERT_EQ(body.data()[i], buffer1[0]) << i; | |
| 424 ASSERT_EQ(body.data()[i + 1], buffer2[0]) << i; | |
| 425 } | |
| 426 } | |
| 427 | |
| 428 TEST_P(QuicSpdyStreamTest, StreamFlowControlBlocked) { | |
| 429 // Tests that we send a BLOCKED frame to the peer when we attempt to write, | |
| 430 // but are flow control blocked. | |
| 431 Initialize(kShouldProcessData); | |
| 432 | |
| 433 // Set a small flow control limit. | |
| 434 const uint64_t kWindow = 36; | |
| 435 QuicFlowControllerPeer::SetSendWindowOffset(stream_->flow_controller(), | |
| 436 kWindow); | |
| 437 EXPECT_EQ(kWindow, QuicFlowControllerPeer::SendWindowOffset( | |
| 438 stream_->flow_controller())); | |
| 439 | |
| 440 // Try to send more data than the flow control limit allows. | |
| 441 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 442 string body; | |
| 443 const uint64_t kOverflow = 15; | |
| 444 GenerateBody(&body, kWindow + kOverflow); | |
| 445 | |
| 446 EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)); | |
| 447 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 448 .WillOnce(Return(QuicConsumedData(kWindow, true))); | |
| 449 stream_->WriteOrBufferData(body, false, nullptr); | |
| 450 | |
| 451 // Should have sent as much as possible, resulting in no send window left. | |
| 452 EXPECT_EQ(0u, | |
| 453 QuicFlowControllerPeer::SendWindowSize(stream_->flow_controller())); | |
| 454 | |
| 455 // And we should have queued the overflowed data. | |
| 456 EXPECT_EQ(kOverflow, ReliableQuicStreamPeer::SizeOfQueuedData(stream_)); | |
| 457 } | |
| 458 | |
| 459 TEST_P(QuicSpdyStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) { | |
| 460 // The flow control receive window decreases whenever we add new bytes to the | |
| 461 // sequencer, whether they are consumed immediately or buffered. However we | |
| 462 // only send WINDOW_UPDATE frames based on increasing number of bytes | |
| 463 // consumed. | |
| 464 | |
| 465 // Don't process data - it will be buffered instead. | |
| 466 Initialize(!kShouldProcessData); | |
| 467 | |
| 468 // Expect no WINDOW_UPDATE frames to be sent. | |
| 469 EXPECT_CALL(*connection_, SendWindowUpdate(_, _)).Times(0); | |
| 470 | |
| 471 // Set a small flow control receive window. | |
| 472 const uint64_t kWindow = 36; | |
| 473 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), | |
| 474 kWindow); | |
| 475 QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), | |
| 476 kWindow); | |
| 477 EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset( | |
| 478 stream_->flow_controller())); | |
| 479 | |
| 480 // Stream receives enough data to fill a fraction of the receive window. | |
| 481 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 482 string body; | |
| 483 GenerateBody(&body, kWindow / 3); | |
| 484 stream_->OnStreamHeaders(headers); | |
| 485 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 486 | |
| 487 QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 488 stream_->OnStreamFrame(frame1); | |
| 489 EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize( | |
| 490 stream_->flow_controller())); | |
| 491 | |
| 492 // Now receive another frame which results in the receive window being over | |
| 493 // half full. This should all be buffered, decreasing the receive window but | |
| 494 // not sending WINDOW_UPDATE. | |
| 495 QuicStreamFrame frame2(kClientDataStreamId1, false, kWindow / 3, | |
| 496 StringPiece(body)); | |
| 497 stream_->OnStreamFrame(frame2); | |
| 498 EXPECT_EQ( | |
| 499 kWindow - (2 * kWindow / 3), | |
| 500 QuicFlowControllerPeer::ReceiveWindowSize(stream_->flow_controller())); | |
| 501 } | |
| 502 | |
| 503 TEST_P(QuicSpdyStreamTest, StreamFlowControlWindowUpdate) { | |
| 504 // Tests that on receipt of data, the stream updates its receive window offset | |
| 505 // appropriately, and sends WINDOW_UPDATE frames when its receive window drops | |
| 506 // too low. | |
| 507 Initialize(kShouldProcessData); | |
| 508 | |
| 509 // Set a small flow control limit. | |
| 510 const uint64_t kWindow = 36; | |
| 511 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), | |
| 512 kWindow); | |
| 513 QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), | |
| 514 kWindow); | |
| 515 EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowOffset( | |
| 516 stream_->flow_controller())); | |
| 517 | |
| 518 // Stream receives enough data to fill a fraction of the receive window. | |
| 519 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 520 string body; | |
| 521 GenerateBody(&body, kWindow / 3); | |
| 522 stream_->OnStreamHeaders(headers); | |
| 523 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 524 stream_->MarkHeadersConsumed(headers.length()); | |
| 525 | |
| 526 QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 527 stream_->OnStreamFrame(frame1); | |
| 528 EXPECT_EQ(kWindow - (kWindow / 3), QuicFlowControllerPeer::ReceiveWindowSize( | |
| 529 stream_->flow_controller())); | |
| 530 | |
| 531 // Now receive another frame which results in the receive window being over | |
| 532 // half full. This will trigger the stream to increase its receive window | |
| 533 // offset and send a WINDOW_UPDATE. The result will be again an available | |
| 534 // window of kWindow bytes. | |
| 535 QuicStreamFrame frame2(kClientDataStreamId1, false, kWindow / 3, | |
| 536 StringPiece(body)); | |
| 537 EXPECT_CALL(*connection_, | |
| 538 SendWindowUpdate(kClientDataStreamId1, | |
| 539 QuicFlowControllerPeer::ReceiveWindowOffset( | |
| 540 stream_->flow_controller()) + | |
| 541 2 * kWindow / 3)); | |
| 542 stream_->OnStreamFrame(frame2); | |
| 543 EXPECT_EQ(kWindow, QuicFlowControllerPeer::ReceiveWindowSize( | |
| 544 stream_->flow_controller())); | |
| 545 } | |
| 546 | |
| 547 TEST_P(QuicSpdyStreamTest, ConnectionFlowControlWindowUpdate) { | |
| 548 // Tests that on receipt of data, the connection updates its receive window | |
| 549 // offset appropriately, and sends WINDOW_UPDATE frames when its receive | |
| 550 // window drops too low. | |
| 551 Initialize(kShouldProcessData); | |
| 552 | |
| 553 // Set a small flow control limit for streams and connection. | |
| 554 const uint64_t kWindow = 36; | |
| 555 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), | |
| 556 kWindow); | |
| 557 QuicFlowControllerPeer::SetMaxReceiveWindow(stream_->flow_controller(), | |
| 558 kWindow); | |
| 559 QuicFlowControllerPeer::SetReceiveWindowOffset(stream2_->flow_controller(), | |
| 560 kWindow); | |
| 561 QuicFlowControllerPeer::SetMaxReceiveWindow(stream2_->flow_controller(), | |
| 562 kWindow); | |
| 563 QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(), | |
| 564 kWindow); | |
| 565 QuicFlowControllerPeer::SetMaxReceiveWindow(session_->flow_controller(), | |
| 566 kWindow); | |
| 567 | |
| 568 // Supply headers to both streams so that they are happy to receive data. | |
| 569 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 570 stream_->OnStreamHeaders(headers); | |
| 571 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 572 stream_->MarkHeadersConsumed(headers.length()); | |
| 573 stream2_->OnStreamHeaders(headers); | |
| 574 stream2_->OnStreamHeadersComplete(false, headers.size()); | |
| 575 stream2_->MarkHeadersConsumed(headers.length()); | |
| 576 | |
| 577 // Each stream gets a quarter window of data. This should not trigger a | |
| 578 // WINDOW_UPDATE for either stream, nor for the connection. | |
| 579 string body; | |
| 580 GenerateBody(&body, kWindow / 4); | |
| 581 QuicStreamFrame frame1(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 582 stream_->OnStreamFrame(frame1); | |
| 583 QuicStreamFrame frame2(kClientDataStreamId2, false, 0, StringPiece(body)); | |
| 584 stream2_->OnStreamFrame(frame2); | |
| 585 | |
| 586 // Now receive a further single byte on one stream - again this does not | |
| 587 // trigger a stream WINDOW_UPDATE, but now the connection flow control window | |
| 588 // is over half full and thus a connection WINDOW_UPDATE is sent. | |
| 589 EXPECT_CALL(*connection_, SendWindowUpdate(kClientDataStreamId1, _)).Times(0); | |
| 590 EXPECT_CALL(*connection_, SendWindowUpdate(kClientDataStreamId2, _)).Times(0); | |
| 591 EXPECT_CALL(*connection_, | |
| 592 SendWindowUpdate(0, QuicFlowControllerPeer::ReceiveWindowOffset( | |
| 593 session_->flow_controller()) + | |
| 594 1 + kWindow / 2)); | |
| 595 QuicStreamFrame frame3(kClientDataStreamId1, false, (kWindow / 4), | |
| 596 StringPiece("a")); | |
| 597 stream_->OnStreamFrame(frame3); | |
| 598 } | |
| 599 | |
| 600 TEST_P(QuicSpdyStreamTest, StreamFlowControlViolation) { | |
| 601 // Tests that on if the peer sends too much data (i.e. violates the flow | |
| 602 // control protocol), then we terminate the connection. | |
| 603 | |
| 604 // Stream should not process data, so that data gets buffered in the | |
| 605 // sequencer, triggering flow control limits. | |
| 606 Initialize(!kShouldProcessData); | |
| 607 | |
| 608 // Set a small flow control limit. | |
| 609 const uint64_t kWindow = 50; | |
| 610 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), | |
| 611 kWindow); | |
| 612 | |
| 613 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 614 stream_->OnStreamHeaders(headers); | |
| 615 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 616 | |
| 617 // Receive data to overflow the window, violating flow control. | |
| 618 string body; | |
| 619 GenerateBody(&body, kWindow + 1); | |
| 620 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 621 EXPECT_CALL(*connection_, | |
| 622 CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _)); | |
| 623 stream_->OnStreamFrame(frame); | |
| 624 } | |
| 625 | |
| 626 TEST_P(QuicSpdyStreamTest, TestHandlingQuicRstStreamNoError) { | |
| 627 Initialize(kShouldProcessData); | |
| 628 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 629 stream_->OnStreamHeaders(headers); | |
| 630 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 631 | |
| 632 stream_->OnStreamReset( | |
| 633 QuicRstStreamFrame(stream_->id(), QUIC_STREAM_NO_ERROR, 0)); | |
| 634 EXPECT_TRUE(stream_->write_side_closed()); | |
| 635 EXPECT_FALSE(stream_->reading_stopped()); | |
| 636 } | |
| 637 | |
| 638 TEST_P(QuicSpdyStreamTest, ConnectionFlowControlViolation) { | |
| 639 // Tests that on if the peer sends too much data (i.e. violates the flow | |
| 640 // control protocol), at the connection level (rather than the stream level) | |
| 641 // then we terminate the connection. | |
| 642 | |
| 643 // Stream should not process data, so that data gets buffered in the | |
| 644 // sequencer, triggering flow control limits. | |
| 645 Initialize(!kShouldProcessData); | |
| 646 | |
| 647 // Set a small flow control window on streams, and connection. | |
| 648 const uint64_t kStreamWindow = 50; | |
| 649 const uint64_t kConnectionWindow = 10; | |
| 650 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), | |
| 651 kStreamWindow); | |
| 652 QuicFlowControllerPeer::SetReceiveWindowOffset(session_->flow_controller(), | |
| 653 kConnectionWindow); | |
| 654 | |
| 655 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 656 stream_->OnStreamHeaders(headers); | |
| 657 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 658 | |
| 659 // Send enough data to overflow the connection level flow control window. | |
| 660 string body; | |
| 661 GenerateBody(&body, kConnectionWindow + 1); | |
| 662 EXPECT_LT(body.size(), kStreamWindow); | |
| 663 QuicStreamFrame frame(kClientDataStreamId1, false, 0, StringPiece(body)); | |
| 664 | |
| 665 EXPECT_CALL(*connection_, | |
| 666 CloseConnection(QUIC_FLOW_CONTROL_RECEIVED_TOO_MUCH_DATA, _, _)); | |
| 667 stream_->OnStreamFrame(frame); | |
| 668 } | |
| 669 | |
| 670 TEST_P(QuicSpdyStreamTest, StreamFlowControlFinNotBlocked) { | |
| 671 // An attempt to write a FIN with no data should not be flow control blocked, | |
| 672 // even if the send window is 0. | |
| 673 | |
| 674 Initialize(kShouldProcessData); | |
| 675 | |
| 676 // Set a flow control limit of zero. | |
| 677 QuicFlowControllerPeer::SetReceiveWindowOffset(stream_->flow_controller(), 0); | |
| 678 EXPECT_EQ(0u, QuicFlowControllerPeer::ReceiveWindowOffset( | |
| 679 stream_->flow_controller())); | |
| 680 | |
| 681 // Send a frame with a FIN but no data. This should not be blocked. | |
| 682 string body = ""; | |
| 683 bool fin = true; | |
| 684 | |
| 685 EXPECT_CALL(*connection_, SendBlocked(kClientDataStreamId1)).Times(0); | |
| 686 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 687 .WillOnce(Return(QuicConsumedData(0, fin))); | |
| 688 | |
| 689 stream_->WriteOrBufferData(body, fin, nullptr); | |
| 690 } | |
| 691 | |
| 692 TEST_P(QuicSpdyStreamTest, ReceivingTrailers) { | |
| 693 // Test that receiving trailing headers from the peer works, and can be read | |
| 694 // from the stream and consumed. | |
| 695 Initialize(kShouldProcessData); | |
| 696 | |
| 697 // Receive initial headers. | |
| 698 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 699 stream_->OnStreamHeaders(headers); | |
| 700 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 701 stream_->MarkHeadersConsumed(stream_->decompressed_headers().size()); | |
| 702 | |
| 703 // Receive trailing headers. | |
| 704 SpdyHeaderBlock trailers_block; | |
| 705 trailers_block["key1"] = "value1"; | |
| 706 trailers_block["key2"] = "value2"; | |
| 707 trailers_block["key3"] = "value3"; | |
| 708 trailers_block[kFinalOffsetHeaderKey] = "0"; | |
| 709 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 710 stream_->OnStreamHeaders(trailers); | |
| 711 stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size()); | |
| 712 | |
| 713 // The trailers should be decompressed, and readable from the stream. | |
| 714 EXPECT_TRUE(stream_->trailers_decompressed()); | |
| 715 const string decompressed_trailers = stream_->decompressed_trailers(); | |
| 716 EXPECT_EQ(trailers, decompressed_trailers); | |
| 717 | |
| 718 // Consuming the trailers erases them from the stream. | |
| 719 stream_->MarkTrailersConsumed(decompressed_trailers.size()); | |
| 720 EXPECT_EQ("", stream_->decompressed_trailers()); | |
| 721 } | |
| 722 | |
| 723 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutOffset) { | |
| 724 // Test that receiving trailers without a final offset field is an error. | |
| 725 Initialize(kShouldProcessData); | |
| 726 | |
| 727 // Receive initial headers. | |
| 728 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 729 stream_->OnStreamHeaders(headers); | |
| 730 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 731 stream_->MarkHeadersConsumed(stream_->decompressed_headers().size()); | |
| 732 | |
| 733 const string body = "this is the body"; | |
| 734 // Receive trailing headers, without kFinalOffsetHeaderKey. | |
| 735 SpdyHeaderBlock trailers_block; | |
| 736 trailers_block["key1"] = "value1"; | |
| 737 trailers_block["key2"] = "value2"; | |
| 738 trailers_block["key3"] = "value3"; | |
| 739 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 740 stream_->OnStreamHeaders(trailers); | |
| 741 | |
| 742 // Verify that the trailers block didn't contain a final offset. | |
| 743 EXPECT_EQ("", trailers_block[kFinalOffsetHeaderKey].as_string()); | |
| 744 | |
| 745 // Receipt of the malformed trailers will close the connection. | |
| 746 EXPECT_CALL(*connection_, | |
| 747 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _)) | |
| 748 .Times(1); | |
| 749 stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size()); | |
| 750 } | |
| 751 | |
| 752 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithoutFin) { | |
| 753 // Test that received Trailers must always have the FIN set. | |
| 754 Initialize(kShouldProcessData); | |
| 755 | |
| 756 // Receive initial headers. | |
| 757 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 758 stream_->OnStreamHeaders(headers); | |
| 759 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 760 | |
| 761 // Receive trailing headers with FIN deliberately set to false. | |
| 762 SpdyHeaderBlock trailers_block; | |
| 763 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 764 stream_->OnStreamHeaders(trailers); | |
| 765 | |
| 766 EXPECT_CALL(*connection_, | |
| 767 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _)) | |
| 768 .Times(1); | |
| 769 stream_->OnStreamHeadersComplete(/*fin=*/false, trailers.size()); | |
| 770 } | |
| 771 | |
| 772 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterFin) { | |
| 773 // If Trailers are sent, neither Headers nor Body should contain a FIN. | |
| 774 Initialize(kShouldProcessData); | |
| 775 | |
| 776 // Receive initial headers with FIN set. | |
| 777 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 778 stream_->OnStreamHeaders(headers); | |
| 779 stream_->OnStreamHeadersComplete(/*fin=*/true, headers.size()); | |
| 780 | |
| 781 // Receive trailing headers after FIN already received. | |
| 782 SpdyHeaderBlock trailers_block; | |
| 783 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 784 stream_->OnStreamHeaders(trailers); | |
| 785 | |
| 786 EXPECT_CALL(*connection_, | |
| 787 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _)) | |
| 788 .Times(1); | |
| 789 stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size()); | |
| 790 } | |
| 791 | |
| 792 TEST_P(QuicSpdyStreamTest, ReceivingTrailersAfterBodyWithFin) { | |
| 793 // If body data are received with a FIN, no trailers should then arrive. | |
| 794 Initialize(kShouldProcessData); | |
| 795 | |
| 796 // Receive initial headers without FIN set. | |
| 797 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 798 stream_->OnStreamHeaders(headers); | |
| 799 stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size()); | |
| 800 | |
| 801 // Receive body data, with FIN. | |
| 802 QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, "body"); | |
| 803 stream_->OnStreamFrame(frame); | |
| 804 | |
| 805 // Receive trailing headers after FIN already received. | |
| 806 SpdyHeaderBlock trailers_block; | |
| 807 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 808 stream_->OnStreamHeaders(trailers); | |
| 809 | |
| 810 EXPECT_CALL(*connection_, | |
| 811 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _)) | |
| 812 .Times(1); | |
| 813 stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size()); | |
| 814 } | |
| 815 | |
| 816 TEST_P(QuicSpdyStreamTest, ReceivingTrailersWithOffset) { | |
| 817 // Test that when receiving trailing headers with an offset before response | |
| 818 // body, stream is closed at the right offset. | |
| 819 Initialize(kShouldProcessData); | |
| 820 | |
| 821 // Receive initial headers. | |
| 822 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 823 stream_->OnStreamHeaders(headers); | |
| 824 stream_->OnStreamHeadersComplete(false, headers.size()); | |
| 825 stream_->MarkHeadersConsumed(stream_->decompressed_headers().size()); | |
| 826 | |
| 827 const string body = "this is the body"; | |
| 828 // Receive trailing headers. | |
| 829 SpdyHeaderBlock trailers_block; | |
| 830 trailers_block["key1"] = "value1"; | |
| 831 trailers_block["key2"] = "value2"; | |
| 832 trailers_block["key3"] = "value3"; | |
| 833 trailers_block[kFinalOffsetHeaderKey] = base::IntToString(body.size()); | |
| 834 string trailers = SpdyUtils::SerializeUncompressedHeaders(trailers_block); | |
| 835 stream_->OnStreamHeaders(trailers); | |
| 836 stream_->OnStreamHeadersComplete(/*fin=*/true, trailers.size()); | |
| 837 | |
| 838 // The trailers should be decompressed, and readable from the stream. | |
| 839 EXPECT_TRUE(stream_->trailers_decompressed()); | |
| 840 const string decompressed_trailers = stream_->decompressed_trailers(); | |
| 841 EXPECT_EQ(trailers, decompressed_trailers); | |
| 842 // Consuming the trailers erases them from the stream. | |
| 843 stream_->MarkTrailersConsumed(decompressed_trailers.size()); | |
| 844 stream_->MarkTrailersDelivered(); | |
| 845 EXPECT_EQ("", stream_->decompressed_trailers()); | |
| 846 | |
| 847 EXPECT_FALSE(stream_->IsDoneReading()); | |
| 848 // Receive and consume body. | |
| 849 QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/false, 0, body); | |
| 850 stream_->OnStreamFrame(frame); | |
| 851 EXPECT_EQ(body, stream_->data()); | |
| 852 EXPECT_TRUE(stream_->IsDoneReading()); | |
| 853 } | |
| 854 | |
| 855 TEST_P(QuicSpdyStreamTest, ClosingStreamWithNoTrailers) { | |
| 856 // Verify that a stream receiving headers, body, and no trailers is correctly | |
| 857 // marked as done reading on consumption of headers and body. | |
| 858 Initialize(kShouldProcessData); | |
| 859 | |
| 860 // Receive and consume initial headers with FIN not set. | |
| 861 string headers = SpdyUtils::SerializeUncompressedHeaders(headers_); | |
| 862 stream_->OnStreamHeaders(headers); | |
| 863 stream_->OnStreamHeadersComplete(/*fin=*/false, headers.size()); | |
| 864 stream_->MarkHeadersConsumed(headers.size()); | |
| 865 | |
| 866 // Receive and consume body with FIN set, and no trailers. | |
| 867 const string kBody = string(1024, 'x'); | |
| 868 QuicStreamFrame frame(kClientDataStreamId1, /*fin=*/true, 0, kBody); | |
| 869 stream_->OnStreamFrame(frame); | |
| 870 | |
| 871 EXPECT_TRUE(stream_->IsDoneReading()); | |
| 872 } | |
| 873 | |
| 874 TEST_P(QuicSpdyStreamTest, WritingTrailersSendsAFin) { | |
| 875 // Test that writing trailers will send a FIN, as Trailers are the last thing | |
| 876 // to be sent on a stream. | |
| 877 Initialize(kShouldProcessData); | |
| 878 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 879 .Times(AnyNumber()) | |
| 880 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | |
| 881 | |
| 882 // Write the initial headers, without a FIN. | |
| 883 EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _)); | |
| 884 stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr); | |
| 885 | |
| 886 // Writing trailers implicitly sends a FIN. | |
| 887 SpdyHeaderBlock trailers; | |
| 888 trailers["trailer key"] = "trailer value"; | |
| 889 EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _)); | |
| 890 stream_->WriteTrailers(std::move(trailers), nullptr); | |
| 891 EXPECT_TRUE(stream_->fin_sent()); | |
| 892 } | |
| 893 | |
| 894 TEST_P(QuicSpdyStreamTest, WritingTrailersFinalOffset) { | |
| 895 // Test that when writing trailers, the trailers that are actually sent to the | |
| 896 // peer contain the final offset field indicating last byte of data. | |
| 897 Initialize(kShouldProcessData); | |
| 898 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 899 .Times(AnyNumber()) | |
| 900 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | |
| 901 | |
| 902 // Write the initial headers. | |
| 903 EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _)); | |
| 904 stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr); | |
| 905 | |
| 906 // Write non-zero body data to force a non-zero final offset. | |
| 907 const int kBodySize = 1 * 1024; // 1 MB | |
| 908 stream_->WriteOrBufferData(string(kBodySize, 'x'), false, nullptr); | |
| 909 | |
| 910 // The final offset field in the trailing headers is populated with the | |
| 911 // number of body bytes written (including queued bytes). | |
| 912 SpdyHeaderBlock trailers; | |
| 913 trailers["trailer key"] = "trailer value"; | |
| 914 SpdyHeaderBlock trailers_with_offset(trailers.Clone()); | |
| 915 trailers_with_offset[kFinalOffsetHeaderKey] = base::IntToString(kBodySize); | |
| 916 EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _)); | |
| 917 stream_->WriteTrailers(std::move(trailers), nullptr); | |
| 918 EXPECT_EQ(trailers_with_offset, session_->GetWriteHeaders()); | |
| 919 } | |
| 920 | |
| 921 TEST_P(QuicSpdyStreamTest, WritingTrailersClosesWriteSide) { | |
| 922 // Test that if trailers are written after all other data has been written | |
| 923 // (headers and body), that this closes the stream for writing. | |
| 924 Initialize(kShouldProcessData); | |
| 925 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 926 .Times(AnyNumber()) | |
| 927 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | |
| 928 | |
| 929 // Write the initial headers. | |
| 930 EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _)); | |
| 931 stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr); | |
| 932 | |
| 933 // Write non-zero body data. | |
| 934 const int kBodySize = 1 * 1024; // 1 MB | |
| 935 stream_->WriteOrBufferData(string(kBodySize, 'x'), false, nullptr); | |
| 936 EXPECT_EQ(0u, stream_->queued_data_bytes()); | |
| 937 | |
| 938 // Headers and body have been fully written, there is no queued data. Writing | |
| 939 // trailers marks the end of this stream, and thus the write side is closed. | |
| 940 EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _)); | |
| 941 stream_->WriteTrailers(SpdyHeaderBlock(), nullptr); | |
| 942 EXPECT_TRUE(stream_->write_side_closed()); | |
| 943 } | |
| 944 | |
| 945 TEST_P(QuicSpdyStreamTest, WritingTrailersWithQueuedBytes) { | |
| 946 // Test that the stream is not closed for writing when trailers are sent | |
| 947 // while there are still body bytes queued. | |
| 948 Initialize(kShouldProcessData); | |
| 949 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 950 .Times(AnyNumber()) | |
| 951 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | |
| 952 | |
| 953 // Write the initial headers. | |
| 954 EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _)); | |
| 955 stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/false, nullptr); | |
| 956 | |
| 957 // Write non-zero body data, but only consume partially, ensuring queueing. | |
| 958 const int kBodySize = 1 * 1024; // 1 MB | |
| 959 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 960 .WillOnce(Return(QuicConsumedData(kBodySize - 1, false))); | |
| 961 stream_->WriteOrBufferData(string(kBodySize, 'x'), false, nullptr); | |
| 962 if (!session_->force_hol_blocking()) { | |
| 963 EXPECT_EQ(1u, stream_->queued_data_bytes()); | |
| 964 } | |
| 965 | |
| 966 // Writing trailers will send a FIN, but not close the write side of the | |
| 967 // stream as there are queued bytes. | |
| 968 EXPECT_CALL(*session_, WriteHeadersMock(_, _, true, _, _)); | |
| 969 stream_->WriteTrailers(SpdyHeaderBlock(), nullptr); | |
| 970 EXPECT_TRUE(stream_->fin_sent()); | |
| 971 if (!session_->force_hol_blocking()) { | |
| 972 EXPECT_FALSE(stream_->write_side_closed()); | |
| 973 } | |
| 974 } | |
| 975 | |
| 976 TEST_P(QuicSpdyStreamTest, WritingTrailersAfterFIN) { | |
| 977 // Test that it is not possible to write Trailers after a FIN has been sent. | |
| 978 Initialize(kShouldProcessData); | |
| 979 EXPECT_CALL(*session_, WritevData(_, _, _, _, _, _)) | |
| 980 .Times(AnyNumber()) | |
| 981 .WillRepeatedly(Invoke(MockQuicSession::ConsumeAllData)); | |
| 982 | |
| 983 // Write the initial headers, with a FIN. | |
| 984 EXPECT_CALL(*session_, WriteHeadersMock(_, _, _, _, _)); | |
| 985 stream_->WriteHeaders(SpdyHeaderBlock(), /*fin=*/true, nullptr); | |
| 986 EXPECT_TRUE(stream_->fin_sent()); | |
| 987 | |
| 988 // Writing Trailers should fail, as the FIN has already been sent. | |
| 989 // populated with the number of body bytes written. | |
| 990 EXPECT_DFATAL(stream_->WriteTrailers(SpdyHeaderBlock(), nullptr), | |
| 991 "Trailers cannot be sent after a FIN"); | |
| 992 } | |
| 993 | |
| 994 } // namespace | |
| 995 } // namespace test | |
| 996 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2193073003:
Move shared files in net/quic/ into net/quic/core/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master