diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index b8e7f0c..a855482 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -142,7 +142,7 @@
       delete frame;
       return;
     }
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
     DCHECK_EQ(1u, collector_.packets()->size());
     time_wait_list_manager_->AddConnectionIdToTimeWait(
         server_connection_id_, ietf_quic,
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 4c381d4..1f985dc 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -186,12 +186,13 @@
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
-bool QuicPacketCreator::ConsumeCryptoData(EncryptionLevel level,
-                                          size_t write_length,
-                                          QuicStreamOffset offset,
-                                          bool needs_full_padding,
-                                          TransmissionType transmission_type,
-                                          QuicFrame* frame) {
+bool QuicPacketCreator::ConsumeCryptoDataToFillCurrentPacket(
+    EncryptionLevel level,
+    size_t write_length,
+    QuicStreamOffset offset,
+    bool needs_full_padding,
+    TransmissionType transmission_type,
+    QuicFrame* frame) {
   if (!CreateCryptoFrame(level, write_length, offset, frame)) {
     return false;
   }
@@ -208,13 +209,14 @@
                   transmission_type);
 }
 
-bool QuicPacketCreator::ConsumeData(QuicStreamId id,
-                                    size_t data_size,
-                                    QuicStreamOffset offset,
-                                    bool fin,
-                                    bool needs_full_padding,
-                                    TransmissionType transmission_type,
-                                    QuicFrame* frame) {
+bool QuicPacketCreator::ConsumeDataToFillCurrentPacket(
+    QuicStreamId id,
+    size_t data_size,
+    QuicStreamOffset offset,
+    bool fin,
+    bool needs_full_padding,
+    TransmissionType transmission_type,
+    QuicFrame* frame) {
   if (!HasRoomForStreamFrame(id, offset, data_size)) {
     return false;
   }
@@ -391,7 +393,7 @@
   packet_.encryption_level = default_encryption_level;
 }
 
-void QuicPacketCreator::Flush() {
+void QuicPacketCreator::FlushCurrentPacket() {
   if (!HasPendingFrames() && pending_padding_bytes_ == 0) {
     return;
   }
@@ -948,7 +950,7 @@
       /* last_frame_in_packet= */ true, GetPacketNumberLength());
   if (frame_len == 0) {
     // Current open packet is full.
-    Flush();
+    FlushCurrentPacket();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
@@ -1083,7 +1085,8 @@
   client_connection_id_ = client_connection_id;
 }
 
-void QuicPacketCreator::SetTransmissionType(TransmissionType type) {
+void QuicPacketCreator::SetTransmissionTypeOfNextPackets(
+    TransmissionType type) {
   DCHECK(can_set_transmission_type_);
 
   if (!can_set_transmission_type()) {
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index 9f00842..a3f6c00 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -103,22 +103,22 @@
   // full.
   // If current packet is not full, creates a stream frame that fits into the
   // open packet and adds it to the packet.
-  bool ConsumeData(QuicStreamId id,
-                   size_t data_length,
-                   QuicStreamOffset offset,
-                   bool fin,
-                   bool needs_full_padding,
-                   TransmissionType transmission_type,
-                   QuicFrame* frame);
+  bool ConsumeDataToFillCurrentPacket(QuicStreamId id,
+                                      size_t data_size,
+                                      QuicStreamOffset offset,
+                                      bool fin,
+                                      bool needs_full_padding,
+                                      TransmissionType transmission_type,
+                                      QuicFrame* frame);
 
   // Creates a CRYPTO frame that fits into the current packet (which must be
   // empty) and adds it to the packet.
-  bool ConsumeCryptoData(EncryptionLevel level,
-                         size_t write_length,
-                         QuicStreamOffset offset,
-                         bool needs_full_padding,
-                         TransmissionType transmission_type,
-                         QuicFrame* frame);
+  bool ConsumeCryptoDataToFillCurrentPacket(EncryptionLevel level,
+                                            size_t write_length,
+                                            QuicStreamOffset offset,
+                                            bool needs_full_padding,
+                                            TransmissionType transmission_type,
+                                            QuicFrame* frame);
 
   // Returns true if current open packet can accommodate more stream frames of
   // stream |id| at |offset| and data length |data_size|, false otherwise.
@@ -138,7 +138,7 @@
 
   // Serializes all added frames into a single packet and invokes the delegate_
   // to further process the SerializedPacket.
-  void Flush();
+  void FlushCurrentPacket();
 
   // Optimized method to create a QuicStreamFrame and serialize it. Adds the
   // QuicStreamFrame to the returned SerializedPacket.  Sets
@@ -269,7 +269,7 @@
   void AddPendingPadding(QuicByteCount size);
 
   // Sets transmission type of next constructed packets.
-  void SetTransmissionType(TransmissionType type);
+  void SetTransmissionTypeOfNextPackets(TransmissionType type);
 
   // Sets the retry token to be sent over the wire in IETF Initial packets.
   void SetRetryToken(QuicStringPiece retry_token);
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index d0cfdae..8d79cc4 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -83,24 +83,24 @@
         producer_(producer),
         version_(framer->transport_version()) {}
 
-  bool ConsumeData(QuicStreamId id,
-                   const struct iovec* iov,
-                   int iov_count,
-                   size_t total_length,
-                   size_t iov_offset,
-                   QuicStreamOffset offset,
-                   bool fin,
-                   bool needs_full_padding,
-                   TransmissionType transmission_type,
-                   QuicFrame* frame) {
+  bool ConsumeDataToFillCurrentPacket(QuicStreamId id,
+                                      const struct iovec* iov,
+                                      int iov_count,
+                                      size_t total_length,
+                                      size_t iov_offset,
+                                      QuicStreamOffset offset,
+                                      bool fin,
+                                      bool needs_full_padding,
+                                      TransmissionType transmission_type,
+                                      QuicFrame* frame) {
     // Save data before data is consumed.
     QuicByteCount data_length = total_length - iov_offset;
     if (data_length > 0) {
       producer_->SaveStreamData(id, iov, iov_count, iov_offset, data_length);
     }
-    return QuicPacketCreator::ConsumeData(id, data_length - iov_offset, offset,
-                                          fin, needs_full_padding,
-                                          transmission_type, frame);
+    return QuicPacketCreator::ConsumeDataToFillCurrentPacket(
+        id, data_length - iov_offset, offset, fin, needs_full_padding,
+        transmission_type, frame);
   }
 
   void StopSendingVersion() {
@@ -598,24 +598,25 @@
   ProcessPacket(serialized);
 }
 
-TEST_P(QuicPacketCreatorTest, ConsumeCryptoData) {
+TEST_P(QuicPacketCreatorTest, ConsumeCryptoDataToFillCurrentPacket) {
   std::string data = "crypto data";
   QuicFrame frame;
-  ASSERT_TRUE(creator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data.length(), 0,
-                                         /*needs_full_padding=*/true,
-                                         NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
+      ENCRYPTION_INITIAL, data.length(), 0,
+      /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
   EXPECT_EQ(frame.crypto_frame->data_length, data.length());
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
-TEST_P(QuicPacketCreatorTest, ConsumeData) {
+TEST_P(QuicPacketCreatorTest, ConsumeDataToFillCurrentPacket) {
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   QuicFrame frame;
   MakeIOVector("test", &iov_);
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
-                                   false, false, NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
+      NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, stream_id, "test", 0u, false);
@@ -628,8 +629,9 @@
   MakeIOVector("test", &iov_);
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
-                                   true, false, NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false,
+      NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, stream_id, "test", 0u, true);
@@ -641,8 +643,9 @@
   QuicFrame frame;
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(stream_id, nullptr, 0u, 0u, 0u, 0u, true,
-                                   false, NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, nullptr, 0u, 0u, 0u, 0u, true, false, NOT_RETRANSMISSION,
+      &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(0u, consumed);
   CheckStreamFrame(frame, stream_id, std::string(), 0u, true);
@@ -671,12 +674,12 @@
       EXPECT_CALL(delegate_, OnSerializedPacket(_))
           .WillRepeatedly(Invoke(
               this, &QuicPacketCreatorTest::ClearSerializedPacketForTests));
-      ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_,
-                                       1u, iov_.iov_len, 0u, kOffset, false,
-                                       false, NOT_RETRANSMISSION, &frame));
+      ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+          GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u,
+          kOffset, false, false, NOT_RETRANSMISSION, &frame));
       size_t bytes_consumed = frame.stream_frame.data_length;
       EXPECT_LT(0u, bytes_consumed);
-      creator_.Flush();
+      creator_.FlushCurrentPacket();
     }
   }
 }
@@ -695,9 +698,9 @@
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
     QuicFrame frame;
     MakeIOVector(data, &iov_);
-    ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_,
-                                     1u, iov_.iov_len, 0u, kOffset, false,
-                                     false, NOT_RETRANSMISSION, &frame));
+    ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+        GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset,
+        false, false, NOT_RETRANSMISSION, &frame));
 
     // BytesFree() returns bytes available for the next frame, which will
     // be two bytes smaller since the stream frame would need to be grown.
