[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 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 |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "net/quic/test_tools/quic_test_utils.h" |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 6 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 7 | #include "base/sha1.h" |
[email protected] | 701bc89 | 2013-01-17 04:51:54 | [diff] [blame] | 8 | #include "base/stl_util.h" |
[email protected] | b12764d | 2013-12-02 22:28:30 | [diff] [blame] | 9 | #include "base/strings/string_number_conversions.h" |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 10 | #include "net/quic/crypto/crypto_framer.h" |
[email protected] | 6f54ab3 | 2013-03-02 17:43:35 | [diff] [blame] | 11 | #include "net/quic/crypto/crypto_handshake.h" |
[email protected] | 872edd9e | 2013-01-16 08:51:15 | [diff] [blame] | 12 | #include "net/quic/crypto/crypto_utils.h" |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 13 | #include "net/quic/crypto/null_encrypter.h" |
[email protected] | 4df6984 | 2013-02-27 06:32:16 | [diff] [blame] | 14 | #include "net/quic/crypto/quic_decrypter.h" |
| 15 | #include "net/quic/crypto/quic_encrypter.h" |
rtenneti | 16a2077 | 2015-02-17 18:58:48 | [diff] [blame] | 16 | #include "net/quic/quic_data_writer.h" |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 17 | #include "net/quic/quic_framer.h" |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 18 | #include "net/quic/quic_packet_creator.h" |
[email protected] | 79d13dcb | 2014-02-05 07:23:13 | [diff] [blame] | 19 | #include "net/quic/quic_utils.h" |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 20 | #include "net/quic/test_tools/crypto_test_utils.h" |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 21 | #include "net/quic/test_tools/quic_connection_peer.h" |
[email protected] | c244c5a1 | 2013-05-07 20:55:04 | [diff] [blame] | 22 | #include "net/spdy/spdy_frame_builder.h" |
rch | c99f380c | 2015-03-26 19:50:56 | [diff] [blame] | 23 | #include "net/tools/quic/quic_per_connection_packet_writer.h" |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 24 | |
[email protected] | c244c5a1 | 2013-05-07 20:55:04 | [diff] [blame] | 25 | using base::StringPiece; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 26 | using std::max; |
| 27 | using std::min; |
| 28 | using std::string; |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 29 | using testing::Invoke; |
[email protected] | bc356fe | 2014-06-19 11:14:14 | [diff] [blame] | 30 | using testing::_; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 31 | |
| 32 | namespace net { |
| 33 | namespace test { |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 34 | namespace { |
| 35 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 36 | // No-op alarm implementation used by MockConnectionHelper. |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 37 | class TestAlarm : public QuicAlarm { |
| 38 | public: |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 39 | explicit TestAlarm(QuicAlarm::Delegate* delegate) : QuicAlarm(delegate) {} |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 40 | |
dcheng | b03027d | 2014-10-21 12:00:20 | [diff] [blame] | 41 | void SetImpl() override {} |
| 42 | void CancelImpl() override {} |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 43 | }; |
| 44 | |
| 45 | } // namespace |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 46 | |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 47 | QuicAckFrame MakeAckFrame(QuicPacketNumber largest_observed) { |
[email protected] | fb35b0a | 2014-04-15 21:06:49 | [diff] [blame] | 48 | QuicAckFrame ack; |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame] | 49 | ack.largest_observed = largest_observed; |
| 50 | ack.entropy_hash = 0; |
[email protected] | fb35b0a | 2014-04-15 21:06:49 | [diff] [blame] | 51 | return ack; |
| 52 | } |
| 53 | |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 54 | QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges, |
| 55 | QuicPacketNumber least_unacked) { |
[email protected] | 310d37b | 2014-08-02 06:15:37 | [diff] [blame] | 56 | QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked); |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 57 | // Add enough missing packets to get num_nack_ranges nack ranges. |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 58 | for (QuicPacketNumber i = 1; i < 2 * num_nack_ranges; i += 2) { |
rtenneti | 493d90ef | 2015-09-14 04:43:11 | [diff] [blame] | 59 | ack.missing_packets.Add(least_unacked + i); |
[email protected] | aa7e4ef | 2014-05-28 03:53:15 | [diff] [blame] | 60 | } |
| 61 | return ack; |
| 62 | } |
| 63 | |
rtenneti | b6ac61a5 | 2015-02-11 20:20:52 | [diff] [blame] | 64 | QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer, |
| 65 | const QuicPacketHeader& header, |
| 66 | const QuicFrames& frames) { |
[email protected] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 67 | const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize); |
| 68 | size_t packet_size = GetPacketHeaderSize(header); |
| 69 | for (size_t i = 0; i < frames.size(); ++i) { |
| 70 | DCHECK_LE(packet_size, max_plaintext_size); |
| 71 | bool first_frame = i == 0; |
| 72 | bool last_frame = i == frames.size() - 1; |
| 73 | const size_t frame_size = framer->GetSerializedFrameLength( |
| 74 | frames[i], max_plaintext_size - packet_size, first_frame, last_frame, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 75 | header.is_in_fec_group, header.public_header.packet_number_length); |
[email protected] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 76 | DCHECK(frame_size); |
| 77 | packet_size += frame_size; |
| 78 | } |
rtenneti | 16a2077 | 2015-02-17 18:58:48 | [diff] [blame] | 79 | return BuildUnsizedDataPacket(framer, header, frames, packet_size); |
| 80 | } |
| 81 | |
| 82 | QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer, |
| 83 | const QuicPacketHeader& header, |
| 84 | const QuicFrames& frames, |
| 85 | size_t packet_size) { |
| 86 | char* buffer = new char[packet_size]; |
alyssar | c39b80f | 2015-10-22 17:13:58 | [diff] [blame] | 87 | size_t length = framer->BuildDataPacket(header, frames, buffer, packet_size); |
| 88 | DCHECK_NE(0u, length); |
| 89 | // Re-construct the data packet with data ownership. |
| 90 | return new QuicPacket(buffer, length, /* owns_buffer */ true, |
rtenneti | 16a2077 | 2015-02-17 18:58:48 | [diff] [blame] | 91 | header.public_header.connection_id_length, |
| 92 | header.public_header.version_flag, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 93 | header.public_header.packet_number_length); |
[email protected] | 9cda5fd | 2014-06-03 10:20:28 | [diff] [blame] | 94 | } |
| 95 | |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 96 | uint64_t SimpleRandom::RandUint64() { |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 97 | unsigned char hash[base::kSHA1Length]; |
| 98 | base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_), |
| 99 | hash); |
| 100 | memcpy(&seed_, hash, sizeof(seed_)); |
| 101 | return seed_; |
| 102 | } |
| 103 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 104 | MockFramerVisitor::MockFramerVisitor() { |
| 105 | // By default, we want to accept packets. |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 106 | ON_CALL(*this, OnProtocolVersionMismatch(_)) |
| 107 | .WillByDefault(testing::Return(false)); |
| 108 | |
| 109 | // By default, we want to accept packets. |
[email protected] | ec86d546 | 2013-11-17 16:04:49 | [diff] [blame] | 110 | ON_CALL(*this, OnUnauthenticatedHeader(_)) |
| 111 | .WillByDefault(testing::Return(true)); |
| 112 | |
[email protected] | 066d818 | 2014-01-04 02:02:45 | [diff] [blame] | 113 | ON_CALL(*this, OnUnauthenticatedPublicHeader(_)) |
| 114 | .WillByDefault(testing::Return(true)); |
| 115 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 116 | ON_CALL(*this, OnPacketHeader(_)).WillByDefault(testing::Return(true)); |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 117 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 118 | ON_CALL(*this, OnStreamFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 119 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 120 | ON_CALL(*this, OnAckFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 121 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 122 | ON_CALL(*this, OnStopWaitingFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | 93dd91f | 2014-02-27 00:09:03 | [diff] [blame] | 123 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 124 | ON_CALL(*this, OnPingFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | d8c52211 | 2014-04-23 09:23:25 | [diff] [blame] | 125 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 126 | ON_CALL(*this, OnRstStreamFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 127 | |
| 128 | ON_CALL(*this, OnConnectionCloseFrame(_)) |
| 129 | .WillByDefault(testing::Return(true)); |
| 130 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 131 | ON_CALL(*this, OnGoAwayFrame(_)).WillByDefault(testing::Return(true)); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 132 | } |
| 133 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 134 | MockFramerVisitor::~MockFramerVisitor() {} |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 135 | |
[email protected] | 4887809 | 2013-07-26 14:51:56 | [diff] [blame] | 136 | bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) { |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 137 | return false; |
| 138 | } |
| 139 | |
[email protected] | 066d818 | 2014-01-04 02:02:45 | [diff] [blame] | 140 | bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader( |
| 141 | const QuicPacketPublicHeader& header) { |
| 142 | return true; |
| 143 | } |
| 144 | |
[email protected] | ec86d546 | 2013-11-17 16:04:49 | [diff] [blame] | 145 | bool NoOpFramerVisitor::OnUnauthenticatedHeader( |
| 146 | const QuicPacketHeader& header) { |
| 147 | return true; |
| 148 | } |
| 149 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 150 | bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) { |
| 151 | return true; |
| 152 | } |
| 153 | |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 154 | bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) { |
| 155 | return true; |
| 156 | } |
| 157 | |
| 158 | bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) { |
| 159 | return true; |
| 160 | } |
| 161 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 162 | bool NoOpFramerVisitor::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) { |
[email protected] | 93dd91f | 2014-02-27 00:09:03 | [diff] [blame] | 163 | return true; |
| 164 | } |
| 165 | |
[email protected] | d8c52211 | 2014-04-23 09:23:25 | [diff] [blame] | 166 | bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) { |
| 167 | return true; |
| 168 | } |
| 169 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 170 | bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& frame) { |
[email protected] | a57e027 | 2013-04-26 07:31:47 | [diff] [blame] | 171 | return true; |
| 172 | } |
| 173 | |
| 174 | bool NoOpFramerVisitor::OnConnectionCloseFrame( |
| 175 | const QuicConnectionCloseFrame& frame) { |
| 176 | return true; |
| 177 | } |
| 178 | |
| 179 | bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) { |
| 180 | return true; |
| 181 | } |
| 182 | |
[email protected] | cb23a92 | 2014-02-20 17:42:38 | [diff] [blame] | 183 | bool NoOpFramerVisitor::OnWindowUpdateFrame( |
| 184 | const QuicWindowUpdateFrame& frame) { |
| 185 | return true; |
| 186 | } |
| 187 | |
| 188 | bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) { |
| 189 | return true; |
| 190 | } |
| 191 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 192 | MockConnectionVisitor::MockConnectionVisitor() {} |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 193 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 194 | MockConnectionVisitor::~MockConnectionVisitor() {} |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 195 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 196 | MockConnectionHelper::MockConnectionHelper() {} |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 197 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 198 | MockConnectionHelper::~MockConnectionHelper() {} |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 199 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 200 | const QuicClock* MockConnectionHelper::GetClock() const { |
[email protected] | 9c0b135 | 2012-11-04 00:03:27 | [diff] [blame] | 201 | return &clock_; |
| 202 | } |
| 203 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 204 | QuicRandom* MockConnectionHelper::GetRandomGenerator() { |
[email protected] | 9558c5d3 | 2012-12-22 00:08:14 | [diff] [blame] | 205 | return &random_generator_; |
| 206 | } |
| 207 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 208 | QuicAlarm* MockConnectionHelper::CreateAlarm(QuicAlarm::Delegate* delegate) { |
[email protected] | 965dbe6 | 2013-08-09 21:34:31 | [diff] [blame] | 209 | return new TestAlarm(delegate); |
| 210 | } |
| 211 | |
jdorfman | 5a60672 | 2016-01-04 17:41:29 | [diff] [blame] | 212 | QuicBufferAllocator* MockConnectionHelper::GetBufferAllocator() { |
| 213 | return &buffer_allocator_; |
| 214 | } |
| 215 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 216 | void MockConnectionHelper::AdvanceTime(QuicTime::Delta delta) { |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 217 | clock_.AdvanceTime(delta); |
| 218 | } |
| 219 | |
rtenneti | 3fe4ebbc | 2014-11-16 16:43:47 | [diff] [blame] | 220 | QuicPacketWriter* NiceMockPacketWriterFactory::Create( |
| 221 | QuicConnection* /*connection*/) const { |
| 222 | return new testing::NiceMock<MockPacketWriter>(); |
| 223 | } |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 224 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 225 | MockConnection::MockConnection(MockConnectionHelper* helper, |
| 226 | Perspective perspective) |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 227 | : MockConnection(kTestConnectionId, |
rtenneti | 8696cf9 | 2014-11-14 21:12:12 | [diff] [blame] | 228 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 229 | helper, |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 230 | perspective, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 231 | QuicSupportedVersions()) {} |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 232 | |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 233 | MockConnection::MockConnection(IPEndPoint address, |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 234 | MockConnectionHelper* helper, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 235 | Perspective perspective) |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 236 | : MockConnection(kTestConnectionId, |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 237 | address, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 238 | helper, |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 239 | perspective, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 240 | QuicSupportedVersions()) {} |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 241 | |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 242 | MockConnection::MockConnection(QuicConnectionId connection_id, |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 243 | MockConnectionHelper* helper, |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 244 | Perspective perspective) |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 245 | : MockConnection(connection_id, |
rtenneti | fb3fa6c | 2015-03-16 23:04:55 | [diff] [blame] | 246 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 247 | helper, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 248 | perspective, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 249 | QuicSupportedVersions()) {} |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 250 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 251 | MockConnection::MockConnection(MockConnectionHelper* helper, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 252 | Perspective perspective, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 253 | const QuicVersionVector& supported_versions) |
| 254 | : MockConnection(kTestConnectionId, |
| 255 | IPEndPoint(TestPeerIPAddress(), kTestPort), |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 256 | helper, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 257 | perspective, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 258 | supported_versions) {} |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 259 | |
| 260 | MockConnection::MockConnection(QuicConnectionId connection_id, |
| 261 | IPEndPoint address, |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 262 | MockConnectionHelper* helper, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 263 | Perspective perspective, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 264 | const QuicVersionVector& supported_versions) |
| 265 | : QuicConnection(connection_id, |
| 266 | address, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 267 | helper, |
rtenneti | fb3fa6c | 2015-03-16 23:04:55 | [diff] [blame] | 268 | NiceMockPacketWriterFactory(), |
| 269 | /* owns_writer= */ true, |
| 270 | perspective, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 271 | supported_versions) { |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 272 | ON_CALL(*this, OnError(_)) |
| 273 | .WillByDefault( |
| 274 | Invoke(this, &PacketSavingConnection::QuicConnection_OnError)); |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 275 | } |
| 276 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 277 | MockConnection::~MockConnection() {} |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 278 | |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 279 | void MockConnection::AdvanceTime(QuicTime::Delta delta) { |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 280 | static_cast<MockConnectionHelper*>(helper())->AdvanceTime(delta); |
[email protected] | fe053f9 | 2013-04-23 20:18:55 | [diff] [blame] | 281 | } |
| 282 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 283 | PacketSavingConnection::PacketSavingConnection(MockConnectionHelper* helper, |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 284 | Perspective perspective) |
| 285 | : MockConnection(helper, perspective) {} |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 286 | |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 287 | PacketSavingConnection::PacketSavingConnection( |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 288 | MockConnectionHelper* helper, |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 289 | Perspective perspective, |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 290 | const QuicVersionVector& supported_versions) |
rtenneti | 8a4a073 | 2015-10-18 00:45:51 | [diff] [blame] | 291 | : MockConnection(helper, perspective, supported_versions) {} |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 292 | |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 293 | PacketSavingConnection::~PacketSavingConnection() { |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 294 | STLDeleteElements(&encrypted_packets_); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 295 | } |
| 296 | |
rtenneti | 31e9fd6 | 2014-09-16 05:22:15 | [diff] [blame] | 297 | void PacketSavingConnection::SendOrQueuePacket(QueuedPacket packet) { |
rtenneti | e0ee6eb | 2015-05-01 00:55:09 | [diff] [blame] | 298 | if (!packet.serialized_packet.packet->owns_buffer()) { |
| 299 | scoped_ptr<QuicEncryptedPacket> encrypted_deleter( |
| 300 | packet.serialized_packet.packet); |
| 301 | packet.serialized_packet.packet = packet.serialized_packet.packet->Clone(); |
| 302 | } |
rtenneti | b6ac61a5 | 2015-02-11 20:20:52 | [diff] [blame] | 303 | encrypted_packets_.push_back(packet.serialized_packet.packet); |
rtenneti | 31e9fd6 | 2014-09-16 05:22:15 | [diff] [blame] | 304 | // Transfer ownership of the packet to the SentPacketManager and the |
| 305 | // ack notifier to the AckNotifierManager. |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 306 | sent_packet_manager_.OnPacketSent(&packet.serialized_packet, 0, |
| 307 | QuicTime::Zero(), 1000, NOT_RETRANSMISSION, |
| 308 | HAS_RETRANSMITTABLE_DATA); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 309 | } |
| 310 | |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 311 | MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection) |
| 312 | : QuicSpdySession(connection, DefaultQuicConfig()) { |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 313 | crypto_stream_.reset(new QuicCryptoStream(this)); |
| 314 | Initialize(); |
[email protected] | bbb1007 | 2014-06-13 07:41:59 | [diff] [blame] | 315 | ON_CALL(*this, WritevData(_, _, _, _, _, _)) |
[email protected] | cff7b7b | 2013-01-11 08:49:07 | [diff] [blame] | 316 | .WillByDefault(testing::Return(QuicConsumedData(0, false))); |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 317 | } |
| 318 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 319 | MockQuicSpdySession::~MockQuicSpdySession() {} |
[email protected] | 044ac2b | 2012-11-13 21:41:06 | [diff] [blame] | 320 | |
jokulik | 2324d28 | 2015-12-08 21:42:57 | [diff] [blame] | 321 | // static |
| 322 | QuicConsumedData MockQuicSpdySession::ConsumeAllData( |
| 323 | QuicStreamId /*id*/, |
| 324 | const QuicIOVector& data, |
| 325 | QuicStreamOffset /*offset*/, |
| 326 | bool fin, |
| 327 | FecProtection /*fec_protection*/, |
| 328 | QuicAckListenerInterface* /*ack_notifier_delegate*/) { |
| 329 | return QuicConsumedData(data.total_length, fin); |
| 330 | } |
| 331 | |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 332 | TestQuicSpdyServerSession::TestQuicSpdyServerSession( |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 333 | QuicConnection* connection, |
| 334 | const QuicConfig& config, |
| 335 | const QuicCryptoServerConfig* crypto_config) |
jokulik | c971baf9 | 2016-01-06 00:36:39 | [diff] [blame^] | 336 | : QuicServerSessionBase(config, connection, &visitor_, crypto_config) { |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 337 | Initialize(); |
[email protected] | ccb3421 | 2014-07-18 09:27:50 | [diff] [blame] | 338 | } |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 339 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 340 | TestQuicSpdyServerSession::~TestQuicSpdyServerSession() {} |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 341 | |
jokulik | c971baf9 | 2016-01-06 00:36:39 | [diff] [blame^] | 342 | QuicCryptoServerStreamBase* |
| 343 | TestQuicSpdyServerSession::CreateQuicCryptoServerStream( |
| 344 | const QuicCryptoServerConfig* crypto_config) { |
| 345 | return new QuicCryptoServerStream(crypto_config, this); |
| 346 | } |
| 347 | |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 348 | QuicCryptoServerStream* TestQuicSpdyServerSession::GetCryptoStream() { |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 349 | return static_cast<QuicCryptoServerStream*>( |
jokulik | c971baf9 | 2016-01-06 00:36:39 | [diff] [blame^] | 350 | QuicServerSessionBase::GetCryptoStream()); |
[email protected] | 2532de1 | 2013-05-09 12:29:33 | [diff] [blame] | 351 | } |
| 352 | |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 353 | TestQuicSpdyClientSession::TestQuicSpdyClientSession( |
| 354 | QuicConnection* connection, |
| 355 | const QuicConfig& config, |
| 356 | const QuicServerId& server_id, |
| 357 | QuicCryptoClientConfig* crypto_config) |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 358 | : QuicClientSessionBase(connection, config) { |
| 359 | crypto_stream_.reset(new QuicCryptoClientStream( |
| 360 | server_id, this, CryptoTestUtils::ProofVerifyContextForTesting(), |
| 361 | crypto_config)); |
| 362 | Initialize(); |
[email protected] | 90f62f09 | 2014-03-24 02:41:23 | [diff] [blame] | 363 | } |
| 364 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 365 | TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {} |
[email protected] | 90f62f09 | 2014-03-24 02:41:23 | [diff] [blame] | 366 | |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 367 | QuicCryptoClientStream* TestQuicSpdyClientSession::GetCryptoStream() { |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 368 | return crypto_stream_.get(); |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 369 | } |
| 370 | |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 371 | MockPacketWriter::MockPacketWriter() { |
rtenneti | 493d90ef | 2015-09-14 04:43:11 | [diff] [blame] | 372 | ON_CALL(*this, GetMaxPacketSize(_)) |
| 373 | .WillByDefault(testing::Return(kMaxPacketSize)); |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 374 | } |
| 375 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 376 | MockPacketWriter::~MockPacketWriter() {} |
[email protected] | cbd731e | 2013-10-24 00:20:39 | [diff] [blame] | 377 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 378 | MockSendAlgorithm::MockSendAlgorithm() {} |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 379 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 380 | MockSendAlgorithm::~MockSendAlgorithm() {} |
[email protected] | 8d659e2 | 2013-01-19 04:26:10 | [diff] [blame] | 381 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 382 | MockLossAlgorithm::MockLossAlgorithm() {} |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 383 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 384 | MockLossAlgorithm::~MockLossAlgorithm() {} |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 385 | |
ckrasic | ea295fe | 2015-10-31 05:03:27 | [diff] [blame] | 386 | MockAckListener::MockAckListener() {} |
[email protected] | 97cf302 | 2013-09-05 14:30:16 | [diff] [blame] | 387 | |
ckrasic | ea295fe | 2015-10-31 05:03:27 | [diff] [blame] | 388 | MockAckListener::~MockAckListener() {} |
[email protected] | 97cf302 | 2013-09-05 14:30:16 | [diff] [blame] | 389 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 390 | MockNetworkChangeVisitor::MockNetworkChangeVisitor() {} |
[email protected] | a692ad9d | 2014-07-18 21:35:24 | [diff] [blame] | 391 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 392 | MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {} |
[email protected] | a692ad9d | 2014-07-18 21:35:24 | [diff] [blame] | 393 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 394 | namespace { |
| 395 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 396 | string HexDumpWithMarks(const char* data, |
| 397 | int length, |
| 398 | const bool* marks, |
| 399 | int mark_length) { |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 400 | static const char kHexChars[] = "0123456789abcdef"; |
| 401 | static const int kColumns = 4; |
| 402 | |
| 403 | const int kSizeLimit = 1024; |
| 404 | if (length > kSizeLimit || mark_length > kSizeLimit) { |
| 405 | LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes."; |
| 406 | length = min(length, kSizeLimit); |
| 407 | mark_length = min(mark_length, kSizeLimit); |
| 408 | } |
| 409 | |
| 410 | string hex; |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 411 | for (const char *row = data; length > 0; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 412 | row += kColumns, length -= kColumns) { |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 413 | for (const char* p = row; p < row + 4; ++p) { |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 414 | if (p < row + length) { |
| 415 | const bool mark = |
| 416 | (marks && (p - data) < mark_length && marks[p - data]); |
| 417 | hex += mark ? '*' : ' '; |
| 418 | hex += kHexChars[(*p & 0xf0) >> 4]; |
| 419 | hex += kHexChars[*p & 0x0f]; |
| 420 | hex += mark ? '*' : ' '; |
| 421 | } else { |
| 422 | hex += " "; |
| 423 | } |
| 424 | } |
| 425 | hex = hex + " "; |
| 426 | |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 427 | for (const char* p = row; p < row + 4 && p < row + length; ++p) { |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 428 | hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.'; |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 429 | } |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 430 | |
| 431 | hex = hex + '\n'; |
| 432 | } |
| 433 | return hex; |
| 434 | } |
| 435 | |
| 436 | } // namespace |
| 437 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 438 | IPAddressNumber TestPeerIPAddress() { |
| 439 | return Loopback4(); |
| 440 | } |
[email protected] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 441 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 442 | QuicVersion QuicVersionMax() { |
| 443 | return QuicSupportedVersions().front(); |
| 444 | } |
[email protected] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 445 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 446 | QuicVersion QuicVersionMin() { |
| 447 | return QuicSupportedVersions().back(); |
| 448 | } |
[email protected] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 449 | |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 450 | IPAddressNumber Loopback4() { |
[email protected] | 300ccd5 | 2014-01-25 08:00:19 | [diff] [blame] | 451 | IPAddressNumber addr; |
| 452 | CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr)); |
[email protected] | c05a6d22 | 2013-12-16 19:42:03 | [diff] [blame] | 453 | return addr; |
| 454 | } |
| 455 | |
[email protected] | 730b35d7 | 2014-06-05 03:23:22 | [diff] [blame] | 456 | IPAddressNumber Loopback6() { |
| 457 | IPAddressNumber addr; |
| 458 | CHECK(ParseIPLiteralToNumber("::1", &addr)); |
| 459 | return addr; |
| 460 | } |
| 461 | |
rtenneti | e0ee6eb | 2015-05-01 00:55:09 | [diff] [blame] | 462 | IPAddressNumber Any4() { |
| 463 | IPAddressNumber any4; |
| 464 | CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4)); |
| 465 | return any4; |
| 466 | } |
| 467 | |
[email protected] | 9bb57c7 | 2014-03-31 20:36:04 | [diff] [blame] | 468 | void GenerateBody(string* body, int length) { |
| 469 | body->clear(); |
| 470 | body->reserve(length); |
| 471 | for (int i = 0; i < length; ++i) { |
| 472 | body->append(1, static_cast<char>(32 + i % (126 - 32))); |
| 473 | } |
| 474 | } |
| 475 | |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 476 | QuicEncryptedPacket* ConstructEncryptedPacket(QuicConnectionId connection_id, |
| 477 | bool version_flag, |
| 478 | bool reset_flag, |
| 479 | QuicPacketNumber packet_number, |
| 480 | const string& data) { |
rtenneti | 9e0fb50 | 2015-03-08 06:07:16 | [diff] [blame] | 481 | return ConstructEncryptedPacket( |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 482 | connection_id, version_flag, reset_flag, packet_number, data, |
| 483 | PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER); |
rtenneti | 9e0fb50 | 2015-03-08 06:07:16 | [diff] [blame] | 484 | } |
| 485 | |
| 486 | QuicEncryptedPacket* ConstructEncryptedPacket( |
| 487 | QuicConnectionId connection_id, |
| 488 | bool version_flag, |
| 489 | bool reset_flag, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 490 | QuicPacketNumber packet_number, |
rtenneti | 9e0fb50 | 2015-03-08 06:07:16 | [diff] [blame] | 491 | const string& data, |
| 492 | QuicConnectionIdLength connection_id_length, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 493 | QuicPacketNumberLength packet_number_length) { |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 494 | return ConstructEncryptedPacket(connection_id, version_flag, reset_flag, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 495 | packet_number, data, connection_id_length, |
| 496 | packet_number_length, nullptr); |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | QuicEncryptedPacket* ConstructEncryptedPacket( |
| 500 | QuicConnectionId connection_id, |
| 501 | bool version_flag, |
| 502 | bool reset_flag, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 503 | QuicPacketNumber packet_number, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 504 | const string& data, |
| 505 | QuicConnectionIdLength connection_id_length, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 506 | QuicPacketNumberLength packet_number_length, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 507 | QuicVersionVector* versions) { |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 508 | QuicPacketHeader header; |
| 509 | header.public_header.connection_id = connection_id; |
rtenneti | 9e0fb50 | 2015-03-08 06:07:16 | [diff] [blame] | 510 | header.public_header.connection_id_length = connection_id_length; |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 511 | header.public_header.version_flag = version_flag; |
| 512 | header.public_header.reset_flag = reset_flag; |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 513 | header.public_header.packet_number_length = packet_number_length; |
rtenneti | 8dd12b2 | 2015-10-21 01:26:38 | [diff] [blame] | 514 | header.packet_number = packet_number; |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 515 | header.entropy_flag = false; |
| 516 | header.entropy_hash = 0; |
| 517 | header.fec_flag = false; |
| 518 | header.is_in_fec_group = NOT_IN_FEC_GROUP; |
| 519 | header.fec_group = 0; |
rtenneti | a4228ea | 2015-06-04 02:31:44 | [diff] [blame] | 520 | QuicStreamFrame stream_frame(1, false, 0, StringPiece(data)); |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 521 | QuicFrame frame(&stream_frame); |
| 522 | QuicFrames frames; |
| 523 | frames.push_back(frame); |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 524 | QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(), |
| 525 | QuicTime::Zero(), Perspective::IS_CLIENT); |
| 526 | |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 527 | scoped_ptr<QuicPacket> packet( |
rtenneti | b6ac61a5 | 2015-02-11 20:20:52 | [diff] [blame] | 528 | BuildUnsizedDataPacket(&framer, header, frames)); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 529 | EXPECT_TRUE(packet != nullptr); |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 530 | char* buffer = new char[kMaxPacketSize]; |
| 531 | size_t encrypted_length = framer.EncryptPayload( |
| 532 | ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize); |
| 533 | EXPECT_NE(0u, encrypted_length); |
| 534 | return new QuicEncryptedPacket(buffer, encrypted_length, true); |
[email protected] | ffc34bf | 2014-03-07 02:42:02 | [diff] [blame] | 535 | } |
| 536 | |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 537 | QuicEncryptedPacket* ConstructMisFramedEncryptedPacket( |
| 538 | QuicConnectionId connection_id, |
| 539 | bool version_flag, |
| 540 | bool reset_flag, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 541 | QuicPacketNumber packet_number, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 542 | const string& data, |
| 543 | QuicConnectionIdLength connection_id_length, |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 544 | QuicPacketNumberLength packet_number_length, |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 545 | QuicVersionVector* versions) { |
| 546 | QuicPacketHeader header; |
| 547 | header.public_header.connection_id = connection_id; |
| 548 | header.public_header.connection_id_length = connection_id_length; |
| 549 | header.public_header.version_flag = version_flag; |
| 550 | header.public_header.reset_flag = reset_flag; |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 551 | header.public_header.packet_number_length = packet_number_length; |
rtenneti | 8dd12b2 | 2015-10-21 01:26:38 | [diff] [blame] | 552 | header.packet_number = packet_number; |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 553 | header.entropy_flag = false; |
| 554 | header.entropy_hash = 0; |
| 555 | header.fec_flag = false; |
| 556 | header.is_in_fec_group = NOT_IN_FEC_GROUP; |
| 557 | header.fec_group = 0; |
rtenneti | a4228ea | 2015-06-04 02:31:44 | [diff] [blame] | 558 | QuicStreamFrame stream_frame(1, false, 0, StringPiece(data)); |
rtenneti | 85816fdf | 2015-05-25 03:01:10 | [diff] [blame] | 559 | QuicFrame frame(&stream_frame); |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 560 | QuicFrames frames; |
rtenneti | 85816fdf | 2015-05-25 03:01:10 | [diff] [blame] | 561 | frames.push_back(frame); |
| 562 | QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(), |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 563 | QuicTime::Zero(), Perspective::IS_CLIENT); |
rtenneti | 85816fdf | 2015-05-25 03:01:10 | [diff] [blame] | 564 | |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 565 | scoped_ptr<QuicPacket> packet( |
| 566 | BuildUnsizedDataPacket(&framer, header, frames)); |
| 567 | EXPECT_TRUE(packet != nullptr); |
rtenneti | 85816fdf | 2015-05-25 03:01:10 | [diff] [blame] | 568 | |
| 569 | // Now set the packet's private flags byte to 0xFF, which is an invalid value. |
| 570 | reinterpret_cast<unsigned char*>( |
| 571 | packet->mutable_data())[GetStartOfEncryptedData( |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 572 | connection_id_length, version_flag, packet_number_length)] = 0xFF; |
rtenneti | 85816fdf | 2015-05-25 03:01:10 | [diff] [blame] | 573 | |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 574 | char* buffer = new char[kMaxPacketSize]; |
| 575 | size_t encrypted_length = framer.EncryptPayload( |
| 576 | ENCRYPTION_NONE, packet_number, *packet, buffer, kMaxPacketSize); |
| 577 | EXPECT_NE(0u, encrypted_length); |
| 578 | return new QuicEncryptedPacket(buffer, encrypted_length, true); |
rch | c081544 | 2015-04-18 13:29:46 | [diff] [blame] | 579 | } |
| 580 | |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 581 | void CompareCharArraysWithHexError(const string& description, |
| 582 | const char* actual, |
| 583 | const int actual_len, |
| 584 | const char* expected, |
| 585 | const int expected_len) { |
[email protected] | b007e63 | 2013-10-28 08:39:25 | [diff] [blame] | 586 | EXPECT_EQ(actual_len, expected_len); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 587 | const int min_len = min(actual_len, expected_len); |
| 588 | const int max_len = max(actual_len, expected_len); |
[email protected] | 4356f0f | 2013-04-07 00:58:17 | [diff] [blame] | 589 | scoped_ptr<bool[]> marks(new bool[max_len]); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 590 | bool identical = (actual_len == expected_len); |
| 591 | for (int i = 0; i < min_len; ++i) { |
| 592 | if (actual[i] != expected[i]) { |
| 593 | marks[i] = true; |
| 594 | identical = false; |
| 595 | } else { |
| 596 | marks[i] = false; |
| 597 | } |
| 598 | } |
| 599 | for (int i = min_len; i < max_len; ++i) { |
| 600 | marks[i] = true; |
| 601 | } |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 602 | if (identical) |
| 603 | return; |
| 604 | ADD_FAILURE() << "Description:\n" << description << "\n\nExpected:\n" |
| 605 | << HexDumpWithMarks(expected, expected_len, marks.get(), |
| 606 | max_len) |
| 607 | << "\nActual:\n" |
| 608 | << HexDumpWithMarks(actual, actual_len, marks.get(), max_len); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 609 | } |
| 610 | |
[email protected] | b12764d | 2013-12-02 22:28:30 | [diff] [blame] | 611 | bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) { |
| 612 | bytes->clear(); |
| 613 | if (hex.empty()) |
| 614 | return true; |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 615 | std::vector<uint8_t> v; |
[email protected] | b12764d | 2013-12-02 22:28:30 | [diff] [blame] | 616 | if (!base::HexStringToBytes(hex.as_string(), &v)) |
| 617 | return false; |
| 618 | if (!v.empty()) |
| 619 | bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size()); |
| 620 | return true; |
| 621 | } |
| 622 | |
[email protected] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 623 | static QuicPacket* ConstructPacketFromHandshakeMessage( |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 624 | QuicConnectionId connection_id, |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 625 | const CryptoHandshakeMessage& message, |
| 626 | bool should_include_version) { |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 627 | CryptoFramer crypto_framer; |
[email protected] | dc2cc74 | 2012-10-21 13:56:13 | [diff] [blame] | 628 | scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message)); |
rtenneti | 6f48aa9 | 2015-03-16 02:18:48 | [diff] [blame] | 629 | QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), |
| 630 | Perspective::IS_CLIENT); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 631 | |
| 632 | QuicPacketHeader header; |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 633 | header.public_header.connection_id = connection_id; |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 634 | header.public_header.reset_flag = false; |
[email protected] | 14e8106c | 2013-03-14 16:25:33 | [diff] [blame] | 635 | header.public_header.version_flag = should_include_version; |
rtenneti | 8dd12b2 | 2015-10-21 01:26:38 | [diff] [blame] | 636 | header.packet_number = 1; |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 637 | header.entropy_flag = false; |
| 638 | header.entropy_hash = 0; |
| 639 | header.fec_flag = false; |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 640 | header.fec_group = 0; |
| 641 | |
[email protected] | be24ab2 | 2012-10-22 03:01:52 | [diff] [blame] | 642 | QuicStreamFrame stream_frame(kCryptoStreamId, false, 0, |
rtenneti | a4228ea | 2015-06-04 02:31:44 | [diff] [blame] | 643 | data->AsStringPiece()); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 644 | |
[email protected] | be24ab2 | 2012-10-22 03:01:52 | [diff] [blame] | 645 | QuicFrame frame(&stream_frame); |
| 646 | QuicFrames frames; |
| 647 | frames.push_back(frame); |
rtenneti | b6ac61a5 | 2015-02-11 20:20:52 | [diff] [blame] | 648 | return BuildUnsizedDataPacket(&quic_framer, header, frames); |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 649 | } |
| 650 | |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 651 | QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id, |
| 652 | QuicTag tag) { |
[email protected] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 653 | CryptoHandshakeMessage message; |
[email protected] | ccc66e8a | 2013-03-26 08:26:14 | [diff] [blame] | 654 | message.set_tag(tag); |
[email protected] | 3aa9ca7 | 2014-02-27 19:39:43 | [diff] [blame] | 655 | return ConstructPacketFromHandshakeMessage(connection_id, message, false); |
[email protected] | d3d15bf | 2013-01-30 02:51:54 | [diff] [blame] | 656 | } |
| 657 | |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 658 | size_t GetPacketLengthForOneStream(QuicVersion version, |
| 659 | bool include_version, |
| 660 | QuicConnectionIdLength connection_id_length, |
| 661 | QuicPacketNumberLength packet_number_length, |
| 662 | InFecGroup is_in_fec_group, |
| 663 | size_t* payload_length) { |
[email protected] | f62262b | 2013-07-05 20:57:30 | [diff] [blame] | 664 | *payload_length = 1; |
| 665 | const size_t stream_length = |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 666 | NullEncrypter().GetCiphertextSize(*payload_length) + |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 667 | QuicPacketCreator::StreamFramePacketOverhead( |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 668 | PACKET_8BYTE_CONNECTION_ID, include_version, packet_number_length, 0u, |
| 669 | is_in_fec_group); |
rtenneti | c14c8ab | 2015-06-18 05:47:40 | [diff] [blame] | 670 | const size_t ack_length = |
| 671 | NullEncrypter().GetCiphertextSize( |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 672 | QuicFramer::GetMinAckFrameSize(PACKET_1BYTE_PACKET_NUMBER)) + |
rtenneti | 2318668 | 2014-10-30 01:49:33 | [diff] [blame] | 673 | GetPacketHeaderSize(connection_id_length, include_version, |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 674 | /*include_path_id=*/false, packet_number_length, |
| 675 | is_in_fec_group); |
[email protected] | f62262b | 2013-07-05 20:57:30 | [diff] [blame] | 676 | if (stream_length < ack_length) { |
| 677 | *payload_length = 1 + ack_length - stream_length; |
| 678 | } |
| 679 | |
[email protected] | 5dafdb6 | 2013-11-14 01:24:26 | [diff] [blame] | 680 | return NullEncrypter().GetCiphertextSize(*payload_length) + |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 681 | QuicPacketCreator::StreamFramePacketOverhead( |
| 682 | connection_id_length, include_version, packet_number_length, 0u, |
| 683 | is_in_fec_group); |
[email protected] | 5351cc4b | 2013-03-03 07:22:41 | [diff] [blame] | 684 | } |
| 685 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 686 | TestEntropyCalculator::TestEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 687 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 688 | TestEntropyCalculator::~TestEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 689 | |
[email protected] | 4887809 | 2013-07-26 14:51:56 | [diff] [blame] | 690 | QuicPacketEntropyHash TestEntropyCalculator::EntropyHash( |
rtenneti | a004d33 | 2015-08-28 06:44:57 | [diff] [blame] | 691 | QuicPacketNumber packet_number) const { |
[email protected] | 9db44391 | 2013-02-25 05:27:03 | [diff] [blame] | 692 | return 1u; |
| 693 | } |
| 694 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 695 | MockEntropyCalculator::MockEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 696 | |
[email protected] | a5b9817 | 2014-06-18 07:01:59 | [diff] [blame] | 697 | MockEntropyCalculator::~MockEntropyCalculator() {} |
[email protected] | 8e01c06 | 2013-10-31 07:35:31 | [diff] [blame] | 698 | |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 699 | QuicConfig DefaultQuicConfig() { |
| 700 | QuicConfig config; |
[email protected] | 7d56135 | 2014-06-20 09:09:21 | [diff] [blame] | 701 | config.SetInitialStreamFlowControlWindowToSend( |
| 702 | kInitialStreamFlowControlWindowForTest); |
| 703 | config.SetInitialSessionFlowControlWindowToSend( |
| 704 | kInitialSessionFlowControlWindowForTest); |
[email protected] | b06431078 | 2013-05-30 21:12:17 | [diff] [blame] | 705 | return config; |
| 706 | } |
| 707 | |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 708 | QuicConfig DefaultQuicConfigStatelessRejects() { |
| 709 | QuicConfig config = DefaultQuicConfig(); |
| 710 | QuicTagVector copt; |
| 711 | copt.push_back(kSREJ); |
| 712 | config.SetConnectionOptionsToSend(copt); |
| 713 | return config; |
| 714 | } |
| 715 | |
[email protected] | 4d64079 | 2013-12-18 22:21:08 | [diff] [blame] | 716 | QuicVersionVector SupportedVersions(QuicVersion version) { |
| 717 | QuicVersionVector versions; |
| 718 | versions.push_back(version); |
| 719 | return versions; |
| 720 | } |
| 721 | |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 722 | TestWriterFactory::TestWriterFactory() : current_writer_(nullptr) {} |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 723 | TestWriterFactory::~TestWriterFactory() {} |
| 724 | |
rch | c99f380c | 2015-03-26 19:50:56 | [diff] [blame] | 725 | QuicPacketWriter* TestWriterFactory::Create(QuicPacketWriter* writer, |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 726 | QuicConnection* connection) { |
| 727 | return new PerConnectionPacketWriter(this, writer, connection); |
| 728 | } |
| 729 | |
| 730 | void TestWriterFactory::OnPacketSent(WriteResult result) { |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 731 | if (current_writer_ != nullptr && result.status == WRITE_STATUS_ERROR) { |
[email protected] | ca4e0d9 | 2014-08-22 16:33:22 | [diff] [blame] | 732 | current_writer_->connection()->OnWriteError(result.error_code); |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 733 | current_writer_ = nullptr; |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 734 | } |
| 735 | } |
| 736 | |
| 737 | void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) { |
| 738 | if (current_writer_ == writer) { |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 739 | current_writer_ = nullptr; |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 740 | } |
| 741 | } |
| 742 | |
| 743 | TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter( |
| 744 | TestWriterFactory* factory, |
rch | c99f380c | 2015-03-26 19:50:56 | [diff] [blame] | 745 | QuicPacketWriter* writer, |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 746 | QuicConnection* connection) |
rjshade | d5ced07 | 2015-12-18 19:26:02 | [diff] [blame] | 747 | : QuicPerConnectionPacketWriter(writer, connection), factory_(factory) {} |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 748 | |
| 749 | TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() { |
| 750 | factory_->Unregister(this); |
| 751 | } |
| 752 | |
| 753 | WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket( |
| 754 | const char* buffer, |
| 755 | size_t buf_len, |
| 756 | const IPAddressNumber& self_address, |
| 757 | const IPEndPoint& peer_address) { |
rtenneti | be63573 | 2014-10-02 22:51:42 | [diff] [blame] | 758 | // A DCHECK(factory_current_writer_ == nullptr) would be wrong here -- this |
| 759 | // class may be used in a setting where connection()->OnPacketSent() is called |
| 760 | // in a different way, so TestWriterFactory::OnPacketSent might never be |
| 761 | // called. |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 762 | factory_->current_writer_ = this; |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 763 | return tools::QuicPerConnectionPacketWriter::WritePacket( |
| 764 | buffer, buf_len, self_address, peer_address); |
[email protected] | 6d51582 | 2014-08-22 01:58:06 | [diff] [blame] | 765 | } |
| 766 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 767 | MockQuicConnectionDebugVisitor::MockQuicConnectionDebugVisitor() {} |
rtenneti | 9529380 | 2015-03-27 18:59:23 | [diff] [blame] | 768 | |
rtenneti | 021e882 | 2015-10-18 23:59:57 | [diff] [blame] | 769 | MockQuicConnectionDebugVisitor::~MockQuicConnectionDebugVisitor() {} |
rtenneti | 9529380 | 2015-03-27 18:59:23 | [diff] [blame] | 770 | |
fayang | a31a74b | 2015-12-28 17:27:14 | [diff] [blame] | 771 | MockReceivedPacketManager::MockReceivedPacketManager(QuicConnectionStats* stats) |
| 772 | : QuicReceivedPacketManager(stats) {} |
| 773 | |
| 774 | MockReceivedPacketManager::~MockReceivedPacketManager() {} |
| 775 | |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 776 | void CreateClientSessionForTest(QuicServerId server_id, |
| 777 | bool supports_stateless_rejects, |
| 778 | QuicTime::Delta connection_start_time, |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 779 | QuicVersionVector supported_versions, |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 780 | MockConnectionHelper* helper, |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 781 | QuicCryptoClientConfig* crypto_client_config, |
| 782 | PacketSavingConnection** client_connection, |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 783 | TestQuicSpdyClientSession** client_session) { |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 784 | CHECK(crypto_client_config); |
| 785 | CHECK(client_connection); |
| 786 | CHECK(client_session); |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 787 | CHECK(!connection_start_time.IsZero()) |
| 788 | << "Connections must start at non-zero times, otherwise the " |
| 789 | << "strike-register will be unhappy."; |
| 790 | |
| 791 | QuicConfig config = supports_stateless_rejects |
| 792 | ? DefaultQuicConfigStatelessRejects() |
| 793 | : DefaultQuicConfig(); |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 794 | *client_connection = new PacketSavingConnection( |
| 795 | helper, Perspective::IS_CLIENT, supported_versions); |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 796 | *client_session = new TestQuicSpdyClientSession( |
| 797 | *client_connection, config, server_id, crypto_client_config); |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 798 | (*client_connection)->AdvanceTime(connection_start_time); |
| 799 | } |
| 800 | |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 801 | void CreateServerSessionForTest(QuicServerId server_id, |
| 802 | QuicTime::Delta connection_start_time, |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 803 | QuicVersionVector supported_versions, |
rch | 99b644c | 2015-11-04 05:25:28 | [diff] [blame] | 804 | MockConnectionHelper* helper, |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 805 | QuicCryptoServerConfig* server_crypto_config, |
| 806 | PacketSavingConnection** server_connection, |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 807 | TestQuicSpdyServerSession** server_session) { |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 808 | CHECK(server_crypto_config); |
| 809 | CHECK(server_connection); |
| 810 | CHECK(server_session); |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 811 | CHECK(!connection_start_time.IsZero()) |
| 812 | << "Connections must start at non-zero times, otherwise the " |
| 813 | << "strike-register will be unhappy."; |
| 814 | |
zhongyi | b867702 | 2015-12-01 05:51:30 | [diff] [blame] | 815 | *server_connection = new PacketSavingConnection( |
| 816 | helper, Perspective::IS_SERVER, supported_versions); |
rtenneti | b865eb8 | 2015-06-17 20:21:46 | [diff] [blame] | 817 | *server_session = new TestQuicSpdyServerSession( |
rtenneti | d39bd76 | 2015-06-12 01:05:52 | [diff] [blame] | 818 | *server_connection, DefaultQuicConfig(), server_crypto_config); |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 819 | |
| 820 | // We advance the clock initially because the default time is zero and the |
Avi Drissman | 13fc893 | 2015-12-20 04:40:46 | [diff] [blame] | 821 | // strike register worries that we've just overflowed a uint32_t time. |
rtenneti | a2ea916 | 2015-05-15 19:26:44 | [diff] [blame] | 822 | (*server_connection)->AdvanceTime(connection_start_time); |
| 823 | } |
| 824 | |
ckrasic | 99850b3 | 2015-10-16 21:15:58 | [diff] [blame] | 825 | QuicStreamId QuicClientDataStreamId(int i) { |
| 826 | return kClientDataStreamId1 + 2 * i; |
| 827 | } |
| 828 | |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 829 | } // namespace test |
[email protected] | 8b37a09 | 2012-10-18 21:53:49 | [diff] [blame] | 830 | } // namespace net |