diff --git a/quiche/quic/core/quic_flags_list.h b/quiche/quic/core/quic_flags_list.h
index 653029c..2b404a7 100644
--- a/quiche/quic/core/quic_flags_list.h
+++ b/quiche/quic/core/quic_flags_list.h
@@ -63,6 +63,8 @@
 QUIC_FLAG(quic_reloadable_flag_quic_remove_connection_migration_connection_option_v2, false)
 // If true, include stream information in idle timeout connection close detail.
 QUIC_FLAG(quic_reloadable_flag_quic_add_stream_info_to_idle_close_detail, true)
+// If true, lowers the minimum packet size to that in the spec.
+QUIC_FLAG(quic_restart_flag_quic_allow_smaller_packets, false)
 // If true, quic server will send ENABLE_CONNECT_PROTOCOL setting and and endpoint will validate required request/response headers and extended CONNECT mechanism and update code counts of valid/invalid headers.
 QUIC_FLAG(quic_reloadable_flag_quic_verify_request_headers_2, true)
 // If true, reject or send error response code upon receiving invalid request or response headers. This flag depends on --gfe2_reloadable_flag_quic_verify_request_headers_2.
diff --git a/quiche/quic/core/quic_packet_creator.cc b/quiche/quic/core/quic_packet_creator.cc
index ad4e785..cfcd3e2 100644
--- a/quiche/quic/core/quic_packet_creator.cc
+++ b/quiche/quic/core/quic_packet_creator.cc
@@ -19,6 +19,7 @@
 #include "absl/types/optional.h"
 #include "quiche/quic/core/crypto/crypto_protocol.h"
 #include "quiche/quic/core/frames/quic_frame.h"
+#include "quiche/quic/core/frames/quic_padding_frame.h"
 #include "quiche/quic/core/frames/quic_path_challenge_frame.h"
 #include "quiche/quic/core/frames/quic_stream_frame.h"
 #include "quiche/quic/core/quic_chaos_protector.h"
@@ -167,8 +168,10 @@
 
   max_packet_length_ = length;
   max_plaintext_size_ = framer_->GetMaxPlaintextSize(max_packet_length_);
-  QUIC_BUG_IF(quic_bug_12398_2, max_plaintext_size_ - PacketHeaderSize() <
-                                    MinPlaintextPacketSize(framer_->version()))
+  QUIC_BUG_IF(
+      quic_bug_12398_2,
+      max_plaintext_size_ - PacketHeaderSize() <
+          MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength()))
       << ENDPOINT << "Attempted to set max packet length too small";
 }
 
