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()) {
 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), crypto_stream_(nullptr) {
 330   InitializeSession();
 331 }
 332
 333 TestSession::~TestSession() {}
 334
 335 void TestSession::SetCryptoStream(QuicCryptoStream* stream) {
 336   crypto_stream_ = stream;
 337 }
 338
 339 QuicCryptoStream* TestSession::GetCryptoStream() {
 340   return crypto_stream_;
 341 }
 342
 343 TestClientSession::TestClientSession(QuicConnection* connection,
 344                                      const QuicConfig& config)
 345     : QuicClientSessionBase(connection, config),
 346       crypto_stream_(nullptr) {
 347   EXPECT_CALL(*this, OnProofValid(_)).Times(AnyNumber());
 348   InitializeSession();
 349 }
 350
 351 TestClientSession::~TestClientSession() {}
 352
 353 void TestClientSession::SetCryptoStream(QuicCryptoStream* stream) {
 354   crypto_stream_ = stream;
 355 }
 356
 357 QuicCryptoStream* TestClientSession::GetCryptoStream() {
 358   return crypto_stream_;
 359 }
 360
 361 MockPacketWriter::MockPacketWriter() {
 362 }
 363
 364 MockPacketWriter::~MockPacketWriter() {
 365 }
 366
 367 MockSendAlgorithm::MockSendAlgorithm() {
 368 }
 369
 370 MockSendAlgorithm::~MockSendAlgorithm() {
 371 }
 372
 373 MockLossAlgorithm::MockLossAlgorithm() {
 374 }
 375
 376 MockLossAlgorithm::~MockLossAlgorithm() {
 377 }
 378
 379 MockAckNotifierDelegate::MockAckNotifierDelegate() {
 380 }
 381
 382 MockAckNotifierDelegate::~MockAckNotifierDelegate() {
 383 }
 384
 385 MockNetworkChangeVisitor::MockNetworkChangeVisitor() {
 386 }
 387
 388 MockNetworkChangeVisitor::~MockNetworkChangeVisitor() {
 389 }
 390
 391 namespace {
 392
 393 string HexDumpWithMarks(const char* data, int length,
 394                         const bool* marks, int mark_length) {
 395   static const char kHexChars[] = "0123456789abcdef";
 396   static const int kColumns = 4;
 397
 398   const int kSizeLimit = 1024;
 399   if (length > kSizeLimit || mark_length > kSizeLimit) {
 400     LOG(ERROR) << "Only dumping first " << kSizeLimit << " bytes.";
 401     length = min(length, kSizeLimit);
 402     mark_length = min(mark_length, kSizeLimit);
 403   }
 404
 405   string hex;
 406   for (const char* row = data; length > 0;
 407        row += kColumns, length -= kColumns) {
 408     for (const char *p = row; p < row + 4; ++p) {
 409       if (p < row + length) {
 410         const bool mark =
 411             (marks && (p - data) < mark_length && marks[p - data]);
 412         hex += mark ? '*' : ' ';
 413         hex += kHexChars[(*p & 0xf0) >> 4];
 414         hex += kHexChars[*p & 0x0f];
 415         hex += mark ? '*' : ' ';
 416       } else {
 417         hex += "    ";
 418       }
 419     }
 420     hex = hex + "  ";
 421
 422     for (const char *p = row; p < row + 4 && p < row + length; ++p)
 423       hex += (*p >= 0x20 && *p <= 0x7f) ? (*p) : '.';
 424
 425     hex = hex + '\n';
 426   }
 427   return hex;
 428 }
 429
 430 }  // namespace
 431
 432 IPAddressNumber TestPeerIPAddress() { return Loopback4(); }
 433
 434 QuicVersion QuicVersionMax() { return QuicSupportedVersions().front(); }
 435
 436 QuicVersion QuicVersionMin() { return QuicSupportedVersions().back(); }
 437
 438 IPAddressNumber Loopback4() {
 439   IPAddressNumber addr;
 440   CHECK(ParseIPLiteralToNumber("127.0.0.1", &addr));
 441   return addr;
 442 }
 443
 444 IPAddressNumber Loopback6() {
 445   IPAddressNumber addr;
 446   CHECK(ParseIPLiteralToNumber("::1", &addr));
 447   return addr;
 448 }
 449
 450 void GenerateBody(string* body, int length) {
 451   body->clear();
 452   body->reserve(length);
 453   for (int i = 0; i < length; ++i) {
 454     body->append(1, static_cast<char>(32 + i % (126 - 32)));
 455   }
 456 }
 457
 458 QuicEncryptedPacket* ConstructEncryptedPacket(
 459     QuicConnectionId connection_id,
 460     bool version_flag,
 461     bool reset_flag,
 462     QuicPacketSequenceNumber sequence_number,
 463     const string& data) {
 464   QuicPacketHeader header;
 465   header.public_header.connection_id = connection_id;
 466   header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
 467   header.public_header.version_flag = version_flag;
 468   header.public_header.reset_flag = reset_flag;
 469   header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
 470   header.packet_sequence_number = sequence_number;
 471   header.entropy_flag = false;
 472   header.entropy_hash = 0;
 473   header.fec_flag = false;
 474   header.is_in_fec_group = NOT_IN_FEC_GROUP;
 475   header.fec_group = 0;
 476   QuicStreamFrame stream_frame(1, false, 0, MakeIOVector(data));
 477   QuicFrame frame(&stream_frame);
 478   QuicFrames frames;
 479   frames.push_back(frame);
 480   QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
 481   scoped_ptr<QuicPacket> packet(
 482       BuildUnsizedDataPacket(&framer, header, frames).packet);
 483   EXPECT_TRUE(packet != nullptr);
 484   QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
 485                                                         sequence_number,
 486                                                         *packet);
 487   EXPECT_TRUE(encrypted != nullptr);
 488   return encrypted;
 489 }
 490
 491 void CompareCharArraysWithHexError(
 492     const string& description,
 493     const char* actual,
 494     const int actual_len,
 495     const char* expected,
 496     const int expected_len) {
 497   EXPECT_EQ(actual_len, expected_len);
 498   const int min_len = min(actual_len, expected_len);
 499   const int max_len = max(actual_len, expected_len);
 500   scoped_ptr<bool[]> marks(new bool[max_len]);
 501   bool identical = (actual_len == expected_len);
 502   for (int i = 0; i < min_len; ++i) {
 503     if (actual[i] != expected[i]) {
 504       marks[i] = true;
 505       identical = false;
 506     } else {
 507       marks[i] = false;
 508     }
 509   }
 510   for (int i = min_len; i < max_len; ++i) {
 511     marks[i] = true;
 512   }
 513   if (identical) return;
 514   ADD_FAILURE()
 515       << "Description:\n"
 516       << description
 517       << "\n\nExpected:\n"
 518       << HexDumpWithMarks(expected, expected_len, marks.get(), max_len)
 519       << "\nActual:\n"
 520       << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 521 }
 522
 523 bool DecodeHexString(const base::StringPiece& hex, std::string* bytes) {
 524   bytes->clear();
 525   if (hex.empty())
 526     return true;
 527   std::vector<uint8> v;
 528   if (!base::HexStringToBytes(hex.as_string(), &v))
 529     return false;
 530   if (!v.empty())
 531     bytes->assign(reinterpret_cast<const char*>(&v[0]), v.size());
 532   return true;
 533 }
 534
 535 static QuicPacket* ConstructPacketFromHandshakeMessage(
 536     QuicConnectionId connection_id,
 537     const CryptoHandshakeMessage& message,
 538     bool should_include_version) {
 539   CryptoFramer crypto_framer;
 540   scoped_ptr<QuicData> data(crypto_framer.ConstructHandshakeMessage(message));
 541   QuicFramer quic_framer(QuicSupportedVersions(), QuicTime::Zero(), false);
 542
 543   QuicPacketHeader header;
 544   header.public_header.connection_id = connection_id;
 545   header.public_header.reset_flag = false;
 546   header.public_header.version_flag = should_include_version;
 547   header.packet_sequence_number = 1;
 548   header.entropy_flag = false;
 549   header.entropy_hash = 0;
 550   header.fec_flag = false;
 551   header.fec_group = 0;
 552
 553   QuicStreamFrame stream_frame(kCryptoStreamId, false, 0,
 554                                MakeIOVector(data->AsStringPiece()));
 555
 556   QuicFrame frame(&stream_frame);
 557   QuicFrames frames;
 558   frames.push_back(frame);
 559   return BuildUnsizedDataPacket(&quic_framer, header, frames).packet;
 560 }
 561
 562 QuicPacket* ConstructHandshakePacket(QuicConnectionId connection_id,
 563                                      QuicTag tag) {
 564   CryptoHandshakeMessage message;
 565   message.set_tag(tag);
 566   return ConstructPacketFromHandshakeMessage(connection_id, message, false);
 567 }
 568
 569 size_t GetPacketLengthForOneStream(
 570     QuicVersion version,
 571     bool include_version,
 572     QuicSequenceNumberLength sequence_number_length,
 573     InFecGroup is_in_fec_group,
 574     size_t* payload_length) {
 575   *payload_length = 1;
 576   const size_t stream_length =
 577       NullEncrypter().GetCiphertextSize(*payload_length) +
 578       QuicPacketCreator::StreamFramePacketOverhead(
 579           PACKET_8BYTE_CONNECTION_ID, include_version,
 580           sequence_number_length, 0u, is_in_fec_group);
 581   const size_t ack_length = NullEncrypter().GetCiphertextSize(
 582       QuicFramer::GetMinAckFrameSize(
 583           sequence_number_length, PACKET_1BYTE_SEQUENCE_NUMBER)) +
 584       GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version,
 585                           sequence_number_length, is_in_fec_group);
 586   if (stream_length < ack_length) {
 587     *payload_length = 1 + ack_length - stream_length;
 588   }
 589
 590   return NullEncrypter().GetCiphertextSize(*payload_length) +
 591       QuicPacketCreator::StreamFramePacketOverhead(
 592           PACKET_8BYTE_CONNECTION_ID, include_version,
 593           sequence_number_length, 0u, is_in_fec_group);
 594 }
 595
 596 TestEntropyCalculator::TestEntropyCalculator() {}
 597
 598 TestEntropyCalculator::~TestEntropyCalculator() {}
 599
 600 QuicPacketEntropyHash TestEntropyCalculator::EntropyHash(
 601     QuicPacketSequenceNumber sequence_number) const {
 602   return 1u;
 603 }
 604
 605 MockEntropyCalculator::MockEntropyCalculator() {}
 606
 607 MockEntropyCalculator::~MockEntropyCalculator() {}
 608
 609 QuicConfig DefaultQuicConfig() {
 610   QuicConfig config;
 611   config.SetInitialFlowControlWindowToSend(
 612       kInitialSessionFlowControlWindowForTest);
 613   config.SetInitialStreamFlowControlWindowToSend(
 614       kInitialStreamFlowControlWindowForTest);
 615   config.SetInitialSessionFlowControlWindowToSend(
 616       kInitialSessionFlowControlWindowForTest);
 617   return config;
 618 }
 619
 620 QuicVersionVector SupportedVersions(QuicVersion version) {
 621   QuicVersionVector versions;
 622   versions.push_back(version);
 623   return versions;
 624 }
 625
 626 TestWriterFactory::TestWriterFactory() : current_writer_(nullptr) {}
 627 TestWriterFactory::~TestWriterFactory() {}
 628
 629 QuicPacketWriter* TestWriterFactory::Create(QuicServerPacketWriter* writer,
 630                                             QuicConnection* connection) {
 631   return new PerConnectionPacketWriter(this, writer, connection);
 632 }
 633
 634 void TestWriterFactory::OnPacketSent(WriteResult result) {
 635   if (current_writer_ != nullptr && result.status == WRITE_STATUS_ERROR) {
 636     current_writer_->connection()->OnWriteError(result.error_code);
 637     current_writer_ = nullptr;
 638   }
 639 }
 640
 641 void TestWriterFactory::Unregister(PerConnectionPacketWriter* writer) {
 642   if (current_writer_ == writer) {
 643     current_writer_ = nullptr;
 644   }
 645 }
 646
 647 TestWriterFactory::PerConnectionPacketWriter::PerConnectionPacketWriter(
 648     TestWriterFactory* factory,
 649     QuicServerPacketWriter* writer,
 650     QuicConnection* connection)
 651     : QuicPerConnectionPacketWriter(writer, connection),
 652       factory_(factory) {
 653 }
 654
 655 TestWriterFactory::PerConnectionPacketWriter::~PerConnectionPacketWriter() {
 656   factory_->Unregister(this);
 657 }
 658
 659 WriteResult TestWriterFactory::PerConnectionPacketWriter::WritePacket(
 660     const char* buffer,
 661     size_t buf_len,
 662     const IPAddressNumber& self_address,
 663     const IPEndPoint& peer_address) {
 664   // A DCHECK(factory_current_writer_ == nullptr) would be wrong here -- this
 665   // class may be used in a setting where connection()->OnPacketSent() is called
 666   // in a different way, so TestWriterFactory::OnPacketSent might never be
 667   // called.
 668   factory_->current_writer_ = this;
 669   return QuicPerConnectionPacketWriter::WritePacket(buffer,
 670                                                     buf_len,
 671                                                     self_address,
 672                                                     peer_address);
 673 }
 674
 675 }  // namespace test
 676 }  // namespace net