src/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_framer.h"
  17 #include "net/quic/quic_packet_creator.h"
  18 #include "net/quic/quic_utils.h"
  19 #include "net/quic/test_tools/quic_connection_peer.h"
  20 #include "net/spdy/spdy_frame_builder.h"
  21
  22 using base::StringPiece;
  23 using std::max;
  24 using std::min;
  25 using std::string;
  26 using testing::AnyNumber;
  27 using testing::_;
  28
  29 namespace net {
  30 namespace test {
  31 namespace {
  32
  33 // No-op alarm implementation used by MockHelper.
  34 class TestAlarm : public QuicAlarm {
  35  public:
  36   explicit TestAlarm(QuicAlarm::Delegate* delegate)
  37       : QuicAlarm(delegate) {
  38   }
  39
  40   void SetImpl() override {}
  41   void CancelImpl() override {}
  42 };
  43
  44 }  // namespace
  45
  46 QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed) {
  47   QuicAckFrame ack;
  48   ack.largest_observed = largest_observed;
  49   ack.entropy_hash = 0;
  50   return ack;
  51 }
  52
  53 QuicAckFrame MakeAckFrameWithNackRanges(
  54     size_t num_nack_ranges, QuicPacketSequenceNumber least_unacked) {
  55   QuicAckFrame ack = MakeAckFrame(2 * num_nack_ranges + least_unacked);
  56   // Add enough missing packets to get num_nack_ranges nack ranges.
  57   for (QuicPacketSequenceNumber i = 1; i < 2 * num_nack_ranges; i += 2) {
  58     ack.missing_packets.insert(least_unacked + i);
  59   }
  60   return ack;
  61 }
  62
  63 SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer,
  64                                         const QuicPacketHeader& header,
  65                                         const QuicFrames& frames) {
  66   const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
  67   size_t packet_size = GetPacketHeaderSize(header);
  68   for (size_t i = 0; i < frames.size(); ++i) {
  69     DCHECK_LE(packet_size, max_plaintext_size);
  70     bool first_frame = i == 0;
  71     bool last_frame = i == frames.size() - 1;
  72     const size_t frame_size = framer->GetSerializedFrameLength(
  73         frames[i], max_plaintext_size - packet_size, first_frame, last_frame,
  74         header.is_in_fec_group,
  75         header.public_header.sequence_number_length);
  76     DCHECK(frame_size);
  77     packet_size += frame_size;
  78   }
  79   return framer->BuildDataPacket(header, frames, packet_size);
  80 }
  81
  82 uint64 SimpleRandom::RandUint64() {
  83   unsigned char hash[base::kSHA1Length];
  84   base::SHA1HashBytes(reinterpret_cast<unsigned char*>(&seed_), sizeof(seed_),
  85                       hash);
  86   memcpy(&seed_, hash, sizeof(seed_));
  87   return seed_;
  88 }
  89
  90 MockFramerVisitor::MockFramerVisitor() {
  91   // By default, we want to accept packets.
  92   ON_CALL(*this, OnProtocolVersionMismatch(_))
  93       .WillByDefault(testing::Return(false));
  94
  95   // By default, we want to accept packets.
  96   ON_CALL(*this, OnUnauthenticatedHeader(_))
  97       .WillByDefault(testing::Return(true));
  98
  99   ON_CALL(*this, OnUnauthenticatedPublicHeader(_))
 100       .WillByDefault(testing::Return(true));
 101
 102   ON_CALL(*this, OnPacketHeader(_))
 103       .WillByDefault(testing::Return(true));
 104
 105   ON_CALL(*this, OnStreamFrame(_))
 106       .WillByDefault(testing::Return(true));
 107
 108   ON_CALL(*this, OnAckFrame(_))
 109       .WillByDefault(testing::Return(true));
 110
 111   ON_CALL(*this, OnCongestionFeedbackFrame(_))
 112       .WillByDefault(testing::Return(true));
 113
 114   ON_CALL(*this, OnStopWaitingFrame(_))
 115       .WillByDefault(testing::Return(true));
 116
 117   ON_CALL(*this, OnPingFrame(_))
 118       .WillByDefault(testing::Return(true));
 119
 120   ON_CALL(*this, OnRstStreamFrame(_))
 121       .WillByDefault(testing::Return(true));
 122
 123   ON_CALL(*this, OnConnectionCloseFrame(_))
 124       .WillByDefault(testing::Return(true));
 125
 126   ON_CALL(*this, OnGoAwayFrame(_))
 127       .WillByDefault(testing::Return(true));
 128 }
 129
 130 MockFramerVisitor::~MockFramerVisitor() {
 131 }
 132
 133 bool NoOpFramerVisitor::OnProtocolVersionMismatch(QuicVersion version) {
 134   return false;
 135 }
 136
 137 bool NoOpFramerVisitor::OnUnauthenticatedPublicHeader(
 138     const QuicPacketPublicHeader& header) {
 139   return true;
 140 }
 141
 142 bool NoOpFramerVisitor::OnUnauthenticatedHeader(
 143     const QuicPacketHeader& header) {
 144   return true;
 145 }
 146
 147 bool NoOpFramerVisitor::OnPacketHeader(const QuicPacketHeader& header) {
 148   return true;
 149 }
 150
 151 bool NoOpFramerVisitor::OnStreamFrame(const QuicStreamFrame& frame) {
 152   return true;
 153 }
 154
 155 bool NoOpFramerVisitor::OnAckFrame(const QuicAckFrame& frame) {
 156   return true;
 157 }
 158
 159 bool NoOpFramerVisitor::OnCongestionFeedbackFrame(
 160     const QuicCongestionFeedbackFrame& frame) {
 161   return true;
 162 }
 163
 164 bool NoOpFramerVisitor::OnStopWaitingFrame(
 165     const QuicStopWaitingFrame& frame) {
 166   return true;
 167 }
 168
 169 bool NoOpFramerVisitor::OnPingFrame(const QuicPingFrame& frame) {
 170   return true;
 171 }
 172
 173 bool NoOpFramerVisitor::OnRstStreamFrame(
 174     const QuicRstStreamFrame& frame) {
 175   return true;
 176 }
 177
 178 bool NoOpFramerVisitor::OnConnectionCloseFrame(
 179     const QuicConnectionCloseFrame& frame) {
 180   return true;
 181 }
 182
 183 bool NoOpFramerVisitor::OnGoAwayFrame(const QuicGoAwayFrame& frame) {
 184   return true;
 185 }
 186
 187 bool NoOpFramerVisitor::OnWindowUpdateFrame(
 188     const QuicWindowUpdateFrame& frame) {
 189   return true;
 190 }
 191
 192 bool NoOpFramerVisitor::OnBlockedFrame(const QuicBlockedFrame& frame) {
 193   return true;
 194 }
 195
 196 MockConnectionVisitor::MockConnectionVisitor() {
 197 }
 198
 199 MockConnectionVisitor::~MockConnectionVisitor() {
 200 }
 201
 202 MockHelper::MockHelper() {
 203 }
 204
 205 MockHelper::~MockHelper() {
 206 }
 207
 208 const QuicClock* MockHelper::GetClock() const {
 209   return &clock_;
 210 }
 211
 212 QuicRandom* MockHelper::GetRandomGenerator() {
 213   return &random_generator_;
 214 }
 215
 216 QuicAlarm* MockHelper::CreateAlarm(QuicAlarm::Delegate* delegate) {
 217   return new TestAlarm(delegate);
 218 }
 219
 220 void MockHelper::AdvanceTime(QuicTime::Delta delta) {
 221   clock_.AdvanceTime(delta);
 222 }
 223
 224 namespace {
 225 class NiceMockPacketWriterFactory
 226     : public QuicConnection::PacketWriterFactory {
 227  public:
 228   NiceMockPacketWriterFactory() {}
 229   ~NiceMockPacketWriterFactory() override {}
 230
 231   QuicPacketWriter* Create(QuicConnection* /*connection*/) const override {
 232     return new testing::NiceMock<MockPacketWriter>();
 233   }
 234
 235  private:
 236   DISALLOW_COPY_AND_ASSIGN(NiceMockPacketWriterFactory);
 237 };
 238 }  // namespace
 239
 240 MockConnection::MockConnection(bool is_server)
 241     : QuicConnection(kTestConnectionId,
 242                      IPEndPoint(TestPeerIPAddress(), kTestPort),
 243                      new testing::NiceMock<MockHelper>(),
 244                      NiceMockPacketWriterFactory(),
 245                      /* owns_writer= */ true,
 246                      is_server, QuicSupportedVersions()),
 247       helper_(helper()) {
 248 }
 249
 250 MockConnection::MockConnection(IPEndPoint address,
 251                                bool is_server)
 252     : QuicConnection(kTestConnectionId, address,
 253                      new testing::NiceMock<MockHelper>(),
 254                      NiceMockPacketWriterFactory(),
 255                      /* owns_writer= */ true,
 256                      is_server, QuicSupportedVersions()),
 257       helper_(helper()) {
 258 }
 259
 260 MockConnection::MockConnection(QuicConnectionId connection_id,
 261                                bool is_server)
 262     : QuicConnection(connection_id,
 263                      IPEndPoint(TestPeerIPAddress(), kTestPort),
 264                      new testing::NiceMock<MockHelper>(),
 265                      NiceMockPacketWriterFactory(),
 266                      /* owns_writer= */ true,
 267                      is_server, QuicSupportedVersions()),
 268       helper_(helper()) {
 269 }
 270
 271 MockConnection::MockConnection(bool is_server,
 272                                const QuicVersionVector& supported_versions)
 273     : QuicConnection(kTestConnectionId,
 274                      IPEndPoint(TestPeerIPAddress(), kTestPort),
 275                      new testing::NiceMock<MockHelper>(),
 276                      NiceMockPacketWriterFactory(),
 277                      /* owns_writer= */ true,
 278                      is_server, supported_versions),
 279       helper_(helper()) {
 280 }
 281
 282 MockConnection::~MockConnection() {
 283 }
 284
 285 void MockConnection::AdvanceTime(QuicTime::Delta delta) {
 286   static_cast<MockHelper*>(helper())->AdvanceTime(delta);
 287 }
 288
 289 PacketSavingConnection::PacketSavingConnection(bool is_server)
 290     : MockConnection(is_server) {
 291 }
 292
 293 PacketSavingConnection::PacketSavingConnection(
 294     bool is_server,
 295     const QuicVersionVector& supported_versions)
 296     : MockConnection(is_server, supported_versions) {
 297 }
 298
 299 PacketSavingConnection::~PacketSavingConnection() {
 300   STLDeleteElements(&packets_);
 301   STLDeleteElements(&encrypted_packets_);
 302 }
 303
 304 void PacketSavingConnection::SendOrQueuePacket(QueuedPacket packet) {
 305   packets_.push_back(packet.serialized_packet.packet);
 306   QuicEncryptedPacket* encrypted = QuicConnectionPeer::GetFramer(this)->
 307       EncryptPacket(packet.encryption_level,
 308                     packet.serialized_packet.sequence_number,
 309                     *packet.serialized_packet.packet);
 310   encrypted_packets_.push_back(encrypted);
 311   // Transfer ownership of the packet to the SentPacketManager and the
 312   // ack notifier to the AckNotifierManager.
 313   sent_packet_manager_.OnPacketSent(
 314       &packet.serialized_packet, 0, QuicTime::Zero(), 1000,
 315       NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 316 }
 317
 318 MockSession::MockSession(QuicConnection* connection)
 319     : QuicSession(connection, DefaultQuicConfig(), /*is_secure=*/false) {
 320   InitializeSession();
 321   ON_CALL(*this, WritevData(_, _, _, _, _, _))
 322       .WillByDefault(testing::Return(QuicConsumedData(0, false)));
 323 }
 324
 325 MockSession::~MockSession() {
 326 }
 327
 328 TestSession::TestSession(QuicConnection* connection, const QuicConfig& config)
 329     : QuicSession(connection, config, /*is_secure=*/false),
 330       crypto_stream_(nullptr) {
 331   InitializeSession();
 332 }
 333
 334 TestSession::~TestSession() {}
 335
 336 void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
 337   crypto_stream_ = stream;
 338 }
 339
 340 QuicCryptoStream* TestSession::GetCryptoStream() {
 341   return crypto_stream_;
 342 }
 343
 344 TestClientSession::TestClientSession(QuicConnection* connection,
 345                                      const QuicConfig& config)
 346     : QuicClientSessionBase(connection, config, /*is_secure=*/false),
 347       crypto_stream_(nullptr) {
 348   EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
 349   InitializeSession();
 350 }
 351
 352 TestClientSession::~TestClientSession() {}
 353
 354 void TestClientSession::SetCryptoStream(QuicCryptoStream* stream) {
 355   crypto_stream_ = stream;
 356 }
 357
 358 QuicCryptoStream* TestClientSession::GetCryptoStream() {
 359   return crypto_stream_;
 360 }
 361
 362 MockPacketWriter::MockPacketWriter() {
 363 }
 364
 365 MockPacketWriter::~MockPacketWriter() {
 366 }
 367
 368 MockSendAlgorithm::MockSendAlgorithm() {
 369 }
 370
 371 MockSendAlgorithm::~MockSendAlgorithm() {
 372 }
 373
 374 MockLossAlgorithm::MockLossAlgorithm() {
 375 }
 376
 377 MockLossAlgorithm::~MockLossAlgorithm() {
 378 }
 379
 380 MockAckNotifierDelegate::MockAckNotifierDelegate() {
 381 }
 382
 383 MockAckNotifierDelegate::~MockAckNotifierDelegate() {
 384 }
 385
 386 MockNetworkChangeVisitor::MockNetworkChangeVisitor() {
 387 }
 388
 389 MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {
 390 }
 391
 392 namespace {
 393
 394 string HexDumpWithMarks(const char* data, int length,
 395                         const bool* marks, int mark_length) {
 396   static const char kHexChars[] = "0123456789abcdef";
 397   static const int kColumns = 4;
 398
 399   const int kSizeLimit = 1024;
 400   if (length > kSizeLimit || mark_length > kSizeLimit) {
 401     LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
 402     length = min(length, kSizeLimit);
 403     mark_length = min(mark_length, kSizeLimit);
 404   }
 405
 406   string hex;
 407   for (const char* row = data; length > 0;
 408        row += kColumns, length -= kColumns) {
 409     for (const char *p = row; p < row + 4; ++p) {
 410       if (p < row + length) {
 411         const bool mark =
 412             (marks && (p - data) < mark_length && marks[p - data]);
 413         hex += mark ? '*' : ' ';
 414         hex += kHexChars[(*p & 0xf0) >> 4];
 415         hex += kHexChars[*p & 0x0f];
 416         hex += mark ? '*' : ' ';
 417       } else {
 418         hex += "    ";
 419       }
 420     }
 421     hex = hex + "  ";
 422
 423     for (const char *p = row; p < row + 4 && p < row + length; ++p)
 424       hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
 425
 426     hex = hex + '\n';
 427   }
 428   return hex;
 429 }
 430
 431 }  // namespace
 432
 433 IPAddressNumber TestPeerIPAddress() { return Loopback4(); }
 434
 435 QuicVersion QuicVersionMax() { return QuicSupportedVersions().front(); }
 436
 437 QuicVersion QuicVersionMin() { return QuicSupportedVersions().back(); }
 438
 439 IPAddressNumber Loopback4() {
 440   IPAddressNumber addr;
 441   CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr));
 442   return addr;
 443 }
 444
 445 IPAddressNumber Loopback6() {
 446   IPAddressNumber addr;
 447   CHECK(ParseIPLiteralToNumber("::1", &addr));
 448   return addr;
 449 }
 450
 451 void GenerateBody(string* body, int length) {
 452   body->clear();
 453   body->reserve(length);
 454   for (int i = 0; i < length; ++i) {
 455     body->append(1, static_cast<char>(32 + i % (126 - 32)));
 456   }
 457 }
 458
 459 QuicEncryptedPacket* ConstructEncryptedPacket(
 460     QuicConnectionId connection_id,
 461     bool version_flag,
 462     bool reset_flag,
 463     QuicPacketSequenceNumber sequence_number,
 464     const string& data) {
 465   QuicPacketHeader header;
 466   header.public_header.connection_id = connection_id;
 467   header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
 468   header.public_header.version_flag = version_flag;
 469   header.public_header.reset_flag = reset_flag;
 470   header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
 471   header.packet_sequence_number = sequence_number;
 472   header.entropy_flag = false;
 473   header.entropy_hash = 0;
 474   header.fec_flag = false;
 475   header.is_in_fec_group = NOT_IN_FEC_GROUP;
 476   header.fec_group = 0;
 477   QuicStreamFrame stream_frame(1, false, 0, MakeIOVector(data));
 478   QuicFrame frame(&stream_frame);
 479   QuicFrames frames;
 480   frames.push_back(frame);
 481   QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
 482   scoped_ptr<QuicPacket> packet(
 483       BuildUnsizedDataPacket(&framer, header, frames).packet);
 484   EXPECT_TRUE(packet != nullptr);
 485   QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
 486                                                         sequence_number,
 487                                                         *packet);
 488   EXPECT_TRUE(encrypted != nullptr);
 489   return encrypted;
 490 }
 491
 492 void CompareCharArraysWithHexError(
 493     const string& description,
 494     const char* actual,
 495     const int actual_len,
 496     const char* expected,
 497     const int expected_len) {
 498   EXPECT_EQ(actual_len, expected_len);
 499   const int min_len = min(actual_len, expected_len);
 500   const int max_len = max(actual_len, expected_len);
 501   scoped_ptr<bool[]> marks(new bool[max_len]);
 502   bool identical = (actual_len == expected_len);
 503   for (int i = 0; i < min_len; ++i) {
 504     if (actual[i] != expected[i]) {
 505       marks[i] = true;
 506       identical = false;
 507     } else {
 508       marks[i] = false;
 509     }
 510   }
 511   for (int i = min_len; i < max_len; ++i) {
 512     marks[i] = true;
 513   }
 514   if (identical) return;
 515   ADD_FAILURE()
 516       << "Description:\n"
 517       << description
 518       << "\n\nExpected:\n"
 519       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
 520       << "\nActual:\n"
 521       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 522 }
 523
 524 bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
 525   bytes->clear();
 526   if (hex.empty())
 527     return true;
 528   std::vector<uint8> v;
 529   if (!base::HexStringToBytes(hex.as_string(), &v))
 530     return false;
 531   if (!v.empty())
 532     bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
 533   return true;
 534 }
 535
 536 static QuicPacket* ConstructPacketFromHandshakeMessage(
 537     QuicConnectionId connection_id,
 538     const CryptoHandshakeMessage& message,
 539     bool should_include_version) {
 540   CryptoFramer crypto_framer;
 541   scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
 542   QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), false);
 543
 544   QuicPacketHeader header;
 545   header.public_header.connection_id = connection_id;
 546   header.public_header.reset_flag = false;
 547   header.public_header.version_flag = should_include_version;
 548   header.packet_sequence_number = 1;
 549   header.entropy_flag = false;
 550   header.entropy_hash = 0;
 551   header.fec_flag = false;
 552   header.fec_group = 0;
 553
 554   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
 555                                MakeIOVector(data->AsStringPiece()));
 556
 557   QuicFrame frame(&stream_frame);
 558   QuicFrames frames;
 559   frames.push_back(frame);
 560   return BuildUnsizedDataPacket(&quic_framer, header, frames).packet;
 561 }
 562
 563 QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
 564                                      QuicTag tag) {
 565   CryptoHandshakeMessage message;
 566   message.set_tag(tag);
 567   return ConstructPacketFromHandshakeMessage(connection_id, message, false);
 568 }
 569
 570 size_t GetPacketLengthForOneStream(
 571     QuicVersion version,
 572     bool include_version,
 573     QuicConnectionIdLength connection_id_length,
 574     QuicSequenceNumberLength sequence_number_length,
 575     InFecGroup is_in_fec_group,
 576     size_t* payload_length) {
 577   *payload_length = 1;
 578   const size_t stream_length =
 579       NullEncrypter().GetCiphertextSize(*payload_length) +
 580       QuicPacketCreator::StreamFramePacketOverhead(
 581           PACKET_8BYTE_CONNECTION_ID, include_version,
 582           sequence_number_length, 0u, is_in_fec_group);
 583   const size_t ack_length = NullEncrypter().GetCiphertextSize(
 584       QuicFramer::GetMinAckFrameSize(
 585           sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
 586       GetPacketHeaderSize(connection_id_length, include_version,
 587                           sequence_number_length, is_in_fec_group);
 588   if (stream_length < ack_length) {
 589     *payload_length = 1 + ack_length - stream_length;
 590   }
 591
 592   return NullEncrypter().GetCiphertextSize(*payload_length) +
 593       QuicPacketCreator::StreamFramePacketOverhead(
 594           connection_id_length, include_version,
 595           sequence_number_length, 0u, is_in_fec_group);
 596 }
 597
 598 TestEntropyCalculator::TestEntropyCalculator() {}
 599
 600 TestEntropyCalculator::~TestEntropyCalculator() {}
 601
 602 QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
 603     QuicPacketSequenceNumber sequence_number) const {
 604   return 1u;
 605 }
 606
 607 MockEntropyCalculator::MockEntropyCalculator() {}
 608
 609 MockEntropyCalculator::~MockEntropyCalculator() {}
 610
 611 QuicConfig DefaultQuicConfig() {
 612   QuicConfig config;
 613   config.SetInitialFlowControlWindowToSend(
 614       kInitialSessionFlowControlWindowForTest);
 615   config.SetInitialStreamFlowControlWindowToSend(
 616       kInitialStreamFlowControlWindowForTest);
 617   config.SetInitialSessionFlowControlWindowToSend(
 618       kInitialSessionFlowControlWindowForTest);
 619   return config;
 620 }
 621
 622 QuicVersionVector SupportedVersions(QuicVersion version) {
 623   QuicVersionVector versions;
 624   versions.push_back(version);
 625   return versions;
 626 }
 627
 628 TestWriterFactory::TestWriterFactory() : current_writer_(nullptr) {}
 629 TestWriterFactory::~TestWriterFactory() {}
 630
 631 QuicPacketWriter* TestWriterFactory::Create(QuicServerPacketWriter* writer,
 632                                             QuicConnection* connection) {
 633   return new PerConnectionPacketWriter(this, writer, connection);
 634 }
 635
 636 void TestWriterFactory::OnPacketSent(WriteResult result) {
 637   if (current_writer_ != nullptr && result.status == WRITE_STATUS_ERROR) {
 638     current_writer_->connection()->OnWriteError(result.error_code);
 639     current_writer_ = nullptr;
 640   }
 641 }
 642
 643 void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) {
 644   if (current_writer_ == writer) {
 645     current_writer_ = nullptr;
 646   }
 647 }
 648
 649 TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter(
 650     TestWriterFactory* factory,
 651     QuicServerPacketWriter* writer,
 652     QuicConnection* connection)
 653     : QuicPerConnectionPacketWriter(writer, connection),
 654       factory_(factory) {
 655 }
 656
 657 TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() {
 658   factory_->Unregister(this);
 659 }
 660
 661 WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
 662     const char* buffer,
 663     size_t buf_len,
 664     const IPAddressNumber& self_address,
 665     const IPEndPoint& peer_address) {
 666   // A DCHECK(factory_current_writer_ == nullptr) would be wrong here -- this
 667   // class may be used in a setting where connection()->OnPacketSent() is called
 668   // in a different way, so TestWriterFactory::OnPacketSent might never be
 669   // called.
 670   factory_->current_writer_ = this;
 671   return QuicPerConnectionPacketWriter::WritePacket(buffer,
 672                                                     buf_len,
 673                                                     self_address,
 674                                                     peer_address);
 675 }
 676
 677 }  // namespace test
 678 }  // namespace net