@@ -197,7 +200,8 @@
     return;
   }
   if (framer_->GetMaxPlaintextSize(length) <
-      PacketHeaderSize() + MinPlaintextPacketSize(framer_->version())) {
+      PacketHeaderSize() +
+          MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength())) {
     // Please note: this would not guarantee to fit next packet if the size of
     // packet header increases (e.g., encryption level changes).
     QUIC_DLOG(INFO) << ENDPOINT << length
@@ -611,16 +615,20 @@
   size_t bytes_consumed = std::min<size_t>(available_size, remaining_data_size);
   size_t plaintext_bytes_written = min_frame_size + bytes_consumed;
   bool needs_padding = false;
-  if (plaintext_bytes_written < MinPlaintextPacketSize(framer_->version())) {
+  const size_t min_plaintext_size =
+      MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength());
+  if (plaintext_bytes_written < min_plaintext_size) {
     needs_padding = true;
-    // Recalculate sizes with the stream frame not being marked as the last
-    // frame in the packet.
-    min_frame_size = QuicFramer::GetMinStreamFrameSize(
-        framer_->transport_version(), id, stream_offset,
-        /* last_frame_in_packet= */ false, remaining_data_size);
-    available_size = max_plaintext_size_ - writer.length() - min_frame_size;
-    bytes_consumed = std::min<size_t>(available_size, remaining_data_size);
-    plaintext_bytes_written = min_frame_size + bytes_consumed;
+    if (!GetQuicRestartFlag(quic_allow_smaller_packets)) {
+      // Recalculate sizes with the stream frame not being marked as the last
+      // frame in the packet.
+      min_frame_size = QuicFramer::GetMinStreamFrameSize(
+          framer_->transport_version(), id, stream_offset,
+          /* last_frame_in_packet= */ false, remaining_data_size);
+      available_size = max_plaintext_size_ - writer.length() - min_frame_size;
+      bytes_consumed = std::min<size_t>(available_size, remaining_data_size);
+      plaintext_bytes_written = min_frame_size + bytes_consumed;
+    }
   }
 
   const bool set_fin = fin && (bytes_consumed == remaining_data_size);
@@ -634,6 +642,15 @@
 
   // TODO(ianswett): AppendTypeByte and AppendStreamFrame could be optimized
   // into one method that takes a QuicStreamFrame, if warranted.
+  if (needs_padding && GetQuicRestartFlag(quic_allow_smaller_packets)) {
+    QUIC_RESTART_FLAG_COUNT_N(quic_allow_smaller_packets, 2, 5);
+    if (!writer.WritePaddingBytes(min_plaintext_size -
+                                  plaintext_bytes_written)) {
+      QUIC_BUG(quic_bug_10752_12) << ENDPOINT << "Unable to add padding bytes";
+      return;
+    }
+    needs_padding = false;
+  }
   bool omit_frame_length = !needs_padding;
   if (!framer_->AppendTypeByte(QuicFrame(frame), omit_frame_length, &writer)) {
     QUIC_BUG(quic_bug_10752_10) << ENDPOINT << "AppendTypeByte failed";
@@ -643,10 +660,8 @@
     QUIC_BUG(quic_bug_10752_11) << ENDPOINT << "AppendStreamFrame failed";
     return;
   }
-  if (needs_padding &&
-      plaintext_bytes_written < MinPlaintextPacketSize(framer_->version()) &&
-      !writer.WritePaddingBytes(MinPlaintextPacketSize(framer_->version()) -
-                                plaintext_bytes_written)) {
+  if (needs_padding && plaintext_bytes_written < min_plaintext_size &&
+      !writer.WritePaddingBytes(min_plaintext_size - plaintext_bytes_written)) {
     QUIC_BUG(quic_bug_10752_12) << ENDPOINT << "Unable to add padding bytes";
     return;
   }
@@ -737,6 +752,18 @@
          std::min(max_plaintext_size_, PacketSize() + ExpansionOnNewFrame());
 }
 
+size_t QuicPacketCreator::BytesFreeForPadding() const {
+  size_t consumed = PacketSize();
+
+  if (!GetQuicRestartFlag(quic_allow_smaller_packets)) {
+    consumed += ExpansionOnNewFrame();
+  } else {
+    // The next frame (which is PADDING) will be prepended to the packet.
+    QUIC_RESTART_FLAG_COUNT_N(quic_allow_smaller_packets, 5, 5);
+  }
+  return max_plaintext_size_ - std::min(max_plaintext_size_, consumed);
+}
+
 size_t QuicPacketCreator::PacketSize() const {
   return queued_frames_.empty() ? PacketHeaderSize() : packet_size_;
 }
@@ -1680,7 +1707,8 @@
   // Calculate frame bytes and bytes free with this frame added.
   const size_t frame_bytes = PacketSize() - PacketHeaderSize() +
                              ExpansionOnNewFrame() + serialized_frame_length;
-  if (frame_bytes >= MinPlaintextPacketSize(framer_->version())) {
+  if (frame_bytes >=
+      MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength())) {
     // No extra bytes is needed.
     return serialized_frame_length;
   }
@@ -1694,7 +1722,8 @@
   // padding + expansion.
   const size_t extra_bytes_needed = std::max(
       1 + ExpansionOnNewFrameWithLastFrame(frame, framer_->transport_version()),
-      MinPlaintextPacketSize(framer_->version()) - frame_bytes);
+      MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength()) -
+          frame_bytes);
   if (bytes_free < extra_bytes_needed) {
     // This frame does not fit.
     return 0;
@@ -1814,13 +1843,24 @@
     return;
   }
   const size_t frame_bytes = PacketSize() - PacketHeaderSize();
