net/quic/test_tools/quic_test_utils.cc

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