@@ -706,7 +709,7 @@
     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     DeleteSerializedPacket();
   }
@@ -740,7 +743,7 @@
         .WillRepeatedly(
             Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     if (!QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
-      ASSERT_TRUE(creator_.ConsumeData(
+      ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
           QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
           &iov_, 1u, iov_.iov_len, 0u, kOffset, false, true, NOT_RETRANSMISSION,
           &frame));
@@ -748,13 +751,13 @@
       EXPECT_LT(0u, bytes_consumed);
     } else {
       producer_.SaveCryptoData(ENCRYPTION_INITIAL, kOffset, data);
-      ASSERT_TRUE(creator_.ConsumeCryptoData(
+      ASSERT_TRUE(creator_.ConsumeCryptoDataToFillCurrentPacket(
           ENCRYPTION_INITIAL, data.length(), kOffset,
           /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
       size_t bytes_consumed = frame.crypto_frame->data_length;
       EXPECT_LT(0u, bytes_consumed);
     }
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     // If there is not enough space in the packet to fit a padding frame
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
@@ -788,12 +791,12 @@
     MakeIOVector(data, &iov_);
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-    ASSERT_TRUE(creator_.ConsumeData(GetNthClientInitiatedStreamId(1), &iov_,
-                                     1u, iov_.iov_len, 0u, kOffset, false,
-                                     false, NOT_RETRANSMISSION, &frame));
+    ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+        GetNthClientInitiatedStreamId(1), &iov_, 1u, iov_.iov_len, 0u, kOffset,
+        false, false, NOT_RETRANSMISSION, &frame));
     size_t bytes_consumed = frame.stream_frame.data_length;
     EXPECT_LT(0u, bytes_consumed);
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     if (bytes_free > 0) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
@@ -1304,12 +1307,13 @@
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
-                                   true, false, NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, true, false,
+      NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   // The entire payload could not be consumed.
   EXPECT_GT(payload_length, consumed);
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
   DeleteSerializedPacket();
 }
 
@@ -1353,8 +1357,9 @@
   QuicFrame frame;
   MakeIOVector("test", &iov_);
   EXPECT_CALL(debug, OnFrameAddedToPacket(_));
-  ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
-                                   false, false, NOT_RETRANSMISSION, &frame));
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
+      NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
@@ -1524,11 +1529,12 @@
                &iov);
   QuicFrame frame;
   EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_CRYPTO_CHLO_TOO_LARGE, _));