-  if (frame_bytes >= MinPlaintextPacketSize(framer_->version())) {
+  if (frame_bytes >=
+      MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength())) {
     return;
   }
-  const QuicByteCount min_header_protection_padding =
-      std::max(1 + ExpansionOnNewFrame(),
-               MinPlaintextPacketSize(framer_->version()) - frame_bytes) -
-      ExpansionOnNewFrame();
+  QuicByteCount min_header_protection_padding;
+  if (GetQuicRestartFlag(quic_allow_smaller_packets)) {
+    QUIC_RESTART_FLAG_COUNT_N(quic_allow_smaller_packets, 4, 5);
+    min_header_protection_padding =
+        MinPlaintextPacketSize(framer_->version(), GetPacketNumberLength()) -
+        frame_bytes;
+  } else {
+    min_header_protection_padding =
+        std::max(1 + ExpansionOnNewFrame(),
+                 MinPlaintextPacketSize(framer_->version(),
+                                        GetPacketNumberLength()) -
+                     frame_bytes) -
+        ExpansionOnNewFrame();
+  }
   // Update pending_padding_bytes_.
   pending_padding_bytes_ =
       std::max(pending_padding_bytes_, min_header_protection_padding);
@@ -1876,7 +1916,7 @@
 void QuicPacketCreator::MaybeAddPadding() {
   // The current packet should have no padding bytes because padding is only
   // added when this method is called just before the packet is serialized.
-  if (BytesFree() == 0) {
+  if (BytesFreeForPadding() == 0) {
     // Don't pad full packets.
     return;
   }
@@ -1903,15 +1943,36 @@
 
   int padding_bytes = -1;
   if (!needs_full_padding_) {
-    padding_bytes = std::min<int16_t>(pending_padding_bytes_, BytesFree());
+    padding_bytes =
+        std::min<int16_t>(pending_padding_bytes_, BytesFreeForPadding());
     pending_padding_bytes_ -= padding_bytes;
   }
 
-  bool success = AddFrame(QuicFrame(QuicPaddingFrame(padding_bytes)),
-                          packet_.transmission_type);
-  QUIC_BUG_IF(quic_bug_10752_36, !success)
-      << ENDPOINT << "Failed to add padding_bytes: " << padding_bytes
-      << " transmission_type: " << packet_.transmission_type;
+  if (!queued_frames_.empty() &&
+      GetQuicRestartFlag(quic_allow_smaller_packets)) {
+    // Insert PADDING before the other frames to avoid adding a length field
+    // to any trailing STREAM frame.
+    QUIC_RESTART_FLAG_COUNT_N(quic_allow_smaller_packets, 3, 5);
+    if (needs_full_padding_) {
+      padding_bytes = BytesFreeForPadding();
+    }
+    // AddFrame cannot be used here because it adds the frame to the end of the
+    // packet.
+    QuicFrame frame{QuicPaddingFrame(padding_bytes)};
+    queued_frames_.insert(queued_frames_.begin(), frame);
+    packet_size_ += padding_bytes;
+    packet_.nonretransmittable_frames.push_back(frame);
+    if (packet_.transmission_type == NOT_RETRANSMISSION) {
+      packet_.bytes_not_retransmitted.emplace(
+          packet_.bytes_not_retransmitted.value_or(0) + padding_bytes);
+    }
+  } else {
+    bool success = AddFrame(QuicFrame(QuicPaddingFrame(padding_bytes)),
+                            packet_.transmission_type);
+    QUIC_BUG_IF(quic_bug_10752_36, !success)
+        << ENDPOINT << "Failed to add padding_bytes: " << padding_bytes
+        << " transmission_type: " << packet_.transmission_type;
+  }
 }
 
 bool QuicPacketCreator::IncludeNonceInPublicHeader() const {
@@ -2055,7 +2116,8 @@
 
 // static
 size_t QuicPacketCreator::MinPlaintextPacketSize(
-    const ParsedQuicVersion& version) {
+    const ParsedQuicVersion& version,
+    QuicPacketNumberLength packet_number_length) {
   if (!version.HasHeaderProtection()) {
     return 0;
   }
@@ -2077,7 +2139,10 @@
   // 1.3 is used, unittests still use NullEncrypter/NullDecrypter (and other
   // test crypters) which also only use 12 byte tags.
   //
-  // TODO(b/234061734): Set this based on the handshake protocol in use.
+  if (GetQuicRestartFlag(quic_allow_smaller_packets)) {
+    QUIC_RESTART_FLAG_COUNT_N(quic_allow_smaller_packets, 1, 5);
+    return (version.UsesTls() ? 4 : 8) - packet_number_length;
+  }
   return 7;
 }
 
diff --git a/quiche/quic/core/quic_packet_creator.h b/quiche/quic/core/quic_packet_creator.h
index 0bcd745..785efb1 100644
--- a/quiche/quic/core/quic_packet_creator.h
+++ b/quiche/quic/core/quic_packet_creator.h
@@ -212,6 +212,10 @@
   // value than max_packet_size - PacketSize(), in this case.
   size_t BytesFree() const;
 
+  // Since PADDING frames are always prepended, a separate function computes
+  // available space without considering STREAM frame expansion.
+  size_t BytesFreeForPadding() const;
+
   // Returns the number of bytes that the packet will expand by if a new frame
   // is added to the packet. If the last frame was a stream frame, it will
   // expand slightly when a new frame is added, and this method returns the
@@ -428,7 +432,9 @@
   }
 
   // Returns the minimum size that the plaintext of a packet must be.
-  static size_t MinPlaintextPacketSize(const ParsedQuicVersion& version);
+  static size_t MinPlaintextPacketSize(
+      const ParsedQuicVersion& version,
+      QuicPacketNumberLength packet_number_length);
 
   // Indicates whether packet flusher is currently attached.
   bool PacketFlusherAttached() const;
diff --git a/quiche/quic/core/quic_packet_creator_test.cc b/quiche/quic/core/quic_packet_creator_test.cc
index f71d9e4..6dcd4a5 100644
--- a/quiche/quic/core/quic_packet_creator_test.cc
+++ b/quiche/quic/core/quic_packet_creator_test.cc
@@ -279,17 +279,24 @@
                          ::testing::PrintToStringParamName());
 
 TEST_P(QuicPacketCreatorTest, SerializeFrames) {
+  ParsedQuicVersion version = client_framer_.version();
   for (int i = ENCRYPTION_INITIAL; i < NUM_ENCRYPTION_LEVELS; ++i) {
     EncryptionLevel level = static_cast<EncryptionLevel>(i);
+    bool has_ack = false, has_stream = false;
     creator_.set_encryption_level(level);
+    size_t payload_len = 0;
     if (level != ENCRYPTION_ZERO_RTT) {
       frames_.push_back(QuicFrame(new QuicAckFrame(InitAckFrame(1))));
+      has_ack = true;
+      payload_len += version.UsesTls() ? 12 : 6;
     }
-    QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
-        client_framer_.transport_version(), Perspective::IS_CLIENT);
     if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
+      QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
+          client_framer_.transport_version(), Perspective::IS_CLIENT);
       frames_.push_back(QuicFrame(
           QuicStreamFrame(stream_id, false, 0u, absl::string_view())));
