diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index b01906d..3d1e483 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -5354,89 +5354,35 @@
   if (connection_.SupportsMultiplePacketNumberSpaces()) {
     return;
   }
-  // All packets carry version info till version is negotiated.
-  size_t payload_length;
-  size_t length = GetPacketLengthForOneStream(
-      connection_.version().transport_version, kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID,
-      QuicPacketCreatorPeer::GetPacketNumberLength(creator_),
-      QuicPacketCreatorPeer::GetRetryTokenLengthLength(creator_),
-      QuicPacketCreatorPeer::GetLengthLength(creator_), &payload_length);
-  connection_.SetMaxPacketLength(length);
 
   // Queue the first packet.
+  size_t payload_length = connection_.max_packet_length();
   EXPECT_CALL(*send_algorithm_, CanSend(_)).WillOnce(testing::Return(false));
   const std::string payload(payload_length, 'a');
-  EXPECT_EQ(0u, connection_.SendStreamDataWithString(3, payload, 0, NO_FIN)
+  QuicStreamId first_bidi_stream_id(QuicUtils::GetFirstBidirectionalStreamId(
+      connection_.version().transport_version, Perspective::IS_CLIENT));
+  EXPECT_EQ(0u, connection_
+                    .SendStreamDataWithString(first_bidi_stream_id, payload, 0,
+                                              NO_FIN)
                     .bytes_consumed);
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
-TEST_P(QuicConnectionTest, LoopThroughSendingPackets) {
+TEST_P(QuicConnectionTest, SendingThreePackets) {
   if (connection_.SupportsMultiplePacketNumberSpaces()) {
     return;
   }
-  // All packets carry version info till version is negotiated.
-  size_t payload_length;
 
-  // Number of packets this test generates. The goal is to have
-  // kPacketCount packets, each the same size (overhead and payload).
-  // The payload will vary depending on the overhead (which in turn
-  // varies per the QUIC packet encoding rules).
-  const int kPacketCount = 7;
-
-  // Get the basic packet size. This assumes, among other things, a
-  // stream offset of 0.
-  size_t length = GetPacketLengthForOneStream(
-      connection_.version().transport_version, kIncludeVersion,
-      !kIncludeDiversificationNonce, PACKET_8BYTE_CONNECTION_ID,
-      PACKET_0BYTE_CONNECTION_ID,
-      QuicPacketCreatorPeer::GetPacketNumberLength(creator_),
-      QuicPacketCreatorPeer::GetRetryTokenLengthLength(creator_),
-      QuicPacketCreatorPeer::GetLengthLength(creator_), &payload_length);
-  // GetPacketLengthForOneStream() assumes a stream offset of 0 in determining
-  // packet length. The size of the offset field in a stream frame is
-  // 0 for offset 0, and 2 for non-zero offsets up through 16K (for
-  // versions other than 99) and 1 for non-zero offsets through 16K
-  // for version 99. Increase the length by 1 or 2, as apporpriate, so
-  // that subsequent packets containing subsequent stream frames with
-  // non-zero offsets will fit within the packet length.
-  if (connection_.version().transport_version == QUIC_VERSION_99) {
-    length = length + 1;
-  } else {
-    length = length + 2;
-  }
-
-  connection_.SetMaxPacketLength(length);
-
-  // Queue the first packet.
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
-      .Times(kPacketCount);
-
-  size_t total_payload_length = payload_length * kPacketCount;
-  // The first frame of the stream is at offset 0. When the offset is
-  // 0, it is not included in the stream frame. Increase the total
-  // payload so that the "missing" offset byte in the first packet is
-  // occupied by a payload byte. The net result is that each of the N
-  // packets of the test will contain a single stream frame, each of
-  // which will be the same size (overhead + data).
-  if (connection_.version().transport_version == QUIC_VERSION_99) {
-    // Version 99 encodes the offset in 1 byte for the scope of this test.
-    total_payload_length = total_payload_length + 1;
-  } else {
-    // Versions other than 99 encode the offset in 2 bytes for the
-    // scope of this test.
-    total_payload_length = total_payload_length + 2;
-  }
+  // Make the payload twice the size of the packet, so 3 packets are written.
+  size_t total_payload_length = 2 * connection_.max_packet_length();
   const std::string payload(total_payload_length, 'a');
-
-  EXPECT_EQ(payload.size(),
-            connection_
-                .SendStreamDataWithString(QuicUtils::GetCryptoStreamId(
-                                              connection_.transport_version()),
-                                          payload, 0, NO_FIN)
-                .bytes_consumed);
+  QuicStreamId first_bidi_stream_id(QuicUtils::GetFirstBidirectionalStreamId(
+      connection_.version().transport_version, Perspective::IS_CLIENT));
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
+  EXPECT_EQ(payload.size(), connection_
+                                .SendStreamDataWithString(first_bidi_stream_id,
+                                                          payload, 0, NO_FIN)
+                                .bytes_consumed);
 }
 
 TEST_P(QuicConnectionTest, LoopThroughSendingPacketsWithTruncation) {
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index 45f2651..1cdc3e4 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -1197,18 +1197,9 @@
   }
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
   // A string larger than fits into a frame.
-  size_t payload_length;
-  creator_.SetMaxPacketLength(GetPacketLengthForOneStream(
-      client_framer_.transport_version(),
-      QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-      !kIncludeDiversificationNonce,
-      creator_.GetDestinationConnectionIdLength(),
-      creator_.GetSourceConnectionIdLength(),
-      QuicPacketCreatorPeer::GetPacketNumberLength(&creator_),
-      QuicPacketCreatorPeer::GetRetryTokenLengthLength(&creator_),
-      QuicPacketCreatorPeer::GetLengthLength(&creator_), &payload_length));
   QuicFrame frame;
-  const std::string too_long_payload(payload_length * 2, 'a');
+  size_t payload_length = creator_.max_packet_length();
+  const std::string too_long_payload(payload_length, 'a');
   MakeIOVector(too_long_payload, &iov_);
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ -1217,9 +1208,8 @@
   ASSERT_TRUE(creator_.ConsumeData(stream_id, &iov_, 1u, iov_.iov_len, 0u, 0u,
                                    true, false, NOT_RETRANSMISSION, &frame));
   size_t consumed = frame.stream_frame.data_length;
-  EXPECT_EQ(payload_length, consumed);
-  const std::string payload(payload_length, 'a');
-  CheckStreamFrame(frame, stream_id, payload, 0u, false);
+  // The entire payload could not be consumed.
+  EXPECT_GT(payload_length, consumed);
   creator_.Flush();
   DeleteSerializedPacket();
 }
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index c80a055..db57071 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -982,45 +982,6 @@
                 << HexDumpWithMarks(actual, actual_len, marks.get(), max_len);
 }
 