-  EXPECT_QUIC_BUG(creator_.ConsumeData(QuicUtils::GetCryptoStreamId(
-                                           client_framer_.transport_version()),
-                                       &iov, 1u, iov.iov_len, 0u, 0u, false,
-                                       false, NOT_RETRANSMISSION, &frame),
-                  "Client hello won't fit in a single packet.");
+  EXPECT_QUIC_BUG(
+      creator_.ConsumeDataToFillCurrentPacket(
+          QuicUtils::GetCryptoStreamId(client_framer_.transport_version()),
+          &iov, 1u, iov.iov_len, 0u, 0u, false, false, NOT_RETRANSMISSION,
+          &frame),
+      "Client hello won't fit in a single packet.");
 }
 
 TEST_P(QuicPacketCreatorTest, PendingPadding) {
@@ -1541,7 +1547,7 @@
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   // Flush all paddings.
   while (creator_.pending_padding_bytes() > 0) {
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
     {
       InSequence s;
       EXPECT_CALL(framer_visitor_, OnPacket());
@@ -1565,12 +1571,12 @@
   MakeIOVector("test", &iov_);
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
       stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
       /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
   EXPECT_EQ(kMaxNumRandomPaddingBytes, creator_.pending_padding_bytes());
 }
 
@@ -1647,9 +1653,10 @@
   }
   ProcessPacket(serialized_packet_);
 
-  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
-                       NOT_RETRANSMISSION, &frame);
-  creator_.Flush();
+  creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
+                                          0u, 0u, false, false,
+                                          NOT_RETRANSMISSION, &frame);
+  creator_.FlushCurrentPacket();
   {
     InSequence s;
     EXPECT_CALL(framer_visitor_, OnPacket());
@@ -1690,22 +1697,23 @@
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   // Send stream frame of size kStreamFramePayloadSize.
   MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize), &iov_);