+      has_stream = true;
+      payload_len += 2;
     }
     SerializedPacket serialized = SerializeAllFrames(frames_);
     EXPECT_EQ(level, serialized.encryption_level);
@@ -297,7 +304,13 @@
       delete frames_[0].ack_frame;
     }
     frames_.clear();
-
+    ASSERT_GT(payload_len, 0);  // Must have a frame!
+    size_t min_payload =
+        (version.UsesTls() && GetQuicRestartFlag(quic_allow_smaller_packets))
+            ? 3
+            : 7;
+    bool need_padding =
+        (version.HasHeaderProtection() && (payload_len < min_payload));
     {
       InSequence s;
       EXPECT_CALL(framer_visitor_, OnPacket());
@@ -305,7 +318,10 @@
       EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
       EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
       EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-      if (level != ENCRYPTION_ZERO_RTT) {
+      if (need_padding && GetQuicRestartFlag(quic_allow_smaller_packets)) {
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
+      }
+      if (has_ack) {
         EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _))
             .WillOnce(Return(true));
         EXPECT_CALL(framer_visitor_,
@@ -314,12 +330,11 @@
         EXPECT_CALL(framer_visitor_, OnAckFrameEnd(QuicPacketNumber(1)))
             .WillOnce(Return(true));
       }
-      if (level != ENCRYPTION_INITIAL && level != ENCRYPTION_HANDSHAKE) {
+      if (has_stream) {
         EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
       }
-      if (client_framer_.version().HasHeaderProtection()) {
-        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_))
-            .Times(testing::AnyNumber());
+      if (need_padding && !GetQuicRestartFlag(quic_allow_smaller_packets)) {
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
       }
       EXPECT_CALL(framer_visitor_, OnPacketComplete());
     }
