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 <string>
@@ skipping 35 matching lines @@
 // Returns QuicConfig set to default values.
 QuicConfig DefaultQuicConfig();
 
 class MockFramerVisitor : public QuicFramerVisitorInterface {
  public:
   MockFramerVisitor();
   ~MockFramerVisitor();
 
   MOCK_METHOD1(OnError, void(QuicFramer* framer));
   // The constructor sets this up to return false by default.
-  MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicTag version));
+  MOCK_METHOD1(OnProtocolVersionMismatch, bool(QuicVersion version));
   MOCK_METHOD0(OnPacket, void());
   MOCK_METHOD1(OnPublicResetPacket, void(const QuicPublicResetPacket& header));
   MOCK_METHOD1(OnVersionNegotiationPacket,
                void(const QuicVersionNegotiationPacket& packet));
   MOCK_METHOD0(OnRevivedPacket, void());
   // The constructor sets this up to return true by default.
   MOCK_METHOD1(OnPacketHeader, bool(const QuicPacketHeader& header));
   MOCK_METHOD1(OnFecProtectedPayload, void(base::StringPiece payload));
   MOCK_METHOD1(OnStreamFrame, bool(const QuicStreamFrame& frame));
   MOCK_METHOD1(OnAckFrame, bool(const QuicAckFrame& frame));
@@ skipping 14 matching lines @@
  public:
   NoOpFramerVisitor() {}
 
   virtual void OnError(QuicFramer* framer) OVERRIDE {}
   virtual void OnPacket() OVERRIDE {}
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE {}
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) OVERRIDE {}
   virtual void OnRevivedPacket() OVERRIDE {}
-  virtual bool OnProtocolVersionMismatch(QuicTag version) OVERRIDE;
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
   virtual bool OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
   virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
   virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
   virtual bool OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) OVERRIDE;
@@ skipping 136 matching lines @@
                                 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(QuicTag version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
     return false;
   }
 
  private:
   const bool has_mock_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class PacketSavingConnection : public MockConnection {
@@ skipping 72 matching lines @@
                void(QuicPacketSequenceNumber, QuicByteCount, QuicTime::Delta));
   MOCK_METHOD1(OnIncomingLoss, void(QuicTime));
   MOCK_METHOD4(SentPacket, void(QuicTime sent_time, QuicPacketSequenceNumber,
                                 QuicByteCount, Retransmission));
   MOCK_METHOD2(AbandoningPacket, void(QuicPacketSequenceNumber sequence_number,
                                       QuicByteCount abandoned_bytes));
   MOCK_METHOD3(TimeUntilSend, QuicTime::Delta(QuicTime now, Retransmission,
                                               HasRetransmittableData));
   MOCK_METHOD0(BandwidthEstimate, QuicBandwidth(void));
   MOCK_METHOD0(SmoothedRtt, QuicTime::Delta(void));
+  MOCK_METHOD0(RetransmissionDelay, QuicTime::Delta(void));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSendAlgorithm);
 };
 
 class TestEntropyCalculator :
       public QuicReceivedEntropyHashCalculatorInterface {
  public:
   TestEntropyCalculator() { }
   virtual ~TestEntropyCalculator() { }
 
-  virtual QuicPacketEntropyHash ReceivedEntropyHash(
+  virtual QuicPacketEntropyHash EntropyHash(
       QuicPacketSequenceNumber sequence_number) const OVERRIDE;
 };
 
 class TestDecompressorVisitor : public QuicSpdyDecompressor::Visitor {
  public:
   virtual ~TestDecompressorVisitor() {}
   virtual bool OnDecompressedData(base::StringPiece data) OVERRIDE;
   virtual void OnDecompressionError() OVERRIDE;
 
   string data() { return data_; }
   bool error() { return error_; }
 
  private:
   string data_;
   bool error_;
 };
 
 }  // namespace test
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_