-  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
-                       NOT_RETRANSMISSION, &frame);
-  creator_.Flush();
+  creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
+                                          0u, 0u, false, false,
+                                          NOT_RETRANSMISSION, &frame);
+  creator_.FlushCurrentPacket();
   // 1 byte padding is sent.
   EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
   // Send stream frame of size kStreamFramePayloadSize + 1.
   MakeIOVector(QuicStringPiece(buf, kStreamFramePayloadSize + 1), &iov_);
-  creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u,
-                       kStreamFramePayloadSize, false, false,
-                       NOT_RETRANSMISSION, &frame);
+  creator_.ConsumeDataToFillCurrentPacket(stream_id, &iov_, 1u, iov_.iov_len,
+                                          0u, kStreamFramePayloadSize, false,
+                                          false, NOT_RETRANSMISSION, &frame);
   // No padding is sent.
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
   EXPECT_EQ(pending_padding_bytes - 1, creator_.pending_padding_bytes());
   // Flush all paddings.
   while (creator_.pending_padding_bytes() > 0) {
-    creator_.Flush();
+    creator_.FlushCurrentPacket();
   }
   EXPECT_EQ(0u, creator_.pending_padding_bytes());
 }
@@ -1720,7 +1728,7 @@
   MakeIOVector("test", &iov_);
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  ASSERT_TRUE(creator_.ConsumeData(
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
       stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false,
       /*needs_full_padding=*/true, NOT_RETRANSMISSION, &frame));
 
@@ -1729,7 +1737,7 @@
         EXPECT_EQ(expected_buffer, serialized_packet->encrypted_buffer);
         ClearSerializedPacket(serialized_packet);
       }));
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
 }
 
 // Test for error found in
@@ -1764,7 +1772,7 @@
   EXPECT_TRUE(
       creator_.AddSavedFrame(QuicFrame(message_frame), NOT_RETRANSMISSION));
   EXPECT_TRUE(creator_.HasPendingFrames());
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
 
   QuicMessageFrame* frame2 =
       new QuicMessageFrame(2, MakeSpan(&allocator_, "message", &storage));
@@ -1776,14 +1784,15 @@
       new QuicMessageFrame(3, MakeSpan(&allocator_, "message2", &storage));
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(frame3), NOT_RETRANSMISSION));
   EXPECT_EQ(1u, creator_.ExpansionOnNewFrame());
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
 
   QuicFrame frame;
   MakeIOVector("test", &iov_);
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  EXPECT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
-                                   false, false, NOT_RETRANSMISSION, &frame));
+  EXPECT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u, false, false,
+      NOT_RETRANSMISSION, &frame));
   QuicMessageFrame* frame4 =
       new QuicMessageFrame(4, MakeSpan(&allocator_, "message", &storage));
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(frame4), NOT_RETRANSMISSION));
@@ -1834,7 +1843,7 @@
                 creator_.GetCurrentLargestMessagePayload());
       EXPECT_CALL(delegate_, OnSerializedPacket(_))
           .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-      creator_.Flush();
+      creator_.FlushCurrentPacket();
       ASSERT_TRUE(serialized_packet_.encrypted_buffer);
       DeleteSerializedPacket();
     }