@@ -409,8 +424,10 @@
   const size_t overhead =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
       GetEncryptionOverhead();
-  for (size_t i = overhead + QuicPacketCreator::MinPlaintextPacketSize(
-                                 client_framer_.version());
+  for (size_t i = overhead +
+                  QuicPacketCreator::MinPlaintextPacketSize(
+                      client_framer_.version(),
+                      QuicPacketCreatorPeer::GetPacketNumberLength(&creator_));
        i < overhead + 100; ++i) {
     SCOPED_TRACE(i);
     creator_.SetMaxPacketLength(i);
@@ -478,7 +495,12 @@
     overhead +=
         QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxOutgoingPacketSize);
   } else {
-    overhead += GetStreamFrameOverhead(client_framer_.transport_version());
+    overhead +=
+        GetQuicRestartFlag(quic_allow_smaller_packets)
+            ? QuicFramer::GetMinStreamFrameSize(
+                  client_framer_.transport_version(),
+                  GetNthClientInitiatedStreamId(1), kOffset, false, 0)
+            : GetStreamFrameOverhead(client_framer_.transport_version());
   }
   ASSERT_GT(kMaxOutgoingPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
@@ -516,7 +538,7 @@
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
     // will not be padded.
     // Padding is skipped when we try to send coalesced packets.
-    if ((bytes_free < 3 &&
+    if ((!GetQuicRestartFlag(quic_allow_smaller_packets) && bytes_free < 3 &&
          !QuicVersionUsesCryptoFrames(client_framer_.transport_version())) ||
         client_framer_.version().CanSendCoalescedPackets()) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
@@ -1495,20 +1517,20 @@
   }
   EXPECT_FALSE(creator_.HasPendingFrames());
 
-  // Send one byte of stream data.
-  const std::string data("a");
-  producer_.SaveStreamData(GetNthClientInitiatedStreamId(0), data);
+  // Send zero bytes of stream data. This requires padding.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   size_t num_bytes_consumed;
-  creator_.CreateAndSerializeStreamFrame(
-      GetNthClientInitiatedStreamId(0), data.length(), 0, 0, true,
-      NOT_RETRANSMISSION, &num_bytes_consumed);
-  EXPECT_EQ(1u, num_bytes_consumed);
+  creator_.CreateAndSerializeStreamFrame(GetNthClientInitiatedStreamId(0), 0, 0,
+                                         0, true, NOT_RETRANSMISSION,
+                                         &num_bytes_consumed);
+  EXPECT_EQ(0u, num_bytes_consumed);
 
   // Check that a packet is created.
   ASSERT_TRUE(serialized_packet_->encrypted_buffer);
   ASSERT_FALSE(serialized_packet_->retransmittable_frames.empty());
+  ASSERT_EQ(serialized_packet_->packet_number_length,
+            PACKET_1BYTE_PACKET_NUMBER);
   {
     InSequence s;
     EXPECT_CALL(framer_visitor_, OnPacket());
@@ -1516,9 +1538,16 @@
     EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     if (client_framer_.version().HasHeaderProtection()) {
-      EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
+      if (GetQuicRestartFlag(quic_allow_smaller_packets)) {
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
+        EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+      } else {
+        EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
+      }
+    } else {
+      EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     }
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
@@ -1639,13 +1668,14 @@
   // 1.
   QuicStreamId stream_id = QuicUtils::GetFirstBidirectionalStreamId(
       client_framer_.transport_version(), Perspective::IS_CLIENT);
-  size_t length =
-      GetPacketHeaderOverhead(client_framer_.transport_version()) +
-      GetEncryptionOverhead() +
-      QuicFramer::GetMinStreamFrameSize(
-          client_framer_.transport_version(), stream_id, 0,
-          /*last_frame_in_packet=*/false, kStreamFramePayloadSize + 1) +
-      kStreamFramePayloadSize + 1;
+  size_t length = GetPacketHeaderOverhead(client_framer_.transport_version()) +
+                  GetEncryptionOverhead() +
+                  QuicFramer::GetMinStreamFrameSize(
+                      client_framer_.transport_version(), stream_id, 0,
+                      /*last_frame_in_packet=*/
+                      GetQuicRestartFlag(quic_allow_smaller_packets),
+                      kStreamFramePayloadSize + 1) +
+                  kStreamFramePayloadSize + 1;
   creator_.SetMaxPacketLength(length);
   creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
   QuicByteCount pending_padding_bytes = creator_.pending_padding_bytes();
@@ -2098,8 +2128,13 @@
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_))
         .WillOnce(DoAll(SaveArg<0>(&header), Return(true)));
+    if (client_framer_.version().HasHeaderProtection() &&
+        GetQuicRestartFlag(quic_allow_smaller_packets)) {
+      EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
+    }
     EXPECT_CALL(framer_visitor_, OnPingFrame(_));
-    if (client_framer_.version().HasHeaderProtection()) {
+    if (client_framer_.version().HasHeaderProtection() &&
+        !GetQuicRestartFlag(quic_allow_smaller_packets)) {
       EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
     }
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
@@ -2277,27 +2312,38 @@
     EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_, _));
     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
     if (i != ENCRYPTION_ZERO_RTT) {
+      if (GetQuicRestartFlag(quic_allow_smaller_packets) &&
+          i != ENCRYPTION_INITIAL) {
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_))
+            .Times(testing::AtMost(1));
+      }
       EXPECT_CALL(framer_visitor_, OnAckFrameStart(_, _))
           .WillOnce(Return(true));
       EXPECT_CALL(framer_visitor_,
                   OnAckRange(QuicPacketNumber(1), QuicPacketNumber(2)))
           .WillOnce(Return(true));
       EXPECT_CALL(framer_visitor_, OnAckFrameEnd(_)).WillOnce(Return(true));
