OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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_packet_creator.h" | 5 #include "net/quic/core/quic_packet_creator.h" |
6 | 6 |
7 #include <cstdint> | 7 #include <cstdint> |
8 #include <memory> | 8 #include <memory> |
9 #include <ostream> | 9 #include <ostream> |
10 #include <string> | 10 #include <string> |
(...skipping 17 matching lines...) Expand all Loading... |
28 using testing::InSequence; | 28 using testing::InSequence; |
29 using testing::Return; | 29 using testing::Return; |
30 using testing::SaveArg; | 30 using testing::SaveArg; |
31 using testing::StrictMock; | 31 using testing::StrictMock; |
32 using testing::_; | 32 using testing::_; |
33 | 33 |
34 namespace net { | 34 namespace net { |
35 namespace test { | 35 namespace test { |
36 namespace { | 36 namespace { |
37 | 37 |
| 38 const QuicStreamId kGetNthClientInitiatedStreamId1 = kHeadersStreamId + 2; |
| 39 |
38 // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}. | 40 // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}. |
39 struct TestParams { | 41 struct TestParams { |
40 TestParams(QuicVersion version, | 42 TestParams(QuicVersion version, |
41 bool version_serialization, | 43 bool version_serialization, |
42 QuicConnectionIdLength length) | 44 QuicConnectionIdLength length) |
43 : version(version), | 45 : version(version), |
44 connection_id_length(length), | 46 connection_id_length(length), |
45 version_serialization(version_serialization) {} | 47 version_serialization(version_serialization) {} |
46 | 48 |
47 friend std::ostream& operator<<(std::ostream& os, const TestParams& p) { | 49 friend std::ostream& operator<<(std::ostream& os, const TestParams& p) { |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
181 // Returns the number of bytes of overhead that will be added to a packet | 183 // Returns the number of bytes of overhead that will be added to a packet |
182 // of maximum length. | 184 // of maximum length. |
183 size_t GetEncryptionOverhead() { | 185 size_t GetEncryptionOverhead() { |
184 return creator_.max_packet_length() - | 186 return creator_.max_packet_length() - |
185 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()); | 187 client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()); |
186 } | 188 } |
187 | 189 |
188 // Returns the number of bytes consumed by the non-data fields of a stream | 190 // Returns the number of bytes consumed by the non-data fields of a stream |
189 // frame, assuming it is the last frame in the packet | 191 // frame, assuming it is the last frame in the packet |
190 size_t GetStreamFrameOverhead() { | 192 size_t GetStreamFrameOverhead() { |
191 return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset, | 193 return QuicFramer::GetMinStreamFrameSize(kGetNthClientInitiatedStreamId1, |
192 true); | 194 kOffset, true); |
193 } | 195 } |
194 | 196 |
195 QuicIOVector MakeIOVectorFromStringPiece(QuicStringPiece s) { | 197 QuicIOVector MakeIOVectorFromStringPiece(QuicStringPiece s) { |
196 return MakeIOVector(s, &iov_); | 198 return MakeIOVector(s, &iov_); |
197 } | 199 } |
198 | 200 |
199 QuicPendingRetransmission CreateRetransmission( | 201 QuicPendingRetransmission CreateRetransmission( |
200 const QuicFrames& retransmittable_frames, | 202 const QuicFrames& retransmittable_frames, |
201 bool has_crypto_handshake, | 203 bool has_crypto_handshake, |
202 int num_padding_bytes, | 204 int num_padding_bytes, |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
507 EXPECT_TRUE(creator_.HasPendingFrames()); | 509 EXPECT_TRUE(creator_.HasPendingFrames()); |
508 } | 510 } |
509 | 511 |
510 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) { | 512 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) { |
511 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); | 513 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); |
512 const size_t overhead = GetPacketHeaderOverhead(client_framer_.version()) + | 514 const size_t overhead = GetPacketHeaderOverhead(client_framer_.version()) + |
513 GetEncryptionOverhead(); | 515 GetEncryptionOverhead(); |
514 for (size_t i = overhead; i < overhead + 100; ++i) { | 516 for (size_t i = overhead; i < overhead + 100; ++i) { |
515 creator_.SetMaxPacketLength(i); | 517 creator_.SetMaxPacketLength(i); |
516 const bool should_have_room = i > overhead + GetStreamFrameOverhead(); | 518 const bool should_have_room = i > overhead + GetStreamFrameOverhead(); |
517 ASSERT_EQ(should_have_room, | 519 ASSERT_EQ(should_have_room, creator_.HasRoomForStreamFrame( |
518 creator_.HasRoomForStreamFrame(kClientDataStreamId1, kOffset)); | 520 kGetNthClientInitiatedStreamId1, kOffset)); |
519 if (should_have_room) { | 521 if (should_have_room) { |
520 QuicFrame frame; | 522 QuicFrame frame; |
521 QuicIOVector io_vector(MakeIOVectorFromStringPiece("testdata")); | 523 QuicIOVector io_vector(MakeIOVectorFromStringPiece("testdata")); |
522 EXPECT_CALL(delegate_, OnSerializedPacket(_)) | 524 EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
523 .WillRepeatedly(Invoke( | 525 .WillRepeatedly(Invoke( |
524 this, &QuicPacketCreatorTest::ClearSerializedPacketForTests)); | 526 this, &QuicPacketCreatorTest::ClearSerializedPacketForTests)); |
525 ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, | 527 ASSERT_TRUE(creator_.ConsumeData(kGetNthClientInitiatedStreamId1, |
526 kOffset, false, false, &frame)); | 528 io_vector, 0u, kOffset, false, false, |
| 529 &frame)); |
527 ASSERT_TRUE(frame.stream_frame); | 530 ASSERT_TRUE(frame.stream_frame); |
528 size_t bytes_consumed = frame.stream_frame->data_length; | 531 size_t bytes_consumed = frame.stream_frame->data_length; |
529 EXPECT_LT(0u, bytes_consumed); | 532 EXPECT_LT(0u, bytes_consumed); |
530 creator_.Flush(); | 533 creator_.Flush(); |
531 } | 534 } |
532 } | 535 } |
533 } | 536 } |
534 | 537 |
535 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) { | 538 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) { |
536 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); | 539 creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); |
537 // Compute the total overhead for a single frame in packet. | 540 // Compute the total overhead for a single frame in packet. |
538 const size_t overhead = GetPacketHeaderOverhead(client_framer_.version()) + | 541 const size_t overhead = GetPacketHeaderOverhead(client_framer_.version()) + |
539 GetEncryptionOverhead() + GetStreamFrameOverhead(); | 542 GetEncryptionOverhead() + GetStreamFrameOverhead(); |
540 size_t capacity = kDefaultMaxPacketSize - overhead; | 543 size_t capacity = kDefaultMaxPacketSize - overhead; |
541 // Now, test various sizes around this size. | 544 // Now, test various sizes around this size. |
542 for (int delta = -5; delta <= 5; ++delta) { | 545 for (int delta = -5; delta <= 5; ++delta) { |
543 string data(capacity + delta, 'A'); | 546 string data(capacity + delta, 'A'); |
544 size_t bytes_free = delta > 0 ? 0 : 0 - delta; | 547 size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
545 QuicFrame frame; | 548 QuicFrame frame; |
546 QuicIOVector io_vector(MakeIOVectorFromStringPiece(data)); | 549 QuicIOVector io_vector(MakeIOVectorFromStringPiece(data)); |
547 ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, | 550 ASSERT_TRUE(creator_.ConsumeData(kGetNthClientInitiatedStreamId1, io_vector, |
548 kOffset, false, false, &frame)); | 551 0u, kOffset, false, false, &frame)); |
549 ASSERT_TRUE(frame.stream_frame); | 552 ASSERT_TRUE(frame.stream_frame); |
550 | 553 |
551 // BytesFree() returns bytes available for the next frame, which will | 554 // BytesFree() returns bytes available for the next frame, which will |
552 // be two bytes smaller since the stream frame would need to be grown. | 555 // be two bytes smaller since the stream frame would need to be grown. |
553 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame()); | 556 EXPECT_EQ(2u, creator_.ExpansionOnNewFrame()); |
554 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2; | 557 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2; |
555 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; | 558 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; |
556 EXPECT_CALL(delegate_, OnSerializedPacket(_)) | 559 EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
557 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); | 560 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
558 creator_.Flush(); | 561 creator_.Flush(); |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
606 size_t capacity = kDefaultMaxPacketSize - overhead; | 609 size_t capacity = kDefaultMaxPacketSize - overhead; |
607 // Now, test various sizes around this size. | 610 // Now, test various sizes around this size. |
608 for (int delta = -5; delta <= 5; ++delta) { | 611 for (int delta = -5; delta <= 5; ++delta) { |
609 string data(capacity + delta, 'A'); | 612 string data(capacity + delta, 'A'); |
610 size_t bytes_free = delta > 0 ? 0 : 0 - delta; | 613 size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
611 | 614 |
612 QuicFrame frame; | 615 QuicFrame frame; |
613 QuicIOVector io_vector(MakeIOVectorFromStringPiece(data)); | 616 QuicIOVector io_vector(MakeIOVectorFromStringPiece(data)); |
614 EXPECT_CALL(delegate_, OnSerializedPacket(_)) | 617 EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
615 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); | 618 .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
616 ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, | 619 ASSERT_TRUE(creator_.ConsumeData(kGetNthClientInitiatedStreamId1, io_vector, |
617 kOffset, false, false, &frame)); | 620 0u, kOffset, false, false, &frame)); |
618 ASSERT_TRUE(frame.stream_frame); | 621 ASSERT_TRUE(frame.stream_frame); |
619 size_t bytes_consumed = frame.stream_frame->data_length; | 622 size_t bytes_consumed = frame.stream_frame->data_length; |
620 EXPECT_LT(0u, bytes_consumed); | 623 EXPECT_LT(0u, bytes_consumed); |
621 creator_.Flush(); | 624 creator_.Flush(); |
622 ASSERT_TRUE(serialized_packet_.encrypted_buffer); | 625 ASSERT_TRUE(serialized_packet_.encrypted_buffer); |
623 if (bytes_free > 0) { | 626 if (bytes_free > 0) { |
624 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, | 627 EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, |
625 serialized_packet_.encrypted_length); | 628 serialized_packet_.encrypted_length); |
626 } else { | 629 } else { |
627 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length); | 630 EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length); |
(...skipping 395 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1023 // Flush all paddings. | 1026 // Flush all paddings. |
1024 while (creator_.pending_padding_bytes() > 0) { | 1027 while (creator_.pending_padding_bytes() > 0) { |
1025 creator_.Flush(); | 1028 creator_.Flush(); |
1026 } | 1029 } |
1027 EXPECT_EQ(0u, creator_.pending_padding_bytes()); | 1030 EXPECT_EQ(0u, creator_.pending_padding_bytes()); |
1028 } | 1031 } |
1029 | 1032 |
1030 } // namespace | 1033 } // namespace |
1031 } // namespace test | 1034 } // namespace test |
1032 } // namespace net | 1035 } // namespace net |
OLD | NEW |