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 21 matching lines @@
   MockDelegate() {}
   virtual ~MockDelegate() {}
 
   MOCK_METHOD2(CanWrite, bool(Retransmission retransmission,
                               HasRetransmittableData retransmittable));
 
   MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
   MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
   MOCK_METHOD1(OnSerializedPacket, bool(const SerializedPacket& packet));
 
-  void SetCanWrite(bool can_write) {
+  void SetCanWriteAnything() {
     EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
-        .WillRepeatedly(Return(can_write));
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+        .WillRepeatedly(Return(true));
+  }
+
+  void SetCanNotWrite() {
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+        .WillRepeatedly(Return(false));
+  }
+
+  // Use this when only ack and feedback frames should be allowed to be written.
+  void SetCanWriteOnlyNonRetransmittable() {
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, _))
+        .WillRepeatedly(Return(false));
+    EXPECT_CALL(*this, CanWrite(NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA))
+        .WillRepeatedly(Return(true));
   }
 
  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 15 matching lines @@
   size_t num_stream_frames;
 
   QuicFecGroupNumber fec_group;
 };
 
 }  // namespace
 
 class QuicPacketGeneratorTest : public ::testing::Test {
  protected:
   QuicPacketGeneratorTest()
-      : framer_(kQuicVersion1, QuicTime::Zero(), false),
+      : framer_(QuicVersionMax(), QuicTime::Zero(), false),
         creator_(42, &framer_, &random_, false),
         generator_(&delegate_, NULL, &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() {
@@ skipping 96 matching lines @@
   SerializedPacket packet2_;
   SerializedPacket packet3_;
   SerializedPacket packet4_;
   SerializedPacket packet5_;
 
  private:
   scoped_ptr<char[]> data_array_;
 };
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
-  delegate_.SetCanWrite(false);
+  delegate_.SetCanNotWrite();
 
   generator_.SetShouldSendAck(false);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteOnlyNonRetransmittable();
   generator_.StartBatchOperations();
 
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 
   generator_.SetShouldSendAck(false);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteOnlyNonRetransmittable();
 
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
 
   generator_.SetShouldSendAck(false);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_ack_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest,
        ShouldSendAckWithFeedback_WritableAndShouldNotFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteOnlyNonRetransmittable();
   generator_.StartBatchOperations();
 
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
       Return(CreateFeedbackFrame()));
 
   generator_.SetShouldSendAck(true);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest,
        ShouldSendAckWithFeedback_WritableAndShouldFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteOnlyNonRetransmittable();
 
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
       Return(CreateFeedbackFrame()));
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
 
   generator_.SetShouldSendAck(true);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_ack_frames = 1;
   contents.num_feedback_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritable) {
-  delegate_.SetCanWrite(false);
+  delegate_.SetCanNotWrite();
+
+  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
+  EXPECT_TRUE(generator_.HasQueuedFrames());
+}
+
+TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
+  delegate_.SetCanWriteOnlyNonRetransmittable();
 
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
 
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_rst_stream_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_NotWritable) {
-  delegate_.SetCanWrite(false);
+  delegate_.SetCanNotWrite();
 
   QuicConsumedData consumed = generator_.ConsumeData(1, "foo", 2, true);
   EXPECT_EQ(0u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   QuicConsumedData consumed = generator_.ConsumeData(1, "foo", 2, true);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
   QuicConsumedData consumed = generator_.ConsumeData(1, "foo", 2, true);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest,
        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   generator_.ConsumeData(1, "foo", 2, true);
   QuicConsumedData consumed = generator_.ConsumeData(3, "quux", 7, false);
   EXPECT_EQ(4u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeData_BatchOperations) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   generator_.ConsumeData(1, "foo", 2, true);
   QuicConsumedData consumed = generator_.ConsumeData(3, "quux", 7, false);
   EXPECT_EQ(4u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
   // Now both frames will be flushed out.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
   generator_.FinishBatchOperations();
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_stream_frames = 2;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   // Send FEC every two packets.
   creator_.options()->max_packets_per_fec_group = 2;
 
   {
     InSequence dummy;
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
         DoAll(SaveArg<0>(&packet_), Return(true)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
         DoAll(SaveArg<0>(&packet2_), Return(true)));
@@ skipping 15 matching lines @@
 
   CheckPacketHasSingleStreamFrame(packet_);
   CheckPacketHasSingleStreamFrame(packet2_);
   CheckPacketIsFec(packet3_, 1);
 
   CheckPacketHasSingleStreamFrame(packet4_);
   CheckPacketIsFec(packet5_, 4);
 }
 
 TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) {
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   // Send FEC every six packets.
   creator_.options()->max_packets_per_fec_group = 6;
 
   {
     InSequence dummy;
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
         DoAll(SaveArg<0>(&packet_), Return(true)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
         DoAll(SaveArg<0>(&packet2_), Return(true)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
         DoAll(SaveArg<0>(&packet3_), Return(true)));
   }
 
   // Send enough data to create 2 packets: one full and one partial.
   size_t data_len = 1 * kMaxPacketSize + 100;
   QuicConsumedData consumed =
       generator_.ConsumeData(3, CreateData(data_len), 0, true);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   CheckPacketHasSingleStreamFrame(packet_);
   CheckPacketHasSingleStreamFrame(packet2_);
   CheckPacketIsFec(packet3_, 1);
 }
 
 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {
-  delegate_.SetCanWrite(false);
+  delegate_.SetCanNotWrite();
 
   generator_.SetShouldSendAck(true);
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   generator_.StartBatchOperations();
 
   // When the first write operation is invoked, the ack and feedback
   // frames will be returned.
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
       Return(CreateFeedbackFrame()));
 
   // Send some data and a control frame
   generator_.ConsumeData(3, "quux", 7, false);
   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 
   // All five frames will be flushed out in a single packet.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
   generator_.FinishBatchOperations();
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_ack_frames = 1;
   contents.num_goaway_frames = 1;
   contents.num_feedback_frames = 1;
   contents.num_rst_stream_frames = 1;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) {
-  delegate_.SetCanWrite(false);
+  delegate_.SetCanNotWrite();
 
   generator_.SetShouldSendAck(true);
   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
   EXPECT_TRUE(generator_.HasQueuedFrames());
 
-  delegate_.SetCanWrite(true);
+  delegate_.SetCanWriteAnything();
 
   generator_.StartBatchOperations();
 
   // When the first write operation is invoked, the ack and feedback
   // frames will be returned.
   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
       Return(CreateFeedbackFrame()));
 
   {
@@ skipping 26 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