+      if (!GetQuicRestartFlag(quic_allow_smaller_packets)) {
+        EXPECT_CALL(framer_visitor_, OnPaddingFrame(_))
+            .Times(testing::AtMost(1));
+      }
     }
     if (i == ENCRYPTION_INITIAL) {
       // Verify padding is added.
       EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
-    } else if (i != ENCRYPTION_ZERO_RTT) {
-      EXPECT_CALL(framer_visitor_, OnPaddingFrame(_)).Times(testing::AtMost(1));
+    }
+    if (GetQuicRestartFlag(quic_allow_smaller_packets) &&
+        i == ENCRYPTION_ZERO_RTT) {
+      EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
     }
     if (i != ENCRYPTION_INITIAL && i != ENCRYPTION_HANDSHAKE) {
       EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
     }
-    if (i == ENCRYPTION_ZERO_RTT) {
+    if (!GetQuicRestartFlag(quic_allow_smaller_packets) &&
+        i == ENCRYPTION_ZERO_RTT) {
       EXPECT_CALL(framer_visitor_, OnPaddingFrame(_));
     }
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
-
     server_framer_.ProcessPacket(*packets[i]);
   }
 }
@@ -2307,7 +2353,9 @@
   QuicByteCount previous_max_packet_length = creator_.max_packet_length();
   const size_t overhead =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
