Implement the variable length changes necessary to easily accommodate

net/quic/quic_connection_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_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "net/base/net_errors.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
@@ skipping 951 matching lines @@
   EXPECT_EQ(8u, last_ack()->sent_info.least_unacked);
 
   // But if we send more data it should.
   SendStreamDataToPeer(1, "eep", 6, !kFin, &last_packet);  // Packet 9
   EXPECT_EQ(9u, last_packet);
   SendAckPacketToPeer();  // Packet10
   EXPECT_EQ(9u, last_ack()->sent_info.least_unacked);
 }
 
 TEST_F(QuicConnectionTest, FECSending) {
-  // Limit to one byte per packet.
   // All packets carry version info till version is negotiated.
+  size_t payload_length;
   connection_.options()->max_packet_length =
-      GetPacketLengthForOneStream(kIncludeVersion, IN_FEC_GROUP, 4);
+      GetPacketLengthForOneStream(
+          kIncludeVersion, IN_FEC_GROUP, &payload_length);
   // And send FEC every two packets.
   connection_.options()->max_packets_per_fec_group = 2;
 
   // Send 4 data packets and 2 FEC packets.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(6);
-  connection_.SendStreamData(1, "foodfoodfoodfood", 0, !kFin);
+  // TODO(ianswett): The first stream frame will consume 2 fewer bytes.
+  const string payload(payload_length * 4, 'a');
+  connection_.SendStreamData(1, payload, 0, !kFin);
   // Expect the FEC group to be closed after SendStreamData.
   EXPECT_FALSE(creator_.ShouldSendFec(true));
 }
 
 TEST_F(QuicConnectionTest, FECQueueing) {
-  // Limit to one byte per packet.
   // All packets carry version info till version is negotiated.
+  size_t payload_length;
   connection_.options()->max_packet_length =
-      GetPacketLengthForOneStream(kIncludeVersion, IN_FEC_GROUP, 4);
+      GetPacketLengthForOneStream(
+          kIncludeVersion, IN_FEC_GROUP, &payload_length);
   // And send FEC every two packets.
   connection_.options()->max_packets_per_fec_group = 2;
 
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
   helper_->set_blocked(true);
-  connection_.SendStreamData(1, "food", 0, !kFin);
+  const string payload(payload_length, 'a');
+  connection_.SendStreamData(1, payload, 0, !kFin);
   EXPECT_FALSE(creator_.ShouldSendFec(true));
   // Expect the first data packet and the fec packet to be queued.
   EXPECT_EQ(2u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, AbandonFECFromCongestionWindow) {
   connection_.options()->max_packets_per_fec_group = 1;
   // 1 Data and 1 FEC packet.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(2);
   connection_.SendStreamData(1, "foo", 0, !kFin);
@@ skipping 891 matching lines @@
       ENCRYPTION_NONE, 1, packet, kTestEntropyHash, HAS_RETRANSMITTABLE_DATA);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // OnCanWrite should not send the packet (because of the delay)
   // but should still return true.
   EXPECT_TRUE(connection_.OnCanWrite());
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, TestQueueLimitsOnSendStreamData) {
-  // Limit to one byte per packet.
   // All packets carry version info till version is negotiated.
+  size_t payload_length;
   connection_.options()->max_packet_length =
-      GetPacketLengthForOneStream(kIncludeVersion, NOT_IN_FEC_GROUP, 4);
+      GetPacketLengthForOneStream(
+          kIncludeVersion, NOT_IN_FEC_GROUP, &payload_length);
 
   // Queue the first packet.
   EXPECT_CALL(*send_algorithm_,
               TimeUntilSend(_, NOT_RETRANSMISSION, _)).WillOnce(
                   testing::Return(QuicTime::Delta::FromMicroseconds(10)));
-  EXPECT_EQ(0u, connection_.SendStreamData(
-      1, "EnoughDataToQueue", 0, !kFin).bytes_consumed);
+  const string payload(payload_length, 'a');
+  EXPECT_EQ(0u,
+            connection_.SendStreamData(1, payload, 0, !kFin).bytes_consumed);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 TEST_F(QuicConnectionTest, LoopThroughSendingPackets) {
-  // Limit to 4 bytes per packet.
   // All packets carry version info till version is negotiated.
+  size_t payload_length;
   connection_.options()->max_packet_length =
-      GetPacketLengthForOneStream(kIncludeVersion, NOT_IN_FEC_GROUP, 4);
+      GetPacketLengthForOneStream(
+          kIncludeVersion, NOT_IN_FEC_GROUP, &payload_length);
 
   // Queue the first packet.
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(7);
-  EXPECT_EQ(27u, connection_.SendStreamData(
-                1, "EnoughDataToQueueStreamData", 0, !kFin).bytes_consumed);
+  // TODO(ianswett): The first stream frame will consume 2 fewer bytes.
+  const string payload(payload_length * 7, 'a');
+  EXPECT_EQ(payload.size(),
+            connection_.SendStreamData(1, payload, 0, !kFin).bytes_consumed);
 }
 
 TEST_F(QuicConnectionTest, NoAckForClose) {
   ProcessPacket(1);
   EXPECT_CALL(*send_algorithm_, OnIncomingAck(_, _, _)).Times(0);
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(*send_algorithm_, SentPacket(_, _, _, _)).Times(0);
   ProcessClosePacket(2, 0);
 }
 
@@ skipping 295 matching lines @@
   EXPECT_CALL(visitor_, OnCanWrite()).Times(1).WillOnce(Return(true));
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_PEER_GOING_AWAY, true));
   EXPECT_CALL(visitor_, OnPacket(_, _, _, _)).Times(0);
 
   connection_.ProcessUdpPacket(IPEndPoint(), IPEndPoint(), *encrypted);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net