Refactor the Connection and Generator so the Creator is completely

net/quic/quic_packet_generator_test.cc

Index: net/quic/quic_packet_generator_test.cc
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index c2919385c76d2e1eb0263f23524da2f2289a8338..7738a8c98680c048b9153bac9c82a82f5aa1eb11 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -12,6 +12,7 @@
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
+#include "net/quic/test_tools/quic_packet_generator_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -105,8 +106,8 @@ class QuicPacketGeneratorTest : public ::testing::Test {
  protected:
   QuicPacketGeneratorTest()
       : framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
-        creator_(42, &framer_, &random_, false),
-        generator_(&delegate_, NULL, &creator_),
+        generator_(42, &framer_, &random_, &delegate_),
+        creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)),
         packet_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
         packet2_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
         packet3_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
@@ -223,9 +224,9 @@ class QuicPacketGeneratorTest : public ::testing::Test {
 
   QuicFramer framer_;
   MockRandom random_;
-  QuicPacketCreator creator_;
   StrictMock<MockDelegate> delegate_;
   QuicPacketGenerator generator_;
+  QuicPacketCreator* creator_;
   SimpleQuicFramer simple_framer_;
   SerializedPacket packet_;
   SerializedPacket packet2_;
@@ -450,7 +451,7 @@ TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) {
   delegate_.SetCanWriteAnything();
 
   // Send FEC every two packets.
-  creator_.set_max_packets_per_fec_group(2);
+  creator_->set_max_packets_per_fec_group(2);
 
   {
     InSequence dummy;
@@ -488,7 +489,7 @@ TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) {
   delegate_.SetCanWriteAnything();
 
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(6);
+  creator_->set_max_packets_per_fec_group(6);
   {
     InSequence dummy;
     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
@@ -519,9 +520,9 @@ TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
   // but not enough for a stream frame of 0 offset and one with non-zero offset.
   size_t length =
       NullEncrypter().GetCiphertextSize(0) +
-      GetPacketHeaderSize(creator_.connection_id_length(),
+      GetPacketHeaderSize(creator_->connection_id_length(),
                           true,
-                          creator_.next_sequence_number_length(),
+                          creator_->next_sequence_number_length(),
                           NOT_IN_FEC_GROUP) +
       // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
       // than the GetMinStreamFrameSize.
@@ -529,7 +530,7 @@ TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
                                         NOT_IN_FEC_GROUP) + 3 +
       QuicFramer::GetMinStreamFrameSize(framer_.version(), 1, 0, true,
                                         NOT_IN_FEC_GROUP) + 1;
-  creator_.set_max_packet_length(length);
+  creator_->set_max_packet_length(length);
   delegate_.SetCanWriteAnything();
   {
      InSequence dummy;
@@ -565,8 +566,8 @@ TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
   delegate_.SetCanWriteAnything();
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
-  EXPECT_FALSE(creator_.IsFecProtected());
+  creator_->set_max_packets_per_fec_group(2);
+  EXPECT_FALSE(creator_->IsFecProtected());
 
   // Send one unprotected data packet.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
@@ -576,7 +577,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
                              NULL);
   EXPECT_EQ(1u, consumed.bytes_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
-  EXPECT_FALSE(creator_.IsFecProtected());
+  EXPECT_FALSE(creator_->IsFecProtected());
   // Verify that one data packet was sent.
   PacketContents contents;
   contents.num_stream_frames = 1;
@@ -616,7 +617,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
                                     MAY_FEC_PROTECT, NULL);
   EXPECT_EQ(1u, consumed.bytes_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
-  EXPECT_FALSE(creator_.IsFecProtected());
+  EXPECT_FALSE(creator_->IsFecProtected());
   // Verify that one unprotected data packet was sent.
   CheckPacketContains(contents, packet7_);
 }
@@ -624,7 +625,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
   delegate_.SetCanWriteAnything();
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
+  creator_->set_max_packets_per_fec_group(2);
 
   generator_.StartBatchOperations();
   // Queue enough data to prevent a stream frame with a non-zero offset from
@@ -632,12 +633,12 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
   QuicConsumedData consumed = generator_.ConsumeData(
       7, CreateData(1u), 0, true, MAY_FEC_PROTECT, NULL);
   EXPECT_EQ(1u, consumed.bytes_consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
+  EXPECT_TRUE(creator_->HasPendingFrames());
 
   // Queue protected data for sending. Should cause queued frames to be flushed.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
       DoAll(SaveArg<0>(&packet_), Return(true)));
-  EXPECT_FALSE(creator_.IsFecProtected());
+  EXPECT_FALSE(creator_->IsFecProtected());
   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
                                     MUST_FEC_PROTECT, NULL);
   EXPECT_EQ(1u, consumed.bytes_consumed);
@@ -645,13 +646,13 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
   contents.num_stream_frames = 1;
   // Transmitted packet was not FEC protected.
   CheckPacketContains(contents, packet_);
-  EXPECT_TRUE(creator_.IsFecProtected());
-  EXPECT_TRUE(creator_.HasPendingFrames());
+  EXPECT_TRUE(creator_->IsFecProtected());
+  EXPECT_TRUE(creator_->HasPendingFrames());
 }
 
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
+  creator_->set_max_packets_per_fec_group(2);
 
   // Queue control frames in generator.
   delegate_.SetCanNotWrite();
@@ -668,8 +669,8 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
 
   // Generator should have queued control frames, and creator should be empty.
   EXPECT_TRUE(generator_.HasQueuedFrames());
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  EXPECT_FALSE(creator_.IsFecProtected());
+  EXPECT_FALSE(creator_->HasPendingFrames());
+  EXPECT_FALSE(creator_->IsFecProtected());
 
   // Queue protected data for sending. Should cause queued frames to be flushed.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
@@ -684,15 +685,15 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
   CheckPacketContains(contents, packet_);
 
   // FEC protection should be on in creator.
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->IsFecProtected());
 }
 
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
   delegate_.SetCanWriteAnything();
 
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
-  EXPECT_FALSE(creator_.IsFecProtected());
+  creator_->set_max_packets_per_fec_group(2);
+  EXPECT_FALSE(creator_->IsFecProtected());
 
   // Queue stream frame to be protected in creator.
   generator_.StartBatchOperations();
