diff --git a/quic/core/chlo_extractor_test.cc b/quic/core/chlo_extractor_test.cc
index 57d8925..cea445d 100644
--- a/quic/core/chlo_extractor_test.cc
+++ b/quic/core/chlo_extractor_test.cc
@@ -99,7 +99,7 @@
   TestDelegate delegate_;
   QuicPacketHeader header_;
   std::unique_ptr<QuicEncryptedPacket> packet_;
-  char buffer_[kMaxPacketSize];
+  char buffer_[kMaxOutgoingPacketSize];
 };
 
 TEST_F(ChloExtractorTest, FindsValidChlo) {
diff --git a/quic/core/congestion_control/bbr_sender.cc b/quic/core/congestion_control/bbr_sender.cc
index 9de79cd..1c0d274 100644
--- a/quic/core/congestion_control/bbr_sender.cc
+++ b/quic/core/congestion_control/bbr_sender.cc
@@ -686,7 +686,7 @@
       // we allow an extra packet since QUIC checks CWND before sending a
       // packet.
       if (unacked_packets_->bytes_in_flight() <
-          ProbeRttCongestionWindow() + kMaxPacketSize) {
+          ProbeRttCongestionWindow() + kMaxOutgoingPacketSize) {
         exit_probe_rtt_at_ = now + kProbeRttTime;
         probe_rtt_round_passed_ = false;
       }
diff --git a/quic/core/congestion_control/bbr_sender_test.cc b/quic/core/congestion_control/bbr_sender_test.cc
index b3ed286..3d40e0a 100644
--- a/quic/core/congestion_control/bbr_sender_test.cc
+++ b/quic/core/congestion_control/bbr_sender_test.cc
@@ -63,8 +63,8 @@
 const QuicTime::Delta kLocalPropagationDelay =
     QuicTime::Delta::FromMilliseconds(2);
 const QuicTime::Delta kTestTransferTime =
-    kTestLinkBandwidth.TransferTime(kMaxPacketSize) +
-    kLocalLinkBandwidth.TransferTime(kMaxPacketSize);
+    kTestLinkBandwidth.TransferTime(kMaxOutgoingPacketSize) +
+    kLocalLinkBandwidth.TransferTime(kMaxOutgoingPacketSize);
 const QuicTime::Delta kTestRtt =
     (kTestPropagationDelay + kLocalPropagationDelay + kTestTransferTime) * 2;
 const QuicByteCount kTestBdp = kTestRtt * kTestLinkBandwidth;
@@ -1091,7 +1091,8 @@
   QuicBandwidth pacing_rate = original_pacing_rate;
   const QuicByteCount original_cwnd = sender_->GetCongestionWindow();
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(), kMaxOutgoingPacketSize));
   QuicPacketNumber largest_sent =
       bbr_sender_.connection()->sent_packet_manager().GetLargestSentPacket();
   for (QuicPacketNumber packet_number =
@@ -1141,7 +1142,8 @@
   QuicBandwidth pacing_rate = original_pacing_rate;
   const QuicByteCount original_cwnd = sender_->GetCongestionWindow();
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(), kMaxOutgoingPacketSize));
   QuicPacketNumber largest_sent =
       bbr_sender_.connection()->sent_packet_manager().GetLargestSentPacket();
   for (QuicPacketNumber packet_number =
diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc
index c6e0145..0172dfc 100644
--- a/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -92,20 +92,20 @@
   AckedPacketVector packets_acked;
   // No loss on one ack.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // No loss on two acks.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(3, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // Loss on three acks.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, {1});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -121,14 +121,14 @@
   AckedPacketVector packets_acked;
   // Nack the first packet 3 times in a single StretchAck.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, {1});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -143,8 +143,8 @@
   AckedPacketVector packets_acked;
   // Nack the first packet 3 times in an AckFrame with three missing packets.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, {1});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -158,8 +158,8 @@
   AckedPacketVector packets_acked;
   // Early retransmit when the final packet gets acked and the first is nacked.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   EXPECT_EQ(clock_.Now() + 1.25 * rtt_stats_.smoothed_rtt(),
@@ -184,7 +184,8 @@
   // elapsed since the packets were sent.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(kNumSentPackets));
   packets_acked.push_back(AckedPacket(QuicPacketNumber(kNumSentPackets),
-                                      kMaxPacketSize, QuicTime::Zero()));
+                                      kMaxOutgoingPacketSize,
+                                      QuicTime::Zero()));
   // This simulates a single ack following multiple missing packets with FACK.
   VerifyLosses(kNumSentPackets, packets_acked, {1, 2});
   packets_acked.clear();
@@ -221,8 +222,8 @@
     unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
   }
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   EXPECT_EQ(clock_.Now() + 0.25 * rtt_stats_.smoothed_rtt(),
             loss_algorithm_.GetLossTimeout());
@@ -244,8 +245,8 @@
     unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
   }
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   EXPECT_EQ(clock_.Now() + 0.25 * rtt_stats_.smoothed_rtt(),
@@ -276,8 +277,8 @@
     unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
   }
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, {1});
 }
 
@@ -292,20 +293,20 @@
   AckedPacketVector packets_acked;
   // No loss on one ack.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // No loss on two acks.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(3, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // Loss on three acks.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, {1});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -323,22 +324,22 @@
   AckedPacketVector packets_acked;
   // Nack the first packet 3 times in a single StretchAck.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(3));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(3), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(3), kMaxOutgoingPacketSize, QuicTime::Zero()));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // The timer isn't set because we expect more acks.
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // Process another ack and then packet 1 will be lost.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(5), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(5), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(5, packets_acked, {1});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -354,16 +355,16 @@
   AckedPacketVector packets_acked;
   // Nack the first packet 3 times in an AckFrame with three missing packets.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(4));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(4), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(4), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(4, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // The timer isn't set because we expect more acks.
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // Process another ack and then packet 1 and 2 will be lost.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(5));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(5), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(5), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(5, packets_acked, {1, 2});
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
 }
