Land Recent QUIC Changes

net/quic/test_tools/quic_test_utils.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include <vector>
@@ skipping 166 matching lines @@
 };
 
 class MockHelper : public QuicConnectionHelperInterface {
  public:
   MockHelper();
   virtual ~MockHelper();
 
   MOCK_METHOD1(SetConnection, void(QuicConnection* connection));
   const QuicClock* GetClock() const;
   QuicRandom* GetRandomGenerator();
+  void AdvanceTime(QuicTime::Delta delta);
   MOCK_METHOD2(WritePacketToWire, int(const QuicEncryptedPacket& packet,
                                       int* error));
   MOCK_METHOD0(IsWriteBlockedDataBuffered, bool());
   MOCK_METHOD1(IsWriteBlocked, bool(int));
   MOCK_METHOD1(SetRetransmissionAlarm, void(QuicTime::Delta delay));
   MOCK_METHOD1(SetAckAlarm, void(QuicTime::Delta delay));
   MOCK_METHOD1(SetSendAlarm, void(QuicTime alarm_time));
   MOCK_METHOD1(SetTimeoutAlarm, void(QuicTime::Delta delay));
   MOCK_METHOD0(IsSendAlarmSet, bool());
   MOCK_METHOD0(UnregisterSendAlarmIfRegistered, void());
   MOCK_METHOD0(ClearAckAlarm, void());
  private:
-  const MockClock clock_;
+  MockClock clock_;
   MockRandom random_generator_;
 };
 
 class MockConnection : public QuicConnection {
  public:
   // Uses a MockHelper.
   MockConnection(QuicGuid guid, IPEndPoint address, bool is_server);
   MockConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper,
                  bool is_server);
   virtual ~MockConnection();
 
+  // If the constructor that uses a MockHelper has been used then this method
+  // will advance the time of the MockClock.
+  void AdvanceTime(QuicTime::Delta delta);
+
   MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet));
   MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
   MOCK_METHOD2(SendConnectionCloseWithDetails, void(QuicErrorCode error,
                                                     const string& details));
   MOCK_METHOD2(SendRstStream, void(QuicStreamId id,
                                    QuicRstStreamErrorCode error));
   MOCK_METHOD3(SendGoAway, void(QuicErrorCode error,
                                 QuicStreamId last_good_stream_id,
                                 const string& reason));
   MOCK_METHOD0(OnCanWrite, bool());
 
   void ProcessUdpPacketInternal(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet) {
     QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
   }
 
   virtual bool OnProtocolVersionMismatch(QuicVersionTag version) OVERRIDE {
     return false;
   }
 
  private:
+  const bool has_mock_helper_;
+
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class PacketSavingConnection : public MockConnection {
  public:
   PacketSavingConnection(QuicGuid guid, IPEndPoint address, bool is_server);
   virtual ~PacketSavingConnection();
 
   virtual bool SendOrQueuePacket(
       QuicPacketSequenceNumber sequence_number,
@@ skipping 65 matching lines @@
 
   virtual QuicPacketEntropyHash ReceivedEntropyHash(
       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_