@@ -1861,7 +1870,7 @@
 TEST_P(QuicPacketCreatorTest, PacketTransmissionType) {
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   creator_.set_can_set_transmission_type(true);
-  creator_.SetTransmissionType(NOT_RETRANSMISSION);
+  creator_.SetTransmissionTypeOfNextPackets(NOT_RETRANSMISSION);
 
   QuicAckFrame temp_ack_frame = InitAckFrame(1);
   QuicFrame ack_frame(&temp_ack_frame);
@@ -1886,7 +1895,7 @@
   ASSERT_FALSE(serialized_packet_.encrypted_buffer);
 
   EXPECT_TRUE(creator_.AddSavedFrame(padding_frame, TLP_RETRANSMISSION));
-  creator_.Flush();
+  creator_.FlushCurrentPacket();
   ASSERT_TRUE(serialized_packet_.encrypted_buffer);
 
   if (creator_.can_set_transmission_type()) {
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index d4e879f..14e6b63 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -68,14 +68,14 @@
   // should be driven by encryption level, and we should stop flushing in this
   // spot.
   if (packet_creator_.HasPendingRetransmittableFrames()) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 
   size_t total_bytes_consumed = 0;
 
   while (total_bytes_consumed < write_length) {
     QuicFrame frame;
-    if (!packet_creator_.ConsumeCryptoData(
+    if (!packet_creator_.ConsumeCryptoDataToFillCurrentPacket(
             level, write_length - total_bytes_consumed,
             offset + total_bytes_consumed, fully_pad_crypto_handshake_packets_,
             next_transmission_type_, &frame)) {
@@ -88,11 +88,11 @@
     total_bytes_consumed += frame.crypto_frame->data_length;
 
     // TODO(ianswett): Move to having the creator flush itself when it's full.
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
-  packet_creator_.Flush();
+  packet_creator_.FlushCurrentPacket();
 
   return total_bytes_consumed;
 }
@@ -112,14 +112,14 @@
   // To make reasoning about crypto frames easier, we don't combine them with
   // other retransmittable frames in a single packet.
   if (has_handshake && packet_creator_.HasPendingRetransmittableFrames()) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
 
   if (!packet_creator_.HasRoomForStreamFrame(id, offset, write_length)) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 
   if (!fin && (write_length == 0)) {
@@ -139,10 +139,10 @@
     bool needs_full_padding =
         has_handshake && fully_pad_crypto_handshake_packets_;
 
-    if (!packet_creator_.ConsumeData(id, write_length - total_bytes_consumed,
-                                     offset + total_bytes_consumed, fin,
-                                     needs_full_padding,
-                                     next_transmission_type_, &frame)) {
+    if (!packet_creator_.ConsumeDataToFillCurrentPacket(
+            id, write_length - total_bytes_consumed,
+            offset + total_bytes_consumed, fin, needs_full_padding,
+            next_transmission_type_, &frame)) {
       // The creator is always flushed if there's not enough room for a new
       // stream frame before ConsumeData, so ConsumeData should always succeed.
       QUIC_BUG << "Failed to ConsumeData, stream:" << id;
@@ -166,7 +166,7 @@
       break;
     }
     // TODO(ianswett): Move to having the creator flush itself when it's full.
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
 
     run_fast_path =
         !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() &&
@@ -180,7 +180,7 @@
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
   if (has_handshake) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
@@ -227,7 +227,7 @@
   SetMaxPacketLength(target_mtu);
   const bool success =
       packet_creator_.AddPaddedSavedFrame(frame, next_transmission_type_);
-  packet_creator_.Flush();
+  packet_creator_.FlushCurrentPacket();
   // The only reason AddFrame can fail is that the packet is too full to fit in
   // a ping.  This is not possible for any sane MTU.
   DCHECK(success);
@@ -248,7 +248,7 @@
 }
 
 void QuicPacketGenerator::Flush() {
-  packet_creator_.Flush();
+  packet_creator_.FlushCurrentPacket();
   SendRemainingPendingPadding();
   flusher_attached_ = false;
   if (GetQuicFlag(FLAGS_quic_export_server_num_packets_per_write_histogram)) {
@@ -265,7 +265,7 @@
 }
 
 void QuicPacketGenerator::FlushAllQueuedFrames() {
-  packet_creator_.Flush();
+  packet_creator_.FlushCurrentPacket();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
@@ -372,7 +372,7 @@
   while (
       packet_creator_.pending_padding_bytes() > 0 && !HasPendingFrames() &&
       delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, NOT_HANDSHAKE)) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
 }
 
@@ -386,7 +386,7 @@
 }
 
 void QuicPacketGenerator::SetTransmissionType(TransmissionType type) {
-  packet_creator_.SetTransmissionType(type);
+  packet_creator_.SetTransmissionTypeOfNextPackets(type);
   if (packet_creator_.can_set_transmission_type()) {
     next_transmission_type_ = type;
   }
@@ -411,7 +411,7 @@
     return MESSAGE_STATUS_TOO_LARGE;
   }
   if (!packet_creator_.HasRoomForMessageFrame(message_length)) {
-    packet_creator_.Flush();
+    packet_creator_.FlushCurrentPacket();
   }
   QuicMessageFrame* frame = new QuicMessageFrame(message_id, message);
   const bool success =
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index d1edfcb..6e395df 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -677,7 +677,7 @@
   EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
-  creator_->Flush();
+  creator_->FlushCurrentPacket();
   EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());