OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/core/quic_headers_stream.h" | 5 #include "net/quic/core/quic_headers_stream.h" |
6 | 6 |
7 #include <cstdint> | 7 #include <cstdint> |
8 #include <ostream> | 8 #include <ostream> |
9 #include <string> | 9 #include <string> |
10 #include <tuple> | 10 #include <tuple> |
(...skipping 206 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
217 next_promised_stream_id_(2) { | 217 next_promised_stream_id_(2) { |
218 headers_[":version"] = "HTTP/1.1"; | 218 headers_[":version"] = "HTTP/1.1"; |
219 headers_[":status"] = "200 Ok"; | 219 headers_[":status"] = "200 Ok"; |
220 headers_["content-length"] = "11"; | 220 headers_["content-length"] = "11"; |
221 framer_ = std::unique_ptr<SpdyFramer>( | 221 framer_ = std::unique_ptr<SpdyFramer>( |
222 new SpdyFramer(SpdyFramer::ENABLE_COMPRESSION)); | 222 new SpdyFramer(SpdyFramer::ENABLE_COMPRESSION)); |
223 framer_->set_visitor(&visitor_); | 223 framer_->set_visitor(&visitor_); |
224 EXPECT_EQ(version(), session_.connection()->version()); | 224 EXPECT_EQ(version(), session_.connection()->version()); |
225 EXPECT_TRUE(headers_stream_ != nullptr); | 225 EXPECT_TRUE(headers_stream_ != nullptr); |
226 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); | 226 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); |
227 client_id_1_ = | |
228 QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 0); | |
229 client_id_2_ = | |
230 QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 1); | |
231 client_id_3_ = | |
232 QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, 2); | |
233 next_stream_id_ = QuicSpdySessionPeer::NextStreamId(session_); | |
234 } | |
235 | |
236 QuicStreamId GetNthClientInitiatedId(int n) { | |
237 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(session_, n); | |
238 } | 227 } |
239 | 228 |
240 QuicConsumedData SaveIov(const QuicIOVector& data) { | 229 QuicConsumedData SaveIov(const QuicIOVector& data) { |
241 const iovec* iov = data.iov; | 230 const iovec* iov = data.iov; |
242 int count = data.iov_count; | 231 int count = data.iov_count; |
243 int consumed = 0; | 232 int consumed = 0; |
244 for (int i = 0; i < count; ++i) { | 233 for (int i = 0; i < count; ++i) { |
245 saved_data_.append(static_cast<char*>(iov[i].iov_base), iov[i].iov_len); | 234 saved_data_.append(static_cast<char*>(iov[i].iov_base), iov[i].iov_len); |
246 consumed += iov[i].iov_len; | 235 consumed += iov[i].iov_len; |
247 } | 236 } |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
365 QuicVersionVector GetVersion() { | 354 QuicVersionVector GetVersion() { |
366 QuicVersionVector versions; | 355 QuicVersionVector versions; |
367 versions.push_back(version()); | 356 versions.push_back(version()); |
368 return versions; | 357 return versions; |
369 } | 358 } |
370 | 359 |
371 void TearDownLocalConnectionState() { | 360 void TearDownLocalConnectionState() { |
372 QuicConnectionPeer::TearDownLocalConnectionState(connection_); | 361 QuicConnectionPeer::TearDownLocalConnectionState(connection_); |
373 } | 362 } |
374 | 363 |
375 QuicStreamId NextPromisedStreamId() { | 364 QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; } |
376 return next_promised_stream_id_ += next_stream_id_; | |
377 } | |
378 | 365 |
379 static const bool kFrameComplete = true; | 366 static const bool kFrameComplete = true; |
380 static const bool kHasPriority = true; | 367 static const bool kHasPriority = true; |
381 | 368 |
382 const TestParams test_params_; | 369 const TestParams test_params_; |
383 MockQuicConnectionHelper helper_; | 370 MockQuicConnectionHelper helper_; |
384 MockAlarmFactory alarm_factory_; | 371 MockAlarmFactory alarm_factory_; |
385 StrictMock<MockQuicConnection>* connection_; | 372 StrictMock<MockQuicConnection>* connection_; |
386 StrictMock<MockQuicSpdySession> session_; | 373 StrictMock<MockQuicSpdySession> session_; |
387 QuicHeadersStream* headers_stream_; | 374 QuicHeadersStream* headers_stream_; |
388 SpdyHeaderBlock headers_; | 375 SpdyHeaderBlock headers_; |
389 std::unique_ptr<TestHeadersHandler> headers_handler_; | 376 std::unique_ptr<TestHeadersHandler> headers_handler_; |
390 string body_; | 377 string body_; |
391 string saved_data_; | 378 string saved_data_; |
392 string saved_header_data_; | 379 string saved_header_data_; |
393 string saved_payloads_; | 380 string saved_payloads_; |
394 std::unique_ptr<SpdyFramer> framer_; | 381 std::unique_ptr<SpdyFramer> framer_; |
395 StrictMock<MockVisitor> visitor_; | 382 StrictMock<MockVisitor> visitor_; |
396 QuicStreamFrame stream_frame_; | 383 QuicStreamFrame stream_frame_; |
397 QuicStreamId next_promised_stream_id_; | 384 QuicStreamId next_promised_stream_id_; |
398 QuicStreamId client_id_1_; | |
399 QuicStreamId client_id_2_; | |
400 QuicStreamId client_id_3_; | |
401 QuicStreamId next_stream_id_; | |
402 }; | 385 }; |
403 | 386 |
404 // Run all tests with each version, perspective (client or server), | 387 // Run all tests with each version, perspective (client or server), |
405 // HTTP/2 and HPACK decoder. | 388 // HTTP/2 and HPACK decoder. |
406 INSTANTIATE_TEST_CASE_P( | 389 INSTANTIATE_TEST_CASE_P( |
407 Tests, | 390 Tests, |
408 QuicHeadersStreamTest, | 391 QuicHeadersStreamTest, |
409 ::testing::Combine(::testing::ValuesIn(AllSupportedVersions()), | 392 ::testing::Combine(::testing::ValuesIn(AllSupportedVersions()), |
410 ::testing::Values(Perspective::IS_CLIENT, | 393 ::testing::Values(Perspective::IS_CLIENT, |
411 Perspective::IS_SERVER), | 394 Perspective::IS_SERVER), |
412 ::testing::Values(HTTP2_DECODER_SPDY, | 395 ::testing::Values(HTTP2_DECODER_SPDY, |
413 HTTP2_DECODER_NEW), | 396 HTTP2_DECODER_NEW), |
414 ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER3))); | 397 ::testing::Values(HPACK_DECODER_SPDY, HPACK_DECODER3))); |
415 | 398 |
416 TEST_P(QuicHeadersStreamTest, StreamId) { | 399 TEST_P(QuicHeadersStreamTest, StreamId) { |
417 EXPECT_EQ(3u, headers_stream_->id()); | 400 EXPECT_EQ(3u, headers_stream_->id()); |
418 } | 401 } |
419 | 402 |
420 TEST_P(QuicHeadersStreamTest, WriteHeaders) { | 403 TEST_P(QuicHeadersStreamTest, WriteHeaders) { |
421 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 404 for (QuicStreamId stream_id = kClientDataStreamId1; |
422 stream_id += next_stream_id_) { | 405 stream_id < kClientDataStreamId3; stream_id += 2) { |
423 for (bool fin : kFins) { | 406 for (bool fin : kFins) { |
424 if (perspective() == Perspective::IS_SERVER) { | 407 if (perspective() == Perspective::IS_SERVER) { |
425 WriteAndExpectResponseHeaders(stream_id, fin); | 408 WriteAndExpectResponseHeaders(stream_id, fin); |
426 } else { | 409 } else { |
427 for (SpdyPriority priority = 0; priority < 7; ++priority) { | 410 for (SpdyPriority priority = 0; priority < 7; ++priority) { |
428 // TODO(rch): implement priorities correctly. | 411 // TODO(rch): implement priorities correctly. |
429 WriteAndExpectRequestHeaders(stream_id, fin, 0); | 412 WriteAndExpectRequestHeaders(stream_id, fin, 0); |
430 } | 413 } |
431 } | 414 } |
432 } | 415 } |
433 } | 416 } |
434 } | 417 } |
435 | 418 |
436 TEST_P(QuicHeadersStreamTest, WritePushPromises) { | 419 TEST_P(QuicHeadersStreamTest, WritePushPromises) { |
437 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 420 for (QuicStreamId stream_id = kClientDataStreamId1; |
438 stream_id += next_stream_id_) { | 421 stream_id < kClientDataStreamId3; stream_id += 2) { |
439 QuicStreamId promised_stream_id = NextPromisedStreamId(); | 422 QuicStreamId promised_stream_id = NextPromisedStreamId(); |
440 if (perspective() == Perspective::IS_SERVER) { | 423 if (perspective() == Perspective::IS_SERVER) { |
441 // Write the headers and capture the outgoing data | 424 // Write the headers and capture the outgoing data |
442 EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _, | 425 EXPECT_CALL(session_, WritevData(headers_stream_, kHeadersStreamId, _, _, |
443 NO_FIN, _)) | 426 NO_FIN, _)) |
444 .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov))); | 427 .WillOnce(WithArgs<2>(Invoke(this, &QuicHeadersStreamTest::SaveIov))); |
445 session_.WritePushPromise(stream_id, promised_stream_id, | 428 session_.WritePushPromise(stream_id, promised_stream_id, |
446 headers_.Clone()); | 429 headers_.Clone()); |
447 | 430 |
448 // Parse the outgoing data and check that it matches was was written. | 431 // Parse the outgoing data and check that it matches was was written. |
(...skipping 10 matching lines...) Expand all Loading... |
459 saved_data_.clear(); | 442 saved_data_.clear(); |
460 } else { | 443 } else { |
461 EXPECT_QUIC_BUG(session_.WritePushPromise(stream_id, promised_stream_id, | 444 EXPECT_QUIC_BUG(session_.WritePushPromise(stream_id, promised_stream_id, |
462 headers_.Clone()), | 445 headers_.Clone()), |
463 "Client shouldn't send PUSH_PROMISE"); | 446 "Client shouldn't send PUSH_PROMISE"); |
464 } | 447 } |
465 } | 448 } |
466 } | 449 } |
467 | 450 |
468 TEST_P(QuicHeadersStreamTest, ProcessRawData) { | 451 TEST_P(QuicHeadersStreamTest, ProcessRawData) { |
469 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 452 for (QuicStreamId stream_id = kClientDataStreamId1; |
470 stream_id += next_stream_id_) { | 453 stream_id < kClientDataStreamId3; stream_id += 2) { |
471 for (bool fin : {false, true}) { | 454 for (bool fin : {false, true}) { |
472 for (SpdyPriority priority = 0; priority < 7; ++priority) { | 455 for (SpdyPriority priority = 0; priority < 7; ++priority) { |
473 // Replace with "WriteHeadersAndSaveData" | 456 // Replace with "WriteHeadersAndSaveData" |
474 SpdySerializedFrame frame; | 457 SpdySerializedFrame frame; |
475 if (perspective() == Perspective::IS_SERVER) { | 458 if (perspective() == Perspective::IS_SERVER) { |
476 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 459 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
477 headers_frame.set_fin(fin); | 460 headers_frame.set_fin(fin); |
478 headers_frame.set_has_priority(true); | 461 headers_frame.set_has_priority(true); |
479 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); | 462 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); |
480 frame = framer_->SerializeFrame(headers_frame); | 463 frame = framer_->SerializeFrame(headers_frame); |
(...skipping 12 matching lines...) Expand all Loading... |
493 stream_frame_.offset += frame.size(); | 476 stream_frame_.offset += frame.size(); |
494 CheckHeaders(); | 477 CheckHeaders(); |
495 } | 478 } |
496 } | 479 } |
497 } | 480 } |
498 } | 481 } |
499 | 482 |
500 TEST_P(QuicHeadersStreamTest, ProcessPushPromise) { | 483 TEST_P(QuicHeadersStreamTest, ProcessPushPromise) { |
501 if (perspective() == Perspective::IS_SERVER) | 484 if (perspective() == Perspective::IS_SERVER) |
502 return; | 485 return; |
503 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 486 for (QuicStreamId stream_id = kClientDataStreamId1; |
504 stream_id += next_stream_id_) { | 487 stream_id < kClientDataStreamId3; stream_id += 2) { |
505 QuicStreamId promised_stream_id = NextPromisedStreamId(); | 488 QuicStreamId promised_stream_id = NextPromisedStreamId(); |
506 SpdyPushPromiseIR push_promise(stream_id, promised_stream_id, | 489 SpdyPushPromiseIR push_promise(stream_id, promised_stream_id, |
507 headers_.Clone()); | 490 headers_.Clone()); |
508 SpdySerializedFrame frame(framer_->SerializeFrame(push_promise)); | 491 SpdySerializedFrame frame(framer_->SerializeFrame(push_promise)); |
509 if (perspective() == Perspective::IS_SERVER) { | 492 if (perspective() == Perspective::IS_SERVER) { |
510 EXPECT_CALL(*connection_, | 493 EXPECT_CALL(*connection_, |
511 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, | 494 CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, |
512 "PUSH_PROMISE not supported.", _)) | 495 "PUSH_PROMISE not supported.", _)) |
513 .WillRepeatedly(InvokeWithoutArgs( | 496 .WillRepeatedly(InvokeWithoutArgs( |
514 this, &QuicHeadersStreamTest::TearDownLocalConnectionState)); | 497 this, &QuicHeadersStreamTest::TearDownLocalConnectionState)); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
547 headers_stream_->OnStreamFrame(stream_frame_); | 530 headers_stream_->OnStreamFrame(stream_frame_); |
548 EXPECT_EQ(session_.server_push_enabled(), | 531 EXPECT_EQ(session_.server_push_enabled(), |
549 perspective() == Perspective::IS_CLIENT); | 532 perspective() == Perspective::IS_CLIENT); |
550 } | 533 } |
551 | 534 |
552 TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) { | 535 TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) { |
553 EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0); | 536 EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0); |
554 InSequence seq; | 537 InSequence seq; |
555 bool fin = true; | 538 bool fin = true; |
556 for (int stream_num = 0; stream_num < 10; stream_num++) { | 539 for (int stream_num = 0; stream_num < 10; stream_num++) { |
557 QuicStreamId stream_id = GetNthClientInitiatedId(stream_num); | 540 QuicStreamId stream_id = QuicClientDataStreamId(stream_num); |
558 // Replace with "WriteHeadersAndSaveData" | 541 // Replace with "WriteHeadersAndSaveData" |
559 SpdySerializedFrame frame; | 542 SpdySerializedFrame frame; |
560 if (perspective() == Perspective::IS_SERVER) { | 543 if (perspective() == Perspective::IS_SERVER) { |
561 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 544 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
562 headers_frame.set_fin(fin); | 545 headers_frame.set_fin(fin); |
563 headers_frame.set_has_priority(true); | 546 headers_frame.set_has_priority(true); |
564 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); | 547 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); |
565 frame = framer_->SerializeFrame(headers_frame); | 548 frame = framer_->SerializeFrame(headers_frame); |
566 EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)); | 549 EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)); |
567 } else { | 550 } else { |
(...skipping 13 matching lines...) Expand all Loading... |
581 | 564 |
582 TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) { | 565 TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) { |
583 QuicStreamId stream_id; | 566 QuicStreamId stream_id; |
584 bool fin = true; | 567 bool fin = true; |
585 QuicStreamFrame stream_frames[10]; | 568 QuicStreamFrame stream_frames[10]; |
586 SpdySerializedFrame frames[10]; | 569 SpdySerializedFrame frames[10]; |
587 // First create all the frames in order | 570 // First create all the frames in order |
588 { | 571 { |
589 InSequence seq; | 572 InSequence seq; |
590 for (int stream_num = 0; stream_num < 10; ++stream_num) { | 573 for (int stream_num = 0; stream_num < 10; ++stream_num) { |
591 stream_id = GetNthClientInitiatedId(stream_num); | 574 stream_id = QuicClientDataStreamId(stream_num); |
592 if (perspective() == Perspective::IS_SERVER) { | 575 if (perspective() == Perspective::IS_SERVER) { |
593 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 576 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
594 headers_frame.set_fin(fin); | 577 headers_frame.set_fin(fin); |
595 headers_frame.set_has_priority(true); | 578 headers_frame.set_has_priority(true); |
596 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); | 579 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); |
597 frames[stream_num] = framer_->SerializeFrame(headers_frame); | 580 frames[stream_num] = framer_->SerializeFrame(headers_frame); |
598 EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1); | 581 EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1); |
599 } else { | 582 } else { |
600 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 583 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
601 headers_frame.set_fin(fin); | 584 headers_frame.set_fin(fin); |
(...skipping 22 matching lines...) Expand all Loading... |
624 } | 607 } |
625 | 608 |
626 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) { | 609 TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) { |
627 QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024); | 610 QuicSpdySessionPeer::SetMaxUncompressedHeaderBytes(&session_, 256 * 1024); |
628 // We want to create a frame that is more than the SPDY Framer's max control | 611 // We want to create a frame that is more than the SPDY Framer's max control |
629 // frame size, which is 16K, but less than the HPACK decoders max decode | 612 // frame size, which is 16K, but less than the HPACK decoders max decode |
630 // buffer size, which is 32K. | 613 // buffer size, which is 32K. |
631 headers_["key0"] = string(1 << 13, '.'); | 614 headers_["key0"] = string(1 << 13, '.'); |
632 headers_["key1"] = string(1 << 13, '.'); | 615 headers_["key1"] = string(1 << 13, '.'); |
633 headers_["key2"] = string(1 << 13, '.'); | 616 headers_["key2"] = string(1 << 13, '.'); |
634 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 617 for (QuicStreamId stream_id = kClientDataStreamId1; |
635 stream_id += next_stream_id_) { | 618 stream_id < kClientDataStreamId3; stream_id += 2) { |
636 for (bool fin : {false, true}) { | 619 for (bool fin : {false, true}) { |
637 for (SpdyPriority priority = 0; priority < 7; ++priority) { | 620 for (SpdyPriority priority = 0; priority < 7; ++priority) { |
638 // Replace with "WriteHeadersAndSaveData" | 621 // Replace with "WriteHeadersAndSaveData" |
639 SpdySerializedFrame frame; | 622 SpdySerializedFrame frame; |
640 if (perspective() == Perspective::IS_SERVER) { | 623 if (perspective() == Perspective::IS_SERVER) { |
641 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 624 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
642 headers_frame.set_fin(fin); | 625 headers_frame.set_fin(fin); |
643 headers_frame.set_has_priority(true); | 626 headers_frame.set_has_priority(true); |
644 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); | 627 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); |
645 frame = framer_->SerializeFrame(headers_frame); | 628 frame = framer_->SerializeFrame(headers_frame); |
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
855 } | 838 } |
856 } | 839 } |
857 QuicSpdySessionPeer::SetHpackDecoderDebugVisitor( | 840 QuicSpdySessionPeer::SetHpackDecoderDebugVisitor( |
858 &session_, std::move(hpack_decoder_visitor)); | 841 &session_, std::move(hpack_decoder_visitor)); |
859 | 842 |
860 // Create some headers we expect to generate entries in HPACK's | 843 // Create some headers we expect to generate entries in HPACK's |
861 // dynamic table, in addition to content-length. | 844 // dynamic table, in addition to content-length. |
862 headers_["key0"] = string(1 << 1, '.'); | 845 headers_["key0"] = string(1 << 1, '.'); |
863 headers_["key1"] = string(1 << 2, '.'); | 846 headers_["key1"] = string(1 << 2, '.'); |
864 headers_["key2"] = string(1 << 3, '.'); | 847 headers_["key2"] = string(1 << 3, '.'); |
865 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 848 for (QuicStreamId stream_id = kClientDataStreamId1; |
866 stream_id += next_stream_id_) { | 849 stream_id < kClientDataStreamId3; stream_id += 2) { |
867 for (bool fin : {false, true}) { | 850 for (bool fin : {false, true}) { |
868 for (SpdyPriority priority = 0; priority < 7; ++priority) { | 851 for (SpdyPriority priority = 0; priority < 7; ++priority) { |
869 // Replace with "WriteHeadersAndSaveData" | 852 // Replace with "WriteHeadersAndSaveData" |
870 SpdySerializedFrame frame; | 853 SpdySerializedFrame frame; |
871 if (perspective() == Perspective::IS_SERVER) { | 854 if (perspective() == Perspective::IS_SERVER) { |
872 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); | 855 SpdyHeadersIR headers_frame(stream_id, headers_.Clone()); |
873 headers_frame.set_fin(fin); | 856 headers_frame.set_fin(fin); |
874 headers_frame.set_has_priority(true); | 857 headers_frame.set_has_priority(true); |
875 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); | 858 headers_frame.set_weight(Spdy3PriorityToHttp2Weight(0)); |
876 frame = framer_->SerializeFrame(headers_frame); | 859 frame = framer_->SerializeFrame(headers_frame); |
(...skipping 29 matching lines...) Expand all Loading... |
906 } else { | 889 } else { |
907 InSequence seq; | 890 InSequence seq; |
908 for (int i = 1; i < 28; i++) { | 891 for (int i = 1; i < 28; i++) { |
909 EXPECT_CALL(*hpack_encoder_visitor, | 892 EXPECT_CALL(*hpack_encoder_visitor, |
910 OnUseEntry(QuicTime::Delta::FromMilliseconds(i))); | 893 OnUseEntry(QuicTime::Delta::FromMilliseconds(i))); |
911 } | 894 } |
912 } | 895 } |
913 QuicSpdySessionPeer::SetHpackEncoderDebugVisitor( | 896 QuicSpdySessionPeer::SetHpackEncoderDebugVisitor( |
914 &session_, std::move(hpack_encoder_visitor)); | 897 &session_, std::move(hpack_encoder_visitor)); |
915 | 898 |
916 for (QuicStreamId stream_id = client_id_1_; stream_id < client_id_3_; | 899 for (QuicStreamId stream_id = kClientDataStreamId1; |
917 stream_id += next_stream_id_) { | 900 stream_id < kClientDataStreamId3; stream_id += 2) { |
918 for (bool fin : {false, true}) { | 901 for (bool fin : {false, true}) { |
919 if (perspective() == Perspective::IS_SERVER) { | 902 if (perspective() == Perspective::IS_SERVER) { |
920 WriteAndExpectResponseHeaders(stream_id, fin); | 903 WriteAndExpectResponseHeaders(stream_id, fin); |
921 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); | 904 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); |
922 } else { | 905 } else { |
923 for (SpdyPriority priority = 0; priority < 7; ++priority) { | 906 for (SpdyPriority priority = 0; priority < 7; ++priority) { |
924 // TODO(rch): implement priorities correctly. | 907 // TODO(rch): implement priorities correctly. |
925 WriteAndExpectRequestHeaders(stream_id, fin, 0); | 908 WriteAndExpectRequestHeaders(stream_id, fin, 0); |
926 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); | 909 connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1)); |
927 } | 910 } |
928 } | 911 } |
929 } | 912 } |
930 } | 913 } |
931 } | 914 } |
932 | 915 |
933 TEST_P(QuicHeadersStreamTest, WritevStreamData) { | 916 TEST_P(QuicHeadersStreamTest, WritevStreamData) { |
934 QuicStreamId id = client_id_1_; | 917 QuicStreamId id = kClientDataStreamId1; |
935 QuicStreamOffset offset = 0; | 918 QuicStreamOffset offset = 0; |
936 struct iovec iov; | 919 struct iovec iov; |
937 | 920 |
938 // This test will issue a write that will require fragmenting into | 921 // This test will issue a write that will require fragmenting into |
939 // multiple HTTP/2 DATA frames. | 922 // multiple HTTP/2 DATA frames. |
940 const int kMinDataFrames = 4; | 923 const int kMinDataFrames = 4; |
941 const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024; | 924 const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024; |
942 // Set headers stream send window large enough for data written below. | 925 // Set headers stream send window large enough for data written below. |
943 headers_stream_->flow_controller()->UpdateSendWindowOffset(data_len * 2 * 4); | 926 headers_stream_->flow_controller()->UpdateSendWindowOffset(data_len * 2 * 4); |
944 string data(data_len, 'a'); | 927 string data(data_len, 'a'); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
986 TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) { | 969 TEST_P(QuicHeadersStreamTest, WritevStreamDataFinOnly) { |
987 struct iovec iov; | 970 struct iovec iov; |
988 string data; | 971 string data; |
989 | 972 |
990 EXPECT_CALL(session_, | 973 EXPECT_CALL(session_, |
991 WritevData(headers_stream_, kHeadersStreamId, _, _, NO_FIN, _)) | 974 WritevData(headers_stream_, kHeadersStreamId, _, _, NO_FIN, _)) |
992 .WillOnce(WithArgs<2, 5>( | 975 .WillOnce(WithArgs<2, 5>( |
993 Invoke(this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener))); | 976 Invoke(this, &QuicHeadersStreamTest::SaveIovAndNotifyAckListener))); |
994 | 977 |
995 QuicConsumedData consumed_data = session_.WritevStreamData( | 978 QuicConsumedData consumed_data = session_.WritevStreamData( |
996 client_id_1_, MakeIOVector(data, &iov), 0, true, nullptr); | 979 kClientDataStreamId1, MakeIOVector(data, &iov), 0, true, nullptr); |
997 | 980 |
998 EXPECT_EQ(consumed_data.bytes_consumed, 0u); | 981 EXPECT_EQ(consumed_data.bytes_consumed, 0u); |
999 EXPECT_EQ(consumed_data.fin_consumed, true); | 982 EXPECT_EQ(consumed_data.fin_consumed, true); |
1000 } | 983 } |
1001 | 984 |
1002 TEST_P(QuicHeadersStreamTest, WritevStreamDataSendBlocked) { | 985 TEST_P(QuicHeadersStreamTest, WritevStreamDataSendBlocked) { |
1003 QuicStreamId id = client_id_1_; | 986 QuicStreamId id = kClientDataStreamId1; |
1004 QuicStreamOffset offset = 0; | 987 QuicStreamOffset offset = 0; |
1005 struct iovec iov; | 988 struct iovec iov; |
1006 | 989 |
1007 // This test will issue a write that will require fragmenting into | 990 // This test will issue a write that will require fragmenting into |
1008 // multiple HTTP/2 DATA frames. It will ensure that only 1 frame | 991 // multiple HTTP/2 DATA frames. It will ensure that only 1 frame |
1009 // will go out in the case that the underlying session becomes write | 992 // will go out in the case that the underlying session becomes write |
1010 // blocked. Buffering is required to preserve framing, but the | 993 // blocked. Buffering is required to preserve framing, but the |
1011 // amount of buffering is limited to one HTTP/2 data frame. | 994 // amount of buffering is limited to one HTTP/2 data frame. |
1012 const int kMinDataFrames = 4; | 995 const int kMinDataFrames = 4; |
1013 const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024; | 996 const size_t data_len = kSpdyInitialFrameSizeLimit * kMinDataFrames + 1024; |
(...skipping 23 matching lines...) Expand all Loading... |
1037 consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov), | 1020 consumed_data = session_.WritevStreamData(id, MakeIOVector(data, &iov), |
1038 offset, fin, nullptr); | 1021 offset, fin, nullptr); |
1039 | 1022 |
1040 EXPECT_EQ(consumed_data.bytes_consumed, 0u); | 1023 EXPECT_EQ(consumed_data.bytes_consumed, 0u); |
1041 EXPECT_EQ(consumed_data.fin_consumed, false); | 1024 EXPECT_EQ(consumed_data.fin_consumed, false); |
1042 } | 1025 } |
1043 | 1026 |
1044 } // namespace | 1027 } // namespace |
1045 } // namespace test | 1028 } // namespace test |
1046 } // namespace net | 1029 } // namespace net |
OLD | NEW |