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/test_tools/quic_test_utils.h" | 5 #include "net/quic/test_tools/quic_test_utils.h" |
6 | 6 |
7 #include "base/sha1.h" | 7 #include "base/sha1.h" |
8 #include "base/stl_util.h" | 8 #include "base/stl_util.h" |
9 #include "base/strings/string_number_conversions.h" | 9 #include "base/strings/string_number_conversions.h" |
10 #include "net/quic/crypto/crypto_framer.h" | 10 #include "net/quic/crypto/crypto_framer.h" |
(...skipping 25 matching lines...) Expand all Loading... |
36 explicit TestAlarm(QuicAlarm::Delegate* delegate) | 36 explicit TestAlarm(QuicAlarm::Delegate* delegate) |
37 : QuicAlarm(delegate) { | 37 : QuicAlarm(delegate) { |
38 } | 38 } |
39 | 39 |
40 virtual void SetImpl() OVERRIDE {} | 40 virtual void SetImpl() OVERRIDE {} |
41 virtual void CancelImpl() OVERRIDE {} | 41 virtual void CancelImpl() OVERRIDE {} |
42 }; | 42 }; |
43 | 43 |
44 } // namespace | 44 } // namespace |
45 | 45 |
46 QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed, | 46 QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed) { |
47 QuicPacketSequenceNumber least_unacked) { | |
48 QuicAckFrame ack; | 47 QuicAckFrame ack; |
49 ack.received_info.largest_observed = largest_observed; | 48 ack.largest_observed = largest_observed; |
50 ack.received_info.entropy_hash = 0; | 49 ack.entropy_hash = 0; |
51 ack.sent_info.least_unacked = least_unacked; | |
52 ack.sent_info.entropy_hash = 0; | |
53 return ack; | 50 return ack; |
54 } | 51 } |
55 | 52 |
56 QuicAckFrame MakeAckFrameWithNackRanges( | 53 QuicAckFrame MakeAckFrameWithNackRanges( |
57 size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) { | 54 size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) { |
58 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked, | 55 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked); |
59 least_unacked); | |
60 // Add enough missing packets to get num_nack_ranges nack ranges. | 56 // Add enough missing packets to get num_nack_ranges nack ranges. |
61 for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) { | 57 for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) { |
62 ack.received_info.missing_packets.insert(least_unacked + i); | 58 ack.missing_packets.insert(least_unacked + i); |
63 } | 59 } |
64 return ack; | 60 return ack; |
65 } | 61 } |
66 | 62 |
67 SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer, | 63 SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer, |
68 const QuicPacketHeader& header, | 64 const QuicPacketHeader& header, |
69 const QuicFrames& frames) { | 65 const QuicFrames& frames) { |
70 const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize); | 66 const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize); |
71 size_t packet_size = GetPacketHeaderSize(header); | 67 size_t packet_size = GetPacketHeaderSize(header); |
72 for (size_t i = 0; i < frames.size(); ++i) { | 68 for (size_t i = 0; i < frames.size(); ++i) { |
(...skipping 482 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
555 size_t GetPacketLengthForOneStream( | 551 size_t GetPacketLengthForOneStream( |
556 QuicVersion version, | 552 QuicVersion version, |
557 bool include_version, | 553 bool include_version, |
558 QuicSequenceNumberLength sequence_number_length, | 554 QuicSequenceNumberLength sequence_number_length, |
559 InFecGroup is_in_fec_group, | 555 InFecGroup is_in_fec_group, |
560 size_t* payload_length) { | 556 size_t* payload_length) { |
561 *payload_length = 1; | 557 *payload_length = 1; |
562 const size_t stream_length = | 558 const size_t stream_length = |
563 NullEncrypter().GetCiphertextSize(*payload_length) + | 559 NullEncrypter().GetCiphertextSize(*payload_length) + |
564 QuicPacketCreator::StreamFramePacketOverhead( | 560 QuicPacketCreator::StreamFramePacketOverhead( |
565 version, PACKET_8BYTE_CONNECTION_ID, include_version, | 561 PACKET_8BYTE_CONNECTION_ID, include_version, |
566 sequence_number_length, 0u, is_in_fec_group); | 562 sequence_number_length, 0u, is_in_fec_group); |
567 const size_t ack_length = NullEncrypter().GetCiphertextSize( | 563 const size_t ack_length = NullEncrypter().GetCiphertextSize( |
568 QuicFramer::GetMinAckFrameSize( | 564 QuicFramer::GetMinAckFrameSize( |
569 version, sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) + | 565 sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) + |
570 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version, | 566 GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version, |
571 sequence_number_length, is_in_fec_group); | 567 sequence_number_length, is_in_fec_group); |
572 if (stream_length < ack_length) { | 568 if (stream_length < ack_length) { |
573 *payload_length = 1 + ack_length - stream_length; | 569 *payload_length = 1 + ack_length - stream_length; |
574 } | 570 } |
575 | 571 |
576 return NullEncrypter().GetCiphertextSize(*payload_length) + | 572 return NullEncrypter().GetCiphertextSize(*payload_length) + |
577 QuicPacketCreator::StreamFramePacketOverhead( | 573 QuicPacketCreator::StreamFramePacketOverhead( |
578 version, PACKET_8BYTE_CONNECTION_ID, include_version, | 574 PACKET_8BYTE_CONNECTION_ID, include_version, |
579 sequence_number_length, 0u, is_in_fec_group); | 575 sequence_number_length, 0u, is_in_fec_group); |
580 } | 576 } |
581 | 577 |
582 TestEntropyCalculator::TestEntropyCalculator() {} | 578 TestEntropyCalculator::TestEntropyCalculator() {} |
583 | 579 |
584 TestEntropyCalculator::~TestEntropyCalculator() {} | 580 TestEntropyCalculator::~TestEntropyCalculator() {} |
585 | 581 |
586 QuicPacketEntropyHash TestEntropyCalculator::EntropyHash( | 582 QuicPacketEntropyHash TestEntropyCalculator::EntropyHash( |
587 QuicPacketSequenceNumber sequence_number) const { | 583 QuicPacketSequenceNumber sequence_number) const { |
588 return 1u; | 584 return 1u; |
(...skipping 16 matching lines...) Expand all Loading... |
605 } | 601 } |
606 | 602 |
607 QuicVersionVector SupportedVersions(QuicVersion version) { | 603 QuicVersionVector SupportedVersions(QuicVersion version) { |
608 QuicVersionVector versions; | 604 QuicVersionVector versions; |
609 versions.push_back(version); | 605 versions.push_back(version); |
610 return versions; | 606 return versions; |
611 } | 607 } |
612 | 608 |
613 } // namespace test | 609 } // namespace test |
614 } // namespace net | 610 } // namespace net |
OLD | NEW |