@@ -700,8 +701,8 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
                                                      MUST_FEC_PROTECT, NULL);
   EXPECT_EQ(1u, consumed.bytes_consumed);
   // Creator has a pending protected frame.
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->HasPendingFrames());
+  EXPECT_TRUE(creator_->IsFecProtected());
 
   // Add enough unprotected data to exceed size of current packet, so that
   // current packet is sent. Both frames will be sent out in a single packet.
@@ -716,15 +717,15 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
   contents.fec_group = 1u;
   CheckPacketContains(contents, packet_);
   // FEC protection should still be on in creator.
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->IsFecProtected());
 }
 
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
   delegate_.SetCanWriteAnything();
 
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
-  EXPECT_FALSE(creator_.IsFecProtected());
+  creator_->set_max_packets_per_fec_group(2);
+  EXPECT_FALSE(creator_->IsFecProtected());
 
   generator_.StartBatchOperations();
   // Send first packet, FEC protected.
@@ -741,7 +742,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
   CheckPacketContains(contents, packet_);
 
   // FEC should still be on in creator.
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->IsFecProtected());
 
   // Send enough unprotected data to cause second packet to be sent, which gets
   // protected because it happens to fall within an open FEC group. Data packet
@@ -761,7 +762,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 
   // FEC protection should be off in creator.
-  EXPECT_FALSE(creator_.IsFecProtected());
+  EXPECT_FALSE(creator_->IsFecProtected());
 }
 
 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
@@ -769,13 +770,13 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
   generator_.StartBatchOperations();
 
   // Enable FEC.
-  creator_.set_max_packets_per_fec_group(2);
-  EXPECT_FALSE(creator_.IsFecProtected());
+  creator_->set_max_packets_per_fec_group(2);
+  EXPECT_FALSE(creator_->IsFecProtected());
 
   // Queue one byte of FEC protected data.
   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
                                                      MUST_FEC_PROTECT, NULL);
-  EXPECT_TRUE(creator_.HasPendingFrames());
+  EXPECT_TRUE(creator_->HasPendingFrames());
 
   // Add more unprotected data causing first packet to be sent, FEC protected.
   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
@@ -790,7 +791,8 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
   CheckPacketContains(contents, packet_);
 
   // FEC group is still open in creator.
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->IsFecProtected());
+
   // Add data that should be protected, large enough to cause second packet to
   // be sent. Data packet should be followed by FEC packet.
   {
@@ -807,7 +809,7 @@ TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 
   // FEC protection should remain on in creator.
-  EXPECT_TRUE(creator_.IsFecProtected());
+  EXPECT_TRUE(creator_->IsFecProtected());
 }
 
 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {