diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 38656b3..7f3f01e 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -708,7 +708,7 @@
              GetServerConnectionIdAsRecipient(header, perspective_)) ||
          PacketCanReplaceConnectionId(header, perspective_));
 
-  if (!packet_generator_.IsPendingPacketEmpty()) {
+  if (packet_generator_.HasPendingFrames()) {
     // Incoming packets may change a queued ACK frame.
     const std::string error_details =
         "Pending frames must be serialized before incoming packets are "
@@ -1517,16 +1517,10 @@
 }
 
 bool QuicConnection::SendControlFrame(const QuicFrame& frame) {
-  if (!packet_generator_.deprecate_queued_control_frames() &&
-      !CanWrite(HAS_RETRANSMITTABLE_DATA) && frame.type != PING_FRAME) {
-    QUIC_DVLOG(1) << ENDPOINT << "Failed to send control frame: " << frame;
-    // Do not check congestion window for ping.
-    return false;
-  }
   ScopedPacketFlusher flusher(this);
   const bool consumed =
       packet_generator_.ConsumeRetransmittableControlFrame(frame);
-  if (packet_generator_.deprecate_queued_control_frames() && !consumed) {
+  if (!consumed) {
     QUIC_DVLOG(1) << ENDPOINT << "Failed to send control frame: " << frame;
     return false;
   }
@@ -1921,7 +1915,7 @@
       ScopedPacketFlusher flusher(this);
       packet_generator_.FlushAllQueuedFrames();
     }
-    DCHECK(!packet_generator_.HasQueuedFrames());
+    DCHECK(!packet_generator_.HasPendingFrames());
     char buffer[kMaxOutgoingPacketSize];
     packet_generator_.ReserializeAllFrames(pending, buffer,
                                            kMaxOutgoingPacketSize);
@@ -2474,7 +2468,7 @@
 }
 
 void QuicConnection::SetDefaultEncryptionLevel(EncryptionLevel level) {
-  if (level != encryption_level_ && packet_generator_.HasQueuedFrames()) {
+  if (level != encryption_level_ && packet_generator_.HasPendingFrames()) {
     // Flush all queued frames when encryption level changes.
     ScopedPacketFlusher flusher(this);
     packet_generator_.FlushAllQueuedFrames();
@@ -2715,7 +2709,7 @@
 
 bool QuicConnection::HasQueuedData() const {
   return pending_version_negotiation_packet_ || !queued_packets_.empty() ||
-         packet_generator_.HasQueuedFrames();
+         packet_generator_.HasPendingFrames();
 }
 
 bool QuicConnection::CanWriteStreamData() {
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index 210e24d..fe17069 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -27,13 +27,9 @@
       next_transmission_type_(NOT_RETRANSMISSION),
       flusher_attached_(false),
       random_generator_(random_generator),
-      fully_pad_crypto_handshake_packets_(true),
-      deprecate_queued_control_frames_(
-          GetQuicReloadableFlag(quic_deprecate_queued_control_frames)) {}
+      fully_pad_crypto_handshake_packets_(true) {}
 
-QuicPacketGenerator::~QuicPacketGenerator() {
-  DeleteFrames(&queued_control_frames_);
-}
+QuicPacketGenerator::~QuicPacketGenerator() {}
 
 bool QuicPacketGenerator::ConsumeRetransmittableControlFrame(
     const QuicFrame& frame) {
@@ -41,29 +37,23 @@
       << "Adding a control frame with no control frame id: " << frame;
   DCHECK(QuicUtils::IsRetransmittableFrame(frame.type)) << frame;
   MaybeBundleAckOpportunistically();
-  if (deprecate_queued_control_frames_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_deprecate_queued_control_frames);
-    if (packet_creator_.HasPendingFrames()) {
-      if (packet_creator_.AddSavedFrame(frame, next_transmission_type_)) {
-        // There is pending frames and current frame fits.
-        return true;
-      }
+  if (packet_creator_.HasPendingFrames()) {
+    if (packet_creator_.AddSavedFrame(frame, next_transmission_type_)) {
+      // There is pending frames and current frame fits.
+      return true;
     }
-    DCHECK(!packet_creator_.HasPendingFrames());
-    if (frame.type != PING_FRAME && frame.type != CONNECTION_CLOSE_FRAME &&
-        !delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
-                                         NOT_HANDSHAKE)) {
-      // Do not check congestion window for ping or connection close frames.
-      return false;
-    }
-    const bool success =
-        packet_creator_.AddSavedFrame(frame, next_transmission_type_);
-    DCHECK(success);
-    return success;
   }
-  queued_control_frames_.push_back(frame);
-  SendQueuedFrames(/*flush=*/false);
-  return true;
+  DCHECK(!packet_creator_.HasPendingFrames());
+  if (frame.type != PING_FRAME && frame.type != CONNECTION_CLOSE_FRAME &&
+      !delegate_->ShouldGeneratePacket(HAS_RETRANSMITTABLE_DATA,
+                                       NOT_HANDSHAKE)) {
+    // Do not check congestion window for ping or connection close frames.
+    return false;
+  }
+  const bool success =
+      packet_creator_.AddSavedFrame(frame, next_transmission_type_);
+  DCHECK(success);
+  return success;
 }
 
 size_t QuicPacketGenerator::ConsumeCryptoData(EncryptionLevel level,
@@ -77,8 +67,9 @@
   // TODO(nharper): Once we have separate packet number spaces, everything
   // should be driven by encryption level, and we should stop flushing in this
   // spot.
-  const bool flush = packet_creator_.HasPendingRetransmittableFrames();
-  SendQueuedFrames(flush);
+  if (packet_creator_.HasPendingRetransmittableFrames()) {
+    packet_creator_.Flush();
+  }
 
   size_t total_bytes_consumed = 0;
 
@@ -101,7 +92,7 @@
   }
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
-  SendQueuedFrames(/*flush=*/true);
+  packet_creator_.Flush();
 
   return total_bytes_consumed;
 }
@@ -120,9 +111,9 @@
       << "Handshake packets should never send a fin";
   // To make reasoning about crypto frames easier, we don't combine them with
   // other retransmittable frames in a single packet.
-  const bool flush =
-      has_handshake && packet_creator_.HasPendingRetransmittableFrames();
-  SendQueuedFrames(flush);
+  if (has_handshake && packet_creator_.HasPendingRetransmittableFrames()) {
+    packet_creator_.Flush();
+  }
 
   size_t total_bytes_consumed = 0;
   bool fin_consumed = false;
@@ -138,7 +129,7 @@
   // We determine if we can enter the fast path before executing
   // the slow path loop.
   bool run_fast_path =
-      !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+      !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() &&
       write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
 
   while (!run_fast_path && delegate_->ShouldGeneratePacket(
@@ -178,7 +169,7 @@
     packet_creator_.Flush();
 
     run_fast_path =
-        !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+        !has_handshake && state != FIN_AND_PADDING && !HasPendingFrames() &&
         write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
   }
 
@@ -189,7 +180,7 @@
 
   // Don't allow the handshake to be bundled with other retransmittable frames.
   if (has_handshake) {
-    SendQueuedFrames(/*flush=*/true);
+    packet_creator_.Flush();
   }
 
   return QuicConsumedData(total_bytes_consumed, fin_consumed);
@@ -245,40 +236,6 @@
   SetMaxPacketLength(current_mtu);
 }
 
-bool QuicPacketGenerator::CanSendWithNextPendingFrameAddition() const {
-  DCHECK(HasPendingFrames() || packet_creator_.pending_padding_bytes() > 0);
-  HasRetransmittableData retransmittable =
-      packet_creator_.pending_padding_bytes() > 0 ? NO_RETRANSMITTABLE_DATA
-                                                  : HAS_RETRANSMITTABLE_DATA;
-  if (retransmittable == HAS_RETRANSMITTABLE_DATA) {
-    DCHECK(!queued_control_frames_.empty());  // These are retransmittable.
-  }
-  return delegate_->ShouldGeneratePacket(retransmittable, NOT_HANDSHAKE);
-}
-
-void QuicPacketGenerator::SendQueuedFrames(bool flush) {
-  // Only add pending frames if we are SURE we can then send the whole packet.
-  while (HasPendingFrames() &&
-         (flush || CanSendWithNextPendingFrameAddition())) {
-    bool first_frame = packet_creator_.CanSetMaxPacketLength();
-    if (!AddNextPendingFrame() && first_frame) {
-      // A single frame cannot fit into the packet, tear down the connection.
-      QUIC_BUG << "A single frame cannot fit into packet."
-               << " number of queued_control_frames: "
-               << queued_control_frames_.size();
-      if (!queued_control_frames_.empty()) {
-        QUIC_LOG(INFO) << queued_control_frames_[0];
-      }
-      delegate_->OnUnrecoverableError(QUIC_FAILED_TO_SERIALIZE_PACKET,
-                                      "Single frame cannot fit into a packet");
-      return;
-    }
-  }
-  if (flush) {
-    packet_creator_.Flush();
-  }
-}
-
 bool QuicPacketGenerator::PacketFlusherAttached() const {
   return flusher_attached_;
 }
@@ -291,7 +248,6 @@
 }
 
 void QuicPacketGenerator::Flush() {
-  SendQueuedFrames(/*flush=*/false);
   packet_creator_.Flush();
   SendRemainingPendingPadding();
   flusher_attached_ = false;
@@ -309,34 +265,11 @@
 }
 
 void QuicPacketGenerator::FlushAllQueuedFrames() {
-  SendQueuedFrames(/*flush=*/true);
-}
-
-bool QuicPacketGenerator::HasQueuedFrames() const {
-  return packet_creator_.HasPendingFrames() || HasPendingFrames();
-}
-
-bool QuicPacketGenerator::IsPendingPacketEmpty() const {
-  return !packet_creator_.HasPendingFrames();
+  packet_creator_.Flush();
 }
 
 bool QuicPacketGenerator::HasPendingFrames() const {
-  return !queued_control_frames_.empty();
-}
-
-bool QuicPacketGenerator::AddNextPendingFrame() {
-  QUIC_BUG_IF(!flusher_attached_) << "Packet flusher is not attached when "
-                                     "generator tries to write control frames.";
-  QUIC_BUG_IF(queued_control_frames_.empty())
-      << "AddNextPendingFrame called with no queued control frames.";
-
-  if (!packet_creator_.AddSavedFrame(queued_control_frames_.back(),
-                                     next_transmission_type_)) {
-    // Packet was full.
-    return false;
-  }
-  queued_control_frames_.pop_back();
-  return true;
+  return packet_creator_.HasPendingFrames();
 }
 
 void QuicPacketGenerator::StopSendingVersion() {
@@ -427,15 +360,15 @@
 }
 
 void QuicPacketGenerator::SendRemainingPendingPadding() {
-  while (packet_creator_.pending_padding_bytes() > 0 && !HasQueuedFrames() &&
-         CanSendWithNextPendingFrameAddition()) {
+  while (
+      packet_creator_.pending_padding_bytes() > 0 && !HasPendingFrames() &&
+      delegate_->ShouldGeneratePacket(NO_RETRANSMITTABLE_DATA, NOT_HANDSHAKE)) {
     packet_creator_.Flush();
   }
 }
 
 bool QuicPacketGenerator::HasRetransmittableFrames() const {
-  return !queued_control_frames_.empty() ||
-         packet_creator_.HasPendingRetransmittableFrames();
+  return packet_creator_.HasPendingRetransmittableFrames();
 }
 
 bool QuicPacketGenerator::HasPendingStreamFramesOfStream(
@@ -468,7 +401,6 @@
   if (message_length > GetCurrentLargestMessagePayload()) {
     return MESSAGE_STATUS_TOO_LARGE;
   }
-  SendQueuedFrames(/*flush=*/false);
   if (!packet_creator_.HasRoomForMessageFrame(message_length)) {
     packet_creator_.Flush();
   }
diff --git a/quic/core/quic_packet_generator.h b/quic/core/quic_packet_generator.h
index 2f82654..ea7da5d 100644
--- a/quic/core/quic_packet_generator.h
+++ b/quic/core/quic_packet_generator.h
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // Responsible for generating packets on behalf of a QuicConnection.
-// Packets are serialized just-in-time.  Control frames are queued.
+// Packets are serialized just-in-time.
 // Ack and Feedback frames will be requested from the Connection
 // just-in-time.  When a packet needs to be sent, the Generator
 // will serialize a packet and pass it to QuicConnection::SendOrQueuePacket()
@@ -121,16 +121,14 @@
   bool PacketFlusherAttached() const;
   // Attaches packet flusher.
   void AttachPacketFlusher();
-  // Flushes everything, including all queued frames and pending padding.
+  // Flushes everything, including current open packet and pending padding.
   void Flush();
 
-  // Flushes all queued frames, even frames which are not sendable.
+  // Flushes current open packet.
   void FlushAllQueuedFrames();
 
-  bool HasQueuedFrames() const;
-
-  // Whether the pending packet has no frames in it at the moment.
-  bool IsPendingPacketEmpty() const;
+  // Returns true if there are frames pending to be serialized.
+  bool HasPendingFrames() const;
 
   // Makes the framer not serialize the protocol version in sent packets.
   void StopSendingVersion();
@@ -241,26 +239,9 @@
     return fully_pad_crypto_handshake_packets_;
   }
 
-  bool deprecate_queued_control_frames() const {
-    return deprecate_queued_control_frames_;
-  }
-
  private:
   friend class test::QuicPacketGeneratorPeer;
 
-  void SendQueuedFrames(bool flush);
-
-  // Test to see if we have pending ack, or control frames.
-  bool HasPendingFrames() const;
-  // Returns true if addition of a pending frame (which might be
-  // retransmittable) would still allow the resulting packet to be sent now.
-  bool CanSendWithNextPendingFrameAddition() const;
-  // Add exactly one pending frame, preferring ack frames over control frames.
-  // Returns true if a pending frame is successfully added.
-  // Returns false and flushes current open packet if the pending frame cannot
-  // fit into current open packet.
-  bool AddNextPendingFrame();
-
   // Adds a random amount of padding (between 1 to 256 bytes).
   void AddRandomPadding();
 
@@ -275,9 +256,6 @@
   DelegateInterface* delegate_;
 
   QuicPacketCreator packet_creator_;
-  // TODO(fayang): remove this when deprecating
-  // quic_deprecate_queued_control_frames.
-  QuicFrames queued_control_frames_;
 
   // Transmission type of the next serialized packet.
   TransmissionType next_transmission_type_;
@@ -294,9 +272,6 @@
   // when the out-most flusher attaches and gets cleared when the out-most
   // flusher detaches.
   QuicPacketNumber write_start_packet_number_;
-
-  // Latched value of quic_deprecate_queued_control_frames.
-  const bool deprecate_queued_control_frames_;
 };
 
 }  // namespace quic
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index e996c4e..cdb19b3 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -346,15 +346,10 @@
   const bool consumed =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/false);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(consumed);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-    delete rst_frame;
-  } else {
-    EXPECT_TRUE(generator_.HasQueuedFrames());
-    EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  }
+  EXPECT_FALSE(consumed);
+  EXPECT_FALSE(generator_.HasPendingFrames());
+  EXPECT_FALSE(generator_.HasRetransmittableFrames());
+  delete rst_frame;
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
@@ -364,15 +359,10 @@
   const bool consumed =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/false);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(consumed);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-    delete rst_frame;
-  } else {
-    EXPECT_TRUE(generator_.HasQueuedFrames());
-    EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  }
+  EXPECT_FALSE(consumed);
+  EXPECT_FALSE(generator_.HasPendingFrames());
+  EXPECT_FALSE(generator_.HasRetransmittableFrames());
+  delete rst_frame;
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
@@ -381,7 +371,7 @@
   generator_.ConsumeRetransmittableControlFrame(
       QuicFrame(CreateRstStreamFrame()),
       /*bundle_ack=*/false);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 }
 
@@ -392,29 +382,10 @@
   const bool consumed =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/false);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(consumed);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-    delete rst_frame;
-    return;
-  }
-  EXPECT_TRUE(generator_.HasQueuedFrames());
-  EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  generator_.Flush();
-  EXPECT_TRUE(generator_.HasQueuedFrames());
-  EXPECT_TRUE(generator_.HasRetransmittableFrames());
-
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
-  generator_.AttachPacketFlusher();
-  generator_.FlushAllQueuedFrames();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(consumed);
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
-
-  PacketContents contents;
-  contents.num_rst_stream_frames = 1;
-  CheckPacketContains(contents, 0);
+  delete rst_frame;
 }
 
 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
@@ -427,7 +398,7 @@
       QuicFrame(CreateRstStreamFrame()),
       /*bundle_ack=*/false);
   generator_.Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -445,7 +416,7 @@
       generator_.ConsumeCryptoData(ENCRYPTION_INITIAL, data, 0);
   generator_.Flush();
   EXPECT_EQ(data.length(), consumed_bytes);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -463,7 +434,7 @@
       iov_.iov_len, 0, FIN);
   EXPECT_EQ(0u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 }
 
@@ -476,7 +447,7 @@
       iov_.iov_len, 0, FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 }
 
@@ -492,7 +463,7 @@
   generator_.Flush();
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -522,7 +493,7 @@
             .bytes_consumed;
   }
   EXPECT_EQ(7u, consumed_bytes);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -562,7 +533,7 @@
             .bytes_consumed;
   }
   EXPECT_EQ(3u, bytes_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -612,7 +583,7 @@
       generator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 3, NO_FIN);
   EXPECT_EQ(4u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 }
 
@@ -629,14 +600,14 @@
       iov_.iov_len, 3, NO_FIN);
   EXPECT_EQ(4u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   // Now both frames will be flushed out.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -683,7 +654,7 @@
       iov_.iov_len, 0, NO_FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   // This frame will not fit with the existing frame, causing the queued frame
@@ -694,11 +665,11 @@
       iov_.iov_len, 3, FIN);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   creator_->Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -721,7 +692,7 @@
       iov_.iov_len, 0, true);
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -749,7 +720,7 @@
       iov_.iov_len, 0, FIN);
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   PacketContents contents;
@@ -771,31 +742,22 @@
   const bool success =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/true);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(success);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-  } else {
-    EXPECT_TRUE(generator_.HasQueuedFrames());
-    EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  }
+  EXPECT_FALSE(success);
+  EXPECT_FALSE(generator_.HasPendingFrames());
+  EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   delegate_.SetCanWriteAnything();
 
-  if (generator_.deprecate_queued_control_frames()) {
-    generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
-                                                  /*bundle_ack=*/false);
-  }
+  generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
+                                                /*bundle_ack=*/false);
 
   // Create a 10000 byte IOVector.
   CreateData(10000);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
-  if (generator_.deprecate_queued_control_frames()) {
-    generator_.ConsumeRetransmittableControlFrame(
-        QuicFrame(CreateRstStreamFrame()),
-        /*bundle_ack=*/true);
-  }
+  generator_.ConsumeRetransmittableControlFrame(
+      QuicFrame(CreateRstStreamFrame()),
+      /*bundle_ack=*/true);
   QuicConsumedData consumed = generator_.ConsumeData(
       QuicUtils::GetHeadersStreamId(framer_.transport_version()), &iov_, 1u,
       iov_.iov_len, 0, FIN);
@@ -803,7 +765,7 @@
 
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   EXPECT_FALSE(packets_.empty());
@@ -833,7 +795,7 @@
 
   EXPECT_EQ(10000u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   EXPECT_FALSE(packets_.empty());
@@ -852,23 +814,16 @@
   const bool consumed =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/true);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(consumed);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-  } else {
-    EXPECT_TRUE(generator_.HasQueuedFrames());
-    EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  }
+  EXPECT_FALSE(consumed);
+  EXPECT_FALSE(generator_.HasPendingFrames());
+  EXPECT_FALSE(generator_.HasRetransmittableFrames());
   EXPECT_FALSE(generator_.HasPendingStreamFramesOfStream(3));
 
   delegate_.SetCanWriteAnything();
 
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_TRUE(
-        generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
-                                                      /*bundle_ack=*/false));
-  }
+  EXPECT_TRUE(
+      generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
+                                                    /*bundle_ack=*/false));
   // Send some data and a control frame
   MakeIOVector("quux", &iov_);
   generator_.ConsumeData(3, &iov_, 1u, iov_.iov_len, 0, NO_FIN);
@@ -883,7 +838,7 @@
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   generator_.Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
   EXPECT_FALSE(generator_.HasPendingStreamFramesOfStream(3));
 
@@ -907,14 +862,9 @@
   const bool success =
       generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
                                                     /*bundle_ack=*/true);
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_FALSE(success);
-    EXPECT_FALSE(generator_.HasQueuedFrames());
-    EXPECT_FALSE(generator_.HasRetransmittableFrames());
-  } else {
-    EXPECT_TRUE(generator_.HasQueuedFrames());
-    EXPECT_TRUE(generator_.HasRetransmittableFrames());
-  }
+  EXPECT_FALSE(success);
+  EXPECT_FALSE(generator_.HasPendingFrames());
+  EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   delegate_.SetCanWriteAnything();
 
@@ -926,11 +876,9 @@
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketGeneratorTest::SavePacket));
   }
-  if (generator_.deprecate_queued_control_frames()) {
-    EXPECT_TRUE(
-        generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
-                                                      /*bundle_ack=*/false));
-  }
+  EXPECT_TRUE(
+      generator_.ConsumeRetransmittableControlFrame(QuicFrame(rst_frame),
+                                                    /*bundle_ack=*/false));
   // Send enough data to exceed one packet
   size_t data_len = kDefaultMaxPacketSize + 100;
   CreateData(data_len);
