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