@@ -378,8 +379,8 @@
   }
   AckedPacketVector packets_acked;
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   for (size_t i = 1; i < 500; ++i) {
     VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
     packets_acked.clear();
@@ -406,8 +407,8 @@
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // The packet should not be lost until 1.25 RTTs pass.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -438,8 +439,8 @@
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // The packet should not be lost without a nack.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(1));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(1), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(1), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(1, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // The timer should still not be set.
@@ -465,8 +466,8 @@
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // The packet should not be lost until 1.25 RTTs pass.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(10));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(10), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(10), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(10, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -497,8 +498,8 @@
   // The packet should not be lost until 1.25 RTTs pass.
 
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(10));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(10), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(10), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(10, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   if (GetQuicReloadableFlag(quic_eighth_rtt_loss_detection)) {
@@ -515,8 +516,8 @@
   // are lost.
   for (uint64_t i = 1; i <= 9; ++i) {
     unacked_packets_.RemoveFromInFlight(QuicPacketNumber(i));
-    packets_acked.push_back(
-        AckedPacket(QuicPacketNumber(i), kMaxPacketSize, QuicTime::Zero()));
+    packets_acked.push_back(AckedPacket(
+        QuicPacketNumber(i), kMaxOutgoingPacketSize, QuicTime::Zero()));
     VerifyLosses(i, packets_acked, std::vector<uint64_t>{});
     packets_acked.clear();
     EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
@@ -538,8 +539,8 @@
   EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
   // Packet 1 should not be lost until 1/16 RTTs pass.
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
-  packets_acked.push_back(
-      AckedPacket(QuicPacketNumber(2), kMaxPacketSize, QuicTime::Zero()));
+  packets_acked.push_back(AckedPacket(
+      QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
   VerifyLosses(2, packets_acked, std::vector<uint64_t>{});
   packets_acked.clear();
   // Expect the timer to be set to 1/16 RTT's in the future.
diff --git a/quic/core/congestion_control/pacing_sender_test.cc b/quic/core/congestion_control/pacing_sender_test.cc
index 3ed881a..ea9debf 100644
--- a/quic/core/congestion_control/pacing_sender_test.cc
+++ b/quic/core/congestion_control/pacing_sender_test.cc
@@ -52,7 +52,8 @@
     if (burst_size == 0) {
       EXPECT_CALL(*mock_sender_, OnCongestionEvent(_, _, _, _, _));
       LostPacketVector lost_packets;
-      lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+      lost_packets.push_back(
+          LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
       AckedPacketVector empty;
       pacing_sender_->OnCongestionEvent(true, 1234, clock_.Now(), empty,
                                         lost_packets);
@@ -84,15 +85,16 @@
     }
     EXPECT_CALL(*mock_sender_,
                 OnPacketSent(clock_.Now(), bytes_in_flight, packet_number_,
-                             kMaxPacketSize, retransmittable_data));
+                             kMaxOutgoingPacketSize, retransmittable_data));
     EXPECT_CALL(*mock_sender_, GetCongestionWindow())
         .Times(AtMost(1))
         .WillRepeatedly(Return(cwnd * kDefaultTCPMSS));
-    EXPECT_CALL(*mock_sender_, CanSend(bytes_in_flight + kMaxPacketSize))
+    EXPECT_CALL(*mock_sender_,
+                CanSend(bytes_in_flight + kMaxOutgoingPacketSize))
         .Times(AtMost(1))
         .WillRepeatedly(Return(!cwnd_limited));
     pacing_sender_->OnPacketSent(clock_.Now(), bytes_in_flight,
-                                 packet_number_++, kMaxPacketSize,
+                                 packet_number_++, kMaxOutgoingPacketSize,
                                  retransmittable_data);
   }
 
@@ -151,8 +153,9 @@
 
 TEST_F(PacingSenderTest, VariousSending) {
   // Configure pacing rate of 1 packet per 1 ms, no initial burst.
-  InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
-                        kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      0, QuicBandwidth::FromBytesAndTimeDelta(
+             kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   // Now update the RTT and verify that packets are actually paced.
   UpdateRtt();
@@ -206,8 +209,9 @@
 
 TEST_F(PacingSenderTest, InitialBurst) {
   // Configure pacing rate of 1 packet per 1 ms.
-  InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
-                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      10, QuicBandwidth::FromBytesAndTimeDelta(
+              kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   // Update the RTT and verify that the first 10 packets aren't paced.
   UpdateRtt();
@@ -242,8 +246,9 @@
 
 TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
   // Configure pacing rate of 1 packet per 1 ms.
-  InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
-                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      10, QuicBandwidth::FromBytesAndTimeDelta(
+              kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   // Send 10 packets, and verify that they are not paced.
   for (int i = 0; i < kInitialBurstPackets; ++i) {
@@ -277,9 +282,9 @@
 TEST_F(PacingSenderTest, FastSending) {
   // Ensure the pacing sender paces, even when the inter-packet spacing is less
   // than the pacing granularity.
-  InitPacingRate(10,
-                 QuicBandwidth::FromBytesAndTimeDelta(
-                     2 * kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
+                         2 * kMaxOutgoingPacketSize,
+                         QuicTime::Delta::FromMilliseconds(1)));
   // Update the RTT and verify that the first 10 packets aren't paced.
   UpdateRtt();
 
@@ -315,18 +320,20 @@
 
 TEST_F(PacingSenderTest, NoBurstEnteringRecovery) {
   // Configure pacing rate of 1 packet per 1 ms with no burst tokens.
-  InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
-                        kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      0, QuicBandwidth::FromBytesAndTimeDelta(
+             kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
   // Sending a packet will set burst tokens.
   CheckPacketIsSentImmediately();
 
   // Losing a packet will set clear burst tokens.
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
   AckedPacketVector empty_acked;
   EXPECT_CALL(*mock_sender_,
-              OnCongestionEvent(true, kMaxPacketSize, _, IsEmpty(), _));
-  pacing_sender_->OnCongestionEvent(true, kMaxPacketSize, clock_.Now(),
+              OnCongestionEvent(true, kMaxOutgoingPacketSize, _, IsEmpty(), _));
+  pacing_sender_->OnCongestionEvent(true, kMaxOutgoingPacketSize, clock_.Now(),
                                     empty_acked, lost_packets);
   // One packet is sent immediately, because of 1ms pacing granularity.
   CheckPacketIsSentImmediately();
@@ -340,8 +347,9 @@
 
 TEST_F(PacingSenderTest, NoBurstInRecovery) {
   // Configure pacing rate of 1 packet per 1 ms with no burst tokens.
-  InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
-                        kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      0, QuicBandwidth::FromBytesAndTimeDelta(
+             kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   UpdateRtt();
 
@@ -353,8 +361,9 @@
 
 TEST_F(PacingSenderTest, CwndLimited) {
   // Configure pacing rate of 1 packet per 1 ms, no initial burst.
-  InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
-                        kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      0, QuicBandwidth::FromBytesAndTimeDelta(
+             kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   UpdateRtt();
 
@@ -382,8 +391,9 @@
   SetQuicFlag(&FLAGS_quic_lumpy_pacing_size, 3);
   SetQuicFlag(&FLAGS_quic_lumpy_pacing_cwnd_fraction, 0.5f);
   // Configure pacing rate of 1 packet per 1 ms.
-  InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
-                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  InitPacingRate(
+      10, QuicBandwidth::FromBytesAndTimeDelta(
+              kMaxOutgoingPacketSize, QuicTime::Delta::FromMilliseconds(1)));
   UpdateRtt();
 
   // Send 10 packets, and verify that they are not paced.
@@ -438,8 +448,9 @@
 
   // Configure pacing rate of 1 packet per 100 ms.
   QuicTime::Delta inter_packet_delay = QuicTime::Delta::FromMilliseconds(100);
-  InitPacingRate(kInitialBurstPackets, QuicBandwidth::FromBytesAndTimeDelta(
-                                           kMaxPacketSize, inter_packet_delay));
+  InitPacingRate(kInitialBurstPackets,
+                 QuicBandwidth::FromBytesAndTimeDelta(kMaxOutgoingPacketSize,
+                                                      inter_packet_delay));
   UpdateRtt();
 
   // Send kInitialBurstPackets packets, and verify that they are not paced.
diff --git a/quic/core/congestion_control/send_algorithm_test.cc b/quic/core/congestion_control/send_algorithm_test.cc
index b2fa2f8..c07508c 100644
--- a/quic/core/congestion_control/send_algorithm_test.cc
+++ b/quic/core/congestion_control/send_algorithm_test.cc
@@ -63,8 +63,8 @@
 const QuicTime::Delta kTestLinkWiredPropagationDelay =
     QuicTime::Delta::FromMilliseconds(50);
 const QuicTime::Delta kTestWiredTransferTime =
-    kTestLinkWiredBandwidth.TransferTime(kMaxPacketSize) +
-    kLocalLinkBandwidth.TransferTime(kMaxPacketSize);
+    kTestLinkWiredBandwidth.TransferTime(kMaxOutgoingPacketSize) +
+    kLocalLinkBandwidth.TransferTime(kMaxOutgoingPacketSize);
 const QuicTime::Delta kTestWiredRtt =
     (kTestLinkWiredPropagationDelay + kLocalPropagationDelay +
      kTestWiredTransferTime) *
@@ -79,7 +79,7 @@
     QuicBandwidth::FromKBitsPerSecond(200);
 const QuicTime::Delta kTestLinkLowBdpPropagationDelay =
     QuicTime::Delta::FromMilliseconds(50);
-const QuicByteCount kTestPolicerQueue = kMaxPacketSize;
+const QuicByteCount kTestPolicerQueue = kMaxOutgoingPacketSize;
 
 // Satellite network settings.  In a satellite network, the bottleneck
 // buffer is typically sized for non-satellite links , but the
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index ee61e42..2945214 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -50,8 +50,8 @@
     packets_acked_.clear();
     for (uint64_t acked : packets_acked) {
       unacked_packets_->RemoveFromInFlight(QuicPacketNumber(acked));
-      packets_acked_.push_back(AckedPacket(QuicPacketNumber(acked),
-                                           kMaxPacketSize, QuicTime::Zero()));
+      packets_acked_.push_back(AckedPacket(
+          QuicPacketNumber(acked), kMaxOutgoingPacketSize, QuicTime::Zero()));
     }
   }
 
diff --git a/quic/core/crypto/quic_crypto_server_config.cc b/quic/core/crypto/quic_crypto_server_config.cc
index 478e929..88875be 100644
--- a/quic/core/crypto/quic_crypto_server_config.cc
+++ b/quic/core/crypto/quic_crypto_server_config.cc
@@ -910,11 +910,11 @@
       return;
     }
 
-    char plaintext[kMaxPacketSize];
+    char plaintext[kMaxOutgoingPacketSize];
     size_t plaintext_length = 0;
     const bool success = crypters.decrypter->DecryptPacket(
         0 /* packet number */, QuicStringPiece() /* associated data */,
-        cetv_ciphertext, plaintext, &plaintext_length, kMaxPacketSize);
+        cetv_ciphertext, plaintext, &plaintext_length, kMaxOutgoingPacketSize);
     if (!success) {
       context->Fail(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
                     "CETV decryption failure");
diff --git a/quic/core/crypto/transport_parameters.cc b/quic/core/crypto/transport_parameters.cc
index f225785..60fb22c 100644
--- a/quic/core/crypto/transport_parameters.cc
+++ b/quic/core/crypto/transport_parameters.cc
@@ -19,7 +19,7 @@
   kInitialMaxDataId = 1,
   kInitialMaxBidiStreamsId = 2,
   kIdleTimeoutId = 3,
-  kMaxPacketSizeId = 5,
+  kMaxOutgoingPacketSizeId = 5,
   kStatelessResetTokenId = 6,
   kAckDelayExponentId = 7,
   kInitialMaxUniStreamsId = 8,
@@ -150,7 +150,7 @@
   }
   CBB max_packet_size_param;
   if (in.max_packet_size.present) {
-    if (!CBB_add_u16(&params, kMaxPacketSizeId) ||
+    if (!CBB_add_u16(&params, kMaxOutgoingPacketSizeId) ||
         !CBB_add_u16_length_prefixed(&params, &max_packet_size_param) ||
         !CBB_add_u16(&max_packet_size_param, in.max_packet_size.value)) {
       return false;
@@ -255,7 +255,7 @@
           return false;
         }
         break;
-      case kMaxPacketSizeId:
+      case kMaxOutgoingPacketSizeId:
         if (!CBS_get_u16(&value, &out->max_packet_size.value) ||
             CBS_len(&value) != 0) {
           return false;
diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 6935dee..753b951 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -918,7 +918,7 @@
 TEST_P(EndToEndTestWithTls, RequestOverMultiplePackets) {
   // Send a large enough request to guarantee fragmentation.
   std::string huge_request =
-      "/some/path?query=" + std::string(kMaxPacketSize, '.');
+      "/some/path?query=" + std::string(kMaxOutgoingPacketSize, '.');
   AddToCache(huge_request, 200, kBarResponseBody);
 
   ASSERT_TRUE(Initialize());
@@ -930,7 +930,7 @@
 TEST_P(EndToEndTestWithTls, MultiplePacketsRandomOrder) {
   // Send a large enough request to guarantee fragmentation.
   std::string huge_request =
-      "/some/path?query=" + std::string(kMaxPacketSize, '.');
+      "/some/path?query=" + std::string(kMaxOutgoingPacketSize, '.');
   AddToCache(huge_request, 200, kBarResponseBody);
 
   ASSERT_TRUE(Initialize());
@@ -1426,7 +1426,7 @@
   ASSERT_TRUE(Initialize());
   EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
-  std::string body(kMaxPacketSize, 'a');
+  std::string body(kMaxOutgoingPacketSize, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
@@ -1450,7 +1450,7 @@
   ASSERT_TRUE(Initialize());
   EXPECT_TRUE(client_->client()->WaitForCryptoHandshakeConfirmed());
 
-  std::string body(kMaxPacketSize, 'a');
+  std::string body(kMaxOutgoingPacketSize, 'a');
   SpdyHeaderBlock headers;
   headers[":method"] = "POST";
   headers[":path"] = "/foo";
@@ -2267,7 +2267,7 @@
   // Test the AckNotifier's ability to track multiple packets by making the
   // request body exceed the size of a single packet.
   std::string request_string = "a request body bigger than one packet" +
-                               std::string(kMaxPacketSize, '.');
+                               std::string(kMaxOutgoingPacketSize, '.');
 
   // The TestAckListener will cause a failure if not notified.
   QuicReferenceCountedPointer<TestAckListener> ack_listener(
@@ -2802,7 +2802,7 @@
   // update.  This allows headers processing to trigger the error response
   // before the request FIN is processed but receive the request FIN before the
   // response is sent completely.
-  const uint32_t kRequestBodySize = kMaxPacketSize + 10;
+  const uint32_t kRequestBodySize = kMaxOutgoingPacketSize + 10;
   std::string request_body(kRequestBodySize, 'a');
 
   // Send the request.
@@ -3552,10 +3552,11 @@
   }
 
   SetPacketLossPercentage(30);
-  ASSERT_GT(kMaxPacketSize, client_session->GetCurrentLargestMessagePayload());
+  ASSERT_GT(kMaxOutgoingPacketSize,
+            client_session->GetCurrentLargestMessagePayload());
   ASSERT_LT(0, client_session->GetCurrentLargestMessagePayload());
 
-  std::string message_string(kMaxPacketSize, 'a');
+  std::string message_string(kMaxOutgoingPacketSize, 'a');
   QuicStringPiece message_buffer(message_string);
   QuicRandom* random =
       QuicConnectionPeer::GetHelper(client_connection)->GetRandomGenerator();
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 190c0ed..e6e7f57 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -703,7 +703,7 @@
 
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(*send_algorithm, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 10));
+      .WillRepeatedly(Return(kMaxOutgoingPacketSize * 10));
   EXPECT_CALL(*send_algorithm, InRecovery()).WillRepeatedly(Return(false));
   EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
     session_.SendStreamData(stream2);
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 822b269..d90413a 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -2251,8 +2251,9 @@
       packet_generator_.FlushAllQueuedFrames();
     }
     DCHECK(!packet_generator_.HasQueuedFrames());
-    char buffer[kMaxPacketSize];
-    packet_generator_.ReserializeAllFrames(pending, buffer, kMaxPacketSize);
+    char buffer[kMaxOutgoingPacketSize];
+    packet_generator_.ReserializeAllFrames(pending, buffer,
+                                           kMaxOutgoingPacketSize);
   }
 }
 
@@ -2420,7 +2421,7 @@
     }
   }
 
-  DCHECK_LE(encrypted_length, kMaxPacketSize);
+  DCHECK_LE(encrypted_length, kMaxOutgoingPacketSize);
   DCHECK_LE(encrypted_length, packet_generator_.GetCurrentMaxPacketLength());
   QUIC_DVLOG(1) << ENDPOINT << "Sending packet " << packet_number << " : "
                 << (IsRetransmittable(*packet) == HAS_RETRANSMITTABLE_DATA
@@ -3427,8 +3428,8 @@
   if (max_packet_size > writer_limit) {
     max_packet_size = writer_limit;
   }
-  if (max_packet_size > kMaxPacketSize) {
-    max_packet_size = kMaxPacketSize;
+  if (max_packet_size > kMaxOutgoingPacketSize) {
+    max_packet_size = kMaxOutgoingPacketSize;
   }
   return max_packet_size;
 }
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 8176934..7f8b8c8 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -77,9 +77,9 @@
 const QuicByteCount kMtuDiscoveryTargetPacketSizeHigh = 1450;
 const QuicByteCount kMtuDiscoveryTargetPacketSizeLow = 1430;
 
-static_assert(kMtuDiscoveryTargetPacketSizeLow <= kMaxPacketSize,
+static_assert(kMtuDiscoveryTargetPacketSizeLow <= kMaxOutgoingPacketSize,
               "MTU discovery target is too large");
-static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxPacketSize,
+static_assert(kMtuDiscoveryTargetPacketSizeHigh <= kMaxOutgoingPacketSize,
               "MTU discovery target is too large");
 
 static_assert(kMtuDiscoveryTargetPacketSizeLow > kDefaultMaxPacketSize,
diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index b36f888..698bf8b 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -337,7 +337,7 @@
         packets_write_attempts_(0),
         clock_(clock),
         write_pause_time_delta_(QuicTime::Delta::Zero()),
-        max_packet_size_(kMaxPacketSize),
+        max_packet_size_(kMaxOutgoingPacketSize),
         supports_release_time_(false) {}
   TestPacketWriter(const TestPacketWriter&) = delete;
   TestPacketWriter& operator=(const TestPacketWriter&) = delete;
@@ -612,11 +612,11 @@
                   HasRetransmittableData retransmittable,
                   bool has_ack,
                   bool has_pending_frames) {
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     size_t encrypted_length =
         QuicConnectionPeer::GetFramer(this)->EncryptPayload(
             ENCRYPTION_INITIAL, QuicPacketNumber(packet_number), *packet,
-            buffer, kMaxPacketSize);
+            buffer, kMaxOutgoingPacketSize);
     SerializedPacket serialized_packet(
         QuicPacketNumber(packet_number), PACKET_4BYTE_PACKET_NUMBER, buffer,
         encrypted_length, has_ack, has_pending_frames);
@@ -1030,10 +1030,10 @@
           QuicMakeUnique<NullEncrypter>(peer_framer_.perspective()));
     }
 
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     SerializedPacket serialized_packet =
-        QuicPacketCreatorPeer::SerializeAllFrames(&peer_creator_, frames,
-                                                  buffer, kMaxPacketSize);
+        QuicPacketCreatorPeer::SerializeAllFrames(
+            &peer_creator_, frames, buffer, kMaxOutgoingPacketSize);
     connection_.ProcessUdpPacket(
         self_address, peer_address,
         QuicReceivedPacket(serialized_packet.encrypted_buffer,
@@ -1052,16 +1052,17 @@
         &peer_creator_, connection_.perspective() == Perspective::IS_SERVER);
     QuicPacketHeader header;
     QuicPacketCreatorPeer::FillPacketHeader(&peer_creator_, &header);
-    char encrypted_buffer[kMaxPacketSize];
+    char encrypted_buffer[kMaxOutgoingPacketSize];
     size_t length = peer_framer_.BuildDataPacket(
-        header, frames, encrypted_buffer, kMaxPacketSize, ENCRYPTION_INITIAL);
+        header, frames, encrypted_buffer, kMaxOutgoingPacketSize,
+        ENCRYPTION_INITIAL);
     DCHECK_GT(length, 0u);
 
     const size_t encrypted_length = peer_framer_.EncryptInPlace(
         ENCRYPTION_INITIAL, header.packet_number,
         GetStartOfEncryptedData(peer_framer_.version().transport_version,
                                 header),
-        length, kMaxPacketSize, encrypted_buffer);
+        length, kMaxOutgoingPacketSize, encrypted_buffer);
     DCHECK_GT(encrypted_length, 0u);
 
     connection_.ProcessUdpPacket(
@@ -1098,9 +1099,10 @@
           QuicMakeUnique<StrictTaggingDecrypter>(0x01));
     }
 
-    char buffer[kMaxPacketSize];
-    size_t encrypted_length = peer_framer_.EncryptPayload(
-        level, QuicPacketNumber(number), *packet, buffer, kMaxPacketSize);
+    char buffer[kMaxOutgoingPacketSize];
+    size_t encrypted_length =
+        peer_framer_.EncryptPayload(level, QuicPacketNumber(number), *packet,
+                                    buffer, kMaxOutgoingPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -1130,10 +1132,11 @@
                                   EncryptionLevel level) {
     std::unique_ptr<QuicPacket> packet(
         ConstructDataPacket(number, has_stop_waiting, level));
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     peer_creator_.set_encryption_level(level);
-    size_t encrypted_length = peer_framer_.EncryptPayload(
-        level, QuicPacketNumber(number), *packet, buffer, kMaxPacketSize);
+    size_t encrypted_length =
+        peer_framer_.EncryptPayload(level, QuicPacketNumber(number), *packet,
+                                    buffer, kMaxOutgoingPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -1145,10 +1148,10 @@
 
   void ProcessClosePacket(uint64_t number) {
     std::unique_ptr<QuicPacket> packet(ConstructClosePacket(number));
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     size_t encrypted_length = peer_framer_.EncryptPayload(
         ENCRYPTION_INITIAL, QuicPacketNumber(number), *packet, buffer,
-        kMaxPacketSize);
+        kMaxOutgoingPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
@@ -2146,11 +2149,11 @@
   frames.push_back(QuicFrame(frame1_));
   frames.push_back(QuicFrame(padding));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
-                                  *packet, buffer, kMaxPacketSize);
-  EXPECT_EQ(kMaxPacketSize, encrypted_length);
+                                  *packet, buffer, kMaxOutgoingPacketSize);
+  EXPECT_EQ(kMaxOutgoingPacketSize, encrypted_length);
 
   framer_.set_version(version());
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -2158,7 +2161,7 @@
       kSelfAddress, kPeerAddress,
       QuicReceivedPacket(buffer, encrypted_length, QuicTime::Zero(), false));
 
-  EXPECT_EQ(kMaxPacketSize, connection_.max_packet_length());
+  EXPECT_EQ(kMaxOutgoingPacketSize, connection_.max_packet_length());
 }
 
 TEST_P(QuicConnectionTest, IncreaseServerMaxPacketSizeWhileWriterLimited) {
@@ -2190,11 +2193,11 @@
   frames.push_back(QuicFrame(frame1_));
   frames.push_back(QuicFrame(padding));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
-                                  *packet, buffer, kMaxPacketSize);
-  EXPECT_EQ(kMaxPacketSize, encrypted_length);
+                                  *packet, buffer, kMaxOutgoingPacketSize);
+  EXPECT_EQ(kMaxOutgoingPacketSize, encrypted_length);
 
   framer_.set_version(version());
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
@@ -2447,7 +2450,7 @@
   QuicAckFrame frame = InitAckFrame({{second, second + 1}});
   // First nack triggers early retransmit.
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(original, kMaxPacketSize));
+  lost_packets.push_back(LostPacket(original, kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3153,7 +3156,8 @@
   // Lose a packet and ensure it triggers retransmission.
   QuicAckFrame nack_two = ConstructAckFrame(3, 2);
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(2), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(2), kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3254,7 +3258,7 @@
   QuicAckFrame nack_two = ConstructAckFrame(last_packet, last_packet - 1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(last_packet - 1, kMaxPacketSize));
+  lost_packets.push_back(LostPacket(last_packet - 1, kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3392,7 +3396,7 @@
   QuicAckFrame ack = ConstructAckFrame(last_packet, last_packet - 1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(last_packet - 1, kMaxPacketSize));
+  lost_packets.push_back(LostPacket(last_packet - 1, kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3432,7 +3436,8 @@
   BlockOnNextWrite();
 
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(2), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(2), kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3472,7 +3477,7 @@
   QuicAckFrame frame = InitAckFrame({{second, second + 1}});
   // The first nack should retransmit the largest observed packet.
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(original, kMaxPacketSize));
+  lost_packets.push_back(LostPacket(original, kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -3631,10 +3636,10 @@
   const EncryptionLevel level = ENCRYPTION_INITIAL;
   std::unique_ptr<QuicPacket> packet(ConstructDataPacket(
       received_packet_num, has_stop_waiting, ENCRYPTION_INITIAL));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       peer_framer_.EncryptPayload(level, QuicPacketNumber(received_packet_num),
-                                  *packet, buffer, kMaxPacketSize);
+                                  *packet, buffer, kMaxOutgoingPacketSize);
   connection_.ProcessUdpPacket(
       kSelfAddress, kPeerAddress,
       QuicReceivedPacket(buffer, encrypted_length, clock_.Now(), false));
@@ -3718,7 +3723,8 @@
   // 14 packets have been NACK'd and lost.
   LostPacketVector lost_packets;
   for (int i = 1; i < 15; ++i) {
-    lost_packets.push_back(LostPacket(QuicPacketNumber(i), kMaxPacketSize));
+    lost_packets.push_back(
+        LostPacket(QuicPacketNumber(i), kMaxOutgoingPacketSize));
   }
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
@@ -6412,7 +6418,8 @@
   // Ack the second packet, which will retransmit the first packet.
   QuicAckFrame ack = ConstructAckFrame(2, 1);
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -6720,10 +6727,10 @@
   QuicFrames frames;
   frames.push_back(QuicFrame(frame1_));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
-                             buffer, kMaxPacketSize);
+                             buffer, kMaxOutgoingPacketSize);
 
   framer_.set_version(version());
   // Writer's framer's perspective is client, so that it needs to have the right
@@ -6776,10 +6783,10 @@
   QuicFrames frames;
   frames.push_back(QuicFrame(frame1_));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
-                             buffer, kMaxPacketSize);
+                             buffer, kMaxOutgoingPacketSize);
 
   framer_.set_version(version());
   BlockOnNextWrite();
@@ -6839,10 +6846,10 @@
   QuicFrames frames;
   frames.push_back(QuicFrame(frame1_));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encryped_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12), *packet,
-                             buffer, kMaxPacketSize);
+                             buffer, kMaxOutgoingPacketSize);
 
   framer_.set_version(version());
   set_perspective(Perspective::IS_SERVER);
@@ -6897,10 +6904,10 @@
   QuicFrames frames;
   frames.push_back(QuicFrame(frame1_));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(12),
-                                  *packet, buffer, kMaxPacketSize);
+                                  *packet, buffer, kMaxOutgoingPacketSize);
   ASSERT_NE(0u, encrypted_length);
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ -6962,8 +6969,10 @@
                     {QuicPacketNumber(4), QuicPacketNumber(5)}});
 
   LostPacketVector lost_packets;
-  lost_packets.push_back(LostPacket(QuicPacketNumber(1), kMaxPacketSize));
-  lost_packets.push_back(LostPacket(QuicPacketNumber(3), kMaxPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(1), kMaxOutgoingPacketSize));
+  lost_packets.push_back(
+      LostPacket(QuicPacketNumber(3), kMaxOutgoingPacketSize));
   EXPECT_CALL(*loss_algorithm_, DetectLosses(_, _, _, _, _, _))
       .WillOnce(SetArgPointee<5>(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnCongestionEvent(true, _, _, _, _));
@@ -7012,9 +7021,10 @@
   frames.push_back(QuicFrame(&qccf));
   std::unique_ptr<QuicPacket> packet(ConstructPacket(header, frames));
   EXPECT_TRUE(nullptr != packet);
-  char buffer[kMaxPacketSize];
-  size_t encrypted_length = peer_framer_.EncryptPayload(
-      ENCRYPTION_INITIAL, QuicPacketNumber(1), *packet, buffer, kMaxPacketSize);
+  char buffer[kMaxOutgoingPacketSize];
+  size_t encrypted_length =
+      peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(1),
+                                  *packet, buffer, kMaxOutgoingPacketSize);
 
   EXPECT_CALL(visitor_, OnConnectionClosed(QUIC_PEER_GOING_AWAY, _,
                                            ConnectionCloseSource::FROM_PEER));
@@ -8431,9 +8441,10 @@
       ParsedQuicVersion(PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_43));
   std::unique_ptr<QuicPacket> packet(
       ConstructDataPacket(2, !kHasStopWaiting, ENCRYPTION_INITIAL));
-  char buffer[kMaxPacketSize];
-  size_t encrypted_length = peer_framer_.EncryptPayload(
-      ENCRYPTION_INITIAL, QuicPacketNumber(2), *packet, buffer, kMaxPacketSize);
+  char buffer[kMaxOutgoingPacketSize];
+  size_t encrypted_length =
+      peer_framer_.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(2),
+                                  *packet, buffer, kMaxOutgoingPacketSize);
   // Make sure no stream frame is processed.
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(0);
   connection_.ProcessUdpPacket(
diff --git a/quic/core/quic_constants.h b/quic/core/quic_constants.h
index e0bf4ce..4181cb7 100644
--- a/quic/core/quic_constants.h
+++ b/quic/core/quic_constants.h
@@ -32,16 +32,18 @@
 const QuicByteCount kDefaultServerMaxPacketSize = 1000;
 // Maximum transmission unit on Ethernet.
 const QuicByteCount kEthernetMTU = 1500;
-// The maximum packet size of any QUIC packet, based on ethernet's max size,
-// minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
+// The maximum packet size of any QUIC packet over IPv6, based on ethernet's max
+// size, minus the IP and UDP headers. IPv6 has a 40 byte header, UDP adds an
 // additional 8 bytes.  This is a total overhead of 48 bytes.  Ethernet's
 // max packet size is 1500 bytes,  1500 - 48 = 1452.
-const QuicByteCount kMaxPacketSize = 1452;
+const QuicByteCount kMaxV6PacketSize = 1452;
 // The maximum packet size of any QUIC packet over IPv4.
 // 1500(Ethernet) - 20(IPv4 header) - 8(UDP header) = 1472.
 const QuicByteCount kMaxV4PacketSize = 1472;
 // The maximum incoming packet size allowed.
 const QuicByteCount kMaxIncomingPacketSize = kMaxV4PacketSize;
+// The maximum outgoing packet size allowed.
+const QuicByteCount kMaxOutgoingPacketSize = kMaxV6PacketSize;
 // ETH_MAX_MTU - MAX(sizeof(iphdr), sizeof(ip6_hdr)) - sizeof(udphdr).
 const QuicByteCount kMaxGsoPacketSize = 65535 - 40 - 8;
 // Default maximum packet size used in the Linux TCP implementation.
diff --git a/quic/core/quic_default_packet_writer.cc b/quic/core/quic_default_packet_writer.cc
index 3b16a74..a9147c0 100644
--- a/quic/core/quic_default_packet_writer.cc
+++ b/quic/core/quic_default_packet_writer.cc
@@ -40,7 +40,7 @@
 
 QuicByteCount QuicDefaultPacketWriter::GetMaxPacketSize(
     const QuicSocketAddress& peer_address) const {
-  return kMaxPacketSize;
+  return kMaxOutgoingPacketSize;
 }
 
 bool QuicDefaultPacketWriter::SupportsReleaseTime() const {
diff --git a/quic/core/quic_error_codes.h b/quic/core/quic_error_codes.h
index bbdb13f..9954134 100644
--- a/quic/core/quic_error_codes.h
+++ b/quic/core/quic_error_codes.h
@@ -118,7 +118,7 @@
   QUIC_DECRYPTION_FAILURE = 12,
   // There was an error encrypting.
   QUIC_ENCRYPTION_FAILURE = 13,
-  // The packet exceeded kMaxPacketSize.
+  // The packet exceeded kMaxOutgoingPacketSize.
   QUIC_PACKET_TOO_LARGE = 14,
   // The peer is going away.  May be a client or server.
   QUIC_PEER_GOING_AWAY = 16,
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index 4fd6936..c24a23c 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -880,7 +880,7 @@
       free_bytes >= GetMinAckFrameSize(version_.transport_version,
                                        PACKET_6BYTE_PACKET_NUMBER);
   if (can_truncate) {
-    // Truncate the frame so the packet will not exceed kMaxPacketSize.
+    // Truncate the frame so the packet will not exceed kMaxOutgoingPacketSize.
     // Note that we may not use every byte of the writer in this case.
     QUIC_DLOG(INFO) << ENDPOINT
                     << "Truncating large frame, free bytes: " << free_bytes;
diff --git a/quic/core/quic_framer_test.cc b/quic/core/quic_framer_test.cc
index dc6e231..927b100 100644
--- a/quic/core/quic_framer_test.cc
+++ b/quic/core/quic_framer_test.cc
@@ -568,7 +568,7 @@
   // packet fragments in |fragments|.
   std::unique_ptr<QuicEncryptedPacket> AssemblePacketFromFragments(
       const PacketFragments& fragments) {
-    char* buffer = new char[kMaxPacketSize + 1];
+    char* buffer = new char[kMaxOutgoingPacketSize + 1];
     size_t len = 0;
     for (const auto& fragment : fragments) {
       memcpy(buffer + len, fragment.fragment.data(), fragment.fragment.size());
@@ -5408,7 +5408,7 @@
   QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
 
   // clang-format off
-  unsigned char packet[kMaxPacketSize] = {
+  unsigned char packet[kMaxOutgoingPacketSize] = {
     // public flags (8 byte connection_id)
     0x28,
     // connection_id
@@ -5421,7 +5421,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxPacketSize] = {
+  unsigned char packet44[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x32,
     // connection_id
@@ -5434,7 +5434,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet46[kMaxPacketSize] = {
+  unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -5447,7 +5447,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet99[kMaxPacketSize] = {
+  unsigned char packet99[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -5475,7 +5475,7 @@
       PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
-  memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+  memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
@@ -5640,7 +5640,7 @@
   QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
 
   // clang-format off
-  unsigned char packet[kMaxPacketSize] = {
+  unsigned char packet[kMaxOutgoingPacketSize] = {
     // public flags (8 byte connection_id and 4 byte packet number)
     0x28,
     // connection_id
@@ -5653,7 +5653,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxPacketSize] = {
+  unsigned char packet44[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x32,
     // connection_id
@@ -5666,7 +5666,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet46[kMaxPacketSize] = {
+  unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -5679,7 +5679,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet99[kMaxPacketSize] = {
+  unsigned char packet99[kMaxOutgoingPacketSize] = {
     // type (short header, 4 byte packet number)
     0x43,
     // connection_id
@@ -5707,7 +5707,7 @@
       PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
-  memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+  memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
@@ -5729,7 +5729,7 @@
   QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
 
   // clang-format off
-  unsigned char packet[kMaxPacketSize] = {
+  unsigned char packet[kMaxOutgoingPacketSize] = {
     // public flags (8 byte connection_id and 2 byte packet number)
     0x18,
     // connection_id
@@ -5742,7 +5742,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxPacketSize] = {
+  unsigned char packet44[kMaxOutgoingPacketSize] = {
     // type (short header, 2 byte packet number)
     0x31,
     // connection_id
@@ -5755,7 +5755,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet46[kMaxPacketSize] = {
+  unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 2 byte packet number)
     0x41,
     // connection_id
@@ -5768,7 +5768,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet99[kMaxPacketSize] = {
+  unsigned char packet99[kMaxOutgoingPacketSize] = {
     // type (short header, 2 byte packet number)
     0x41,
     // connection_id
@@ -5796,7 +5796,7 @@
       PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_2BYTE_PACKET_NUMBER,
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
-  memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+  memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
@@ -5818,7 +5818,7 @@
   QuicFrames frames = {QuicFrame(QuicPaddingFrame())};
 
   // clang-format off
-  unsigned char packet[kMaxPacketSize] = {
+  unsigned char packet[kMaxOutgoingPacketSize] = {
     // public flags (8 byte connection_id and 1 byte packet number)
     0x08,
     // connection_id
@@ -5831,7 +5831,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet44[kMaxPacketSize] = {
+  unsigned char packet44[kMaxOutgoingPacketSize] = {
     // type (short header, 1 byte packet number)
     0x30,
     // connection_id
@@ -5844,7 +5844,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet46[kMaxPacketSize] = {
+  unsigned char packet46[kMaxOutgoingPacketSize] = {
     // type (short header, 1 byte packet number)
     0x40,
     // connection_id
@@ -5857,7 +5857,7 @@
     0x00, 0x00, 0x00, 0x00
   };
 
-  unsigned char packet99[kMaxPacketSize] = {
+  unsigned char packet99[kMaxOutgoingPacketSize] = {
     // type (short header, 1 byte packet number)
     0x40,
     // connection_id
@@ -5885,7 +5885,7 @@
       PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_1BYTE_PACKET_NUMBER,
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0);
-  memset(p + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
+  memset(p + header_size + 1, 0x00, kMaxOutgoingPacketSize - header_size - 1);
 
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
@@ -8599,7 +8599,7 @@
     packet_size = QUIC_ARRAYSIZE(packet44);
   }
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
 
   size_t length = framer_.BuildConnectivityProbingPacket(
       header, buffer.get(), packet_size, ENCRYPTION_INITIAL);
@@ -8645,7 +8645,7 @@
   };
   // clang-format on
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   MockRandom randomizer;
 
   size_t length = framer_.BuildPaddedPathChallengePacket(
@@ -8698,7 +8698,7 @@
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
   };
   // clang-format on
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   QuicDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = framer_.BuildPathResponsePacket(
@@ -8744,7 +8744,7 @@
     0x00, 0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   QuicDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   size_t length = framer_.BuildPathResponsePacket(
@@ -8793,7 +8793,7 @@
   };
   // clang-format on
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   QuicDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
@@ -8846,7 +8846,7 @@
   };
   // clang-format on
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   QuicDeque<QuicPathFrameBuffer> payloads;
   payloads.push_back(payload0);
   payloads.push_back(payload1);
@@ -9217,9 +9217,9 @@
       PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
       !kIncludeDiversificationNonce, PACKET_4BYTE_PACKET_NUMBER,
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxPacketSize);
+      ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ -9320,9 +9320,9 @@
       kIncludeVersion, !kIncludeDiversificationNonce,
       PACKET_4BYTE_PACKET_NUMBER, VARIABLE_LENGTH_INTEGER_LENGTH_0, 0,
       VARIABLE_LENGTH_INTEGER_LENGTH_0));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length = framer_.EncryptPayload(
-      ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxPacketSize);
+      ENCRYPTION_INITIAL, packet_number, *raw, buffer, kMaxOutgoingPacketSize);
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
@@ -9350,10 +9350,10 @@
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
   std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
   ASSERT_TRUE(raw_ack_packet != nullptr);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
-                             *raw_ack_packet, buffer, kMaxPacketSize);
+                             *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -9390,10 +9390,10 @@
   std::unique_ptr<QuicPacket> raw_ack_packet(
       BuildDataPacket(header, frames, 500));
   ASSERT_TRUE(raw_ack_packet != nullptr);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
-                             *raw_ack_packet, buffer, kMaxPacketSize);
+                             *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
   ASSERT_NE(0u, encrypted_length);
   // Now make sure we can turn our ack packet back into an ack frame.
   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_SERVER);
@@ -9428,10 +9428,10 @@
   std::unique_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
   ASSERT_TRUE(raw_ack_packet != nullptr);
 
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer_.EncryptPayload(ENCRYPTION_INITIAL, header.packet_number,
-                             *raw_ack_packet, buffer, kMaxPacketSize);
+                             *raw_ack_packet, buffer, kMaxOutgoingPacketSize);
   ASSERT_NE(0u, encrypted_length);
 
   // Now make sure we can turn our ack packet back into an ack frame.
diff --git a/quic/core/quic_packet_creator.cc b/quic/core/quic_packet_creator.cc
index 4d5bd14..96b5bc6 100644
--- a/quic/core/quic_packet_creator.cc
+++ b/quic/core/quic_packet_creator.cc
@@ -266,7 +266,7 @@
          // would calculate the correct lengths at the correct time, based on
          // the state at that time/place.
          QuicFramer::GetMinStreamFrameSize(version, 1u, offset, true,
-                                           kMaxPacketSize);
+                                           kMaxOutgoingPacketSize);
 }
 
 void QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
@@ -364,13 +364,13 @@
     return;
   }
 
-  QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxPacketSize];
+  QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
   char* serialized_packet_buffer = delegate_->GetPacketBuffer();
   if (serialized_packet_buffer == nullptr) {
     serialized_packet_buffer = stack_buffer;
   }
 
-  SerializePacket(serialized_packet_buffer, kMaxPacketSize);
+  SerializePacket(serialized_packet_buffer, kMaxOutgoingPacketSize);
   OnSerializedPacket();
 }
 
@@ -418,13 +418,13 @@
   QuicPacketHeader header;
   FillPacketHeader(&header);
 
-  QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxPacketSize];
+  QUIC_CACHELINE_ALIGNED char stack_buffer[kMaxOutgoingPacketSize];
   char* encrypted_buffer = delegate_->GetPacketBuffer();
   if (encrypted_buffer == nullptr) {
     encrypted_buffer = stack_buffer;
   }
 
-  QuicDataWriter writer(kMaxPacketSize, encrypted_buffer);
+  QuicDataWriter writer(kMaxOutgoingPacketSize, encrypted_buffer);
   size_t length_field_offset = 0;
   if (!framer_->AppendPacketHeader(header, &writer, &length_field_offset)) {
     QUIC_BUG << "AppendPacketHeader failed";
@@ -477,7 +477,7 @@
   size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header),
-      writer.length(), kMaxPacketSize, encrypted_buffer);
+      writer.length(), kMaxOutgoingPacketSize, encrypted_buffer);
   if (encrypted_length == 0) {
     QUIC_BUG << "Failed to encrypt packet number " << header.packet_number;
     return;
@@ -637,7 +637,7 @@
   // FillPacketHeader increments packet_number_.
   FillPacketHeader(&header);
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   size_t length = framer_->BuildConnectivityProbingPacket(
       header, buffer.get(), max_plaintext_size_, packet_.encryption_level);
   DCHECK(length);
@@ -645,7 +645,7 @@
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
-      kMaxPacketSize, buffer.get());
+      kMaxOutgoingPacketSize, buffer.get());
   DCHECK(encrypted_length);
 
   OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
@@ -669,7 +669,7 @@
   // FillPacketHeader increments packet_number_.
   FillPacketHeader(&header);
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   size_t length = framer_->BuildPaddedPathChallengePacket(
       header, buffer.get(), max_plaintext_size_, payload, random_,
       packet_.encryption_level);
@@ -678,7 +678,7 @@
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
-      kMaxPacketSize, buffer.get());
+      kMaxOutgoingPacketSize, buffer.get());
   DCHECK(encrypted_length);
 
   OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
@@ -703,7 +703,7 @@
   // FillPacketHeader increments packet_number_.
   FillPacketHeader(&header);
 
-  std::unique_ptr<char[]> buffer(new char[kMaxPacketSize]);
+  std::unique_ptr<char[]> buffer(new char[kMaxOutgoingPacketSize]);
   size_t length = framer_->BuildPathResponsePacket(
       header, buffer.get(), max_plaintext_size_, payloads, is_padded,
       packet_.encryption_level);
@@ -712,7 +712,7 @@
   const size_t encrypted_length = framer_->EncryptInPlace(
       packet_.encryption_level, packet_.packet_number,
       GetStartOfEncryptedData(framer_->transport_version(), header), length,
-      kMaxPacketSize, buffer.get());
+      kMaxOutgoingPacketSize, buffer.get());
   DCHECK(encrypted_length);
 
   OwningSerializedPacketPointer serialize_packet(new SerializedPacket(
diff --git a/quic/core/quic_packet_creator.h b/quic/core/quic_packet_creator.h
index ea93552..85e0091 100644
--- a/quic/core/quic_packet_creator.h
+++ b/quic/core/quic_packet_creator.h
@@ -32,8 +32,9 @@
       : public QuicConnectionCloseDelegateInterface {
    public:
     ~DelegateInterface() override {}
-    // Get a buffer of kMaxPacketSize bytes to serialize the next packet.
-    // If return nullptr, QuicPacketCreator will serialize on a stack buffer.
+    // Get a buffer of kMaxOutgoingPacketSize bytes to serialize the next
+    // packet. If return nullptr, QuicPacketCreator will serialize on a stack
+    // buffer.
     virtual char* GetPacketBuffer() = 0;
     // Called when a packet is serialized. Delegate does not take the ownership
     // of |serialized_packet|, but takes ownership of any frames it removes
diff --git a/quic/core/quic_packet_creator_test.cc b/quic/core/quic_packet_creator_test.cc
index f6d4f5f..d463846 100644
--- a/quic/core/quic_packet_creator_test.cc
+++ b/quic/core/quic_packet_creator_test.cc
@@ -173,7 +173,7 @@
 
   SerializedPacket SerializeAllFrames(const QuicFrames& frames) {
     SerializedPacket packet = QuicPacketCreatorPeer::SerializeAllFrames(
-        &creator_, frames, buffer_, kMaxPacketSize);
+        &creator_, frames, buffer_, kMaxOutgoingPacketSize);
     EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_),
               packet.encryption_level);
     return packet;
@@ -192,8 +192,8 @@
                         bool fin) {
     EXPECT_EQ(STREAM_FRAME, frame.type);
     EXPECT_EQ(stream_id, frame.stream_frame.stream_id);
-    char buf[kMaxPacketSize];
-    QuicDataWriter writer(kMaxPacketSize, buf, HOST_BYTE_ORDER);
+    char buf[kMaxOutgoingPacketSize];
+    QuicDataWriter writer(kMaxOutgoingPacketSize, buf, HOST_BYTE_ORDER);
     if (frame.stream_frame.data_length > 0) {
       producer_.WriteStreamData(stream_id, frame.stream_frame.offset,
                                 frame.stream_frame.data_length, &writer);
@@ -254,7 +254,7 @@
 
   static const QuicStreamOffset kOffset = 0u;
 
-  char buffer_[kMaxPacketSize];
+  char buffer_[kMaxOutgoingPacketSize];
   QuicConnectionId connection_id_;
   QuicFrames frames_;
   QuicFramer server_framer_;
@@ -339,13 +339,13 @@
     frames.push_back(
         QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
   }
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
       ENCRYPTION_INITIAL, PACKET_4BYTE_PACKET_NUMBER));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   // The packet number length is updated after every packet is sent,
   // so there is no need to restore the old length after sending.
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
@@ -386,14 +386,14 @@
         QuicFrame(new QuicCryptoFrame(ENCRYPTION_INITIAL, 0, data.length())));
   }
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
       ENCRYPTION_INITIAL,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   EXPECT_EQ(ENCRYPTION_INITIAL, serialized_packet_.encryption_level);
   DeleteFrames(&frames);
 }
@@ -403,14 +403,14 @@
   QuicFrames frames;
   frames.push_back(QuicFrame(stream_frame));
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, false /* has_crypto_handshake */, 0 /* no padding */,
       ENCRYPTION_INITIAL,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, serialized_packet_.encryption_level);
 }
 
@@ -433,14 +433,14 @@
   }
   QuicFrames frames;
   frames.push_back(frame);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true /* has_crypto_handshake */, -1 /* needs full padding */,
       ENCRYPTION_INITIAL,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
   DeleteFrames(&frames);
 }
@@ -468,14 +468,15 @@
   {
     QuicFrames frames;
     frames.push_back(frame);
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     QuicPendingRetransmission retransmission(CreateRetransmission(
         frames, false /* has_crypto_handshake */,
         kNumPaddingBytes1 /* padding bytes */, ENCRYPTION_INITIAL,
         QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-    creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+    creator_.ReserializeAllFrames(retransmission, buffer,
+                                  kMaxOutgoingPacketSize);
     packet_size = serialized_packet_.encrypted_length;
   }
 
@@ -500,14 +501,14 @@
   const int kNumPaddingBytes2 = 44;
   QuicFrames frames;
   frames.push_back(frame);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, false /* has_crypto_handshake */,
       kNumPaddingBytes2 /* padding bytes */, ENCRYPTION_INITIAL,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
 
   EXPECT_EQ(packet_size, serialized_packet_.encrypted_length);
   DeleteFrames(&frames);
@@ -535,14 +536,15 @@
                                              kOffset, false, &frame);
     QuicFrames frames;
     frames.push_back(frame);
-    char buffer[kMaxPacketSize];
+    char buffer[kMaxOutgoingPacketSize];
     QuicPendingRetransmission retransmission(CreateRetransmission(
         frames, false /* has_crypto_handshake */, -1 /* needs full padding */,
         ENCRYPTION_FORWARD_SECURE,
         QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-    creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+    creator_.ReserializeAllFrames(retransmission, buffer,
+                                  kMaxOutgoingPacketSize);
 
     // 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
@@ -699,11 +701,12 @@
       GetPacketHeaderOverhead(client_framer_.transport_version()) +
       GetEncryptionOverhead();
   if (QuicVersionUsesCryptoFrames(client_framer_.transport_version())) {
-    overhead += QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxPacketSize);
+    overhead +=
+        QuicFramer::GetMinCryptoFrameSize(kOffset, kMaxOutgoingPacketSize);
   } else {
     overhead += GetStreamFrameOverhead(client_framer_.transport_version());
   }
-  ASSERT_GT(kMaxPacketSize, overhead);
+  ASSERT_GT(kMaxOutgoingPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
@@ -1361,7 +1364,7 @@
 
   CryptoHandshakeMessage message;
   message.set_tag(kCHLO);
-  message.set_minimum_size(kMaxPacketSize);
+  message.set_minimum_size(kMaxOutgoingPacketSize);
   CryptoFramer framer;
   std::unique_ptr<QuicData> message_data;
   message_data = framer.ConstructHandshakeMessage(message);
@@ -1430,14 +1433,14 @@
                                /*fin=*/false, 0u, QuicStringPiece());
   QuicFrames frames;
   frames.push_back(QuicFrame(stream_frame));
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true, /*num_padding_bytes=*/0, ENCRYPTION_FORWARD_SECURE,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.AddPendingPadding(kMaxNumRandomPaddingBytes);
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   EXPECT_EQ(0u, creator_.pending_padding_bytes());
   {
     InSequence s;
@@ -1472,14 +1475,14 @@
                                            0u, false, &frame);
   QuicFrames frames;
   frames.push_back(frame);
-  char buffer[kMaxPacketSize];
+  char buffer[kMaxOutgoingPacketSize];
   QuicPendingRetransmission retransmission(CreateRetransmission(
       frames, true, /*num_padding_bytes=*/-1, ENCRYPTION_FORWARD_SECURE,
       QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
+  creator_.ReserializeAllFrames(retransmission, buffer, kMaxOutgoingPacketSize);
   EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
   {
     InSequence s;
@@ -1560,7 +1563,7 @@
 
 TEST_P(QuicPacketCreatorTest, FlushWithExternalBuffer) {
   creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE);
-  char external_buffer[kMaxPacketSize];
+  char external_buffer[kMaxOutgoingPacketSize];
   char* expected_buffer = external_buffer;
   EXPECT_CALL(delegate_, GetPacketBuffer()).WillOnce(Return(expected_buffer));
 
diff --git a/quic/core/quic_packet_generator.cc b/quic/core/quic_packet_generator.cc
index 831689b..6efadcf 100644
--- a/quic/core/quic_packet_generator.cc
+++ b/quic/core/quic_packet_generator.cc
@@ -137,9 +137,9 @@
   }
   // 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() &&
-                       write_length - total_bytes_consumed > kMaxPacketSize;
+  bool run_fast_path =
+      !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+      write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
 
   while (!run_fast_path && delegate_->ShouldGeneratePacket(
                                HAS_RETRANSMITTABLE_DATA,
@@ -177,9 +177,9 @@
     // TODO(ianswett): Move to having the creator flush itself when it's full.
     packet_creator_.Flush();
 
-    run_fast_path = !has_handshake && state != FIN_AND_PADDING &&
-                    !HasQueuedFrames() &&
-                    write_length - total_bytes_consumed > kMaxPacketSize;
+    run_fast_path =
+        !has_handshake && state != FIN_AND_PADDING && !HasQueuedFrames() &&
+        write_length - total_bytes_consumed > kMaxOutgoingPacketSize;
   }
 
   if (run_fast_path) {
diff --git a/quic/core/quic_packet_generator_test.cc b/quic/core/quic_packet_generator_test.cc
index cb22fd5..9edddfc 100644
--- a/quic/core/quic_packet_generator_test.cc
+++ b/quic/core/quic_packet_generator_test.cc
@@ -1046,7 +1046,7 @@
   // Send enough data for three packets.
   size_t data_len = 3 * kDefaultMaxPacketSize + 1;
   size_t packet_len = kDefaultMaxPacketSize + 100;
-  ASSERT_LE(packet_len, kMaxPacketSize);
+  ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
   generator_.SetMaxPacketLength(packet_len);
   EXPECT_EQ(packet_len, generator_.GetCurrentMaxPacketLength());
 
@@ -1082,7 +1082,7 @@
   // one.
   size_t data_len = kDefaultMaxPacketSize;
   size_t packet_len = kDefaultMaxPacketSize + 100;
-  ASSERT_LE(packet_len, kMaxPacketSize);
+  ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
 
   // We expect to see three packets in total.
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
@@ -1136,7 +1136,7 @@
   size_t first_write_len = kDefaultMaxPacketSize / 2;
   size_t packet_len = kDefaultMaxPacketSize + 100;
   size_t second_write_len = packet_len + 1;
-  ASSERT_LE(packet_len, kMaxPacketSize);
+  ASSERT_LE(packet_len, kMaxOutgoingPacketSize);
 
   // First send half of the packet worth of data.  We are in the batch mode, so
   // should not cause packet serialization.
@@ -1223,7 +1223,7 @@
   delegate_.SetCanWriteAnything();
 
   const size_t target_mtu = kDefaultMaxPacketSize + 100;
-  static_assert(target_mtu < kMaxPacketSize,
+  static_assert(target_mtu < kMaxOutgoingPacketSize,
                 "The MTU probe used by the test exceeds maximum packet size");
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
@@ -1248,7 +1248,7 @@
   delegate_.SetCanWriteAnything();
 
   const size_t target_mtu = kDefaultMaxPacketSize + 100;
-  static_assert(target_mtu < kMaxPacketSize,
+  static_assert(target_mtu < kMaxOutgoingPacketSize,
                 "The MTU probe used by the test exceeds maximum packet size");
 
   // Send enough data so it would always cause two packets to be sent.
diff --git a/quic/core/quic_packet_reader.cc b/quic/core/quic_packet_reader.cc
index 3216013..f03aa6d 100644
--- a/quic/core/quic_packet_reader.cc
+++ b/quic/core/quic_packet_reader.cc
@@ -83,7 +83,7 @@
 #if MMSG_MORE_NO_ANDROID
   // Re-set the length fields in case recvmmsg has changed them.
   for (int i = 0; i < kNumPacketsPerReadMmsgCall; ++i) {
-    DCHECK_LE(kMaxPacketSize, packets_[i].iov.iov_len);
+    DCHECK_LE(kMaxOutgoingPacketSize, packets_[i].iov.iov_len);
     msghdr* hdr = &mmsg_hdr_[i].msg_hdr;
     hdr->msg_namelen = sizeof(sockaddr_storage);
     DCHECK_EQ(1, hdr->msg_iovlen);
diff --git a/quic/core/quic_packet_writer.h b/quic/core/quic_packet_writer.h
index c33e9b7..667254f 100644
--- a/quic/core/quic_packet_writer.h
+++ b/quic/core/quic_packet_writer.h
@@ -107,11 +107,11 @@
   //
   // Batch mode:
   // Return the starting address for the next packet's data. A minimum of
-  // kMaxPacketSize is guaranteed to be available from the returned address. If
-  // the internal buffer does not have enough space, nullptr is returned.
-  // All arguments should be identical to the follow-up call to |WritePacket|,
-  // they are here to allow advanced packet memory management in packet writers,
-  // e.g. one packet buffer pool per |peer_address|.
+  // kMaxOutgoingPacketSize is guaranteed to be available from the returned
+  // address. If the internal buffer does not have enough space, nullptr is
+  // returned. All arguments should be identical to the follow-up call to
+  // |WritePacket|, they are here to allow advanced packet memory management in
+  // packet writers, e.g. one packet buffer pool per |peer_address|.
   virtual char* GetNextWriteLocation(const QuicIpAddress& self_address,
                                      const QuicSocketAddress& peer_address) = 0;
 
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index f3016f4..eb76c95 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -842,7 +842,7 @@
 
   EXPECT_CALL(*send_algorithm, CanSend(_)).WillRepeatedly(Return(true));
   EXPECT_CALL(*send_algorithm, GetCongestionWindow())
-      .WillRepeatedly(Return(kMaxPacketSize * 10));
+      .WillRepeatedly(Return(kMaxOutgoingPacketSize * 10));
   EXPECT_CALL(*send_algorithm, InRecovery()).WillRepeatedly(Return(false));
   EXPECT_CALL(*stream2, OnCanWrite()).WillOnce(Invoke([this, stream2]() {
     session_.SendStreamData(stream2);
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index 87f1d6e..e154482 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -72,7 +72,7 @@
 class QuicStreamTestBase : public QuicTestWithParam<ParsedQuicVersion> {
  public:
   QuicStreamTestBase()
-      : initial_flow_control_window_bytes_(kMaxPacketSize),
+      : initial_flow_control_window_bytes_(kMaxOutgoingPacketSize),
         zero_(QuicTime::Delta::Zero()),
         supported_versions_(AllSupportedVersions()) {}
 
diff --git a/quic/core/quic_trace_visitor_test.cc b/quic/core/quic_trace_visitor_test.cc
index ee179bb..1a58153 100644
--- a/quic/core/quic_trace_visitor_test.cc
+++ b/quic/core/quic_trace_visitor_test.cc
@@ -16,7 +16,7 @@
 namespace quic {
 namespace {
 
-const QuicByteCount kTransferSize = 1000 * kMaxPacketSize;
+const QuicByteCount kTransferSize = 1000 * kMaxOutgoingPacketSize;
 const QuicByteCount kTestStreamNumber = 3;
 const QuicTime::Delta kDelay = QuicTime::Delta::FromMilliseconds(20);
 
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index db57071..e5988e0 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -109,7 +109,8 @@
     QuicFramer* framer,
     const QuicPacketHeader& header,
     const QuicFrames& frames) {
-  const size_t max_plaintext_size = framer->GetMaxPlaintextSize(kMaxPacketSize);
+  const size_t max_plaintext_size =
+      framer->GetMaxPlaintextSize(kMaxOutgoingPacketSize);
   size_t packet_size = GetPacketHeaderSize(framer->transport_version(), header);
   for (size_t i = 0; i < frames.size(); ++i) {
     DCHECK_LE(packet_size, max_plaintext_size);
@@ -698,7 +699,7 @@
 
 MockPacketWriter::MockPacketWriter() {
   ON_CALL(*this, GetMaxPacketSize(_))
-      .WillByDefault(testing::Return(kMaxPacketSize));
+      .WillByDefault(testing::Return(kMaxOutgoingPacketSize));
   ON_CALL(*this, IsBatchMode()).WillByDefault(testing::Return(false));
   ON_CALL(*this, GetNextWriteLocation(_, _))
       .WillByDefault(testing::Return(nullptr));
@@ -882,10 +883,10 @@
   std::unique_ptr<QuicPacket> packet(
       BuildUnsizedDataPacket(&framer, header, frames));
   EXPECT_TRUE(packet != nullptr);
-  char* buffer = new char[kMaxPacketSize];
+  char* buffer = new char[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(packet_number),
-                            *packet, buffer, kMaxPacketSize);
+                            *packet, buffer, kMaxOutgoingPacketSize);
   EXPECT_NE(0u, encrypted_length);
   DeleteFrames(&frames);
   return new QuicEncryptedPacket(buffer, encrypted_length, true);
@@ -943,10 +944,10 @@
       VARIABLE_LENGTH_INTEGER_LENGTH_0, 0, VARIABLE_LENGTH_INTEGER_LENGTH_0)] =
       0x1F;
 
-  char* buffer = new char[kMaxPacketSize];
+  char* buffer = new char[kMaxOutgoingPacketSize];
   size_t encrypted_length =
       framer.EncryptPayload(ENCRYPTION_INITIAL, QuicPacketNumber(packet_number),
-                            *packet, buffer, kMaxPacketSize);
+                            *packet, buffer, kMaxOutgoingPacketSize);
   EXPECT_NE(0u, encrypted_length);
   return new QuicEncryptedPacket(buffer, encrypted_length, true);
 }
@@ -1137,12 +1138,13 @@
                           QuicStringPiece message_data,
                           QuicMemSliceStorage* storage) {
   if (message_data.length() == 0) {
-    *storage = QuicMemSliceStorage(nullptr, 0, allocator, kMaxPacketSize);
+    *storage =
+        QuicMemSliceStorage(nullptr, 0, allocator, kMaxOutgoingPacketSize);
     return storage->ToSpan();
   }
   struct iovec iov = {const_cast<char*>(message_data.data()),
                       message_data.length()};
-  *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxPacketSize);
+  *storage = QuicMemSliceStorage(&iov, 1, allocator, kMaxOutgoingPacketSize);
   return storage->ToSpan();
 }
 
diff --git a/quic/test_tools/simulator/quic_endpoint.cc b/quic/test_tools/simulator/quic_endpoint.cc
index b0ce5ca..1072724 100644
--- a/quic/test_tools/simulator/quic_endpoint.cc
+++ b/quic/test_tools/simulator/quic_endpoint.cc
@@ -65,7 +65,7 @@
       writer_(this),
       nic_tx_queue_(simulator,
                     QuicStringPrintf("%s (TX Queue)", name.c_str()),
-                    kMaxPacketSize * kTxQueueSize),
+                    kMaxOutgoingPacketSize * kTxQueueSize),
       connection_(connection_id,
                   GetAddressFromName(peer_name),
                   simulator,
@@ -204,7 +204,7 @@
 void QuicEndpoint::OnPacketDequeued() {
   if (writer_.IsWriteBlocked() &&
       (nic_tx_queue_.capacity() - nic_tx_queue_.bytes_queued()) >=
-          kMaxPacketSize) {
+          kMaxOutgoingPacketSize) {
     writer_.SetWritable();
     connection_.OnCanWrite();
   }
@@ -290,7 +290,7 @@
     PerPacketOptions* options) {
   DCHECK(!IsWriteBlocked());
   DCHECK(options == nullptr);
-  DCHECK(buf_len <= kMaxPacketSize);
+  DCHECK(buf_len <= kMaxOutgoingPacketSize);
 
   // Instead of losing a packet, become write-blocked when the egress queue is
   // full.
@@ -323,7 +323,7 @@
 
 QuicByteCount QuicEndpoint::Writer::GetMaxPacketSize(
     const QuicSocketAddress& /*peer_address*/) const {
-  return kMaxPacketSize;
+  return kMaxOutgoingPacketSize;
 }
 
 bool QuicEndpoint::Writer::SupportsReleaseTime() const {
diff --git a/quic/test_tools/simulator/quic_endpoint_test.cc b/quic/test_tools/simulator/quic_endpoint_test.cc
index 0b25096..5382eb5 100644
--- a/quic/test_tools/simulator/quic_endpoint_test.cc
+++ b/quic/test_tools/simulator/quic_endpoint_test.cc
@@ -104,7 +104,7 @@
       .WillRepeatedly(Return(10 * kDefaultBandwidth));
   EXPECT_CALL(*sender, GetCongestionWindow())
       .WillRepeatedly(
-          Return(kMaxPacketSize * kDefaultMaxCongestionWindowPackets));
+          Return(kMaxOutgoingPacketSize * kDefaultMaxCongestionWindowPackets));
   test::QuicConnectionPeer::SetSendAlgorithm(endpoint_a.connection(), sender);
 
   // First transmit a small, packet-size chunk of data.