-size_t GetPacketLengthForOneStream(
-    QuicTransportVersion version,
-    bool include_version,
-    bool include_diversification_nonce,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length,
-    QuicPacketNumberLength packet_number_length,
-    QuicVariableLengthIntegerLength retry_token_length_length,
-    QuicVariableLengthIntegerLength length_length,
-    size_t* payload_length) {
-  *payload_length = 1;
-  const size_t stream_length =
-      NullEncrypter(Perspective::IS_CLIENT).GetCiphertextSize(*payload_length) +
-      QuicPacketCreator::StreamFramePacketOverhead(
-          version, destination_connection_id_length,
-          source_connection_id_length, include_version,
-          include_diversification_nonce, packet_number_length,
-          retry_token_length_length, length_length, 0u);
-  const size_t ack_length =
-      NullEncrypter(Perspective::IS_CLIENT)
-          .GetCiphertextSize(QuicFramer::GetMinAckFrameSize(
-              version, PACKET_1BYTE_PACKET_NUMBER)) +
-      GetPacketHeaderSize(version, destination_connection_id_length,
-                          source_connection_id_length, include_version,
-                          include_diversification_nonce, packet_number_length,
-                          retry_token_length_length, 0, length_length);
-  if (stream_length < ack_length) {
-    *payload_length = 1 + ack_length - stream_length;
-  }
-
-  return NullEncrypter(Perspective::IS_CLIENT)
-             .GetCiphertextSize(*payload_length) +
-         QuicPacketCreator::StreamFramePacketOverhead(
-             version, destination_connection_id_length,
-             source_connection_id_length, include_version,
-             include_diversification_nonce, packet_number_length,
-             retry_token_length_length, length_length, 0u);
-}
-
 QuicConfig DefaultQuicConfig() {
   QuicConfig config;
   config.SetInitialStreamFlowControlWindowToSend(
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index f61bd25..00c9748 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -158,20 +158,6 @@
                                    const char* expected,
                                    const int expected_len);
 
-// Returns the length of a QuicPacket that is capable of holding either a
-// stream frame or a minimal ack frame.  Sets |*payload_length| to the number
-// of bytes of stream data that will fit in such a packet.
-size_t GetPacketLengthForOneStream(
-    QuicTransportVersion version,
-    bool include_version,
-    bool include_diversification_nonce,
-    QuicConnectionIdLength destination_connection_id_length,
-    QuicConnectionIdLength source_connection_id_length,
-    QuicPacketNumberLength packet_number_length,
-    QuicVariableLengthIntegerLength retry_token_length_length,
-    QuicVariableLengthIntegerLength length_length,
-    size_t* payload_length);
-
 // Returns QuicConfig set to default values.
 QuicConfig DefaultQuicConfig();