Home | History | Annotate | Download | only in test_tools 
      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 
     29 namespace net {
     30 
     31 namespace test {
     32 
     33 static const QuicConnectionId kTestConnectionId = 42;
     34 static const int kTestPort = 123;
     35 static const uint32 kInitialStreamFlowControlWindowForTest =
     36     32 * 1024;  // 32 KB
     37 static 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.
     41 static const QuicStreamId kClientDataStreamId1 = 5;
     42 static const QuicStreamId kClientDataStreamId2 = 7;
     43 static const QuicStreamId kClientDataStreamId3 = 9;
     44 static const QuicStreamId kClientDataStreamId4 = 11;
     45 
     46 // Returns the test peer IP address.
     47 IPAddressNumber TestPeerIPAddress();
     48 
     49 // Upper limit on versions we support.
     50 QuicVersion QuicVersionMax();
     51 
     52 // Lower limit on versions we support.
     53 QuicVersion QuicVersionMin();
     54 
     55 // Returns an address for 127.0.0.1.
     56 IPAddressNumber Loopback4();
     57 
     58 // Returns an address for ::1.
     59 IPAddressNumber Loopback6();
     60 
     61 void GenerateBody(std::string* body, int length);
     62 
     63 // Create an encrypted packet for testing.
     64 QuicEncryptedPacket* ConstructEncryptedPacket(
     65     QuicConnectionId connection_id,
     66     bool version_flag,
     67     bool reset_flag,
     68     QuicPacketSequenceNumber sequence_number,
     69     const std::string& data);
     70 
     71 void CompareCharArraysWithHexError(const std::string& description,
     72                                    const char* actual,
     73                                    const int actual_len,
     74                                    const char* expected,
     75                                    const int expected_len);
     76 
     77 bool 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.
     82 size_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.
     90 QuicConfig DefaultQuicConfig();
     91 
     92 // Returns a version vector consisting of |version|.
     93 QuicVersionVector 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|.
     97 QuicAckFrame 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|.
    101 QuicAckFrame 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.
    107 SerializedPacket BuildUnsizedDataPacket(QuicFramer* framer,
    108                                         const QuicPacketHeader& header,
    109                                         const QuicFrames& frames);
    110 
    111 template<typename SaveType>
    112 class 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.
    134 class 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 
    149 class 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 
    189 class 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 
    227 class 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 
    254 class 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 
    270 class 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 
    325 class 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 
    343 class 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 
    376 class 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 
    394 class 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 
    419 class 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 
    437 class 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 
    474 class 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 
    491 class 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 
    504 class 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 
    517 class 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 
    535 class 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.
    550 class 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