Land Recent QUIC Changes

net/quic/quic_packet_generator_test.cc

 // 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.
 
 #include "net/quic/quic_packet_generator.h"
 
 #include <string>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 13 matching lines @@
 
 namespace net {
 namespace test {
 namespace {
 
 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  public:
   MockDelegate() {}
   virtual ~MockDelegate() {}
 
-  MOCK_METHOD1(CanWrite, bool(bool is_retransmission));
+  MOCK_METHOD2(CanWrite, bool(bool is_retransmission,
+                              bool has_retransmittable_data));
 
   MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
   MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
   MOCK_METHOD1(OnSerializedPacket, bool(const SerializedPacket& packet));
 
   void SetCanWrite(bool can_write) {
-    EXPECT_CALL(*this, CanWrite(false)).WillRepeatedly(Return(can_write));
+    EXPECT_CALL(*this, CanWrite(false, _)).WillRepeatedly(Return(can_write));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 // Simple struct for describing the contents of a packet.
 // Useful in conjunction with a SimpleQuicFrame for validating
 // that a packet contains the expected frames.
 struct PacketContents {
@@ skipping 17 matching lines @@
   QuicFecGroupNumber fec_group;
 };
 
 }  // namespace
 
 class QuicPacketGeneratorTest : public ::testing::Test {
  protected:
   QuicPacketGeneratorTest()
       : framer_(kQuicVersion1,
                 QuicDecrypter::Create(kNULL),
-                QuicEncrypter::Create(kNULL)),
-        creator_(42, &framer_, &random_),
+                QuicEncrypter::Create(kNULL),
+                false),
+        creator_(42, &framer_, &random_, false),
         generator_(&delegate_, &creator_),
         packet_(0, NULL, 0, NULL),
         packet2_(0, NULL, 0, NULL),
         packet3_(0, NULL, 0, NULL),
         packet4_(0, NULL, 0, NULL),
         packet5_(0, NULL, 0, NULL) {
   }
 
   ~QuicPacketGeneratorTest() {
     delete packet_.packet;
     delete packet_.retransmittable_frames;
     delete packet2_.packet;
     delete packet2_.retransmittable_frames;
     delete packet3_.packet;
     delete packet3_.retransmittable_frames;
     delete packet4_.packet;
     delete packet4_.retransmittable_frames;
     delete packet5_.packet;
     delete packet5_.retransmittable_frames;
   }
 
   QuicAckFrame* CreateAckFrame() {
     // TODO(rch): Initialize this so it can be verified later.
-    return new QuicAckFrame(0, 0);
+    return new QuicAckFrame(0, QuicTime::Zero(), 0);
   }
 
   QuicCongestionFeedbackFrame* CreateFeedbackFrame() {
     QuicCongestionFeedbackFrame* frame = new QuicCongestionFeedbackFrame;
     frame->type = kFixRate;
     frame->fix_rate.bitrate = QuicBandwidth::FromBytesPerSecond(42);
     return frame;
   }
 
   QuicRstStreamFrame* CreateRstStreamFrame() {
@@ skipping 386 matching lines @@
 
   // The second should have the remainder of the stream data.
   PacketContents contents2;
   contents2.num_goaway_frames = 1;
   contents2.num_stream_frames = 1;
   CheckPacketContains(contents2, packet2_);
 }
 
 }  // namespace test
 }  // namespace net