-      QuicPacketCreator::MinPlaintextPacketSize(client_framer_.version()) +
+      QuicPacketCreator::MinPlaintextPacketSize(
+          client_framer_.version(),
+          QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)) +
       GetEncryptionOverhead();
   // Make sure a length which cannot accommodate header (includes header
   // protection minimal length) gets rejected.
@@ -2382,7 +2430,9 @@
   const QuicByteCount previous_max_packet_length = creator_.max_packet_length();
   const size_t min_acceptable_packet_size =
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
-      QuicPacketCreator::MinPlaintextPacketSize(client_framer_.version()) +
+      QuicPacketCreator::MinPlaintextPacketSize(
+          client_framer_.version(),
+          QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)) +
       GetEncryptionOverhead();
   // Then set the soft max packet length to the lowest allowed value.
   creator_.SetSoftMaxPacketLength(min_acceptable_packet_size);
@@ -2398,6 +2448,88 @@
   EXPECT_EQ(creator_.max_packet_length(), previous_max_packet_length);
 }
 
+TEST_P(QuicPacketCreatorTest, MinPayloadLength) {
+  ParsedQuicVersion version = client_framer_.version();
+  for (QuicPacketNumberLength pn_length :
+       {PACKET_1BYTE_PACKET_NUMBER, PACKET_2BYTE_PACKET_NUMBER,
+        PACKET_3BYTE_PACKET_NUMBER, PACKET_4BYTE_PACKET_NUMBER}) {
+    if (!version.HasHeaderProtection()) {
+      EXPECT_EQ(creator_.MinPlaintextPacketSize(version, pn_length), 0);
+    } else if (!GetQuicRestartFlag(quic_allow_smaller_packets)) {
+      EXPECT_EQ(creator_.MinPlaintextPacketSize(version, pn_length), 7);
+    } else {
+      EXPECT_EQ(creator_.MinPlaintextPacketSize(version, pn_length),
+                (version.UsesTls() ? 4 : 8) - pn_length);
+    }
+  }
+}
+
+// A variant of StreamFrameConsumption that tests when expansion of the stream
+// frame puts it at or over the max length, but the packet is supposed to be
+// padded to max length.
+TEST_P(QuicPacketCreatorTest, PadWhenAlmostMaxLength) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+  // Compute the total overhead for a single frame in packet.
+  const size_t overhead =
+      GetPacketHeaderOverhead(client_framer_.transport_version()) +
+      GetEncryptionOverhead() +
+      GetStreamFrameOverhead(client_framer_.transport_version());
+  size_t capacity = kDefaultMaxPacketSize - overhead;
+  for (size_t bytes_free = 1; bytes_free <= 2; bytes_free++) {
+    std::string data(capacity - bytes_free, 'A');
+
+    QuicFrame frame;
+    ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+        GetNthClientInitiatedStreamId(1), data, kOffset, false,
+        /*needs_full_padding=*/true, 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.
+    EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
+    EXPECT_EQ(0u, creator_.BytesFree());
+    EXPECT_CALL(delegate_, OnSerializedPacket(_))
+        .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+    creator_.FlushCurrentPacket();
+    /* Without the fix, the packet is not full-length. */
+    if (GetQuicRestartFlag(quic_allow_smaller_packets)) {
+      EXPECT_EQ(serialized_packet_->encrypted_length, kDefaultMaxPacketSize);
+    } else {
+      EXPECT_EQ(serialized_packet_->encrypted_length,
+                kDefaultMaxPacketSize - bytes_free);
+    }
+    DeleteSerializedPacket();
+  }
+}
+
+TEST_P(QuicPacketCreatorTest, MorePendingPaddingThanBytesFree) {
+  creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
+  // Compute the total overhead for a single frame in packet.
+  const size_t overhead =
+      GetPacketHeaderOverhead(client_framer_.transport_version()) +
+      GetEncryptionOverhead() +
+      GetStreamFrameOverhead(client_framer_.transport_version());
+  size_t capacity = kDefaultMaxPacketSize - overhead;
+  const size_t pending_padding = 10;
+  std::string data(capacity - pending_padding, 'A');
+  QuicFrame frame;
+  // The stream frame means that BytesFree() will be less than the
+  // available space, because of the frame length field.
+  ASSERT_TRUE(creator_.ConsumeDataToFillCurrentPacket(
+      GetNthClientInitiatedStreamId(1), data, kOffset, false,
+      /*needs_full_padding=*/false, NOT_RETRANSMISSION, &frame));
+  creator_.AddPendingPadding(pending_padding);
+  EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
+  // BytesFree() does not know about pending_padding because that's added
+  // when flushed.
+  EXPECT_EQ(pending_padding - 2u, creator_.BytesFree());
+  EXPECT_CALL(delegate_, OnSerializedPacket(_))
+      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+  creator_.FlushCurrentPacket();
+  /* Without the fix, the packet is not full-length. */
+  EXPECT_EQ(serialized_packet_->encrypted_length, kDefaultMaxPacketSize);
+  DeleteSerializedPacket();
+}
+
 class MockDelegate : public QuicPacketCreator::DelegateInterface {
  public:
   MockDelegate() {}
@@ -2603,7 +2735,6 @@
     if (num_retransmittable_frames == 0) {
       ASSERT_TRUE(packet.retransmittable_frames.empty());
     } else {
-      ASSERT_FALSE(packet.retransmittable_frames.empty());
       EXPECT_EQ(num_retransmittable_frames,
                 packet.retransmittable_frames.size());
     }
@@ -2926,7 +3057,8 @@
     // frames, so the expected packet length differs slightly.
     expected_packet_length = 32;
   }