@@ -945,7 +893,7 @@
   }
 
   generator_.Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // The first packet should have the queued data and part of the stream data.
@@ -1050,7 +998,7 @@
       /*offset=*/0, FIN);
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // We expect three packets, and first two of them have to be of packet_len
@@ -1088,7 +1036,7 @@
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // Make sure we already have two packets.
@@ -1107,7 +1055,7 @@
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // We expect first data chunk to get fragmented, but the second one to fit
@@ -1137,7 +1085,7 @@
       /*offset=*/0, NO_FIN);
   EXPECT_EQ(first_write_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   // Make sure we have no packets so far.
@@ -1152,7 +1100,7 @@
   generator_.FlushAllQueuedFrames();
   generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // We expect to see exactly one packet serialized after that, because we send
@@ -1170,7 +1118,7 @@
       /*offset=*/first_write_len, FIN);
   EXPECT_EQ(second_write_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   // We expect the first packet to be underfilled, and the second packet be up
@@ -1221,7 +1169,7 @@
 
   generator_.GenerateMtuDiscoveryPacket(target_mtu);
 
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
   ASSERT_EQ(1u, packets_.size());
   EXPECT_EQ(target_mtu, packets_[0].encrypted_length);
@@ -1259,12 +1207,12 @@
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_FALSE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // Send the MTU probe.
   generator_.GenerateMtuDiscoveryPacket(target_mtu);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   // Send data after the MTU probe.
@@ -1277,7 +1225,7 @@
   generator_.Flush();
   EXPECT_EQ(data_len, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   ASSERT_EQ(5u, packets_.size());
@@ -1329,7 +1277,7 @@
   }
   generator_.ConsumeRetransmittableControlFrame(QuicFrame(frame),
                                                 /*bundle_ack=*/false);
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 }
 
@@ -1364,7 +1312,7 @@
       kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
   generator_.Flush();
   EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   EXPECT_EQ(1u, packets_.size());
@@ -1406,7 +1354,7 @@
       kDataStreamId, &iov_, 1u, iov_.iov_len, 0, FIN_AND_PADDING);
   generator_.Flush();
   EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   EXPECT_LE(1u, packets_.size());
@@ -1464,7 +1412,7 @@
                                     FIN_AND_PADDING);
   EXPECT_EQ(kStreamFramePayloadSize, consumed.bytes_consumed);
   generator_.Flush();
-  EXPECT_FALSE(generator_.HasQueuedFrames());
+  EXPECT_FALSE(generator_.HasPendingFrames());
   EXPECT_FALSE(generator_.HasRetransmittableFrames());
 
   EXPECT_LE(2u, packets_.size());
@@ -1502,7 +1450,7 @@
   EXPECT_EQ(MESSAGE_STATUS_SUCCESS,
             generator_.AddMessageFrame(
                 1, MakeSpan(&allocator_, "message", &storage)));
-  EXPECT_TRUE(generator_.HasQueuedFrames());
+  EXPECT_TRUE(generator_.HasPendingFrames());
   EXPECT_TRUE(generator_.HasRetransmittableFrames());
 
   // Add a message which causes the flush of current packet.