blob: 70e01a1197e29645017749d585848af5f0dfc0da [file] [log] [blame]
[email protected]8b37a092012-10-18 21:53:491// 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]9c0b1352012-11-04 00:03:276
rch16c74d1d2016-04-22 06:14:077#include <memory>
8
[email protected]a5b98172014-06-18 07:01:599#include "base/sha1.h"
[email protected]701bc892013-01-17 04:51:5410#include "base/stl_util.h"
[email protected]b12764d2013-12-02 22:28:3011#include "base/strings/string_number_conversions.h"
[email protected]8b37a092012-10-18 21:53:4912#include "net/quic/crypto/crypto_framer.h"
[email protected]6f54ab32013-03-02 17:43:3513#include "net/quic/crypto/crypto_handshake.h"
[email protected]872edd9e2013-01-16 08:51:1514#include "net/quic/crypto/crypto_utils.h"
[email protected]5351cc4b2013-03-03 07:22:4115#include "net/quic/crypto/null_encrypter.h"
[email protected]4df69842013-02-27 06:32:1616#include "net/quic/crypto/quic_decrypter.h"
17#include "net/quic/crypto/quic_encrypter.h"
rtenneti16a20772015-02-17 18:58:4818#include "net/quic/quic_data_writer.h"
[email protected]a57e0272013-04-26 07:31:4719#include "net/quic/quic_framer.h"
[email protected]5351cc4b2013-03-03 07:22:4120#include "net/quic/quic_packet_creator.h"
[email protected]79d13dcb2014-02-05 07:23:1321#include "net/quic/quic_utils.h"
rtennetid39bd762015-06-12 01:05:5222#include "net/quic/test_tools/crypto_test_utils.h"
[email protected]cbd731e2013-10-24 00:20:3923#include "net/quic/test_tools/quic_connection_peer.h"
[email protected]c244c5a12013-05-07 20:55:0424#include "net/spdy/spdy_frame_builder.h"
rchc99f380c2015-03-26 19:50:5625#include "net/tools/quic/quic_per_connection_packet_writer.h"
[email protected]8b37a092012-10-18 21:53:4926
[email protected]c244c5a12013-05-07 20:55:0427using base::StringPiece;
[email protected]8b37a092012-10-18 21:53:4928using std::max;
29using std::min;
30using std::string;
rchc0815442015-04-18 13:29:4631using testing::Invoke;
[email protected]bc356fe2014-06-19 11:14:1432using testing::_;
[email protected]8b37a092012-10-18 21:53:4933
34namespace net {
martijncc5402d2016-02-16 19:08:5835
[email protected]8b37a092012-10-18 21:53:4936namespace test {
[email protected]8b37a092012-10-18 21:53:4937
rtennetia004d332015-08-28 06:44:5738QuicAckFrame MakeAckFrame(QuicPacketNumber largest_observed) {
[email protected]fb35b0a2014-04-15 21:06:4939 QuicAckFrame ack;
[email protected]310d37b2014-08-02 06:15:3740 ack.largest_observed = largest_observed;
41 ack.entropy_hash = 0;
[email protected]fb35b0a2014-04-15 21:06:4942 return ack;
43}
44
rtennetia004d332015-08-28 06:44:5745QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges,
46 QuicPacketNumber least_unacked) {
[email protected]310d37b2014-08-02 06:15:3747 QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
[email protected]aa7e4ef2014-05-28 03:53:1548 // Add enough missing packets to get num_nack_ranges nack ranges.
rtennetia004d332015-08-28 06:44:5749 for (QuicPacketNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
rtenneti493d90ef2015-09-14 04:43:1150 ack.missing_packets.Add(least_unacked + i);
[email protected]aa7e4ef2014-05-28 03:53:1551 }
52 return ack;
53}
54
rtennetib6ac61a52015-02-11 20:20:5255QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
56 const QuicPacketHeader& header,
57 const QuicFrames& frames) {
[email protected]9cda5fd2014-06-03 10:20:2858 const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
59 size_t packet_size = GetPacketHeaderSize(header);
60 for (size_t i = 0; i < frames.size(); ++i) {
61 DCHECK_LE(packet_size, max_plaintext_size);
62 bool first_frame = i == 0;
63 bool last_frame = i == frames.size() - 1;
64 const size_t frame_size = framer->GetSerializedFrameLength(
65 frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
rjshaded069aaee2016-03-11 20:42:1766 header.public_header.packet_number_length);
[email protected]9cda5fd2014-06-03 10:20:2867 DCHECK(frame_size);
68 packet_size += frame_size;
69 }
rtenneti16a20772015-02-17 18:58:4870 return BuildUnsizedDataPacket(framer, header, frames, packet_size);
71}
72
73QuicPacket* BuildUnsizedDataPacket(QuicFramer* framer,
74 const QuicPacketHeader& header,
75 const QuicFrames& frames,
76 size_t packet_size) {
77 char* buffer = new char[packet_size];
alyssarc39b80f2015-10-22 17:13:5878 size_t length = framer->BuildDataPacket(header, frames, buffer, packet_size);
79 DCHECK_NE(0u, length);
80 // Re-construct the data packet with data ownership.
81 return new QuicPacket(buffer, length, /* owns_buffer */ true,
rtenneti16a20772015-02-17 18:58:4882 header.public_header.connection_id_length,
83 header.public_header.version_flag,
rchcaec4242016-01-22 20:49:5284 header.public_header.multipath_flag,
rch012834cf2016-04-26 02:06:3785 header.public_header.nonce != nullptr,
rtennetia004d332015-08-28 06:44:5786 header.public_header.packet_number_length);
[email protected]9cda5fd2014-06-03 10:20:2887}
88
Avi Drissman13fc8932015-12-20 04:40:4689uint64_t SimpleRandom::RandUint64() {
[email protected]a5b98172014-06-18 07:01:5990 unsigned char hash[base::kSHA1Length];
91 base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_),
92 hash);
93 memcpy(&seed_, hash, sizeof(seed_));
94 return seed_;
95}
96
[email protected]8b37a092012-10-18 21:53:4997MockFramerVisitor::MockFramerVisitor() {
98 // By default, we want to accept packets.
[email protected]14e8106c2013-03-14 16:25:3399 ON_CALL(*this, OnProtocolVersionMismatch(_))
100 .WillByDefault(testing::Return(false));
101
102 // By default, we want to accept packets.
[email protected]ec86d5462013-11-17 16:04:49103 ON_CALL(*this, OnUnauthenticatedHeader(_))
104 .WillByDefault(testing::Return(true));
105
[email protected]066d8182014-01-04 02:02:45106 ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
107 .WillByDefault(testing::Return(true));
108
rjshaded5ced072015-12-18 19:26:02109 ON_CALL(*this, OnPacketHeader(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47110
rjshaded5ced072015-12-18 19:26:02111 ON_CALL(*this, OnStreamFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47112
rjshaded5ced072015-12-18 19:26:02113 ON_CALL(*this, OnAckFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47114
rjshaded5ced072015-12-18 19:26:02115 ON_CALL(*this, OnStopWaitingFrame(_)).WillByDefault(testing::Return(true));
[email protected]93dd91f2014-02-27 00:09:03116
rjshadef88b3c72016-04-26 15:25:33117 ON_CALL(*this, OnPaddingFrame(_)).WillByDefault(testing::Return(true));
118
rjshaded5ced072015-12-18 19:26:02119 ON_CALL(*this, OnPingFrame(_)).WillByDefault(testing::Return(true));
[email protected]d8c522112014-04-23 09:23:25120
rjshaded5ced072015-12-18 19:26:02121 ON_CALL(*this, OnRstStreamFrame(_)).WillByDefault(testing::Return(true));
[email protected]a57e0272013-04-26 07:31:47122
123 ON_CALL(*this, OnConnectionCloseFrame(_))
124 .WillByDefault(testing::Return(true));
125
rjshaded5ced072015-12-18 19:26:02126 ON_CALL(*this, OnGoAwayFrame(_)).WillByDefault(testing::Return(true));
[email protected]8b37a092012-10-18 21:53:49127}
128
rtenneti021e8822015-10-18 23:59:57129MockFramerVisitor::~MockFramerVisitor() {}
[email protected]8b37a092012-10-18 21:53:49130
[email protected]48878092013-07-26 14:51:56131bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) {
[email protected]14e8106c2013-03-14 16:25:33132 return false;
133}
134
[email protected]066d8182014-01-04 02:02:45135bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
136 const QuicPacketPublicHeader& header) {
137 return true;
138}
139
[email protected]ec86d5462013-11-17 16:04:49140bool NoOpFramerVisitor::OnUnauthenticatedHeader(
141 const QuicPacketHeader& header) {
142 return true;
143}
144
[email protected]8b37a092012-10-18 21:53:49145bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
146 return true;
147}
148
[email protected]a57e0272013-04-26 07:31:47149bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
150 return true;
151}
152
153bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) {
154 return true;
155}
156
rjshaded5ced072015-12-18 19:26:02157bool NoOpFramerVisitor::OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {
[email protected]93dd91f2014-02-27 00:09:03158 return true;
159}
160
rjshadef88b3c72016-04-26 15:25:33161bool NoOpFramerVisitor::OnPaddingFrame(const QuicPaddingFrame& frame) {
162 return true;
163}
164
[email protected]d8c522112014-04-23 09:23:25165bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
166 return true;
167}
168
rjshaded5ced072015-12-18 19:26:02169bool NoOpFramerVisitor::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
[email protected]a57e0272013-04-26 07:31:47170 return true;
171}
172
173bool NoOpFramerVisitor::OnConnectionCloseFrame(
174 const QuicConnectionCloseFrame& frame) {
175 return true;
176}
177
178bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
179 return true;
180}
181
[email protected]cb23a922014-02-20 17:42:38182bool NoOpFramerVisitor::OnWindowUpdateFrame(
183 const QuicWindowUpdateFrame& frame) {
184 return true;
185}
186
187bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
188 return true;
189}
190
rchcaec4242016-01-22 20:49:52191bool NoOpFramerVisitor::OnPathCloseFrame(const QuicPathCloseFrame& frame) {
192 return true;
193}
194
rtenneti021e8822015-10-18 23:59:57195MockConnectionVisitor::MockConnectionVisitor() {}
[email protected]8d659e22013-01-19 04:26:10196
rtenneti021e8822015-10-18 23:59:57197MockConnectionVisitor::~MockConnectionVisitor() {}
[email protected]8d659e22013-01-19 04:26:10198
rch99b644c2015-11-04 05:25:28199MockConnectionHelper::MockConnectionHelper() {}
[email protected]9c0b1352012-11-04 00:03:27200
rch99b644c2015-11-04 05:25:28201MockConnectionHelper::~MockConnectionHelper() {}
[email protected]9c0b1352012-11-04 00:03:27202
rch99b644c2015-11-04 05:25:28203const QuicClock* MockConnectionHelper::GetClock() const {
[email protected]9c0b1352012-11-04 00:03:27204 return &clock_;
205}
206
rch99b644c2015-11-04 05:25:28207QuicRandom* MockConnectionHelper::GetRandomGenerator() {
[email protected]9558c5d32012-12-22 00:08:14208 return &random_generator_;
209}
210
rch16c74d1d2016-04-22 06:14:07211QuicAlarm* MockAlarmFactory::CreateAlarm(QuicAlarm::Delegate* delegate) {
212 return new MockAlarmFactory::TestAlarm(
jdorfman4ea54a22016-01-21 22:12:50213 QuicArenaScopedPtr<QuicAlarm::Delegate>(delegate));
214}
215
rch16c74d1d2016-04-22 06:14:07216QuicArenaScopedPtr<QuicAlarm> MockAlarmFactory::CreateAlarm(
jdorfman4ea54a22016-01-21 22:12:50217 QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
218 QuicConnectionArena* arena) {
219 if (arena != nullptr) {
rch16c74d1d2016-04-22 06:14:07220 return arena->New<MockAlarmFactory::TestAlarm>(std::move(delegate));
jdorfman4ea54a22016-01-21 22:12:50221 } else {
rch16c74d1d2016-04-22 06:14:07222 return QuicArenaScopedPtr<MockAlarmFactory::TestAlarm>(
jdorfman4ea54a22016-01-21 22:12:50223 new TestAlarm(std::move(delegate)));
224 }
[email protected]965dbe62013-08-09 21:34:31225}
226
jdorfman5a606722016-01-04 17:41:29227QuicBufferAllocator* MockConnectionHelper::GetBufferAllocator() {
228 return &buffer_allocator_;
229}
230
rch99b644c2015-11-04 05:25:28231void MockConnectionHelper::AdvanceTime(QuicTime::Delta delta) {
[email protected]fe053f92013-04-23 20:18:55232 clock_.AdvanceTime(delta);
233}
234
rch99b644c2015-11-04 05:25:28235MockConnection::MockConnection(MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07236 MockAlarmFactory* alarm_factory,
rch99b644c2015-11-04 05:25:28237 Perspective perspective)
rchc0815442015-04-18 13:29:46238 : MockConnection(kTestConnectionId,
rtenneti8696cf92014-11-14 21:12:12239 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51240 helper,
rch16c74d1d2016-04-22 06:14:07241 alarm_factory,
rtenneti6f48aa92015-03-16 02:18:48242 perspective,
rtenneti8a4a0732015-10-18 00:45:51243 QuicSupportedVersions()) {}
[email protected]c05a6d222013-12-16 19:42:03244
rtenneti8a4a0732015-10-18 00:45:51245MockConnection::MockConnection(IPEndPoint address,
rch99b644c2015-11-04 05:25:28246 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07247 MockAlarmFactory* alarm_factory,
rtenneti8a4a0732015-10-18 00:45:51248 Perspective perspective)
rchc0815442015-04-18 13:29:46249 : MockConnection(kTestConnectionId,
rtenneti6f48aa92015-03-16 02:18:48250 address,
rtenneti8a4a0732015-10-18 00:45:51251 helper,
rch16c74d1d2016-04-22 06:14:07252 alarm_factory,
rtenneti6f48aa92015-03-16 02:18:48253 perspective,
rtenneti8a4a0732015-10-18 00:45:51254 QuicSupportedVersions()) {}
[email protected]044ac2b2012-11-13 21:41:06255
[email protected]3aa9ca72014-02-27 19:39:43256MockConnection::MockConnection(QuicConnectionId connection_id,
rch99b644c2015-11-04 05:25:28257 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07258 MockAlarmFactory* alarm_factory,
rtenneti6f48aa92015-03-16 02:18:48259 Perspective perspective)
rchc0815442015-04-18 13:29:46260 : MockConnection(connection_id,
rtennetifb3fa6c2015-03-16 23:04:55261 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51262 helper,
rch16c74d1d2016-04-22 06:14:07263 alarm_factory,
rchc0815442015-04-18 13:29:46264 perspective,
rtenneti8a4a0732015-10-18 00:45:51265 QuicSupportedVersions()) {}
rchc0815442015-04-18 13:29:46266
rch99b644c2015-11-04 05:25:28267MockConnection::MockConnection(MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07268 MockAlarmFactory* alarm_factory,
rtenneti8a4a0732015-10-18 00:45:51269 Perspective perspective,
rchc0815442015-04-18 13:29:46270 const QuicVersionVector& supported_versions)
271 : MockConnection(kTestConnectionId,
272 IPEndPoint(TestPeerIPAddress(), kTestPort),
rtenneti8a4a0732015-10-18 00:45:51273 helper,
rch16c74d1d2016-04-22 06:14:07274 alarm_factory,
rchc0815442015-04-18 13:29:46275 perspective,
rtenneti8a4a0732015-10-18 00:45:51276 supported_versions) {}
rchc0815442015-04-18 13:29:46277
278MockConnection::MockConnection(QuicConnectionId connection_id,
279 IPEndPoint address,
rch99b644c2015-11-04 05:25:28280 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07281 MockAlarmFactory* alarm_factory,
rchc0815442015-04-18 13:29:46282 Perspective perspective,
rchc0815442015-04-18 13:29:46283 const QuicVersionVector& supported_versions)
284 : QuicConnection(connection_id,
285 address,
rtenneti8a4a0732015-10-18 00:45:51286 helper,
rch16c74d1d2016-04-22 06:14:07287 alarm_factory,
jdorfman90d185f32016-01-15 13:22:47288 new testing::NiceMock<MockPacketWriter>(),
rtennetifb3fa6c2015-03-16 23:04:55289 /* owns_writer= */ true,
290 perspective,
rtenneti8a4a0732015-10-18 00:45:51291 supported_versions) {
rchc0815442015-04-18 13:29:46292 ON_CALL(*this, OnError(_))
293 .WillByDefault(
294 Invoke(this, &PacketSavingConnection::QuicConnection_OnError));
[email protected]4d640792013-12-18 22:21:08295}
296
rtenneti021e8822015-10-18 23:59:57297MockConnection::~MockConnection() {}
[email protected]044ac2b2012-11-13 21:41:06298
[email protected]fe053f92013-04-23 20:18:55299void MockConnection::AdvanceTime(QuicTime::Delta delta) {
rch99b644c2015-11-04 05:25:28300 static_cast<MockConnectionHelper*>(helper())->AdvanceTime(delta);
[email protected]fe053f92013-04-23 20:18:55301}
302
rch99b644c2015-11-04 05:25:28303PacketSavingConnection::PacketSavingConnection(MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07304 MockAlarmFactory* alarm_factory,
rtenneti8a4a0732015-10-18 00:45:51305 Perspective perspective)
rch16c74d1d2016-04-22 06:14:07306 : MockConnection(helper, alarm_factory, perspective) {}
[email protected]044ac2b2012-11-13 21:41:06307
[email protected]4d640792013-12-18 22:21:08308PacketSavingConnection::PacketSavingConnection(
rch99b644c2015-11-04 05:25:28309 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07310 MockAlarmFactory* alarm_factory,
rtenneti6f48aa92015-03-16 02:18:48311 Perspective perspective,
[email protected]4d640792013-12-18 22:21:08312 const QuicVersionVector& supported_versions)
rch16c74d1d2016-04-22 06:14:07313 : MockConnection(helper, alarm_factory, perspective, supported_versions) {}
[email protected]4d640792013-12-18 22:21:08314
[email protected]044ac2b2012-11-13 21:41:06315PacketSavingConnection::~PacketSavingConnection() {
[email protected]2532de12013-05-09 12:29:33316 STLDeleteElements(&encrypted_packets_);
[email protected]044ac2b2012-11-13 21:41:06317}
318
zhongyi4a9d27b2016-01-12 20:08:31319void PacketSavingConnection::SendOrQueuePacket(SerializedPacket* packet) {
rtenneti2cae2072016-02-05 02:21:33320 encrypted_packets_.push_back(new QuicEncryptedPacket(
321 QuicUtils::CopyBuffer(*packet), packet->encrypted_length, true));
rtenneti31e9fd62014-09-16 05:22:15322 // Transfer ownership of the packet to the SentPacketManager and the
323 // ack notifier to the AckNotifierManager.
ckrasic062b5522016-02-27 01:14:21324 sent_packet_manager_.OnPacketSent(packet, 0, QuicTime::Zero(),
zhongyi4a9d27b2016-01-12 20:08:31325 NOT_RETRANSMISSION,
rjshaded5ced072015-12-18 19:26:02326 HAS_RETRANSMITTABLE_DATA);
[email protected]044ac2b2012-11-13 21:41:06327}
328
rtennetib865eb82015-06-17 20:21:46329MockQuicSpdySession::MockQuicSpdySession(QuicConnection* connection)
330 : QuicSpdySession(connection, DefaultQuicConfig()) {
rtennetid39bd762015-06-12 01:05:52331 crypto_stream_.reset(new QuicCryptoStream(this));
332 Initialize();
rjshaded069aaee2016-03-11 20:42:17333 ON_CALL(*this, WritevData(_, _, _, _, _))
[email protected]cff7b7b2013-01-11 08:49:07334 .WillByDefault(testing::Return(QuicConsumedData(0, false)));
[email protected]044ac2b2012-11-13 21:41:06335}
336
rtenneti021e8822015-10-18 23:59:57337MockQuicSpdySession::~MockQuicSpdySession() {}
[email protected]044ac2b2012-11-13 21:41:06338
jokulik2324d282015-12-08 21:42:57339// static
340QuicConsumedData MockQuicSpdySession::ConsumeAllData(
341 QuicStreamId /*id*/,
342 const QuicIOVector& data,
343 QuicStreamOffset /*offset*/,
344 bool fin,
jokulik2324d282015-12-08 21:42:57345 QuicAckListenerInterface* /*ack_notifier_delegate*/) {
346 return QuicConsumedData(data.total_length, fin);
347}
348
rtennetib865eb82015-06-17 20:21:46349TestQuicSpdyServerSession::TestQuicSpdyServerSession(
rtennetid39bd762015-06-12 01:05:52350 QuicConnection* connection,
351 const QuicConfig& config,
rjshaded069aaee2016-03-11 20:42:17352 const QuicCryptoServerConfig* crypto_config,
353 QuicCompressedCertsCache* compressed_certs_cache)
354 : QuicServerSessionBase(config,
355 connection,
356 &visitor_,
357 crypto_config,
358 compressed_certs_cache) {
rtennetid39bd762015-06-12 01:05:52359 Initialize();
[email protected]ccb34212014-07-18 09:27:50360}
[email protected]2532de12013-05-09 12:29:33361
rtenneti021e8822015-10-18 23:59:57362TestQuicSpdyServerSession::~TestQuicSpdyServerSession() {}
[email protected]2532de12013-05-09 12:29:33363
jokulikc971baf92016-01-06 00:36:39364QuicCryptoServerStreamBase*
365TestQuicSpdyServerSession::CreateQuicCryptoServerStream(
rjshaded069aaee2016-03-11 20:42:17366 const QuicCryptoServerConfig* crypto_config,
367 QuicCompressedCertsCache* compressed_certs_cache) {
368 return new QuicCryptoServerStream(crypto_config, compressed_certs_cache,
369 FLAGS_enable_quic_stateless_reject_support,
370 this);
jokulikc971baf92016-01-06 00:36:39371}
372
rtennetib865eb82015-06-17 20:21:46373QuicCryptoServerStream* TestQuicSpdyServerSession::GetCryptoStream() {
zhongyib8677022015-12-01 05:51:30374 return static_cast<QuicCryptoServerStream*>(
jokulikc971baf92016-01-06 00:36:39375 QuicServerSessionBase::GetCryptoStream());
[email protected]2532de12013-05-09 12:29:33376}
377
rtennetib865eb82015-06-17 20:21:46378TestQuicSpdyClientSession::TestQuicSpdyClientSession(
379 QuicConnection* connection,
380 const QuicConfig& config,
381 const QuicServerId& server_id,
382 QuicCryptoClientConfig* crypto_config)
ckrasic244375a32016-02-04 21:21:22383 : QuicClientSessionBase(connection, &push_promise_index_, config) {
rtennetid39bd762015-06-12 01:05:52384 crypto_stream_.reset(new QuicCryptoClientStream(
385 server_id, this, CryptoTestUtils::ProofVerifyContextForTesting(),
rtenneti2cae2072016-02-05 02:21:33386 crypto_config, this));
rtennetid39bd762015-06-12 01:05:52387 Initialize();
[email protected]90f62f092014-03-24 02:41:23388}
389
rtenneti021e8822015-10-18 23:59:57390TestQuicSpdyClientSession::~TestQuicSpdyClientSession() {}
[email protected]90f62f092014-03-24 02:41:23391
ckrasic244375a32016-02-04 21:21:22392bool TestQuicSpdyClientSession::IsAuthorized(const string& authority) {
393 return true;
394}
395
rtennetib865eb82015-06-17 20:21:46396QuicCryptoClientStream* TestQuicSpdyClientSession::GetCryptoStream() {
rtennetid39bd762015-06-12 01:05:52397 return crypto_stream_.get();
rtennetia2ea9162015-05-15 19:26:44398}
399
[email protected]cbd731e2013-10-24 00:20:39400MockPacketWriter::MockPacketWriter() {
rtenneti493d90ef2015-09-14 04:43:11401 ON_CALL(*this, GetMaxPacketSize(_))
402 .WillByDefault(testing::Return(kMaxPacketSize));
[email protected]cbd731e2013-10-24 00:20:39403}
404
rtenneti021e8822015-10-18 23:59:57405MockPacketWriter::~MockPacketWriter() {}
[email protected]cbd731e2013-10-24 00:20:39406
rtenneti021e8822015-10-18 23:59:57407MockSendAlgorithm::MockSendAlgorithm() {}
[email protected]8d659e22013-01-19 04:26:10408
rtenneti021e8822015-10-18 23:59:57409MockSendAlgorithm::~MockSendAlgorithm() {}
[email protected]8d659e22013-01-19 04:26:10410
rtenneti021e8822015-10-18 23:59:57411MockLossAlgorithm::MockLossAlgorithm() {}
[email protected]3aa9ca72014-02-27 19:39:43412
rtenneti021e8822015-10-18 23:59:57413MockLossAlgorithm::~MockLossAlgorithm() {}
[email protected]3aa9ca72014-02-27 19:39:43414
ckrasicea295fe2015-10-31 05:03:27415MockAckListener::MockAckListener() {}
[email protected]97cf3022013-09-05 14:30:16416
ckrasicea295fe2015-10-31 05:03:27417MockAckListener::~MockAckListener() {}
[email protected]97cf3022013-09-05 14:30:16418
rtenneti021e8822015-10-18 23:59:57419MockNetworkChangeVisitor::MockNetworkChangeVisitor() {}
[email protected]a692ad9d2014-07-18 21:35:24420
rtenneti021e8822015-10-18 23:59:57421MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {}
[email protected]a692ad9d2014-07-18 21:35:24422
[email protected]8b37a092012-10-18 21:53:49423namespace {
424
rjshaded5ced072015-12-18 19:26:02425string HexDumpWithMarks(const char* data,
426 int length,
427 const bool* marks,
428 int mark_length) {
[email protected]8b37a092012-10-18 21:53:49429 static const char kHexChars[] = "0123456789abcdef";
430 static const int kColumns = 4;
431
432 const int kSizeLimit = 1024;
433 if (length > kSizeLimit || mark_length > kSizeLimit) {
434 LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
435 length = min(length, kSizeLimit);
436 mark_length = min(mark_length, kSizeLimit);
437 }
438
439 string hex;
rjshaded5ced072015-12-18 19:26:02440 for (const char *row = data; length > 0;
[email protected]8b37a092012-10-18 21:53:49441 row += kColumns, length -= kColumns) {
rjshaded5ced072015-12-18 19:26:02442 for (const char* p = row; p < row + 4; ++p) {
[email protected]8b37a092012-10-18 21:53:49443 if (p < row + length) {
444 const bool mark =
445 (marks && (p - data) < mark_length && marks[p - data]);
446 hex += mark ? '*' : ' ';
447 hex += kHexChars[(*p & 0xf0) >> 4];
448 hex += kHexChars[*p & 0x0f];
449 hex += mark ? '*' : ' ';
450 } else {
451 hex += " ";
452 }
453 }
454 hex = hex + " ";
455
rtenneti6f48aa92015-03-16 02:18:48456 for (const char* p = row; p < row + 4 && p < row + length; ++p) {
[email protected]8b37a092012-10-18 21:53:49457 hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
rtenneti6f48aa92015-03-16 02:18:48458 }
[email protected]8b37a092012-10-18 21:53:49459
460 hex = hex + '\n';
461 }
462 return hex;
463}
464
465} // namespace
466
martijncc5402d2016-02-16 19:08:58467IPAddress TestPeerIPAddress() {
rjshaded5ced072015-12-18 19:26:02468 return Loopback4();
469}
[email protected]300ccd52014-01-25 08:00:19470
rjshaded5ced072015-12-18 19:26:02471QuicVersion QuicVersionMax() {
472 return QuicSupportedVersions().front();
473}
[email protected]b007e632013-10-28 08:39:25474
rjshaded5ced072015-12-18 19:26:02475QuicVersion QuicVersionMin() {
476 return QuicSupportedVersions().back();
477}
[email protected]b007e632013-10-28 08:39:25478
martijncc5402d2016-02-16 19:08:58479IPAddress Loopback4() {
eroman36d84e54432016-03-17 03:23:02480 return IPAddress::IPv4Localhost();
[email protected]c05a6d222013-12-16 19:42:03481}
482
martijncc5402d2016-02-16 19:08:58483IPAddress Loopback6() {
eroman36d84e54432016-03-17 03:23:02484 return IPAddress::IPv6Localhost();
[email protected]730b35d72014-06-05 03:23:22485}
486
martijncc5402d2016-02-16 19:08:58487IPAddress Any4() {
eroman36d84e54432016-03-17 03:23:02488 return IPAddress::IPv4AllZeros();
rtennetie0ee6eb2015-05-01 00:55:09489}
490
[email protected]9bb57c72014-03-31 20:36:04491void GenerateBody(string* body, int length) {
492 body->clear();
493 body->reserve(length);
494 for (int i = 0; i < length; ++i) {
495 body->append(1, static_cast<char>(32 + i % (126 - 32)));
496 }
497}
498
rtennetia004d332015-08-28 06:44:57499QuicEncryptedPacket* ConstructEncryptedPacket(QuicConnectionId connection_id,
500 bool version_flag,
jric533399b2016-01-29 07:36:01501 bool multipath_flag,
rtennetia004d332015-08-28 06:44:57502 bool reset_flag,
jric533399b2016-01-29 07:36:01503 QuicPathId path_id,
rtennetia004d332015-08-28 06:44:57504 QuicPacketNumber packet_number,
505 const string& data) {
jric533399b2016-01-29 07:36:01506 return ConstructEncryptedPacket(connection_id, version_flag, multipath_flag,
507 reset_flag, path_id, packet_number, data,
508 PACKET_8BYTE_CONNECTION_ID,
509 PACKET_6BYTE_PACKET_NUMBER);
rtenneti9e0fb502015-03-08 06:07:16510}
511
512QuicEncryptedPacket* ConstructEncryptedPacket(
513 QuicConnectionId connection_id,
514 bool version_flag,
jric533399b2016-01-29 07:36:01515 bool multipath_flag,
rtenneti9e0fb502015-03-08 06:07:16516 bool reset_flag,
jric533399b2016-01-29 07:36:01517 QuicPathId path_id,
rtennetia004d332015-08-28 06:44:57518 QuicPacketNumber packet_number,
rtenneti9e0fb502015-03-08 06:07:16519 const string& data,
520 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57521 QuicPacketNumberLength packet_number_length) {
jric533399b2016-01-29 07:36:01522 return ConstructEncryptedPacket(
523 connection_id, version_flag, multipath_flag, reset_flag, path_id,
524 packet_number, data, connection_id_length, packet_number_length, nullptr);
rchc0815442015-04-18 13:29:46525}
526
527QuicEncryptedPacket* ConstructEncryptedPacket(
528 QuicConnectionId connection_id,
529 bool version_flag,
jric533399b2016-01-29 07:36:01530 bool multipath_flag,
rchc0815442015-04-18 13:29:46531 bool reset_flag,
jric533399b2016-01-29 07:36:01532 QuicPathId path_id,
rtennetia004d332015-08-28 06:44:57533 QuicPacketNumber packet_number,
rchc0815442015-04-18 13:29:46534 const string& data,
535 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57536 QuicPacketNumberLength packet_number_length,
rchc0815442015-04-18 13:29:46537 QuicVersionVector* versions) {
[email protected]ffc34bf2014-03-07 02:42:02538 QuicPacketHeader header;
539 header.public_header.connection_id = connection_id;
rtenneti9e0fb502015-03-08 06:07:16540 header.public_header.connection_id_length = connection_id_length;
[email protected]ffc34bf2014-03-07 02:42:02541 header.public_header.version_flag = version_flag;
jric533399b2016-01-29 07:36:01542 header.public_header.multipath_flag = multipath_flag;
[email protected]ffc34bf2014-03-07 02:42:02543 header.public_header.reset_flag = reset_flag;
rtennetia004d332015-08-28 06:44:57544 header.public_header.packet_number_length = packet_number_length;
jric533399b2016-01-29 07:36:01545 header.path_id = path_id;
rtenneti8dd12b22015-10-21 01:26:38546 header.packet_number = packet_number;
[email protected]ffc34bf2014-03-07 02:42:02547 header.entropy_flag = false;
548 header.entropy_hash = 0;
549 header.fec_flag = false;
550 header.is_in_fec_group = NOT_IN_FEC_GROUP;
551 header.fec_group = 0;
rtennetia4228ea2015-06-04 02:31:44552 QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
[email protected]ffc34bf2014-03-07 02:42:02553 QuicFrame frame(&stream_frame);
554 QuicFrames frames;
555 frames.push_back(frame);
rchc0815442015-04-18 13:29:46556 QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
557 QuicTime::Zero(), Perspective::IS_CLIENT);
558
danakjad1777e2016-04-16 00:56:42559 std::unique_ptr<QuicPacket> packet(
rtennetib6ac61a52015-02-11 20:20:52560 BuildUnsizedDataPacket(&framer, header, frames));
rtennetibe635732014-10-02 22:51:42561 EXPECT_TRUE(packet != nullptr);
rch99b644c2015-11-04 05:25:28562 char* buffer = new char[kMaxPacketSize];
563 size_t encrypted_length = framer.EncryptPayload(
jric533399b2016-01-29 07:36:01564 ENCRYPTION_NONE, path_id, packet_number, *packet, buffer, kMaxPacketSize);
rch99b644c2015-11-04 05:25:28565 EXPECT_NE(0u, encrypted_length);
566 return new QuicEncryptedPacket(buffer, encrypted_length, true);
[email protected]ffc34bf2014-03-07 02:42:02567}
568
jokulikf2bd55c52016-03-24 22:35:30569QuicReceivedPacket* ConstructReceivedPacket(
570 const QuicEncryptedPacket& encrypted_packet,
571 QuicTime receipt_time) {
572 char* buffer = new char[encrypted_packet.length()];
573 memcpy(buffer, encrypted_packet.data(), encrypted_packet.length());
574 return new QuicReceivedPacket(buffer, encrypted_packet.length(), receipt_time,
575 true);
576}
577
rchc0815442015-04-18 13:29:46578QuicEncryptedPacket* ConstructMisFramedEncryptedPacket(
579 QuicConnectionId connection_id,
580 bool version_flag,
jric533399b2016-01-29 07:36:01581 bool multipath_flag,
rchc0815442015-04-18 13:29:46582 bool reset_flag,
jric533399b2016-01-29 07:36:01583 QuicPathId path_id,
rtennetia004d332015-08-28 06:44:57584 QuicPacketNumber packet_number,
rchc0815442015-04-18 13:29:46585 const string& data,
586 QuicConnectionIdLength connection_id_length,
rtennetia004d332015-08-28 06:44:57587 QuicPacketNumberLength packet_number_length,
rchc0815442015-04-18 13:29:46588 QuicVersionVector* versions) {
589 QuicPacketHeader header;
590 header.public_header.connection_id = connection_id;
591 header.public_header.connection_id_length = connection_id_length;
592 header.public_header.version_flag = version_flag;
jric533399b2016-01-29 07:36:01593 header.public_header.multipath_flag = multipath_flag;
rchc0815442015-04-18 13:29:46594 header.public_header.reset_flag = reset_flag;
rtennetia004d332015-08-28 06:44:57595 header.public_header.packet_number_length = packet_number_length;
jric533399b2016-01-29 07:36:01596 header.path_id = path_id;
rtenneti8dd12b22015-10-21 01:26:38597 header.packet_number = packet_number;
rchc0815442015-04-18 13:29:46598 header.entropy_flag = false;
599 header.entropy_hash = 0;
600 header.fec_flag = false;
601 header.is_in_fec_group = NOT_IN_FEC_GROUP;
602 header.fec_group = 0;
rtennetia4228ea2015-06-04 02:31:44603 QuicStreamFrame stream_frame(1, false, 0, StringPiece(data));
rtenneti85816fdf2015-05-25 03:01:10604 QuicFrame frame(&stream_frame);
rchc0815442015-04-18 13:29:46605 QuicFrames frames;
rtenneti85816fdf2015-05-25 03:01:10606 frames.push_back(frame);
607 QuicFramer framer(versions != nullptr ? *versions : QuicSupportedVersions(),
rchc0815442015-04-18 13:29:46608 QuicTime::Zero(), Perspective::IS_CLIENT);
rtenneti85816fdf2015-05-25 03:01:10609
danakjad1777e2016-04-16 00:56:42610 std::unique_ptr<QuicPacket> packet(
rchc0815442015-04-18 13:29:46611 BuildUnsizedDataPacket(&framer, header, frames));
612 EXPECT_TRUE(packet != nullptr);
rtenneti85816fdf2015-05-25 03:01:10613
614 // Now set the packet's private flags byte to 0xFF, which is an invalid value.
615 reinterpret_cast<unsigned char*>(
616 packet->mutable_data())[GetStartOfEncryptedData(
jric533399b2016-01-29 07:36:01617 connection_id_length, version_flag, multipath_flag,
rch012834cf2016-04-26 02:06:37618 false /* no diversification nonce */, packet_number_length)] = 0xFF;
rtenneti85816fdf2015-05-25 03:01:10619
rch99b644c2015-11-04 05:25:28620 char* buffer = new char[kMaxPacketSize];
621 size_t encrypted_length = framer.EncryptPayload(
jric533399b2016-01-29 07:36:01622 ENCRYPTION_NONE, path_id, packet_number, *packet, buffer, kMaxPacketSize);
rch99b644c2015-11-04 05:25:28623 EXPECT_NE(0u, encrypted_length);
624 return new QuicEncryptedPacket(buffer, encrypted_length, true);
rchc0815442015-04-18 13:29:46625}
626
rjshaded5ced072015-12-18 19:26:02627void CompareCharArraysWithHexError(const string& description,
628 const char* actual,
629 const int actual_len,
630 const char* expected,
631 const int expected_len) {
[email protected]b007e632013-10-28 08:39:25632 EXPECT_EQ(actual_len, expected_len);
[email protected]8b37a092012-10-18 21:53:49633 const int min_len = min(actual_len, expected_len);
634 const int max_len = max(actual_len, expected_len);
danakjad1777e2016-04-16 00:56:42635 std::unique_ptr<bool[]> marks(new bool[max_len]);
[email protected]8b37a092012-10-18 21:53:49636 bool identical = (actual_len == expected_len);
637 for (int i = 0; i < min_len; ++i) {
638 if (actual[i] != expected[i]) {
639 marks[i] = true;
640 identical = false;
641 } else {
642 marks[i] = false;
643 }
644 }
645 for (int i = min_len; i < max_len; ++i) {
646 marks[i] = true;
647 }
rjshaded5ced072015-12-18 19:26:02648 if (identical)
649 return;
jric533399b2016-01-29 07:36:01650 ADD_FAILURE() << "Description:\n"
651 << description << "\n\nExpected:\n"
rjshaded5ced072015-12-18 19:26:02652 << HexDumpWithMarks(expected, expected_len, marks.get(),
653 max_len)
654 << "\nActual:\n"
655 << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
[email protected]8b37a092012-10-18 21:53:49656}
657
[email protected]b12764d2013-12-02 22:28:30658bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
659 bytes->clear();
660 if (hex.empty())
661 return true;
Avi Drissman13fc8932015-12-20 04:40:46662 std::vector<uint8_t> v;
[email protected]b12764d2013-12-02 22:28:30663 if (!base::HexStringToBytes(hex.as_string(), &v))
664 return false;
665 if (!v.empty())
666 bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
667 return true;
668}
669
[email protected]d3d15bf2013-01-30 02:51:54670static QuicPacket* ConstructPacketFromHandshakeMessage(
[email protected]3aa9ca72014-02-27 19:39:43671 QuicConnectionId connection_id,
[email protected]14e8106c2013-03-14 16:25:33672 const CryptoHandshakeMessage& message,
673 bool should_include_version) {
[email protected]8b37a092012-10-18 21:53:49674 CryptoFramer crypto_framer;
danakjad1777e2016-04-16 00:56:42675 std::unique_ptr<QuicData> data(
676 crypto_framer.ConstructHandshakeMessage(message));
rtenneti6f48aa92015-03-16 02:18:48677 QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(),
678 Perspective::IS_CLIENT);
[email protected]8b37a092012-10-18 21:53:49679
680 QuicPacketHeader header;
[email protected]3aa9ca72014-02-27 19:39:43681 header.public_header.connection_id = connection_id;
[email protected]9db443912013-02-25 05:27:03682 header.public_header.reset_flag = false;
[email protected]14e8106c2013-03-14 16:25:33683 header.public_header.version_flag = should_include_version;
rtenneti8dd12b22015-10-21 01:26:38684 header.packet_number = 1;
[email protected]9db443912013-02-25 05:27:03685 header.entropy_flag = false;
686 header.entropy_hash = 0;
687 header.fec_flag = false;
[email protected]8b37a092012-10-18 21:53:49688 header.fec_group = 0;
689
[email protected]be24ab22012-10-22 03:01:52690 QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
rtennetia4228ea2015-06-04 02:31:44691 data->AsStringPiece());
[email protected]8b37a092012-10-18 21:53:49692
[email protected]be24ab22012-10-22 03:01:52693 QuicFrame frame(&stream_frame);
694 QuicFrames frames;
695 frames.push_back(frame);
rtennetib6ac61a52015-02-11 20:20:52696 return BuildUnsizedDataPacket(&quic_framer, header, frames);
[email protected]8b37a092012-10-18 21:53:49697}
698
[email protected]3aa9ca72014-02-27 19:39:43699QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
700 QuicTag tag) {
[email protected]d3d15bf2013-01-30 02:51:54701 CryptoHandshakeMessage message;
[email protected]ccc66e8a2013-03-26 08:26:14702 message.set_tag(tag);
[email protected]3aa9ca72014-02-27 19:39:43703 return ConstructPacketFromHandshakeMessage(connection_id, message, false);
[email protected]d3d15bf2013-01-30 02:51:54704}
705
rtennetia004d332015-08-28 06:44:57706size_t GetPacketLengthForOneStream(QuicVersion version,
707 bool include_version,
rchcaec4242016-01-22 20:49:52708 bool include_path_id,
rch012834cf2016-04-26 02:06:37709 bool include_diversification_nonce,
rtennetia004d332015-08-28 06:44:57710 QuicConnectionIdLength connection_id_length,
711 QuicPacketNumberLength packet_number_length,
rtennetia004d332015-08-28 06:44:57712 size_t* payload_length) {
[email protected]f62262b2013-07-05 20:57:30713 *payload_length = 1;
714 const size_t stream_length =
[email protected]5dafdb62013-11-14 01:24:26715 NullEncrypter().GetCiphertextSize(*payload_length) +
[email protected]b064310782013-05-30 21:12:17716 QuicPacketCreator::StreamFramePacketOverhead(
rchcaec4242016-01-22 20:49:52717 PACKET_8BYTE_CONNECTION_ID, include_version, include_path_id,
rch012834cf2016-04-26 02:06:37718 include_diversification_nonce, packet_number_length, 0u);
rtennetic14c8ab2015-06-18 05:47:40719 const size_t ack_length =
720 NullEncrypter().GetCiphertextSize(
rtennetia004d332015-08-28 06:44:57721 QuicFramer::GetMinAckFrameSize(PACKET_1BYTE_PACKET_NUMBER)) +
rtenneti23186682014-10-30 01:49:33722 GetPacketHeaderSize(connection_id_length, include_version,
rch012834cf2016-04-26 02:06:37723 include_path_id, include_diversification_nonce,
724 packet_number_length);
[email protected]f62262b2013-07-05 20:57:30725 if (stream_length < ack_length) {
726 *payload_length = 1 + ack_length - stream_length;
727 }
728
[email protected]5dafdb62013-11-14 01:24:26729 return NullEncrypter().GetCiphertextSize(*payload_length) +
rtennetia004d332015-08-28 06:44:57730 QuicPacketCreator::StreamFramePacketOverhead(
rchcaec4242016-01-22 20:49:52731 connection_id_length, include_version, include_path_id,
rch012834cf2016-04-26 02:06:37732 include_diversification_nonce, packet_number_length, 0u);
[email protected]5351cc4b2013-03-03 07:22:41733}
734
[email protected]a5b98172014-06-18 07:01:59735TestEntropyCalculator::TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31736
[email protected]a5b98172014-06-18 07:01:59737TestEntropyCalculator::~TestEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31738
[email protected]48878092013-07-26 14:51:56739QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
rtennetia004d332015-08-28 06:44:57740 QuicPacketNumber packet_number) const {
[email protected]9db443912013-02-25 05:27:03741 return 1u;
742}
743
[email protected]a5b98172014-06-18 07:01:59744MockEntropyCalculator::MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31745
[email protected]a5b98172014-06-18 07:01:59746MockEntropyCalculator::~MockEntropyCalculator() {}
[email protected]8e01c062013-10-31 07:35:31747
[email protected]b064310782013-05-30 21:12:17748QuicConfig DefaultQuicConfig() {
749 QuicConfig config;
[email protected]7d561352014-06-20 09:09:21750 config.SetInitialStreamFlowControlWindowToSend(
751 kInitialStreamFlowControlWindowForTest);
752 config.SetInitialSessionFlowControlWindowToSend(
753 kInitialSessionFlowControlWindowForTest);
[email protected]b064310782013-05-30 21:12:17754 return config;
755}
756
rtennetia2ea9162015-05-15 19:26:44757QuicConfig DefaultQuicConfigStatelessRejects() {
758 QuicConfig config = DefaultQuicConfig();
759 QuicTagVector copt;
760 copt.push_back(kSREJ);
761 config.SetConnectionOptionsToSend(copt);
762 return config;
763}
764
[email protected]4d640792013-12-18 22:21:08765QuicVersionVector SupportedVersions(QuicVersion version) {
766 QuicVersionVector versions;
767 versions.push_back(version);
768 return versions;
769}
770
rtenneti021e8822015-10-18 23:59:57771MockQuicConnectionDebugVisitor::MockQuicConnectionDebugVisitor() {}
rtenneti95293802015-03-27 18:59:23772
rtenneti021e8822015-10-18 23:59:57773MockQuicConnectionDebugVisitor::~MockQuicConnectionDebugVisitor() {}
rtenneti95293802015-03-27 18:59:23774
fayanga31a74b2015-12-28 17:27:14775MockReceivedPacketManager::MockReceivedPacketManager(QuicConnectionStats* stats)
776 : QuicReceivedPacketManager(stats) {}
777
778MockReceivedPacketManager::~MockReceivedPacketManager() {}
779
rtennetid39bd762015-06-12 01:05:52780void CreateClientSessionForTest(QuicServerId server_id,
781 bool supports_stateless_rejects,
782 QuicTime::Delta connection_start_time,
zhongyib8677022015-12-01 05:51:30783 QuicVersionVector supported_versions,
rch99b644c2015-11-04 05:25:28784 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07785 MockAlarmFactory* alarm_factory,
rtennetid39bd762015-06-12 01:05:52786 QuicCryptoClientConfig* crypto_client_config,
787 PacketSavingConnection** client_connection,
rtennetib865eb82015-06-17 20:21:46788 TestQuicSpdyClientSession** client_session) {
rtennetia2ea9162015-05-15 19:26:44789 CHECK(crypto_client_config);
790 CHECK(client_connection);
791 CHECK(client_session);
rtennetia2ea9162015-05-15 19:26:44792 CHECK(!connection_start_time.IsZero())
793 << "Connections must start at non-zero times, otherwise the "
794 << "strike-register will be unhappy.";
795
796 QuicConfig config = supports_stateless_rejects
797 ? DefaultQuicConfigStatelessRejects()
798 : DefaultQuicConfig();
zhongyib8677022015-12-01 05:51:30799 *client_connection = new PacketSavingConnection(
rch16c74d1d2016-04-22 06:14:07800 helper, alarm_factory, Perspective::IS_CLIENT, supported_versions);
rtennetib865eb82015-06-17 20:21:46801 *client_session = new TestQuicSpdyClientSession(
802 *client_connection, config, server_id, crypto_client_config);
rtennetia2ea9162015-05-15 19:26:44803 (*client_connection)->AdvanceTime(connection_start_time);
804}
805
rjshaded069aaee2016-03-11 20:42:17806void CreateServerSessionForTest(
807 QuicServerId server_id,
808 QuicTime::Delta connection_start_time,
809 QuicVersionVector supported_versions,
810 MockConnectionHelper* helper,
rch16c74d1d2016-04-22 06:14:07811 MockAlarmFactory* alarm_factory,
rjshaded069aaee2016-03-11 20:42:17812 QuicCryptoServerConfig* server_crypto_config,
813 QuicCompressedCertsCache* compressed_certs_cache,
814 PacketSavingConnection** server_connection,
815 TestQuicSpdyServerSession** server_session) {
rtennetia2ea9162015-05-15 19:26:44816 CHECK(server_crypto_config);
817 CHECK(server_connection);
818 CHECK(server_session);
rtennetia2ea9162015-05-15 19:26:44819 CHECK(!connection_start_time.IsZero())
820 << "Connections must start at non-zero times, otherwise the "
821 << "strike-register will be unhappy.";
822
zhongyib8677022015-12-01 05:51:30823 *server_connection = new PacketSavingConnection(
rch16c74d1d2016-04-22 06:14:07824 helper, alarm_factory, Perspective::IS_SERVER, supported_versions);
rtennetib865eb82015-06-17 20:21:46825 *server_session = new TestQuicSpdyServerSession(
rjshaded069aaee2016-03-11 20:42:17826 *server_connection, DefaultQuicConfig(), server_crypto_config,
827 compressed_certs_cache);
rtennetia2ea9162015-05-15 19:26:44828
829 // We advance the clock initially because the default time is zero and the
Avi Drissman13fc8932015-12-20 04:40:46830 // strike register worries that we've just overflowed a uint32_t time.
rtennetia2ea9162015-05-15 19:26:44831 (*server_connection)->AdvanceTime(connection_start_time);
832}
833
ckrasic99850b32015-10-16 21:15:58834QuicStreamId QuicClientDataStreamId(int i) {
835 return kClientDataStreamId1 + 2 * i;
836}
837
[email protected]8b37a092012-10-18 21:53:49838} // namespace test
[email protected]8b37a092012-10-18 21:53:49839} // namespace net