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// Common utilities for Quic tests 6 7#ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ 8#define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ 9 10#include <string> 11#include <vector> 12 13#include "base/strings/string_piece.h" 14#include "net/quic/congestion_control/loss_detection_interface.h" 15#include "net/quic/congestion_control/send_algorithm_interface.h" 16#include "net/quic/quic_ack_notifier.h" 17#include "net/quic/quic_client_session_base.h" 18#include "net/quic/quic_connection.h" 19#include "net/quic/quic_dispatcher.h" 20#include "net/quic/quic_framer.h" 21#include "net/quic/quic_per_connection_packet_writer.h" 22#include "net/quic/quic_sent_packet_manager.h" 23#include "net/quic/quic_session.h" 24#include "net/quic/test_tools/mock_clock.h" 25#include "net/quic/test_tools/mock_random.h" 26#include "net/spdy/spdy_framer.h" 27#include "testing/gmock/include/gmock/gmock.h" 28 29namespace net { 30 31namespace test { 32 33static const QuicConnectionId kTestConnectionId = 42; 34static const int kTestPort = 123; 35static const uint32 kInitialStreamFlowControlWindowForTest = 36 32 * 1024; // 32 KB 37static const uint32 kInitialSessionFlowControlWindowForTest = 38 64 * 1024; // 64 KB 39 40// Data stream IDs start at 5: the crypto stream is 1, headers stream is 3. 41static const QuicStreamId kClientDataStreamId1 = 5; 42static const QuicStreamId kClientDataStreamId2 = 7; 43static const QuicStreamId kClientDataStreamId3 = 9; 44static const QuicStreamId kClientDataStreamId4 = 11; 45 46// Returns the test peer IP address. 47IPAddressNumber TestPeerIPAddress(); 48 49// Upper limit on versions we support. 50QuicVersion QuicVersionMax(); 51 52// Lower limit on versions we support. 53QuicVersion QuicVersionMin(); 54 55// Returns an address for 127.0.0.1. 56IPAddressNumber Loopback4(); 57 58// Returns an address for ::1. 59IPAddressNumber Loopback6(); 60 61void GenerateBody(std::string* body, int length); 62 63// Create an encrypted packet for testing. 64QuicEncryptedPacket* ConstructEncryptedPacket( 65 QuicConnectionId connection_id, 66 bool version_flag, 67 bool reset_flag, 68 QuicPacketSequenceNumber sequence_number, 69 const std::string& data); 70 71void CompareCharArraysWithHexError(const std::string& description, 72 const char* actual, 73 const int actual_len, 74 const char* expected, 75 const int expected_len); 76 77bool DecodeHexString(const base::StringPiece& hex, std::string* bytes); 78 79// Returns the length of a QuicPacket that is capable of holding either a 80// stream frame or a minimal ack frame. Sets |*payload_length| to the number 81// of bytes of stream data that will fit in such a packet. 82size_t GetPacketLengthForOneStream( 83 QuicVersion version, 84 bool include_version, 85 QuicSequenceNumberLength sequence_number_length, 86 InFecGroup is_in_fec_group, 87 size_t* payload_length); 88 89// Returns QuicConfig set to default values. 90QuicConfig DefaultQuicConfig(); 91 92// Returns a version vector consisting of |version|. 93QuicVersionVector SupportedVersions(QuicVersion version); 94 95// Testing convenience method to construct a QuicAckFrame with entropy_hash set 96// to 0 and largest_observed from peer set to |largest_observed|. 97QuicAckFrame MakeAckFrame(QuicPacketSequenceNumber largest_observed); 98 99// Testing convenience method to construct a QuicAckFrame with |num_nack_ranges| 100// nack ranges of width 1 packet, starting from |least_unacked|. 101QuicAckFrame MakeAckFrameWithNackRanges(size_t num_nack_ranges, 102 QuicPacketSequenceNumber least_unacked); 103 104// Returns a SerializedPacket whose |packet| member is owned by the caller, and 105// is populated with the fields in |header| and |frames|, or is NULL if the 106// packet could not be created. 107SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer, 108 const QuicPacketHeader& header, 109 const QuicFrames& frames); 110 111template<typename SaveType> 112class ValueRestore { 113 public: 114 ValueRestore(SaveType* name, SaveType value) 115 : name_(name), 116 value_(*name) { 117 *name_ = value; 118 } 119 ~ValueRestore() { 120 *name_ = value_; 121 } 122 123 private: 124 SaveType* name_; 125 SaveType value_; 126 127 DISALLOW_COPY_AND_ASSIGN(ValueRestore); 128}; 129 130// Simple random number generator used to compute random numbers suitable 131// for pseudo-randomly dropping packets in tests. It works by computing 132// the sha1 hash of the current seed, and using the first 64 bits as 133// the next random number, and the next seed. 134class SimpleRandom { 135 public: 136 SimpleRandom() : seed_(0) {} 137 138 // Returns a random number in the range [0, kuint64max]. 139 uint64 RandUint64(); 140 141 void set_seed(uint64 seed) { seed_ = seed; } 142 143 private: 144 uint64 seed_; 145 146 DISALLOW_COPY_AND_ASSIGN(SimpleRandom); 147}; 148 149class MockFramerVisitor : public QuicFramerVisitorInterface { 150 public: 151 MockFramerVisitor(); 152 virtual ~MockFramerVisitor(); 153 154 MOCK_METHOD1(OnError, void(QuicFramer* framer)); 155 // The constructor sets this up to return false by default. 156 MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicVersion version)); 157 MOCK_METHOD0(OnPacket, void()); 158 MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header)); 159 MOCK_METHOD1(OnVersionNegotiationPacket, 160 void(const QuicVersionNegotiationPacket& packet)); 161 MOCK_METHOD0(OnRevivedPacket, void()); 162 // The constructor sets this up to return true by default. 163 MOCK_METHOD1(OnUnauthenticatedHeader, bool(const QuicPacketHeader& header)); 164 // The constructor sets this up to return true by default. 165 MOCK_METHOD1(OnUnauthenticatedPublicHeader, bool( 166 const QuicPacketPublicHeader& header)); 167 MOCK_METHOD1(OnDecryptedPacket, void(EncryptionLevel level)); 168 MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header)); 169 MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload)); 170 MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame)); 171 MOCK_METHOD1(OnAckFrame, bool(const QuicAckFrame& frame)); 172 MOCK_METHOD1(OnCongestionFeedbackFrame, 173 bool(const QuicCongestionFeedbackFrame& frame)); 174 MOCK_METHOD1(OnStopWaitingFrame, bool(const QuicStopWaitingFrame& frame)); 175 MOCK_METHOD1(OnPingFrame, bool(const QuicPingFrame& frame)); 176 MOCK_METHOD1(OnFecData, void(const QuicFecData& fec)); 177 MOCK_METHOD1(OnRstStreamFrame, bool(const QuicRstStreamFrame& frame)); 178 MOCK_METHOD1(OnConnectionCloseFrame, 179 bool(const QuicConnectionCloseFrame& frame)); 180 MOCK_METHOD1(OnGoAwayFrame, bool(const QuicGoAwayFrame& frame)); 181 MOCK_METHOD1(OnWindowUpdateFrame, bool(const QuicWindowUpdateFrame& frame)); 182 MOCK_METHOD1(OnBlockedFrame, bool(const QuicBlockedFrame& frame)); 183 MOCK_METHOD0(OnPacketComplete, void()); 184 185 private: 186 DISALLOW_COPY_AND_ASSIGN(MockFramerVisitor); 187}; 188 189class NoOpFramerVisitor : public QuicFramerVisitorInterface { 190 public: 191 NoOpFramerVisitor() {} 192 193 virtual void OnError(QuicFramer* framer) OVERRIDE {} 194 virtual void OnPacket() OVERRIDE {} 195 virtual void OnPublicResetPacket( 196 const QuicPublicResetPacket& packet) OVERRIDE {} 197 virtual void OnVersionNegotiationPacket( 198 const QuicVersionNegotiationPacket& packet) OVERRIDE {} 199 virtual void OnRevivedPacket() OVERRIDE {} 200 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE; 201 virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE; 202 virtual bool OnUnauthenticatedPublicHeader( 203 const QuicPacketPublicHeader& header) OVERRIDE; 204 virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {} 205 virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE; 206 virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {} 207 virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE; 208 virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE; 209 virtual bool OnCongestionFeedbackFrame( 210 const QuicCongestionFeedbackFrame& frame) OVERRIDE; 211 virtual bool OnStopWaitingFrame( 212 const QuicStopWaitingFrame& frame) OVERRIDE; 213 virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE; 214 virtual void OnFecData(const QuicFecData& fec) OVERRIDE {} 215 virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE; 216 virtual bool OnConnectionCloseFrame( 217 const QuicConnectionCloseFrame& frame) OVERRIDE; 218 virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE; 219 virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE; 220 virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE; 221 virtual void OnPacketComplete() OVERRIDE {} 222 223 private: 224 DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor); 225}; 226 227class MockConnectionVisitor : public QuicConnectionVisitorInterface { 228 public: 229 MockConnectionVisitor(); 230 virtual ~MockConnectionVisitor(); 231 232 MOCK_METHOD1(OnStreamFrames, void(const std::vector<QuicStreamFrame>& frame)); 233 MOCK_METHOD1(OnWindowUpdateFrames, 234 void(const std::vector<QuicWindowUpdateFrame>& frame)); 235 MOCK_METHOD1(OnBlockedFrames, 236 void(const std::vector<QuicBlockedFrame>& frame)); 237 MOCK_METHOD1(OnRstStream, void(const QuicRstStreamFrame& frame)); 238 MOCK_METHOD1(OnGoAway, void(const QuicGoAwayFrame& frame)); 239 MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer)); 240 MOCK_METHOD0(OnWriteBlocked, void()); 241 MOCK_METHOD0(OnCanWrite, void()); 242 MOCK_METHOD1(OnCongestionWindowChange, void(QuicTime now)); 243 MOCK_CONST_METHOD0(WillingAndAbleToWrite, bool()); 244 MOCK_CONST_METHOD0(HasPendingHandshake, bool()); 245 MOCK_CONST_METHOD0(HasOpenDataStreams, bool()); 246 MOCK_METHOD1(OnSuccessfulVersionNegotiation, 247 void(const QuicVersion& version)); 248 MOCK_METHOD0(OnConfigNegotiated, void()); 249 250 private: 251 DISALLOW_COPY_AND_ASSIGN(MockConnectionVisitor); 252}; 253 254class MockHelper : public QuicConnectionHelperInterface { 255 public: 256 MockHelper(); 257 virtual ~MockHelper(); 258 virtual const QuicClock* GetClock() const OVERRIDE; 259 virtual QuicRandom* GetRandomGenerator() OVERRIDE; 260 virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE; 261 void AdvanceTime(QuicTime::Delta delta); 262 263 private: 264 MockClock clock_; 265 MockRandom random_generator_; 266 267 DISALLOW_COPY_AND_ASSIGN(MockHelper); 268}; 269 270class MockConnection : public QuicConnection { 271 public: 272 // Uses a MockHelper, ConnectionId of 42, and 127.0.0.1:123. 273 explicit MockConnection(bool is_server); 274 275 // Uses a MockHelper, ConnectionId of 42. 276 MockConnection(IPEndPoint address, bool is_server); 277 278 // Uses a MockHelper, and 127.0.0.1:123 279 MockConnection(QuicConnectionId connection_id, bool is_server); 280 281 // Uses a Mock helper, ConnectionId of 42, and 127.0.0.1:123. 282 MockConnection(bool is_server, const QuicVersionVector& supported_versions); 283 284 virtual ~MockConnection(); 285 286 // If the constructor that uses a MockHelper has been used then this method 287 // will advance the time of the MockClock. 288 void AdvanceTime(QuicTime::Delta delta); 289 290 MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address, 291 const IPEndPoint& peer_address, 292 const QuicEncryptedPacket& packet)); 293 MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error)); 294 MOCK_METHOD2(SendConnectionCloseWithDetails, void(QuicErrorCode error, 295 const string& details)); 296 MOCK_METHOD2(SendConnectionClosePacket, void(QuicErrorCode error, 297 const string& details)); 298 MOCK_METHOD3(SendRstStream, void(QuicStreamId id, 299 QuicRstStreamErrorCode error, 300 QuicStreamOffset bytes_written)); 301 MOCK_METHOD3(SendGoAway, void(QuicErrorCode error, 302 QuicStreamId last_good_stream_id, 303 const string& reason)); 304 MOCK_METHOD1(SendBlocked, void(QuicStreamId id)); 305 MOCK_METHOD2(SendWindowUpdate, void(QuicStreamId id, 306 QuicStreamOffset byte_offset)); 307 MOCK_METHOD0(OnCanWrite, void()); 308 309 void ProcessUdpPacketInternal(const IPEndPoint& self_address, 310 const IPEndPoint& peer_address, 311 const QuicEncryptedPacket& packet) { 312 QuicConnection::ProcessUdpPacket(self_address, peer_address, packet); 313 } 314 315 virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE { 316 return false; 317 } 318 319 private: 320 scoped_ptr<QuicConnectionHelperInterface> helper_; 321 322 DISALLOW_COPY_AND_ASSIGN(MockConnection); 323}; 324 325class PacketSavingConnection : public MockConnection { 326 public: 327 explicit PacketSavingConnection(bool is_server); 328 329 PacketSavingConnection(bool is_server, 330 const QuicVersionVector& supported_versions); 331 332 virtual ~PacketSavingConnection(); 333 334 virtual void SendOrQueuePacket(QueuedPacket packet) OVERRIDE; 335 336 std::vector<QuicPacket*> packets_; 337 std::vector<QuicEncryptedPacket*> encrypted_packets_; 338 339 private: 340 DISALLOW_COPY_AND_ASSIGN(PacketSavingConnection); 341}; 342 343class MockSession : public QuicSession { 344 public: 345 explicit MockSession(QuicConnection* connection); 346 virtual ~MockSession(); 347 MOCK_METHOD2(OnConnectionClosed, void(QuicErrorCode error, bool from_peer)); 348 MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id)); 349 MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*()); 350 MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*()); 351 MOCK_METHOD6(WritevData, 352 QuicConsumedData(QuicStreamId id, 353 const IOVector& data, 354 QuicStreamOffset offset, 355 bool fin, 356 FecProtection fec_protection, 357 QuicAckNotifier::DelegateInterface*)); 358 MOCK_METHOD2(OnStreamHeaders, void(QuicStreamId stream_id, 359 base::StringPiece headers_data)); 360 MOCK_METHOD2(OnStreamHeadersPriority, void(QuicStreamId stream_id, 361 QuicPriority priority)); 362 MOCK_METHOD3(OnStreamHeadersComplete, void(QuicStreamId stream_id, 363 bool fin, 364 size_t frame_len)); 365 MOCK_METHOD3(SendRstStream, void(QuicStreamId stream_id, 366 QuicRstStreamErrorCode error, 367 QuicStreamOffset bytes_written)); 368 MOCK_METHOD0(IsCryptoHandshakeConfirmed, bool()); 369 370 using QuicSession::ActivateStream; 371 372 private: 373 DISALLOW_COPY_AND_ASSIGN(MockSession); 374}; 375 376class TestSession : public QuicSession { 377 public: 378 TestSession(QuicConnection* connection, const QuicConfig& config); 379 virtual ~TestSession(); 380 381 MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id)); 382 MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*()); 383 384 void SetCryptoStream(QuicCryptoStream* stream); 385 386 virtual QuicCryptoStream* GetCryptoStream() OVERRIDE; 387 388 private: 389 QuicCryptoStream* crypto_stream_; 390 391 DISALLOW_COPY_AND_ASSIGN(TestSession); 392}; 393 394class TestClientSession : public QuicClientSessionBase { 395 public: 396 TestClientSession(QuicConnection* connection, const QuicConfig& config); 397 virtual ~TestClientSession(); 398 399 // QuicClientSessionBase 400 MOCK_METHOD1(OnProofValid, 401 void(const QuicCryptoClientConfig::CachedState& cached)); 402 MOCK_METHOD1(OnProofVerifyDetailsAvailable, 403 void(const ProofVerifyDetails& verify_details)); 404 405 // TestClientSession 406 MOCK_METHOD1(CreateIncomingDataStream, QuicDataStream*(QuicStreamId id)); 407 MOCK_METHOD0(CreateOutgoingDataStream, QuicDataStream*()); 408 409 void SetCryptoStream(QuicCryptoStream* stream); 410 411 virtual QuicCryptoStream* GetCryptoStream() OVERRIDE; 412 413 private: 414 QuicCryptoStream* crypto_stream_; 415 416 DISALLOW_COPY_AND_ASSIGN(TestClientSession); 417}; 418 419class MockPacketWriter : public QuicPacketWriter { 420 public: 421 MockPacketWriter(); 422 virtual ~MockPacketWriter(); 423 424 MOCK_METHOD4(WritePacket, 425 WriteResult(const char* buffer, 426 size_t buf_len, 427 const IPAddressNumber& self_address, 428 const IPEndPoint& peer_address)); 429 MOCK_CONST_METHOD0(IsWriteBlockedDataBuffered, bool()); 430 MOCK_CONST_METHOD0(IsWriteBlocked, bool()); 431 MOCK_METHOD0(SetWritable, void()); 432 433 private: 434 DISALLOW_COPY_AND_ASSIGN(MockPacketWriter); 435}; 436 437class MockSendAlgorithm : public SendAlgorithmInterface { 438 public: 439 MockSendAlgorithm(); 440 virtual ~MockSendAlgorithm(); 441 442 MOCK_METHOD2(SetFromConfig, void(const QuicConfig& config, bool is_server)); 443 MOCK_METHOD1(SetMaxPacketSize, void(QuicByteCount max_packet_size)); 444 MOCK_METHOD2(OnIncomingQuicCongestionFeedbackFrame, 445 void(const QuicCongestionFeedbackFrame&, 446 QuicTime feedback_receive_time)); 447 MOCK_METHOD4(OnCongestionEvent, void(bool rtt_updated, 448 QuicByteCount bytes_in_flight, 449 const CongestionVector& acked_packets, 450 const CongestionVector& lost_packets)); 451 MOCK_METHOD5(OnPacketSent, 452 bool(QuicTime, QuicByteCount, QuicPacketSequenceNumber, 453 QuicByteCount, HasRetransmittableData)); 454 MOCK_METHOD1(OnRetransmissionTimeout, void(bool)); 455 MOCK_METHOD0(RevertRetransmissionTimeout, void()); 456 MOCK_CONST_METHOD3(TimeUntilSend, 457 QuicTime::Delta(QuicTime now, 458 QuicByteCount bytes_in_flight, 459 HasRetransmittableData)); 460 MOCK_CONST_METHOD0(BandwidthEstimate, QuicBandwidth(void)); 461 MOCK_CONST_METHOD0(HasReliableBandwidthEstimate, bool()); 462 MOCK_METHOD1(OnRttUpdated, void(QuicPacketSequenceNumber)); 463 MOCK_CONST_METHOD0(RetransmissionDelay, QuicTime::Delta(void)); 464 MOCK_CONST_METHOD0(GetCongestionWindow, QuicByteCount()); 465 MOCK_CONST_METHOD0(InSlowStart, bool()); 466 MOCK_CONST_METHOD0(InRecovery, bool()); 467 MOCK_CONST_METHOD0(GetSlowStartThreshold, QuicByteCount()); 468 MOCK_CONST_METHOD0(GetCongestionControlType, CongestionControlType()); 469 470 private: 471 DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm); 472}; 473 474class MockLossAlgorithm : public LossDetectionInterface { 475 public: 476 MockLossAlgorithm(); 477 virtual ~MockLossAlgorithm(); 478 479 MOCK_CONST_METHOD0(GetLossDetectionType, LossDetectionType()); 480 MOCK_METHOD4(DetectLostPackets, 481 SequenceNumberSet(const QuicUnackedPacketMap& unacked_packets, 482 const QuicTime& time, 483 QuicPacketSequenceNumber largest_observed, 484 const RttStats& rtt_stats)); 485 MOCK_CONST_METHOD0(GetLossTimeout, QuicTime()); 486 487 private: 488 DISALLOW_COPY_AND_ASSIGN(MockLossAlgorithm); 489}; 490 491class TestEntropyCalculator : 492 public QuicReceivedEntropyHashCalculatorInterface { 493 public: 494 TestEntropyCalculator(); 495 virtual ~TestEntropyCalculator(); 496 497 virtual QuicPacketEntropyHash EntropyHash( 498 QuicPacketSequenceNumber sequence_number) const OVERRIDE; 499 500 private: 501 DISALLOW_COPY_AND_ASSIGN(TestEntropyCalculator); 502}; 503 504class MockEntropyCalculator : public TestEntropyCalculator { 505 public: 506 MockEntropyCalculator(); 507 virtual ~MockEntropyCalculator(); 508 509 MOCK_CONST_METHOD1( 510 EntropyHash, 511 QuicPacketEntropyHash(QuicPacketSequenceNumber sequence_number)); 512 513 private: 514 DISALLOW_COPY_AND_ASSIGN(MockEntropyCalculator); 515}; 516 517class MockAckNotifierDelegate : public QuicAckNotifier::DelegateInterface { 518 public: 519 MockAckNotifierDelegate(); 520 521 MOCK_METHOD5(OnAckNotification, void(int num_original_packets, 522 int num_original_bytes, 523 int num_retransmitted_packets, 524 int num_retransmitted_bytes, 525 QuicTime::Delta delta_largest_observed)); 526 527 protected: 528 // Object is ref counted. 529 virtual ~MockAckNotifierDelegate(); 530 531 private: 532 DISALLOW_COPY_AND_ASSIGN(MockAckNotifierDelegate); 533}; 534 535class MockNetworkChangeVisitor : 536 public QuicSentPacketManager::NetworkChangeVisitor { 537 public: 538 MockNetworkChangeVisitor(); 539 virtual ~MockNetworkChangeVisitor(); 540 541 MOCK_METHOD1(OnCongestionWindowChange, void(QuicByteCount)); 542 543 private: 544 DISALLOW_COPY_AND_ASSIGN(MockNetworkChangeVisitor); 545}; 546 547// Creates per-connection packet writers that register themselves with the 548// TestWriterFactory on each write so that TestWriterFactory::OnPacketSent can 549// be routed to the appropriate QuicConnection. 550class TestWriterFactory : public QuicDispatcher::PacketWriterFactory { 551 public: 552 TestWriterFactory(); 553 virtual ~TestWriterFactory(); 554 555 virtual QuicPacketWriter* Create(QuicServerPacketWriter* writer, 556 QuicConnection* connection) OVERRIDE; 557 558 // Calls OnPacketSent on the last QuicConnection to write through one of the 559 // packet writers created by this factory. 560 void OnPacketSent(WriteResult result); 561 562 private: 563 class PerConnectionPacketWriter : public QuicPerConnectionPacketWriter { 564 public: 565 PerConnectionPacketWriter(TestWriterFactory* factory, 566 QuicServerPacketWriter* writer, 567 QuicConnection* connection); 568 virtual ~PerConnectionPacketWriter(); 569 570 virtual WriteResult WritePacket( 571 const char* buffer, 572 size_t buf_len, 573 const IPAddressNumber& self_address, 574 const IPEndPoint& peer_address) OVERRIDE; 575 576 private: 577 TestWriterFactory* factory_; 578 }; 579 580 // If an asynchronous write is happening and |writer| gets deleted, this 581 // clears the pointer to it to prevent use-after-free. 582 void Unregister(PerConnectionPacketWriter* writer); 583 584 PerConnectionPacketWriter* current_writer_; 585}; 586 587} // namespace test 588} // namespace net 589 590#endif // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_ 591