-  if (framer_.version().HasHeaderProtection()) {
+  if (framer_.version().HasHeaderProtection() &&
+      !GetQuicRestartFlag(quic_allow_smaller_packets)) {
     expected_packet_length = 33;
   }
   EXPECT_EQ(expected_packet_length, packets_[0].encrypted_length);
@@ -3872,18 +4004,22 @@
     return;
   }
   delegate_.SetCanWriteAnything();
-
+  // If the packet number length > 1, we won't get padding.
+  EXPECT_EQ(QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
+            PACKET_1BYTE_PACKET_NUMBER);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(
           Invoke(this, &QuicPacketCreatorMultiplePacketsTest::SavePacket));
+  // with no data and no offset, this is a 2B STREAM frame.
   creator_.ConsumeData(QuicUtils::GetFirstBidirectionalStreamId(
                            framer_.transport_version(), Perspective::IS_CLIENT),
-                       "a", 0, FIN);
+                       "", 0, FIN);
   creator_.Flush();
   ASSERT_FALSE(packets_[0].nonretransmittable_frames.empty());
   QuicFrame padding = packets_[0].nonretransmittable_frames[0];
   // Verify stream frame expansion is excluded.
-  EXPECT_EQ(3, padding.padding_frame.num_padding_bytes);
+  EXPECT_EQ(padding.padding_frame.num_padding_bytes,
+            GetQuicRestartFlag(quic_allow_smaller_packets) ? 1 : 4);
 }
 
 TEST_F(QuicPacketCreatorMultiplePacketsTest,
diff --git a/quiche/quic/test_tools/quic_test_utils.cc b/quiche/quic/test_tools/quic_test_utils.cc
index 8063aa2..62c8f69 100644
--- a/quiche/quic/test_tools/quic_test_utils.cc
+++ b/quiche/quic/test_tools/quic_test_utils.cc
@@ -939,8 +939,8 @@
     // We need a minimum number of bytes of encrypted payload. This will
     // guarantee that we have at least that much. (It ignores the overhead of
     // the stream/crypto framing, so it overpads slightly.)
-    size_t min_plaintext_size =
-        QuicPacketCreator::MinPlaintextPacketSize(version);
+    size_t min_plaintext_size = QuicPacketCreator::MinPlaintextPacketSize(
+        version, packet_number_length);
     if (data.length() < min_plaintext_size) {
       size_t padding_length = min_plaintext_size - data.length();
       frames.push_back(QuicFrame(QuicPaddingFrame(padding_length)));